A Time-Sensitive Graph Neural Network for Session-Based New Item Recommendation

Abstract

Session-based recommendation plays an important role in daily life and exists in many scenarios, such as online shopping websites and streaming media platforms. Recently, some works have focused on using graph neural networks (GNNs) to recommend new items in session-based scenarios. However, these methods have encountered several limitations. First, existing methods typically ignore the impact of items’ visited time in constructing session graphs, resulting in a departure from real-world recommendation dynamics. Second, sessions are often sparse, making it challenging for GNNs to learn valuable item embedding and user preferences. Third, the existing methods usually overemphasize the impact of the last item on user preferences, neglecting their interest in multiple items in a session. To address these issues, we introduce a time-sensitive graph neural network for new item recommendation in session-based scenarios, namely, TSGNN. Specifically, TSGNN provides a novel time-sensitive session graph constructing technique to solve the first problem. For the second problem, TSGNN introduces graph augmentation and contrastive learning into it. To solve the third problem, TSGNN designs a time-aware attention mechanism to accurately discern user preferences. By evaluating the compatibility between user preferences and candidate new item embeddings, our method recommends items with high relevance scores for users. Comparative experiments demonstrate the superiority of TSGNN over state-of-the-art (SOTA) methods.

1. Introduction

Recommender systems significantly impact people’s daily lives; they filter information for people and recommend things that people may be interested in [1]. Recommendation systems widely exist in different fields, such as e-commerce [2], job markets [3], and streaming media [4]. A key scenario in recommendation systems is session-based recommendations. A session refers to a sequence of actions carried out by a user, such as clicking buttons, viewing pages, or making purchases [5]. These actions occur within a short time and are considered a single visit [6]. This type of recommender system can provide personalized suggestions to users within a specific session, typically without requiring long-term user profiles or histories [7]. These systems are widely used in content streaming [8], news websites [9], and other online platforms [10].

Numerous methods have been developed to design session-based recommender systems. Attention-based methods are crucial in the field of deep learning [11]. It is also crucial in session-based recommendations. For instance, in the work of Zhang et al. [12], a vanilla attention mechanism is utilized to combine heterogeneous features for extracting the transition patterns between items. Yuan et al. [13] provide a dual sparse attention network to mitigate the effect of irrelevant items on user preference. Additionally, topic models have emerged as a recent area of focus. Sottocornola et al. [14] train topic models to track changes in users’ interest in news over time; ref. [15] is a music recommender system where the music consists of a session. This work regards the music list as a set of topics, helping to uncover latent user patterns. In addition to the above two types of methods, there are many other methods, such as collaborative filtering-based methods [16], content-based methods [17], and matrix factorization-based methods [8].

Recently, graph neural networks (GNNs) have been the most popular methods [18,19,20]. Many GNN methods for session-based recommender systems have emerged, such as TMI-GNN [21], RN-GNN [22], and SR-GNN [23]. Compared to other recommender systems, GNN-based recommender systems can learn intricate item conversions and effectively model user behavior within a specific session graph, which is ignored by other methods. Specifically, GNN-based recommender systems model the input session as a graph, in which nodes refer to various items within the session, and edges refer to transitions or relations between items. GNNs are capable of effective feature learning for the items in the session graph. By fully considering and modeling complex inter-relationships between items, these GNN-based methods can understand user behaviors and preferences during recommendations.

However, the methods mentioned above are designed for next item recommendation and might not be effective in recommending new items. This ineffectiveness arises from the lack of user interaction with new items, leading to new items independent of the session graph that are hard to learn by GNNs. To tackle this issue, a GNN for the session-based new item recommendation method (NirGNN) has been proposed recently [24]. NirGNN incorporates a dual-intent network that mimics user decision-making processes through a soft-attention mechanism and a $\beta$ distribution mechanism. To address the challenge of new items that are hard to learn by using GNNs, NirGNN leverages inspiration from zero-shot learning and infers the embedding of new items based on their attributes. Consequently, NirGNN calculates recommendation scores and prioritizes new items with higher scores for user recommendations. Nonetheless, this method may encounter three limitations:

• Lack of Time Sensitivity: The previous research models session graphs simply as directed graphs, failing to consider the temporal aspect of item interactions. This omission is a critical flaw as the timing of an item’s appearance in a session can greatly influence its relevance and importance. Without considering this temporal dimension, the session graph falls short of mirroring the dynamic nature of actual user interactions and preferences.
• Sparsity of Sessions: This scarcity of data within individual sessions poses a significant challenge for accurately learning user intent in graph neural networks. The sparsity sessions can lead to incomplete or biased interpretations of user preferences as the graph neural network has limited interaction data to analyze and learn from.
• Flawed Attention Mechanism: Previous works usually use attention mechanisms to learn users’ preferences. However, the existing attention mechanism disproportionately increases the preference weight of the last item visited by the user. This approach can lead to a skewed understanding of user preferences as it assumes the most recent interaction is the most significant for users. Such a mechanism neglects the possibility that earlier items in the session might hold equal or greater relevance to the user’s preferences. Consequently, this results in recommendations that do not accurately reflect the user’s overall preferences, focusing narrowly on their most recent activity.

As a remedy for the shortcomings, we introduce a time-sensitive method for a session-based new item recommendation, called the Time-Sensitive Graph Neural Network (TSGNN). (1) To address the limitation on time sensitivity, we propose an innovative modeling technique for constructing session graphs that incorporates a temporal element. Specifically, we model the session graph according to the sequence of node visits. To fully express the temporal relationship, we apply a time-sensitive weight to each edge. Consequently, GNN-based models are enabled to learn the temporal information of nodes through these edge weights. With this graph modeling technique, the model considers the temporal sequence of item interactions, ensuring that the appearance of each item is taken into account, and reflects user interactions and preferences over time. (2) To tackle the challenge of sparse sessions, we incorporate a graph augmentation technique into the session graph. This technique involves altering the original graphs, allowing the TSGNN to generate a multitude of augmented graphs. This improvement significantly enriches the session data by providing a set of informative graphs for the GNN encoder. This strategy effectively mitigates the impact of graph sparsity, enhancing the overall performance of the model. (3) To provide a comprehensive attention mechanism, we propose a new attention mechanism, called the time-aware attention network. The time-aware attention mechanism emphasizes the temporal aspects’ influence on the user’s preference learning process. By incorporating this approach, the time-aware attention mechanism mitigates the excessive emphasis often placed on the most recently visited item. Instead, this attention network amplifies the temporal impact on attention allocation, ensuring a more accurate and nuanced interpretation of user preferences.

By focusing on the temporal aspect, TSGNN aims to capture more accurate and comprehensive user preferences than previous works, leading to more relevant recommendations. Our work’s enhancements in session-based new items recommendation can be encapsulated in the following key contributions:

• We highlight and address the problem of previous research that ignores the aspect of time influence in session graph modeling. This inclusion of time sensitivity ensures a dynamic representation of user interactions, aligning the model closely with the actual user behavior and preference.
• We incorporate graph augmentation technology into the session-based new item recommendation process. This innovation significantly reduces the sparsity of session graphs, leading to a situation in which the session graph is easily learned by GNNs.
• We propose a novel attention mechanism specifically designed for learning user preference with a time-aware perspective. This method adjusts the focus of the attention mechanism, ensuring that it accounts for the temporal aspects of user interactions. By doing so, a more accurate understanding of user preferences over time reduces the overemphasis on the most recent interactions, which has been a drawback of previous models.

The structure of this paper is outlined as follows: Section 2 presents the related work relevant to our study. In Section 3, we detail our method, TSGNN, highlighting several innovative techniques, including the time-sensitive weight method, session graph augmentation, and time-aware attention networks. Section 4 describes a series of experiments conducted to validate the efficacy of our proposed methods. Finally, in Section 5, we conclude this paper and offer directions for future research.

2. Related Works

In this section, we will explore the related works in the field of session-based recommendation systems, with a particular focus on session-based recommendation, GNNs for session-based recommendation, and graph augmentation methods.

2.1. Session-Based Recommendation

Session-based recommender systems are designed to provide personalized suggestions to users during a single session [25]. Unlike traditional recommender systems that rely heavily on long-term user profiles and historical data, the session-based recommender system focuses on the short-term, often within the context of a single interaction or visit [26]. Some works use the Markov Chain for session-based recommendation to predict user preferences and actions within a specific session [27]. According to the memoryless property, Markov Chains predict the future state of a recommender system based on its previous state [28]. Each state in a Markov Chain represents a specific user interaction, such as viewing a product or clicking on a link. The transitions between these states, governed by a set of probabilities, reflect the likelihood of a user moving from one action to another. By analyzing these transitions and states, the Markov-Chain-based recommender system can predict a user’s next likely action within a session. User interactions are captured sequentially and temporally using this approach. However, it does face challenges, notably the potential limitation in capturing long-term user preferences since it focuses primarily on short-term session data.

Recently, some researchers have designed recurrent neural network (RNN)-based methods for session-based recommender systems to understand and predict user preferences based on their current sessions [29]. In these systems, RNNs, known for their effectiveness in handling sequential data, are utilized to analyze the sequence of actions a user takes during a session, such as clicking on items, viewing pages, or adding products to a cart [30]. As users interact with various items during a session, the RNN-based model continuously updates its understanding of the user’s current interests. This is achieved through the network’s ability to maintain a form of memory, which helps in capturing the temporal dynamics of user behavior within a session. The model processes each action in the sequence, updating its internal state to reflect the latest interactions, thus providing real-time, dynamic recommendations that evolve as the session progresses [31].

However, despite their effectiveness, these systems also face challenges, such as handling the complexity of RNN-based models and ensuring they are efficient enough to provide real-time recommendations. Moreover, the system’s dependency on session data means that it might not perform as well when dealing with new or infrequent users with limited interaction history.

2.2. Graph Neural Networks for Session-Based Recommendation

Graphs are an important data structure [32,33,34,35], and GNNs are a type of method for solving graph problems that has attracted much attention recently [36,37]. Their applications span a wide range of fields, including federated learning [38], information security [39,40,41], anomaly detection [42,43,44], and the financial sector [45]. Owing to the capability of GNNs to model complex relationship nodes [46], GNN session-based recommender systems have recently become popular [47]. In these systems, GNNs are used to model session data as a graph structure. In this representation, nodes represent items, and edges signify the interactions between users and these items. This graph-based method captures complex relationships and dependencies between items within a session [46]. The strength of GNNs lies in their ability to propagate and aggregate information across the graph, effectively learning representations of items based on their context within the user’s session. For instance, if a user browses through a series of related products, the GNN can understand the underlying pattern or theme of the session, leading to more accurate and relevant recommendations.

GNN-based recommender systems require careful design to efficiently handle the complexity of graph structures. For example, SR-GNN [23] combines global preferences and current session interests using an attention network. MGU-GNN [48] integrates a soft-attention network with a target-based interest-aware network. This model is adept at adjusting to the evolving interests of users while effectively balancing long-term preferences and immediate session-based interests. Its soft-attention network module is specifically designed to harmonize these long-term and current session interests, enhancing the accuracy of predictions regarding the user’s next item. BA-GNN [49] presents an application-specific behavioral GNN tailored for session-based recommendation systems. To enhance the quality of these representations, a sparse self-attention module is implemented, designed to filter out noise in behavior sequences. Additionally, a gating mechanism is employed to form comprehensive session representations.

NirGNN [24] proposes a dual-intent network to understand user preference through two key components: analyzing historical data distribution and establishing an attention mechanism. This network aims to mimic the user’s decision-making process when interacting with new items. NirGNN infers the new item embeddings within the GNN embedding space by utilizing item attributes. This method allows for more accurate predictions and recommendations involving new items.

2.3. Graph Augmentation and Contrastive Learning

Graph augmentation refers to modifying and enhancing existing graphs to improve their quality in various graph learning methods. This can involve several techniques and methods, depending on the specific goals and the nature of the graph. Node augmentation and edge augmentation are common methods. Node augmentation generally modifies the attributes of nodes. This might involve updating weights, labels, or other properties based on new data [50]. Edge augmentation introduces new edges or reduces edges between existing nodes to create an augmented graph [51]. These methods involve changing connections between nodes, helping to explore alternative network structures.

To optimize augmented graphs, we introduce contrastive learning. Graph contrastive learning is an advanced machine learning technique used to learn informative representations of graph-structured data [52,53]. Graph contrastive learning is part of contrastive learning methods [54], which focus on learning to differentiate between similar and dissimilar pairs of data points. Graph contrastive learning specifically focuses on generating node embeddings that bring similar nodes closer together in the representation space while distancing dissimilar nodes. This objective is achieved through the development of a contrastive loss function, which serves as the target for optimization by the learning algorithm. Creating variations of input graphs through graph augmentation helps to generate positive pairs for training. In this approach, the graph data are used to capture their intrinsic properties and relationships. Graph contrastive learning methods have diverse applications across various domains, such as social network analysis [55], bioinformatics [53], and recommendation systems [56]. In these applications, they enable the effective learning of graph embeddings that reflect the underlying structure and relationships, which can then be used for tasks such as node classification [57], link prediction [58], and graph classification [59].

3. Method

This section introduces the preliminary concepts for this paper; provides an overview of our model, TSGNN; and illustrates each component of TSGNN.

3.1. Preliminary

A user’s session consists of items they have visited, e.g., $S=\{v_1,v_2,\dots ,v_n\}$. Each $v_i$ represents one item, and n represents how many items there are. There is an order for every two items in a session, which represents the user’s actions. The session can be constructed as a directed graph $G=(V,X,A)$, where $V\in {\mathbb{R}}^n$ denotes a set of nodes, and $X\in {\mathbb{R}}^{n\times d}$ represents the features of nodes with dimension d. A is the adjacent matrix, and $A_{i,j}=(v_i,v_j)$. An edge in a directed graph is the order of items in a session.

The GNN session-based new item recommendation aims to design a GNN-based method for recommending new items to users. Specifically, the GNN-based methods for new item recommendation often learn user preference by using session graphs. As the new items are not directly learnable by GNNs, the GNN session-based methods often introduce external knowledge, such as attribute to create simulated embeddings for these new items.

3.2. Overview

Figure 1 shows the overview of TSGNN. TSGNN obtains input from user sessions. In step (a), a time-sensitive session graph is constructed from the input session. Subsequently, in step (b), the session graph undergoes augmentation through a graph augmentation function, resulting in two augmented graphs. In step (c), the two augmented graphs are fed into two weights-shared GNN encoders, ensuring that all learned embeddings are located within the same space. The encoding process generates representations for both graphs, which are subsequently fed into a time-aware attention mechanism. This network is tailored to comprehend and capture user preferences, taking into account the impact of time on the session graph. In step (d), TSGNN calculates the compatibility scores between user preferences and new items. It then identifies and recommends the most appropriate item for the user based on these scores. A detailed explanation of each component will be presented in the subsequent sections.

3.3. Time-Sensitive Session Graph Construction

Given the limited consideration of the impact of time on session graph modeling in previous research, we reconsider this aspect in session graph construction. A session is a directed sequence, consisting of various items (nodes) and directed edges between items. The order of directed edges represents the time sequence in which these nodes are visited. The strategy utilized by SR-GNN [23] was followed, which involves transforming a session into a directed session graph. If a node is visited multiple times, we do not create new vertices for each visit. Instead, we directly connect the node, which has been visited multiple times, to its subsequent node (or the preceding node). If a node in the graph is visited multiple times, we do not create new vertices for each visit. Instead, we directly connect the node, which has been visited multiple times, to its subsequent node (or the preceding node). There are two adjacency matrices in a directed session graph: one for an incoming adjacency matrix and one for an outgoing adjacency matrix [23]. Suppose we have an edge $A_{ij}$ with nodes $v_i$ and $v_j$, where $v_i$ starts the edge and $v_j$ ends it. The weight of each edge can be defined as:

$$weigh{t}_{ij}=\frac{D_{in}\left(v_i\right)}{D_{out}\left(v_i\right)},$$

(1)

$D_{in}(·)$ calculates the incoming degree of node $v_i$, while $D_{out}(·)$ calculates the outgoing degree of node $v_i$. Building upon the weighting method of SR-GNN, we incorporate a temporal influence by assigning time weights to each edge and constructing a time-sensitive adjacency matrix. Specifically, edges are sorted by their appearance timestamps, and we assign a rank score $\mathcal{S}\left(A_{ij}\right)$ as a weight for the edge $A_{ij}$. Specifically, the $\mathcal{S}(·)$ calculates the order in which the edge $A_{ij}$ appears. For example, the first edge encountered in the session is assigned a weight of 1, the second edge is assigned a weight of 2, and so forth, with the n-th visited edge receiving a weight of n. The item last visited may reflect the user’s preference over the early visited items. By assigning weights in this manner, different edges are given different degrees of importance based on their time of visit. Recently visited edges are given a higher weight. Consequently, the rank score $\mathcal{S}\left(A_{ij}\right)$ effectively captures the temporal influence. The time-sensitive weighting method can be defined as:

$$weigh{t}_{ij}=\frac{D_{in}\left(v_i\right)\ast \mathcal{S}\left(A_{ij}\right)}{D_{out}\left(v_i\right)},$$

(2)

where $\mathcal{S}$ is a ranking method. We provide an example of how to calculate an outgoing time-sensitive adjacency matrix. As illustrated in Figure 2a, considering a session with 5 items, $v_1\to v_2\to v_3\to v_4\to v_1\to v_5$, our objective is to construct it as a time-sensitive session graph (b), achieved by calculating outgoing and incoming adjacency matrices (c). For edge $A_{12}$, the in-degree of $v_1$ is 1, the out-degree of $v_1$ is 2, and the rank of $A_{12}$ is 1. Consequently, the weight assigned to this edge is $0.5$. The calculation of the incoming adjacent matrix is the same.

3.4. Session Graph Augmentation and Embedding

Using the mechanism mentioned above, a time-sensitive session graph can be constructed. To address the issue of the sparsity of session graphs, we adapt two commonly used methods for session graph augmentation, specifically for the time-sensitive graph. Drawing on established methods [51], we implement ‘drop feature’ and ‘drop edge’ techniques. For node features, we employ a random probability, denoted as $R_f$, to selectively drop features [60], e.g., $X=R_f\times X$. Similarly, we apply this random function $R_e$ to the adjacency matrix, such that $A=R_e\times A$. To learn the embedding $h_i$ for the vertex $v_i$, we use a GNN as an encoder, such as the gated graph neural network (GGNN) [61]. In the case of a node $v_i$, the embedding $h_i$ takes the following form [62]:

$$\begin{array}{cc}\hfill h_i^{\left(1\right)}& ={[x_i^T,0]}^{\top }\hfill \\ \hfill a_i^{\left(t\right)}& ={\left[A_{i:}^{In}(h_1^{(t-1)},\dots ,h_n^{(t-1)})\oplus A_{i:}^{Out}(h_1^{(t-1)},\dots ,h_n^{(t-1)})\right]}^{\top }+b,\hfill \\ \hfill z_i^{\left(t\right)}& =\sigma \left(W_z{a}_i^{\left(t\right)}+U_z{h}_i^{(t-1)}\right),\hfill \\ \hfill r_i^{\left(t\right)}& =\sigma \left(W_r{a}_i^{\left(t\right)}+U_r{h}_i^{(t-1)}\right),\hfill \\ \hfill \widetilde{h_i^{\left(t\right)}}& =tanh\left(W_o{a}_i^{\left(t\right)}+U_o\left(r_i^{\left(t\right)}\odot h_i^{(t-1)}\right)\right),\hfill \\ \hfill h_i^{\left(t\right)}& =\left(1-z_i^{\left(t\right)}\right)\odot h_i^{(t-1)}+z_i^{\left(t\right)}\odot \widetilde{h_i^{\left(t\right)}},\hfill \end{array}$$

(3)

where $A_{i:}^{In}$ and $A_{i:}^{Out}$ denote the incoming and outgoing adjacency matrices of the i-th row in the matrix, respectively. The variable t symbolizes the training step, $\sigma (·)$ signifies the sigmoid function, and ⊙ indicates element-wise multiplication. $W_z,W_r,W_o$ and $U_z,U_r,U_o$ are parameters that can be adjusted during the learning process. A GGNN acquires the embeddings of items within a session graph G by propagating information among neighboring nodes.

3.5. Time-Aware Attention Network

This section introduces a temporal attention network for learning user preferences. It has been found that some previous studies overemphasize users’ preferences based on the last item they visited [23], overlooking the influence of timestamps on user preferences. To address this limitation, we introduce a time-aware attention network to learn user preferences under the time influence. Given that each node’s representation includes temporal information, we utilize the cosine similarity between $h_i$ and $h_j$ to assess the time influence of $h_j$ on $h_i$. By splicing the similarity of the current nodes and other nodes, the preferences of users can be tracked over time. By concatenating these time influences from other nodes, node $h_i$ embodies the information from other items, implicitly reflecting user preferences. The significance of each node is then determined using the attention mechanism. Thus, the overall time-aware attention $\alpha$ is as follows:

$$\alpha =\sigma (W\ast (h_i\oplus \sum _{j\in V\backslash i}\mathtt{cos}(h_i,h_j)h_i)),$$

(4)

where W represents the learnable weights of item embedding vectors, and $cos(·)$ is the cosine similarity function. User preference I influenced by time can be defined as:

$$I=\sum _i^n\alpha \ast h_i.$$

(5)

Time-aware attention networks take into account the temporal order of items, recognizing that the items in which users are viewed are crucial to learning preferences.

3.6. Optimization

After learning the users preference, we employ the following function to compute the recommendation score [24]:

$$\widehat{z_i}=\mathrm{softmax}(I^{\top }\ast c_i),$$

(6)

where $c_i$ is the candidate new item embedding.

To optimize the entire model effectively, we integrate a variety of loss functions for the overall loss. Particularly, since we have added graph augmentation in the model, we employ the InfoNCE loss as a foundational component for model optimization. The InfoNCE loss is formulated as follows [63]:

$${\mathcal{L}}_{\mathrm{InfoNCE}}=-log\frac{exp\left(\cos (h_i,h_i^{+})\right)}{exp\left(\cos (h_i,h_i^{+})\right)+{\sum }_{h_j^{-}}exp\left(\cos (h_i,h_j^{-})\right)}.$$

(7)

Here, $cos(h_i,h_j)$ denotes the similarity between nodes $h_i$ and $h_j$, $h_i^{+}$ is a corresponding node in the augmented graph for $h_i$, and $h_j^{-}$ represents non-corresponding nodes. The essence of this loss is to pull corresponding nodes (those that are augmented versions of the same node) closer together and push non-corresponding nodes apart in the embedding space. Following the augmented method described in Section 3.4, we obtain two augmented graphs $G_1$ and $G_2$. In $G_1$, we select node $h_i$ as the anchor node and $h_j$ as the corresponding node in $G_2$. In both graphs $G_1$ and $G_2$, the node $h_j$ is treated as a positive sample of $h_i$ whereas the other nodes (e.g., $h_k$) are treated as negative samples [60]. Building on this, we can express our contrastive loss function as follows:

$$L_c(h_i,h_j,h_k)=-log\frac{exp(\cos (h_i,h_j)/\tau )}{exp(\cos (h_i,h_j)/\tau )+{\sum }_{k=1}^{N}exp(\cos (h_i,h_k)/\tau )},$$

(8)

where $exp(·)$ represents a exponential function and $\tau$ represents a temperature coefficient. This loss optimizes the graph encoder by making the corresponding nodes more similar and non-corresponding nodes more dissimilar.

In addition, we incorporate two essential loss functions in the recommendation system, including a cross-entropy loss $L_{ce}$ to optimize the recommendation process, and a new item learning loss $L_t=\theta (h_i,c_i)$ to learn new items embeddings. $\theta (·)$ is a distance function. As a result, the final loss function can be formulated as follows:

$$L=L_{ce}(z_i,\widehat{z_i})+\gamma L_c(h_i,h_j,h_k)+(1-\gamma )L_t(h_i,c_i),$$

(9)

where $\widehat{z}$ represents the ground truth item embedding, and $\gamma$ is employed to balance the new item embedding learning loss and the contrastive loss for augmented graph learning. Given that $L_{ce}$ is the primary loss for recommendation, we do not assign a trade-off parameter to it.

4. Experiments

In this section, we conduct a comparative analysis of our method, TSGNN, against other SOTA methods and highlight the benefits and enhanced performance of our approach. We execute our method on an NVIDIA GeForce GTX TITAN X 24G GPU. The outcomes of our experiments, along with an ablation study and an analysis of parameter sensitivity, are reported based on trials conducted using general datasets.

4.1. Datasets

We utilize the dataset provided by the NirGNN [24], which includes two datasets: one dataset is Amazon Grocery and Gourmet Food (Amazon G&GF) and the other is Yelpsmall. Both datasets encompass a comprehensive range of information, including items, users, user–item interaction sessions, timestamps, and user reviews. This array of datasets adequately satisfies the requirements for our experimental conditions, offering a rich source of information to analyze user behavior, preferences, and interaction patterns within session-based recommendation frameworks.

Table 1. Description on datasets.

Dataset	Items	Description
Amazon G&GF	18,889	Including user reviews and item-to-item timestamps.
Yelpsmall	14,726	Including user data, interactions, and reviews.

shows the details of datasets. Following the setting of NirGNN, the Amazon G&GF dataset includes a total of 51,958 train sessions and 37,813 test sessions. Meanwhile, the Yelpsmall dataset includes 19,035 train sessions and 2311 test sessions.

4.2. Baselines

We compare our method with seven state-of-the-art methods, including SR-GNN [23], SR-GNN-ATT, GC-SAN [64], GCE-GNN [65], DHCN [66], COTREC [67], and NirGNN [24].

Table 2. Description of baselines.

Baselines	Description
SR-GNN	The first session-based recommendation method based on GNNs.
SR-GNN-ATT	An attention enhanced version of SR-GNN.
GC-SAN	A multi-layer self-attention based method.
GCE-GNN	A position-aware attention based method.
DHCN	A self-supervised based method with hypergraphs.
COTREC	A co-training self-supervised based method.
NirGNN	A GNN model for session-based new item recommendaiton.

shows the details of baselines. SR-GNN, SR-GNN-ATT, GC-SAN, and GCE-GNN are recognized as classic GNN session-based recommendation systems. Most of them use attention mechanisms that ignore the time influence. By comparing our method with these established approaches, we aim to demonstrate the effectiveness and superiority of the time-aware attention mechanism that we have developed. DHCN and COTREC are self-supervised GNN session-based recommender systems. An analysis contrasting our method with these two highlights the advantages of our self-supervised approach. The NirGNN is the GNN-based recommender system for new item recommendation in session scenarios. It is the first GNN-based approach specifically tailored for session-based new item recommendations, which use dual-intent to learn users’ preferences.

Following the previous works, we use $P@k$ and $MRR@k$ to measure our work’s performance. $P@k$ measures the accuracy of the top k items in a list of predictions. It can be defined as [68]:

$$P@k=\frac{p}{k},$$

(10)

where p indicates how many predictions are correct. $MRR@k$ is a metric used to evaluate the average of the reciprocal ranks of the query items in the recommendation list. It can be defined as:

$$MRR@k=\frac{1}{k}\sum _{i=1}^k\frac{1}{q_i},$$

(11)

where $q_i$ is the position in which $v_i$ appears in the recommendation list [68]. Following the previous works, we select $k=\{10,20\}$ as the range in this paper.

4.3. Performance

In

Table 3. Experiments on Amazon G&GF dataset.

Methods	P@20	MRR@20	P@10	MRR@10
SR-GNN	1.438 ± 0.134	0.336 ± 0.025	0.086 ± 0.078	0.297 ± 0.021
SR-GNN-ATT	0.678 ± 0.202	0.157 ± 0.038	0.375 ± 0.144	0.136 ± 0.040
GC-SAN	2.028 ± 0.108	0.580 ± 0.093	1.288 ± 0.059	0.529 ± 0.090
GCE-GNN	1.650 ± 0.291	0.478 ± 0.082	1.053 ± 0.200	0.441 ± 0.076
DHCN	0.403 ± 0.002	0.058 ± 0.001	0.206 ± 0.001	0.047 ± 0.001
COTREC	1.681 ± 0.837	0.434 ± 0.229	1.078 ± 0.583	0.393 ± 0.213
NirGNN	2.420 ± 0.039	0.599 ± 0.017	1.578 ± 0.056	0.543 ± 0.018
TSGNN	2.669 ± 0.013	0.818 ± 0.024	1.938 ± 0.020	0.760 ± 0.031
Improve (%)	10.29%	36.56%	22.81%	39.96%

and

Table 4. Experiments on Yelpsmall dataset.

Methods	P@20	MRR@20	P@10	MRR@10
SR-GNN	0.764 ± 0.534	0.192 ± 0.118	0.476 ± 0.346	0.180 ± 0.111
SR-GNN-ATT	1.631 ± 0.353	0.410 ± 0.089	0.989 ± 0.183	0.366 ± 0.078
GC-SAN	0.793 ± 0.115	0.174 ± 0.094	0.418 ± 0.144	0.165 ± 0.103
GCE-GNN	1.702 ± 0.462	0.789 ± 0.224	1.428 ± 0.563	0.776 ± 0.229
DHCN	0.396 ± 0.021	0.026 ± 0.001	0.000 ± 0.000	0.000 ± 0.000
COTREC	0.833 ± 0.417	0.256 ± 0.199	1.021 ± 0.583	0.269 ± 0.222
NirGNN	1.817 ± 0.087	1.092 ± 0.017	0.779 ± 0.043	0.299 ± 0.049
TSGNN	1.969 ± 0.541	1.097 ± 0.413	0.822 ± 0.043	0.355 ± 0.068
Improve (%)	8.37%	0.46%	-	-

, the experimental results are detailed. The results of baselines come from NirGNN [24]. From the tables, we can find that the NirGNN is the SOTA baseline. The experimental results demonstrate significant enhancements accomplished by the TSGNN method when compared to existing state-of-the-art methods. For instance, in the Amazon G&GF dataset, our method shows a $10.29\%$ improvement at $P@20$ compared with the NirGNN method. At $MRR@20$ metric, TSGNN achieves a $36.56\%$ enhancement. Additionally, at $P@10$, TSGNN outperforms a $22.81\%$ increase compared to NirGNN. Most notably, TSGNN demonstrates a remarkable $39.96\%$ enhancement in $MRR@10$. Furthermore, in the Yelpsmall dataset, TSGNN exhibits an $8.37\%$ improvement on the $P@20$ metric and a $0.46\%$ increase on $MRR@20$. These results demonstrate the superiority of TSGNN. We observed anomalies in DHCN’s performance in $P@10$ and $MRR@10$. This may also be due to the short session of the Yelpsmall data set, which makes it difficult for DHNC to accurately construct the hypergraph, thereby impacting its recommendation invalidly. Although TSGNN performs poorly on the two metrics on Yelpsmall, it performs optimally on other datasets, which proves its effectiveness. In addition, TSGNN failed on the $P@10$ and $MRR@10$ metrics. This underperformance may be due to the fact that sessions in Yelpsmall have a lower average session length ($4.66$) than sessions in Amazon G&GF ($8.39$). Short sessions may limit the learning ability of graph neural networks, resulting in a decline in various evaluation metrics. Therefore, short sessions may not provide sufficient interaction data for the TSGNN to effectively capture complex user preferences.

4.4. Ablation Study

To confirm the effectiveness of each component in our proposed model, we conducted ablation experiments. The outcomes of these experiments are detailed in

Table 5. An ablation study on Amazon G&GF.

DataSets	P@20	MRR@20	P@10	MRR@10
TSGNN	2.669 ± 0.013	0.818 ± 0.024	1.938 ± 0.020	0.760 ± 0.031
TSGNN w/o weight	2.673 ± 0.063	0.762 ± 0.028	1.829 ± 0.101	0.679 ± 0.097
TSGNN w/o $L_c$	2.685 ± 0.109	0.784 ± 0.002	1.920 ± 0.103	0.753 ± 0.011
TSGNN w/o attention	2.508 ± 0.259	0.811 ± 0.076	1.911 ± 0.980	0.760 ± 0.039

and

Table 6. An ablation study on Yelpsmall.

DataSets	P@20	MRR@20	P@10	MRR@10
TSGNN	1.969 ± 0.541	1.097 ± 0.413	0.822 ± 0.043	0.355 ± 0.068
TSGNN w/o weight	1.731 ± 0.606	1.010 ± 0.277	0.736 ± 0.923	0.186 ± 0.343
TSGNN w/o $L_c$	1.644 ± 0.476	1.077 ± 0.133	1.010 ± 0.447	0.340 ± 0.148
TSGNN w/o attention	1.774 ± 0.346	0.970 ± 0.064	0.736 ± 0.476	0.343 ± 0.031

. TSGNN represents the complete time-sensitive graph neural network. ‘TSGNN w/o weight’ refers to a TSGNN version that replaces the time-sensitive session graph construction with ordinary modeling methods. ‘TSGNN w/o attention’ denotes the TSGNN without the time-aware attention mechanism and uses the general soft-attention mechanism. ‘TSGNN w/o $L_c$’ indicates the TSGNN without graph augmentation and the optimal loss. The results presented in both tables clearly illustrate that each component plays a vital role in enhancing the overall performance of the TSGNN. In Table 5, TSGNN achieves optimal effectiveness when all components are integrated. The ‘TSGNN w/o weight’ method results in a general decline in TSGNN’s performance, underscoring the significance of the temporal weighting modeling approach for this model. Likewise, graph augmentation and contrastive loss hold substantial significance. However, TSGNN’s performance on $P@20$ is lower than that of TSGNN w/o weight. This indicates that while graph augmentation can enhance the richness of graph data, it might also disrupt inherent structures on session graphs. Such an alteration in the graph’s structure could lead to a degradation in the model’s ability to accurately capture and represent the underlying patterns. Eliminating the contrastive loss and graph augmentation results in a decline across all metrics, indicating that this loss component effectively enhances the model’s learning capabilities. ‘TSGNN w/o attention’ leads to a significant decrease in its performance, thereby validating the importance of the attention method. In Table 6, although TSGNN does not secure the top position in the $P@10$ metric, it attains the second-best performance. By comparing with the model without other key components, TSGNN still has advantages, proving that integrating each component into the model is beneficial.

4.5. Parameter Sensitivity Analysis

4.5.1. Analysis for Random Parameters $R_f$ and $R_e$

We conduct sensitivity analysis for the two parameters $R_f$ and $R_e$ on the Amazon G&GF and Yelpsmall datasets, respectively. The results of this analysis are depicted in Figure 3 and Figure 4. In the Amazon G&GF dataset, we observe a correlation between increasing values of $R_f$ and improved model performance. As $R_f$ rises, indicating a gradual reduction in features, the effect of the model becomes better. This suggests that the performance of the model is increasingly dependent on the graph structure. Compared to node features, the structural composition of the data plays an effective role in learning user preferences. For $R_e$, we observe that the influence of varying $R_e$ values on the model’s performance is inconsistent. As $R_e$ increases, there is a noticeable improvement in the model’s effectiveness, reaching its zenith at a value of $0.3$. However, as $R_e$ continues to rise, the model’s performance starts to fluctuate and deteriorate. This trend indicates that an appropriate $R_e$ value can enhance the model’s performance, but exceeding this optimal point leads to diminishing returns. In the Yelpsmall dataset, both $R_f$ and $R_e$ show optimal performance at a value of $0.5$. Different from $R_f$ in Amazon G&GF, as $R_f$ increases, the performance of the model initially increases but then starts to decline, peaking at $0.5$. This shows that for the Yelpsmall data set, the features are as important as the structure. A certain $R_f$ will promote the improvement of the model effect.

4.5.2. Analysis for Loss Parameter $\gamma$

To determine the contribution of each loss, we analyze the parameters of each loss. Figure 5 illustrates the results. Figure 5a reveals that as the $\gamma$ parameter increases, there is a general upward trend in performance, highlighting the efficacy of our augmented method. However, in Figure 5b, we observed fluctuating behavior in the model’s performance. Such fluctuation suggests that the impact of loss proportions on the model is not uniform, indicating a more intricate interplay between the loss parameters and the model’s overall performance.

4.5.3. Analysis for Learning Rate Parameters

We show the learning rate (lr) sensitivity analysis experiment in Figure 6. In the Amazon G&GF dataset, we experiment with various learning rates, including {0.05, 0.01, 0.005, 0.001, and 0.0005}. As illustrated in Figure 6a, the model demonstrates optimal performance at a learning rate of $0.005$. The effectiveness of TSGNN is reduced when the learning rate is too high, such as $0.05$, or too low, such as $0.0005$. As shown in Figure 6b, the model demonstrates its best performance in the Yelpsmall dataset at a learning rate of $0.001$. This variation indicates that different datasets require different learning rates for optimal results, and it is essential to tailor the learning rate to the specific requirements of each dataset.

5. Conclusions

In this paper, we provide a time-sensitive graph neural network (TSGNN) specifically designed for session-based new item recommendations. By applying time-sensitive weights to each edge, TSGNN constructs time-sensitive session graphs, which solves the problem of ignoring user preference learning over time. The ablation experiments demonstrate that the time-sensitive session graph construction method outperforms the approach that does not incorporate time-sensitive weights. TSGNN incorporates graph augmentation technology and contrastive learning into its training process, effectively reducing the limitations on graph sparsity. Moreover, TSGNN adopts a novel strategy to mitigate the influence of the last visited item on user preferences by time-aware attention. This ensures a balanced assessment of each item’s impact on user preference. The results from the ablation study affirm that the time-sensitive attention network substantially enhances the model’s effectiveness. By integrating these three proposed methods, TSGNN surpasses existing SOTA models in a series of experiments, achieving an impressive enhancement of $36.56\%$. In the future, we aim to extend the application of time-sensitive methods across various recommendation fields and implement our proposed techniques in real-world scenarios.