TempGNN: Temporal Graph Neural Networks for Dynamic Session-Based Recommendations

Each unique item is mapped onto a trainable vector $i\in\mathbb{R}^{d}$ in $I$. We apply $L_{2}$ normalization to each embedding during training and inference to reduce the effect of the popularity of items on the model because items with a high frequency during training have a high $L_{2}$ norm, whereas less popular items do not. There are detailed descriptions and experiments in (Gupta et al., 2019). Therefore, our model uses normalized item embedding as

We define temporal embedding for nodes (TN) as a feature of the difference between the prediction timing and click timestamp of each item in a session. This includes information on how much time information should be utilized in predictions, taking into consideration how long ago the interaction was.

Specifically, we first bucketize the time difference. This is a prerequisite for utilizing continuous temporal information, which is difficult to learn. If there are too few buckets, utilizing temporal information has little effect, whereas if the number of buckets is too high, there is a waste of memory with no performance boost. After preparing the appropriate number of buckets, we use a quantile function for the time differences to ensure that each bucket has the same amount of information. This is, of course, performed using the training data. Therefore, the time differences that are not observed during the training process belong to one of the buckets at both ends. After each TN is normalized, it passes through a leaky ReLU function for nonlinearity and a linear layer. In summary, we formulate the $j$-th TN of a session as

where $W\in\mathbb{R}^{d\times d}$ and $b\in\mathbb{R}^{d}$ are learnable parameters, $\sigma^{lr}$ is a leaky ReLU function, $normalize$ means $L_{2}$ normalization, $bucketize^{TN}$ is a function used to obtain a specific bucket index of $TN$, and $TN[]$ is a lookup function that takes one embedding vector corresponding to the index.

The nodes used in our GNN reflect the time information to items. Conventional models have used the addition of two embedding vectors as a combination method. The problem with this is that the same temporal information is reflected if the time buckets are the same, regardless of the type of item. However, the relationship between an item and time is more complex. In reality, the degree of sensitivity to time differs depending on the item, even if the temporal embedding is the same. To capture this complex relationship between an item and time, we propose a novel method for controlling the degree of reflection through a gate network when the two embeddings are aggregated, where the weight is calculated by considering the relationship as

where $\odot$ is an element-wise multiplication, $\sigma^{s}$ is a sigmoid function, $\left[;\right]$ denotes a concatenation, and $W\in\mathbb{R}^{d\times 2d}$ and $b\in\mathbb{R}^{d}$ are trainable parameters.

Our model exchanges information with neighboring nodes by considering their time intervals. This temporal information is very important when exchanging information they have. For example, a time difference between two nodes that is too long might mean they are not adjacent. In addition, a time interval that is too short could mean a miss click within a session. Therefore, we add temporal embedding for edges (TE) to consider temporal information during propagation between adjacent nodes.

We take the timestamp differences of interactions within a session in two directions: incoming and outgoing, and then feature them in the same way as TN in 4.1.2. The formula is

where $j\in\left\{1,2,...,\left|S\right|-1\right\}$.

A star node is a virtual node connected to all nodes in a graph with bidirectional edges. Non-adjacent nodes can also propagate information using the star node as an intermediate node (Pan et al., 2020a). At the same time, it has information that integrates the graph. It is updated like other nodes and initialized to the average value of all nodes in the graph as

where $v_{s}$ denotes the star node and $\left|V\right|$ is the number of nodes in the graph.

GNNs typically go through step message passing and neighbor aggregation in order to update a node (Li et al., 2015; Wu et al., 2020; Niepert et al., 2016). Unlike previous GNN-based methods, we designed this exchange of information by considering time intervals between nodes in the message passing phase. Subsequently, a GGNN is applied as a method for updating node information (Li et al., 2015; Wu et al., 2019).

Message passing and aggregation proceed in both directions for incoming and outgoing edges. Among them, we obtain an aggregated message for the $j$-th node from the neighbors through the incoming edges as

where $W^{I}\in\mathbb{R}^{d\times d}$ and $b^{I}$ are trainable parameters for incoming message passing, $N_{j}^{I}$ is the set of incoming neighbors for the $j$-th node, $e_{ij}\in E$ denotes the temporal embedding of the edge from $v_{i}$ to $v_{j}$, $W\in\mathbb{R}^{d\times 3d}$ and $b$ are learnable parameters, and the gate $g_{ij}$ considers the characteristics of the two nodes and the time interval between them (i.e., an incoming edge) in order to adjust the transmitted information. The formula for outgoing message passing is similar to Equation 6 as

where $W^{O}\in\mathbb{R}^{d\times d}$ and $b^{O}$ are trainable parameters and $N_{j}^{O}$ is the set of outgoing neighbors for the $j$-th node. Then, both directional messages are concatenated to update the node as

Updating nodes proceeds by applying the aggregated message vector and star node. First, the message updates the previous information of a node with a gate as

where $W_{z},W_{r},W_{h}\in\mathbb{R}^{d\times 2d}$, $U_{z},U_{r},U_{h}\in\mathbb{R}^{d\times d}$, and $b_{z},b_{r},b_{h}$ are learnable parameters, $l$ denotes the $l$-th layer of the GNN, and $\sigma^{t}$ is a hyperbolic tangent function. After the propagation of adjacent nodes, the star node is reflected in the update, which considers the overall information in the graph. A gate network helps how much information from the previous star node should be propagated as

where $v_{s}^{l-1}$ is the star node of the previous layer in the GNN and $\sqrt{d}$ denotes a scaling factor. A non-parametric mechanism is applied for efficient learning unlike SGNN-HN (Pan et al., 2020a). Then, the star node is also updated for continuous graph learning using a non-parametric attention mechanism (i.e., a scaled dot product) as

where $\left|V\right|$ is the number of nodes in a graph and $\left[v_{1}^{l},v_{2}^{l},...,v_{\left|V\right|}^{l}\right]\in\mathbb{R}^{\left|V\right|\times d}$ denotes a matrix that includes all nodes in the graph.

This propagation proceeds iteratively with $L$ layers through adjacent and intermediate nodes, which consist of shared parameters. This allows the model to obtain more distant information over multiple propagations. However, the individuality of each node can be diluted if it is excessive. Thus, a highway gate (Pan et al., 2020a) is applied to take advantage of both as

where $v^{f}$ denotes the final node after the highway gate, $v^{L}$ and $v^{0}$ are the node after the propagation of the $L$-th layer and initial node, respectively, and $W\in\mathbb{R}^{d\times 2d}$ and $b$ are trainable parameters.

Nodes that have completed all propagations are transformed back to a session format as

where $\left|S\right|=\left|U\right|$ is the length of the session and $u_{j}\in\left\{v_{1}^{f},v_{2}^{f},...,v_{\left|V\right|}^{f}\right\}$ denotes a node arranged in the original order of the sequence. A representation is obtained by reflecting all nodes in different proportions determined by a soft attention mechanism considering the last and overall information (i.e., a star node) as

where $w_{0}\in\mathbb{R}^{d}$, $W_{1},W_{2},W_{3}\in\mathbb{R}^{d\times d}$, and $b$ are learnable parameters, $u_{\left|S\right|}$ is the last node, and $v_{s}^{L}$ is the star node after $L$ layers. Because the last node could be a decisive clue for estimating a user’s next interaction, a preference vector is formulated as

where $W\in\mathbb{R}^{d\times 2d}$ and $b$ are trainable parameters.

We obtain the normalized probabilities for the next click by measuring the similarities between the preference and all candidate items. To solve the long-tail problem of a recommendation (Gupta et al., 2019), cosine similarity is applied as

where $i_{j}\in I$ is the $j$-th item embedding and $\tilde{y}[j]$, an element of the vector $\tilde{y}\in\mathbb{R}^{\left|I\right|}$, denotes the similarity between the $j$-th item and a user preference. Then, the similarity vector is normalized by a scaled softmax function, which addresses the convergence problem (Gupta et al., 2019; Pan et al., 2020a) as

where $\tau$ is a scaling factor, $\left|I\right|$ is the number of candidate items, and $\hat{y}[j]$ denotes the probability that the next click of a user is the $j$-th candidate item. Then, the items with the highest top-K probabilities in $\hat{y}\in\mathbb{R}^{\left|I\right|}$ are recommended.

We adopt a cross-entropy loss function as an objective function for the probabilities. Our model is trained by minimizing the loss, which is formulated as

where $y[j]\in\left\{0,1\right\}$ is a target that indicates whether the next click is the $j$-th item or not. In other words, $y\in\mathbb{R}^{\left|I\right|}$ is a one-hot vector corresponding to the candidate items.

• •

  Yoochoose was released by RecSys Challenge 2015¹¹1https://recsys.acm.org/recsys15/challenge/, and contains click streams from an e-commerce website from 6 months.

• •

  Diginetica was used as a challenge dataset for CIKM Cup 2016²²2https://competitions.codalab.org/competitions/11161. We only adopt the transaction data.

Our preprocessing of these datasets followed previous studies (Wu et al., 2019; Gupta et al., 2019; Pan et al., 2020a) for fairness. We filtered out sessions with only one item and items that occurred fewer than five times. The sessions were split for training and testing, where the last day of Yoochoose and the last week of Diginetica were used for testing. Items that were not included in the training set were excluded from the testing set. Finally, we split the sessions into several sub-sequences. Specifically, for a session $S=[x_{1},\allowbreak x_{2},\allowbreak...,\allowbreak x_{\left|S\right|}]$, where $x_{j}=\allowbreak(item,timestamp)$ denotes a pair of items and timestamps, we generated sub-sequences and the corresponding next interaction as $\{[x_{1}],x_{2}\},\allowbreak\{[x_{1},x_{2}],\allowbreak x_{3}\},...,\allowbreak\{[x_{1},x_{2},...,x_{\left|S\right|-1}],x_{\left|S\right|}\}$ for the training and testing sets. As Yoochoose is too large, we only utilized the recent 1/64 and 1/4 fractions of the training set, which are denoted as Yoochoose 1/64 and Yoochoose 1/4, respectively. Statistics for the three datasets are shown in Table 1.

• •

  GRU4Rec (Hidasi et al., 2015) applied gated recurrent units (GRUs) to model sequential information in an SBR.

• •

  CSRM (Wang et al., 2019) employed GRUs to model sequential behavior with an attention mechanism and utilized neighbor sessions as auxiliary information.

• •

  STAMP (Liu et al., 2018) applied an attention mechanism to obtain the general preference.

• •

  SR-IEM (Pan et al., 2020b) utilized a modified self-attention mechanism to estimate item importance and recommended the next item based on the global preference and current interest.

• •

  SR-GNN (Wu et al., 2019) adopted GGNNs to obtain item embeddings and recommended by generating a session representation with an attention mechanism.

• •

  NISER+ (Gupta et al., 2019) extended SR-GNN by introducing $L_{2}$ normalization, positional embedding, and dropout.

• •

  SGNN-HN (Pan et al., 2020a) extended SR-GNN by introducing a highway gate to avoid overfitting and a star node, which is a virtual node connected with all nodes.

Following previous studies (Wu et al., 2019; Gupta et al., 2019; Pan et al., 2020a), we used the same evaluation metrics R@K (recall) and M@K (mean reciprocal rank), where K is 20 and 5. R@K represents the proportion of test instances that have the target items in the top-K recommended items. M@K is the average of the reciprocal ranks of the target items in the recommendation list.

We used the recent 10 items in a session to ensure fairness across all models. An Adam optimizer was adopted, where the initial learning rate is 0.001 with a decay factor of 0.1 for every 3 epochs, $\beta_{1}\!=\!0.9$, and $\beta_{2}\!=\!0.999$. In addition, the $L_{2}$ regularization rate was set to $1e^{-5}$. The batch size was 100. All trainable parameters were initialized using a uniform distribution with a range of $\left[\frac{-1}{\sqrt{d}},\frac{1}{\sqrt{d}}\right]$ according to the dimension of each model. For our model, the dimension of the embeddings $d$ was set to 256, the scaling factor $\tau$ was 12, and the number of layers $L$ was 6. The numbers of buckets of TN and TE were 40 and 50, respectively. For the other settings of the baselines, we referred to the corresponding paper and official code.