SSE-PT: SEQUENTIAL RECOMMENDATION VIA PERSONALIZED TRANSFORMER
Year: 2019

Abstract:
Temporal information is crucial for recommendation problems because user preferences are naturally dynamic in the real world. Recent advances in deep learning, especially the discovery of various attention mechanisms and newer architectures in addition to widely used RNN and CNN in natural language processing, have allowed for better use of the temporal ordering of items that each user has engaged with. In particular, the SASRec model, inspired by the popular Transformer model in natural languages processing, has achieved state-of-the-art results. However, SASRec, just like the original Transformer model, is inherently an un-personalized model and does not include personalized user embeddings. To overcome this limitation, we propose a Personalized Transformer (SSE-PT) model, outperforming SASRec by almost 5% in terms of NDCG@10 on 5 real-world datasets. Furthermore, after examining some random users’ engagement history, we find our model not only more interpretable but also able to focus on recent engagement patterns for each user. Moreover, our SSE-PT model with a slight modification, which we call SSE-PT++, can handle extremely long sequences and outperform SASRec in ranking results with comparable training speed, striking a balance between performance and speed requirements. Our novel application of the Stochastic Shared Embeddings (SSE) regularization is essential to the success of personalization. Code and data are open-sourced at https://github.com/SSE-PT/SSE-PT.

heading: 1 INTRODUCTION
text: The sequential recommendation problem has been an important open research question, yet using temporal information to improve recommendation performance has proven to be challenging. SASRec, proposed by (Kang and McAuley, 2018) for sequential recommendation problems, has achieved stateof-the-art results and enjoyed more than 10x speed-up when compared to earlier CNN/RNN-based methods. However, the model used in SASRec is the standard Transformer which is inherently an un-personalized model. In practice, it is important to include a personalized Transformer in SASRec especially for recommender systems, but (Kang and McAuley, 2018) found that adding additional personalized embeddings did not improve the performance of their Transformer model, and postulate that the failure of adding personalization is due to the fact that they already use the user history and the user embeddings only contribute to overfitting. In this work, we propose a novel method, Personalized Transformer (SSE-PT), that successfully introduces personalization into self-attentive neural network architectures.
Introducing user embeddings into the standard transformer model is intrinsically difficult with existing regularization techniques, as unavoidably a large number of user parameters are introduced, which is often at the same scale of the number of training data. But we show that personalization can greatly improve ranking performance with a recent regularization technique called Stochastic Shared Embeddings (SSE) (Wu et al., 2019). The personalized Transformer (SSE-PT) model with SSE regularization works well for all 5 real-world datasets we consider without overfitting, outperforming previous state-of-the-art algorithm SASRec by almost 5% in terms of NDCG@10. Furthermore, after examining some random users’ engagement history, we find our model is not only more interpretable but also able to focus on recent engagement patterns for each user. Moreover, our SSE-PT model with a slight modification, which we call SSE-PT++, can handle extremely long sequences and outperform SASRec in ranking results with comparable training speed, striking a balance between performance and speed requirements.

heading: 2 RELATED WORK

heading: 2.1 SESSION-BASED AND SEQUENTIAL RECOMMENDATION
text: Both session-based and sequential (i.e., next-basket) recommendation algorithms take advantage of additional temporal information to make better personalized recommendations. The main difference between session-based recommendations (Hidasi et al., 2015) and sequential recommendations (Kang and McAuley, 2018) is that the former assumes that the user ids are not recorded and therefore the length of engagement sequences are relatively short. Therefore, session-based recommendations normally do not consider user factors. On the other hand, sequential recommendation treats each sequence as a user’s engagement history (Kang and McAuley, 2018). Both settings, do not explicitly require time-stamps: only the relative temporal orderings are assumed known (in contrast to, for example, timeSVD++ (Koren, 2009) using time-stamps). Initially, sequence data in temporal order are usually modelled with Markov models, in which a future observation is conditioned on the last few observed items (Rendle et al., 2010). In (Rendle et al., 2010), a personalized Markov model with user latent factors is proposed for more personalized results.
In recent years, deep learning techniques, borrowed from natural language processing (NLP) literature, are getting widely used in tackling sequential data. Like word sentences in NLP, item sequences in recommendations can be similarly modelled by recurrent neural networks (RNN) (Hidasi et al., 2015; Hidasi and Karatzoglou, 2018) and convolutional neural network (CNN) (Tang and Wang, 2018) models. Recently, attention models are increasingly used in both NLP (Vaswani et al., 2017; Devlin et al., 2018) and recommender systems (Liu et al., 2018; Kang and McAuley, 2018). SASRec (Kang and McAuley, 2018) is a recent method with state-of-the-art performance among the many deep learning models. Motivated by the Transformer model in neural machine translation (Vaswani et al., 2017), SASRec utilizes a similar architecture to the encoder part of the Transformer model. Our proposed model, SSE-PT, is a personalized extension of the transformer model.

heading: 2.2 REGULARIZATION TECHNIQUES
text: In deep learning, models with many more parameters than data points can easily overfit to the training data. This may prevent us from adding user embeddings as additional parameters into complicated models like the Transformer model (Kang and McAuley, 2018), which can easily have 20 layers with millions of parameters for a medium-sized dataset like Movielens10M (Harper and Konstan, 2016). `2 regularization (Hoerl and Kennard, 1970) is the most widely used approach and has been used in many matrix factorization models in recommender systems; `1 regularization (Tibshirani, 1996) is used when a sparse model is preferred. For deep neural networks, it has been shown that `p regularizations are often too weak, while dropout (Hinton et al., 2012; Srivastava et al., 2014) is more effective in practice. There are many other regularization techniques, including parameter sharing (Goodfellow et al., 2016), max-norm regularization (Srebro et al., 2005), gradient clipping (Pascanu et al., 2013), etc. Very recently, a new regularization technique called Stochastic Shared Embeddings (SSE) (Wu et al., 2019) is proposed as a new means of regularizing embedding layers. We find that the base version SSE-SE is essential to the success of our Personalized Transformer (SSE-PT) model.

heading: 3 METHODOLOGY

heading: 3.1 SEQUENTIAL RECOMMENDATION
text: Given n users and each user engaging with a subset of m items in a temporal order, the goal of sequential recommendation is to learn a good personalized ranking of top K items out of total m items for any given user at any given time point. We assume data in the format of n item sequences:
si = (ji1, ji2, . . . , jiT ) for 1 ≤ i ≤ n. (1) Sequences si of length T contain indices of the last T items that user i has interacted with in the temporal order (from old to new). For different users, the sequence lengths can vary, but we can pad the shorter sequences so all of them have length T . We cannot simply randomly split data points into train/validation/test sets because they come in temporal orders. Instead, we need to make sure our training data is before validation data which is before test data temporally. We use last items in sequences as test sets, second-to-last items as validation sets and the rest as training sets. We
use ranking metrics such as NDCG@K and Recall@K for evaluations, which are defined in the Appendix.

heading: 3.2 PERSONALIZED TRANSFORMER ARCHITECTURE
text: Our model, which we call SSE-PT, is motivated by the Transformer model in (Vaswani et al., 2017) and (Kang and McAuley, 2018). It also utilizes a new regularization technique called stochastic shared embeddings (Wu et al., 2019). In the following sections, we are going to examine each important component of our Personalized Transformer (SSE-PT) model, especially the embedding layer, and the novel application of stochastic shared embeddings (SSE) regularization technique.
Embedding Layer We define a learnable user embedding look-up table U ∈ Rn×du and item embedding look-up table V ∈ Rm×di , where du, di are the number of hidden units for user and item respectively. We also specify learnable positional encoding table P ∈ RT×d, where d = du + di. So each input sequence si ∈ RT will be represented by the following embedding:
E =  [vji1 ; ui] + p1 [vji2 ; ui] + p2
... [vjiT ; ui] + pT  ∈ RT×d, (2) where [vjit ;ui] represents concatenating item embedding vjit ∈ Rdi and user embedding ui ∈ Rdu into embedding Et ∈ Rd for time t. Note that the main difference between our model and (Kang and McAuley, 2018) is that we introduce the user embeddings ui, making our model personalized.
Transformer Encoder On top of the embedding layer, we have B blocks of self-attention layers and fully connected layers, where each layer extracts features for each time step based on the previous layer’s outputs. Since this part is identical to the Transformer encoder used in the original papers (Vaswani et al., 2017; Kang and McAuley, 2018), we will skip the details.
Prediction Layer At time t, the predicted probability of user i engaged item l is: pitl = σ(ritl), (3)
where σ is the sigmoid function and ritl is the predicted score of item l by user l at time point t, defined as:
ritl = F B t−1 · [vl; ui], (4)
where FBt−1 is the output hidden units associated with the transformer encoder at the last timestamp. Although we can use another set of user and item embedding look-up tables for the ui and vl, we
find it better to use the same set of embedding look-up tables U, V as in the embedding layer. But regularization for those embeddings can be different. To distinguish the ui and vl in (4) from ui, vj in (2), we call embeddings in (4) output embeddings and those in (2) input embeddings.
The binary cross entropy loss between predicted probability for the positive item l = ji(t+1) and one uniformly sampled negative item k ∈ Ω is given as −[log(pitl) + log(1− pitk)]. Summing over si and t, we obtain the objective function that we want to minimize is:∑
i ∑T−1 t=1 ∑ k∈Ω − [ log(pitl) + log(1− pitk) ] . (5)
At the inference time, top-K recommendations for user i at time t can be made by sorting scores ritl for all items ` and recommending the first K items in the sorted list.
Novel Application of Stochastic Shared Embeddings The most important regularization technique to SSE-PT model is the Stochastic Shared Embeddings (SSE) (Wu et al., 2019). The main idea of SSE is to stochastically replace embeddings with another embedding with some pre-defined probability during SGD, which has the effect of regularizing the embedding layers. Without SSE, all the existing well-known regularization techniques like layer normalization, dropout and weight decay fail and cannot prevent the model from over-fitting badly after introducing user embeddings. (Wu et al., 2019) develops two versions of SSE, SSE-Graph and SSE-SE. In the simplest uniform case, SSE-SE replaces one embedding with another embedding uniformly with probability p, which is called SSE probability in (Wu et al., 2019). Since we don’t have knowledge graphs for user or items, we simply apply the SSE-SE to our SSE-PT model. We find SSE-SE makes possible training this personalized model with O(ndu) additional parameters.
There are 3 different places in our model that SSE-SE can be applied. We can apply SSE-SE to input/output user embeddings, input item embeddings, and output item embeddings with probabilities pu, pi and py respectively. Note that input user embedding and output user embedding are always replaced at the same time with SSE probability pu. Empirically, we find that SSE-SE to user embeddings and output item embeddings always helps, but SSE-SE to input item embeddings is only useful when the average sequence length is large, e.g., more than 100 in Movielens1M and Movielens10M datasets.
Other Regularization Techniques Besides the SSE (Wu et al., 2019), we also utilized other widely used regularization techniques, including layer normalization (Ba et al., 2016), batch normalization (Ioffe and Szegedy, 2015), residual connections (He et al., 2016), weight decay (Krogh and Hertz, 1992), and dropout (Srivastava et al., 2014). Since they are used in the same way in the previous paper (Kang and McAuley, 2018), we omit the details to the Appendix.

heading: 3.3 HANDLING LONG SEQUENCES: SSE-PT++
text: To handle extremely long sequences, a slight modification can be made on the base SSE-PT model in terms of how input sequences si’s are fed into the SSE-PT neural network. We call the enhanced model SSE-PT++ to distinguish it from the previously discussed SSE-PT model, which cannot handle sequences longer than T .
The motivation of SSE-PT++ over SSE-PT comes from: sometimes we want to make use of extremely long sequences, si = (ji1, ji2, . . . , jit) for 1 ≤ i ≤ n, where t > T , but our SSE-PT model can only handle sequences of maximum length of T . The simplest way is to sample starting index 1 ≤ v ≤ t uniformly and use si = (jiv, ji(v+1), . . . , jiz), where z = min(t, v+T − 1). Although sampling the starting index uniformly from [1, t] can accommodate long sequences of length t > T , this does not work well in practice. Uniform sampling does not take into account the importance of recent items in a long sequence. To solve this dilemma, we introduce an additional hyper-parameter ps which we call sampling probability. It implies that with probability ps, we sample the starting index v uniformly from [1, t−T ] and use sequence si = (jiv, ji(v+1), . . . , ji(v+T−1)) as input. With probability 1−ps, we simply use the recent T items (ji(t−T+1), . . . , jit) as input. If the sequence si is already shorter than T , then we always use the recent input sequence for user i.
Our proposed SSE-PT++ model can work almost as well as SSE-PT with a much smaller T . One can see in Table 2 with T = 100, SSE-PT++ can perform almost as well as SSE-PT. The time complexity
of the SSE-PT model is of order O(T 2d+ Td2). Therefore, reducing T by one half would lead to a theoretically 4x speed-up in terms of the training and inference speeds. As to the model’s space complexity, both SSE-PT and SSE-PT++ are of order O(ndu +mdi + Td+ d2).

heading: 4 EXPERIMENTS
text: In this section, we compare our proposed algorithms, Personalized Transformer (SSE-PT) and SSEPT++, with other state-of-the-art algorithms on real-world datasets. We implement our codes in Tensorflow and conduct all our experiments on a server with 40-core Intel Xeon E5-2630 v4 @ 2.20GHz CPU, 256G RAM and Nvidia GTX 1080 GPUs.
Datasets We use 5 datasets. The first 4 have exactly the same train/dev/test splits as in (Kang and McAuley, 2018). The datasets are: Beauty and Games categories from Amazon product review datasets1; Steam dataset introduced in (Kang and McAuley, 2018), which contains reviews crawled from a large video game distribution platform; Movielens1M dataset (Harper and Konstan, 2016), a widely used benchmark datasets containing one million user movie ratings; Movielens10M dataset with ten million user ratings cleaned by us. Detailed dataset statistics are given in Table 4. One can easily see that the first 3 datasets have short sequences (average length < 12) while the last 2 datasets have very long sequences (> 10x longer).
Evaluation Metrics The evaluation metrics we use are standard ranking metrics, namely NDCG and Recall for top recommendations (See Appendix). We follow the same evaluation setting as the previous paper (Kang and McAuley, 2018): predicting ratings at time point t+ 1 given the previous t ratings. For a large dataset with numerous users and items, the evaluation procedure would be slow because (6) would require computing the ranking of all items based on their predicted scores for every single user. As a means of speed-up evaluations, we sample a fixed number C (e.g., 100) of negative candidates while always keeping the positive item that we know the user will engage next. This way, both Rij and Πi will be narrowed down to a small set of item candidates, and prediction scores will only be computed for those items through a single forward pass of the neural network.
Ideally, we want both NDCG and Recall to be as close to 1 as possible, because NDCG@K = 1 means the positive item is always put on the top-1 position of the top-K ranking list, and Recall@K = 1 means the positive item is always contained by the top-K recommendations the model makes.
Baselines We include 5 non-deep-learning and 6 deep-learning algorithms in our comparisons.
1http://jmcauley.ucsd.edu/data/amazon/
Non-deep-learning Baselines The simplest baseline is PopRec, basically ranking items according to their popularity. More advanced methods such as matrix factorization based baselines include Bayesian personalized ranking for implicit feedback (Rendle et al., 2009), namely BPR; Factorized Markov Chains and Personalized Factorized Markov Chains models (Rendle et al., 2010) also known as FMC and PFMC; and translation based method (He et al., 2017) called TransRec.
Deep-learning Baselines Recent years have seen many advances in deep learning for sequential recommendations. GRU4Rec is the first RNN-based method proposed for this problem (Hidasi et al., 2015); GRU4Rec+ (Hidasi and Karatzoglou, 2018) later is proposed to address some shortcomings of the initial version. Caser is the corresponding CNN-based method (Tang and Wang, 2018). STAMP (Liu et al., 2018) utilizes the attention mechanism without using RNN or CNN as building blocks. Very recently, SASRec utilizes state-of-art Transformer encoder (Vaswani et al., 2017) with selfattention mechanisms. Hierarchical gating networks, also known as HGN (Ma et al., 2019) are also proposed to solve this problem.
Experiment Setup We use the same datasets as in (Kang and McAuley, 2018) and follow the same procedure in the paper: use last items for each user as test data, second-to-last as validation data and the rest as training data. We implemented our method in Tensorflow and solve it with Adam Optimizer (Kingma and Ba, 2014) with a learning rate of 0.001, momentum exponential decay rates β1 = 0.9, β2 = 0.98 and a batch size of 128. In Table 1, since we use the same data, the performance of previous methods except STAMP have been reported in (Kang and McAuley, 2018). We tune the dropout rate, and SSE probabilities pu, pi, py for input user/item embeddings and output embeddings on validation sets and report the best NDCG and Recall for top-K recommendations on test sets. For a fair comparison, we restrict all algorithms to use up to 50 hidden units for item embeddings. For the SSE-PT and SASRec models, we use the same number of transformer encoder blocks (i.e. B = 2) and set the maximum length T = 200 for Movielens 1M and 10M dataset and T = 50 for
other datasets. We use top-K with K = 10 and the number of negatives C = 100 in the evaluation procedure. In practice, using a different K and C does not affect our conclusions.
Comparisons One can easily see from Table 1 that our proposed SSE-PT has the best performance over all previous methods on all four datasets. On most datasets, our SSE-PT improves NDCG by more than 4% when compared with SASRec (Kang and McAuley, 2018) and more than 20% when compared to non-deep-learning methods. SSE-SE, together with dropout and weight decay, is the best choice for regularization, which is evident from Table 3. SSE-SE is a more effective way to regularize our neural networks than any existent techniques including parameter sharing, dropout, weight decay. In practice, these SSE probabilities, just like dropout rate, can be treated as tuning parameters and easily tuned. Movielens10M results are left to Table 6 in the Appendix.

heading: 4.1 ATTENTION MECHANISM VISUALIZATION
text: Apart from evaluating our SSE-PT against SASRec using well-defined ranking metrics on realworld datasets, we also visualize the differences between both methods in terms of their attention mechanisms. In Figure 2, a random user’s engagement history in Movielens1M dataset is given in temporal order (column-wise). We hide the last item whose index is 26 in test set and hope that a temporal collaborative ranking model can figure out item-26 is the one this user will watch next using only previous engagement history. One can see for a typical user; they tend to look at a different style of movies at different times. Earlier on, they watched a variety of movies, including Sci-Fi, animation, thriller, romance, horror, action, comedy and adventure. But later on, in the last two columns of Figure 2, drama and thriller are the two types they like to watch most, especially the drama type. In fact, they watched 9 drama movies out of recent 10 movies. For humans, it is natural to reason that the hidden movie should probably also be drama type. So what about the machine’s reasoning?
For our SSE-PT, the hidden item indexed 26 is put in the first place among its top-5 recommendations. Intelligently, the SSE-PT recommends 3 drama movies, 2 thriller movies and mixing them up in positions. Interestingly, the top recommendation is ‘Othello’, which like the recently watched ‘Richard III’, is an adaptation of a Shakespeare play, and this dependence is reflected in the attention
weight. On the contrast, SASRec cannot provide top-5 recommendations that are personalized enough. It recommends a variety of action, Sci-Fi, comedy, horror, and drama movies but none of them match item-26. Although this user has watched all these types of movies in the past, they do not watch these anymore as one can easily tell from his recent history. Unfortunately, SASRec cannot capture this and does not provide personalized recommendations for this user by focusing more on drama and thriller movies. It is easy to see that in contrast, our SSE-PT model shares with human reasoning that more emphasis should be placed on recent movies.
4.2 TRAINING SPEED
In (Kang and McAuley, 2018), it has been shown that SASRec is about 11 times faster than Caser and 17 times faster than GRU4Rec+ and achieves much better NDCG@10 results so we did not include Caser and GRU4Rec+ in our comparisons. In Figure 3, we only compare the training speeds and ranking performances among SASRec, SSEPT and SSE-PT++ for Movielens1M dataset. Given that we added additional user embeddings into our SSE-PT model, it is expected that it will take slightly longer to train our model than un-personalized SASRec. We find empirically that training speed of the SSE-PT and SSEPT++ model are comparable to that of SASRec, with SSEPT++ being the fastest and the best performing model. It is clear that our SSE-PT and SSE-PT++ achieve much better ranking performances than our baseline SASRec using the same training time.

heading: 4.3 ABLATION STUDY
text: SSE probability Given the importance of SSE regularization for our SSE-PT model, we carefully examined the SSE probability for input user embedding in Table 7 in Appendix. We find that the appropriate hyper-parameter SSE probability is not very sensitive: anywhere between 0.4 and 1.0 gives good results, better than parameter sharing and not using SSE-SE. This is also evident based on comparison results in Table 3.
Sampling Probability Recall that the sampling probability is unique to our SSE-PT++ model. We show in Table 8 in Appendix using an appropriate sampling probability like 0.2→ 0.3 would allow it to outperform SSE-PT when the same maximum length is used.
Number of Attention Blocks We find for our SSE-PT model, a larger number of attention blocks is preferred. One can easily see in Table 9 in Appendix, the optimal ranking performances are achieved at B = 4 or 5 for Movielens1M dataset and at B = 6 for Movielens10M dataset.
Personalization and Number of Negatives Sampled Based on the results in Table 10 in Appendix, we are positive that the personalized model always outperforms the un-personalized one when we use the same regularization techniques. This holds true regardless of how many negatives sampled or what ranking metrics are used during evaluation.

heading: 5 CONCLUSION
text: In this paper, we propose a novel neural network architecture called Personalized Transformer for the temporal collaborative ranking problem. It enjoys the benefits of being a personalized model, therefore achieving better ranking results for individual users than the current state-of-the-art. By examining the attention mechanisms during inference, the model is also more interpretable and tends to pay more attention to recent items in long sequences than un-personalized deep learning models.

heading: 6 APPENDIX
text: • NDCG@K: defined as:
NDCG@K = 1
n n∑ i=1 DCG@K(i,Πi) DCG@K(i,Π∗i ) , (6)
where i represents i-th user and
DCG@K(i,Πi) = K∑ l=1 2RiΠil − 1 log2(l + 1) . (7)
In the DCG definition, Πil represents the index of the l-th ranked item for user i in test data based on the learned score matrix X . R is the rating matrix and Rij is the rating given to item j by user i. Π∗i is the ordering provided by the ground truth rating.
• Recall@K: defined as a fraction of positive items retrieved by the top K recommendations the model makes:
Recall@K = ∑n
i=1 1{∃1 ≤ l ≤ K : RiΠil = 1} n , (8)
here we already assume there is only a single positive item that user will engage next and the indicator function 1{∃1 ≤ l ≤ k : RiΠil = 1} is defined to indicate whether the positive item falls into the top K position in our obtained ranked list using scores predicted in (4).
Layer Normalization Layer normalization (Ba et al., 2016) normalizes neurons within a layer. Previous studies (Ba et al., 2016) show it is more effective than batch normalization for training recurrent neural networks (RNNs). One alternative is the batch normalization (Ioffe and Szegedy, 2015) but we find it does not work as well as the layer normalization in practice even for a reasonable large batch size of 128. Therefore, our SSE-PT model adopts layer normalization.
Residual Connections Residual connections are firstly proposed in ResNet for image classification problems (He et al., 2016). Recent research finds that residual connections can help training very deep neural networks even if they are not convolutional neural networks (Vaswani et al., 2017). Using residual connections allows us to train very deep neural networks here. For example, the best performing model for Movielens10M dataset in Table 9 is the SSE-PT with 6 attention blocks, in which 1 + 6 ∗ 3 + 1 = 20 layers are trained end-to-end.
Weight Decay Weight decay (Krogh and Hertz, 1992), also known as l2 regularization (Hoerl and Kennard, 1970), is applied to all embeddings, including both user and item embeddings.
Dropout Dropout (Srivastava et al., 2014) is applied to the embedding layer E, self-attention layer and pointwise feed-forward layer by stochastically dropping some percentage of hidden units to prevent co-adaption of neurons. Dropout has been shown to be an effective way of regularizing deep learning models.
In summary, layer normalization and dropout are used in all layers except prediction layer. Residual connections are used in both self-attention layer and pointwise feed-forward layer. SSE-SE is used in embedding layer and prediction layer.
SQL-Rank (Wu et al., 2018) and item-based recommendations (Sarwar et al., 2001) are omitted because the former is similar to BPR (Rendle et al., 2009) except using the listwise loss function instead of the pairwise loss function and the latter has been shown inferior to TransRec (He et al., 2017).
6.0.1 DEEP-LEARNING BASELINES
• GRU4Rec: the first RNN-based method proposed for the session-based recommendation problem (Hidasi et al., 2015). It utilizes the GRU structures (Chung et al., 2014) initially proposed for speech modelling.
SAMPLING PROBABILITY NDCG@10 RECALL@10
SASREC (T = 100) 0.5769 0.8045 SSE-PT (T = 100) 0.6142 0.8212
1.0 0.5697 0.7977 0.8 0.5735 0.7801 0.6 0.6062 0.8242 0.4 0.6113 0.8273 0.3 0.6186 0.8318 0.2 0.6193 0.8233 0.0 0.6142 0.8212

Review summaries:
In this paper, the authors study an important recommendation problem, i.e., sequential recommendation, and design a novel and improved model called SSE-PT (Stochastic Shared Embedding - Personalized Transformer). Specifically, the authors mainly follow the previous works of the Transformer model and the stochastic shared embedding (SSE) regularization technique. For the part of the personalized transfer (PT), the authors introduce the user embedding for each user $i$, i.e., $u_i$, shown in Eq.(2) and illustrated in Figure 1. For the part of regularization, the authors find that the SSE technique works well in terms of avoid overfiting in context of other regularization techniques.