Continuous-Time User Preference Modelling
for Temporal Sets Prediction

Over the past decades, time series [24, 25] and temporal events [12, 6] have been widely studied in the temporal data mining community. However, as a more complicated type of temporal data, temporal sets have not been fully investigated yet. Formally, temporal sets could be formalized as a sequence of sets, where each set contains an arbitrary number of elements and is associated with a timestamp [1]. In real-world scenarios, temporal sets are ubiquitous and accurately predicting of temporal sets can help people make better decisions in advance [8, 9, 10, 11].

Indeed, the prediction of temporal sets is much more challenging than the predictive modelling of time series and temporal events. The existing methods for temporal sets prediction could be divided into the following two categories. The first category of methods adopted a set embedding phase to denote each set as a vectorized representation, and then fed the sequence of set representations into sequence models to learn the temporal dependencies in user behaviors. For instance, [3] adopted pooling operations to get the fixed-length representation of each basket and leveraged RNNs to learn the dynamic patterns in each customer’s purchasing behaviors. [8] and [13] first obtained each set’s representation by the average pooling or matrix factorization, and then employed RNNs with the attention mechanism to capture the temporal dependencies. The repeated elements in each user’s sequence are also considered. Methods belonging to the second category designed specialized modules to investigate the elements in sets for further improvements. [9] proposed a dual sequential network with the co-transformer architecture to compute both set-level and element-level representations of each user’s sequence. [10] first learned the relationships of elements within each set based on the constructed set-level co-occurrence graphs, and then extended the attention mechanism and the gating mechanism to mine the temporal dependencies and shared patterns among elements. [11] pointed out the necessity of leveraging the collaborative signals for temporal sets prediction and learned element-specific representations for each user on the constructed temporal graph with the usage of temporal information.

Existing methods for temporal sets prediction implicitly capture the user preference according to the interacted elements and thus fail to capture the continuous evolutionary trend of user preference. To cope with this issue, we present a new framework that explicitly models the evolving dynamics in user preference in a continuous-time manner.

Based on the massive collected data of users, a great number of efforts have been made on user modelling in recent years. Some methods utilized users’ sequences to exploit their dynamics and formalized the task as a sequence learning problem. For example, [2] integrated the Markov chain and matrix factorization to learn the evolving preferences of users. [26] proposed GRU4Rec based on RNNs for session-based recommendation. [18] designed the memory-augmented neural network to capture user sequential behaviors for sequential recommendation. [19] incorporated the knowledge base information into RNN-based memory networks to enhance the model interpretability. [21] proposed a lifelong sequential modelling framework to learn the multi-scale evolving patterns in user behaviors via a hierarchical and periodical updating mechanism. There are also some attempts for user modelling in a non-chronological manner. For click-through rate prediction, [27] computed user representations that are specific to the ads by a local activation unit. [28] and [29] extended the Graph Neural Networks (GNNs) [30, 31, 32] to recommender systems by learning from the user-item interaction graph. They performed graph convolutions to generate embeddings of both users and items, which utilize the graph structure and node feature information simultaneously. [33] removed the feature transformation and nonlinear activation in graph convolutions, and linearly propagated information on the user-item interaction graph.

In this paper, we design a continuous-time user preference modelling framework for temporal sets prediction.

A continuous-time dynamic graph is defined as a chronological sequence of events, where each event can correspond to the modifications of an object or the interactions of multiple objects [34]. Representation learning on continuous-time dynamic graphs aims to provide meaningful representations for nodes in the graph with the consideration of graph dynamics. [35] first constructed temporal dependency interaction graphs which are induced from the sequence of interactions, and then captured both global and local graph information with a dynamic message passing neural network. [36] first considered the temporal dependencies via a time encoding function and then aggregated the neighbor information using the temporal graph attention layer to compute time-aware node representations. [37] designed a general framework for continuous-time dynamic graphs by learning evolving node representations across time. To learn from temporal user-item interaction graphs, [20] employed two RNNs to update the embedding of a user and an item and introduced a projection operator to learn the embedding trajectories of users and items. [38] defined a continuous-time bipartite graph of users and items, and designed a temporal collaborative transformer to consider the temporal dynamics inside sequential patterns and mine the underlying collaborative signals. [39] introduced a unified library for facilitating the development of the continuous-time dynamic graph learning field.

However, the above methods are not specifically designed for predicting temporal sets. They fail to capture the relationships between elements within the same set as well as the correlations between the user and the interacted set. In this paper, we propose a customized continuous-time learning framework for temporal sets prediction.

We first construct a universal sequence by sorting all the user-set interactions in a non-descending order based on the timestamp of each set (as shown on the left of Fig. 2), and then learn from user-set interactions chronologically for encoding the collaborative signals among different users. To be specific, we maintain a memory bank to explicitly store the states of all the users and elements for tracking the evolving preferences. We initialize the memories of all the users and elements as zero vectors, and update the memories of the related user and elements involved in each user-set interaction according to the following message encoders and memory updaters.

Apart from learning from the universal sequence, we also explore the personalized behaviors of each user via the previously interacted elements from his/her own historical sequence. In particular, for user $u_{i}$ that involved in the interaction $e_{k}$, we use $\mathcal{V}_{i}^{t_{k}}=\left\{{v_{j}|\ v_{j}\in\mathbb{S}_{k^{\prime}}\wedge u^{e}_{k^{\prime}}=u_{i}\wedge 0<t_{k^{\prime}}\leq t_{k}}\right\}$ to denote the list of elements that $u_{i}$ have interacted with up to timestamp $t_{k}$. It is worth noticing that $\mathcal{V}_{i}^{t_{k}}$ could contain the same element multiple times, and elements that appear with higher times indicate that they are more preferred by user $u_{i}$. Then, we adaptively aggregate the elements in $\mathcal{V}_{i}^{t_{k}}$ from dual perspectives, i.e., the user perspective and the element perspective.

To provide the appearing probabilities of all the elements in the subsequent set of each user, we design a prediction layer by integrating continuous-time and personalized information. Specifically, the prediction layer first computes the continuous-time and personalized probabilities and then fuses them to make the final predictions.

Our approach constructs a universal sequence in the non-decreasing temporal order and processes each user-set interaction one after another, which makes it time-consuming when handling datasets with long time spans. Classical RNN models assume that different users are independent of each other, so these methods can split the sequences of users into multiple batches and compute on each batch in parallel [26, 40]. However, our approach merges the sequences of users into a universal sequence and thus the users are correlated with each other, making the above technique infeasible. Though [20] proposed an algorithm to accelerate the model efficiency on temporal interaction networks, it can only handle a pairwise user-element interaction and thus fails to handle the user-set interactions since each set contains an arbitrary number of elements.

To this end, we develop a set-batch algorithm to create time-consistent batches in advance and improve our model efficiency. The core of the set-batch algorithm is to satisfy the constraint of temporal orders, such that the memory of any user or any element is updated chronologically. Formally, for $\forall u_{i}\in\mathbb{U},v_{j}\in\mathbb{V},e_{k}=(u^{e}_{k},\mathbb{S}_{k},t_{k}),e_{k^{\prime}}=(u^{e}_{k^{\prime}},\mathbb{S}_{k^{\prime}},t_{k^{\prime}})$, if $u_{i}=u^{e}_{k}\wedge u_{i}=u^{e}_{k^{\prime}}\wedge t_{k}<t_{k^{\prime}}$, then $BatchID(e_{k})<BatchID(e_{k^{\prime}})$. Moreover, if $v_{j}\in\mathbb{S}_{k}\wedge v_{j}\in\mathbb{S}_{k^{\prime}}\wedge t_{k}<t_{k^{\prime}}$, then $BatchID(e_{k})<BatchID(e_{k^{\prime}})$. $BatchID(e_{k})$ is a function to return the index of the batch that contains $e_{k}$.

We show the set-batch algorithm in Algorithm 1. In particular, the set-batch algorithm takes the universal non-decreasing sequence $\mathcal{S}^{t}=\{e_{1},\cdots,e_{K}\}$ as the input and provides the batched data $\mathcal{B}=\left\{B_{1},\cdots,B_{BatchNum}\right\}$³³3For better understanding, we prescribe that the indices of a list start with 1 rather than 0. as the output, where $BatchNum$ denotes the number of batches. Set-batch first initializes $\mathcal{B}$, $user\_idx\_dict$ and $element\_idx\_dict$ in line 1 and line 2, where $user\_idx\_dict$ and $element\_idx\_dict$ are designed to record the largest index of the batch that contains users and elements, respectively. Then, set-batch chronologically processes each user-set interaction $e_{k}$ in line 3. It obtains the index of batch that $e_{k}$ should be inserted from line 4 to line 18 and appends $e_{k}$ to the corresponding position from line 19 to line 22. Finally, the indices of the related user $u^{e}_{k}$ and elements $v_{j}\in\mathbb{S}_{k}$ in $user\_idx\_dict$ and $element\_idx\_dict$ are updated from line 23 to line 26. An example of the set-batch algorithm is shown on the left of Fig. 2.

The complexity of our set-batch algorithm is $\mathcal{O}(|\mathcal{S}^{t}|)$, which is linear to the number of user-set interactions in the sequence $\mathcal{S}^{t}$. We do not need to manually predetermine $BatchNum$ because set-batch can automatically provide $BatchNum$ according to different datasets. The value of $BatchNum$ ranges from 1 to $|\mathcal{S}^{t}|$. The extreme cases are: 1) all the user-set interactions have unique users and elements, and then $BatchNum$ is equal to 1; 2) all the user-set interactions have the same user or the same element, then $BatchNum$ is set to $|\mathcal{S}^{t}|$. It can be verified that the set-batch algorithm satisfies the constraint of temporal orders because it guarantees: 1) each user and each element should appear at most once in each batch; and 2) if batch $B_{b}$ and $B_{b^{\prime}}$ consist of interactions $e_{k}$ and $e_{k^{\prime}}$ with $t_{k}<t_{k^{\prime}}$, and $e_{k}$ and $e_{k^{\prime}}$ contain the same user or the same element, then $b<b^{\prime}$.

To support the calculation on the batched data $\mathcal{B}$, we first perform the padding operation in each batch and then use the masking technique in [17] by setting all the padded values to -$\infty$ before the softmax operations. We treat the task of temporal sets prediction as a multi-label classification problem, where an element corresponds to a label. The ground truth of user $u_{i}$’s next-period set after timestamp $t_{k}$ is denoted by $\bm{y}_{i}^{t_{k}}\in\left\{0,1\right\}^{n}$, where the entry of 1 indicates the corresponding element appears in the next-period set of user $u_{i}$. The multi-label classification problem is converted into multiple binary classification problems, which are optimized by minimizing the cross-entropy loss,

where $y_{i,j}^{t_{k}}$ and $\hat{y}_{i,j}^{t_{k}}$ denote the ground truth and predicted probability of element $v_{j}$ appearing in the next-period set of user $u_{i}$ after timestamp $t_{k}$. We have also tried other widely-used loss functions in recommender systems such as Sampled Softmax [41] and Personalized Ranking with Importance Sampling [42], but they cannot show better performance. In the Appendix, Algorithm 2 shows the training process of CTTSP.

We conduct experiments on four benchmarks:

• •

  JingDong⁴⁴4https://jdata.jd.com/html/detail.html?id=8 contains the actions of users about purchasing, browsing, commenting, following and adding products to shopping carts. We select the purchasing actions in March 2018 and treat products bought on the same day by each user as a set.

• •

  Dunnhumby-Carbo (DC)⁵⁵5https://www.dunnhumby.com/careers/engineering/sourcefiles records the transactions of households at a retailer in two years. We select transactions in the first 60 days to conduct experiments and treat products purchased on the same day by each household as a set.

• •

  TaFeng⁶⁶6https://www.kaggle.com/chiranjivdas09/ta-feng-grocery-dataset includes the shopping transactions at a Chinese grocery store from November 2000 to February 2001. Products bought on the same day by each customer are treated as a set.

• •

  TaoBao⁷⁷7https://tianchi.aliyun.com/dataset/dataDetail?dataId=649 records the online user behaviors about purchasing, clicking, marking products as favors, and adding products to shopping carts. We select the purchasing behaviors and treat categories of products purchased on the same day by each user as a set. This dataset is recorded from November 24, 2017 to December 3, 2017.

We strictly follow [11] to preprocess the datasets. We select the frequent elements that cover 80% records in each dataset. We drop the sequences with lengths less than 4 and crop the sequences with lengths more than 20. Note that the TMS dataset in[11] is not used because the absolute temporal information is unavailable, but we additionally use the TaFeng dataset to do experiments. We compare our method with the existing methods under both transductive and inductive settings. For the transductive setting, we follow [11] to use the last set, the second last set, and the remaining sets of each user for testing, validation, and training. For the inductive setting, we follow [10] to randomly divide each dataset into the training, validation, and testing sets with the ratio of 70%, 10%, and 20% across users. We provide statistics of the datasets in the Appendix.

Our approach is compared with the following baselines:

• •

  TOP uses the most frequent elements in all the users’ sequences as the predictions for any user.

• •

  PTOP predicts the most frequent elements in the individual sequence for each user.

• •

  FPMC utilizes the matrix factorization and Markov chain to predict the next-period basket, which can capture the element transitions as well as long-term user preferences [2].

• •

  DREAM first uses pooling operations to embed baskets into vectors, and then feeds the sequence of basket embeddings into an RNN to predict the next-period basket [3].

• •

  TGN is a general dynamic graph learning framework, which computes evolving representations for nodes in the graph [37]. To adapt TGN for the temporal sets prediction task, we treat each user-set interaction as multiple user-element interactions and separately learn from the user-element interactions.

• •

  RUM is a memory-augmented neural network for sequential recommendation, aiming to exploit sequential behaviors of users [18]. We first use the pooling operation to embed each set and then employ RUM to handle the sequences of set embeddings.

• •

  HPMN introduces a hierarchical framework with an updating mechanism for multiple periods, which can capture the multi-scale sequential patterns in the lifelong behavior sequences of users [21]. We incorporate the pooing operations into HPMN to apply it for predicting temporal sets.

• •

  DIN is designed for the click-through rate prediction, which learns the representation of user interests with respect to each ad by the attention mechanism [27]. We adapt DIN by splitting each set into separate elements and learning from the sequences of elements.

• •

  Sets2Sets first generates the representations of sets via the average pooling and then captures temporal dependencies with an encoder-decoder framework for predicting multi-period sets. It also considers the repeated patterns in user behaviors [8].

• •

  DSNTSP designs a dual transformer-based architecture to learn both element-level and set-level representations for each user’s sequence. A co-transformer module is further proposed to capture the multiple temporal dependencies of elements and sets [9].

• •

  DNNTSP constructs set-level co-occurrence graphs to learn the element relationships and uses the attention mechanism to capture temporal dependencies. The gating mechanism is also employed to discover the shared patterns among elements [10].

• •

  ETGNN first connects the sequences of different users via a temporal graph and then learns from the graph according to an element-guided message aggregation mechanism and a temporal information utilization component [11].

To evaluate the model performance, we follow [10, 11] to rank the top-$K$ elements using the predicted probabilities and set $K$ to 10, 20, 30, and 40. We adopt Recall, Normalized Discounted Cumulative Gain (NDCG), and Personal Hit Ratio (PHR) as the evaluation metrics. Adam optimizer [43] is leveraged to optimize the models. We employ the cosine annealing learning rate scheduler [44] to change the learning rate. Dropout [45] is adopted to prevent models from over-fitting. We train the methods with a fixed 2000 epochs and use an early stopping strategy with a patience of 100. The model with the best performance (more specifically, the highest average NDCG) on the validation set is used for testing. To eliminate the deviations, we run the methods ten times with seeds from 0 to 9 on all the datasets and report the average performance. For the proposed CTTSP, we set the learning rate to 0.001 on all the datasets. We apply the grid search to find the best settings of CTTSP. Specifically, the dropout rate and hidden dimension $d$ are searched in [0.0, 0.05, 0.1, 0.15, 0.2] and [32, 64, 128]. The hyperparameter $\lambda_{up}$ and $\lambda_{cp}$ are both searched in [0.0, 0.05, 0.1, 0.3, 0.5, 0.7, 0.9, 0.95, 1.0]. The settings of our model on different datasets are shown in the Appendix.

Note that the memories of users and elements are continuously updated during the training, validation, and testing process, but the model parameters are not optimized in the validation and testing process to avoid the data leakage issue. We train our model in a mini-batch manner, where the batches are created by our set-batch algorithm in advance. All the experiments are conducted on an Ubuntu machine equipped with one Intel(R) Xeon(R) Gold 6130 CPU @ 2.10GHz, which has 16 physical cores. The GPU device is NVIDIA Tesla T4 with 15 GB memory. Our approach is implemented with PyTorch [46]. Codes and datasets are available at https://github.com/yule-BUAA/CTTSP.

The comparisons of our approach with baselines under the transductive setting are shown in Table I. From Table I, several conclusions can be summarized as follows.

Firstly, PTOP usually shows better performance than TOP because PTOP recommends personalized elements for each user based on his/her individual sequence, while TOP just identically predicts the most frequent elements for all the users which leads to unsatisfactory results. This reveals the importance of learning each user’s personal preference for temporal sets prediction.

Secondly, DREAM is often superior to FPMC because FPMC only utilizes the Markov chain to capture adjacent behaviors while DREAM employs the RNNs to capture temporal dependencies in the whole sequence of each user. This indicates that it is necessary to comprehensively mine the temporal information in users’ historical behaviors.

Thirdly, TGN, RUM, HPMN, and DIN often achieve competitive or better results than the above baselines, indicating some designs for memory networks or recommender systems can also facilitate the prediction of temporal sets. RUM and HPMN perform better than TGN in most cases as they design specialized memory updating mechanisms (i.e., item-level and feature-level versions in RUM, hierarchical and periodical mechanisms in HPMN). DIN learns element-specific representations for each user, which can effectively enhance the expressive ability of the model. However, all of them fail to handle the unique properties of sets and there is still space for improvement.

Fourthly, Sets2Sets, DSNTSP, DNNTSP, and ETGNN, which are customized approaches for the temporal sets prediction problem, usually yield better performance than other baselines. In particular, Sets2Sets additionally explores repeated patterns in user behaviors. DSNTSP learns both the element-level and set-level representations for the sequence of each user. DNNTSP studies the correlations of elements within each set and captures the temporal dependencies of elements across different sets. ETGNN is the best baseline in most cases because it not only learns element-specific representations that are aware of the temporal information for each user but also captures the collaborative signals in high-order user-element interactions.

Finally, CTTSP significantly outperforms the existing methods over all the metrics on all the datasets. The superiority of our approach lies in 1) the continuous-time learning framework to explicitly model the evolving user preferences and exploit the latent collaborative signals among different users; 2) the learning of personalized user behaviors, which can aggregate the previously interacted elements of each user according to the user and elements.

CTTSP is endowed with the inductive ability because 1) the memory of each user in the memory bank is identically initialized as a zero vector at first. When a new user comes, his/her memory can be updated according to the learned model parameters; 2) the static embedding $\bm{e}^{u}$ is shared across the users in Section 4.2.1, which is not influenced by new users. Therefore, we evaluate the model performance under the inductive setting, which predicts the next-period set for users that are not contained in the training set. Note that FPMC, RUM, and ETGNN could only be evaluated under the transductive setting because they contain user-specific trainable parameters and are inherently not inductive. We report the performance of different methods in Fig. 3.

From Fig. 3, we find that the results of baselines vary across different datasets, but our CTTSP often consistently achieves better performance than baselines. The superiority of our approach under the inductive setting may be due to the learning of memories of users and elements, which can help our model discover the correlations across different users, and thus increase the reasoning ability for new users. This advantage indicates the potential of CTTSP in tackling the cold-start problems [47]. We also observe that Sets2Sets usually performs better than baselines and it even achieves higher NDCG than our approach on TaFeng. We owe such a phenomenon to the repeated user behavior learning module in Sets2Sets, which is similar to the PerTOP baseline but with trainable importance weights. PerTOP achieves relatively good NDCG on TaFeng, and its trainable version in Sets2Sets may contribute more and lead to higher NDCG.

We further investigate the importance of continuous-time and personalized information of users. In particular, we vary the continuous-time probability importance $\lambda_{cp}$ in [0.0, 0.05, 0.1, 0.3, 0.5, 0.7, 0.9, 0.95, 1.0] by fixing the user perspective importance $\lambda_{up}$ as its best configuration. Due to space limitations, we report the results on all the datasets in Fig. 4, where $K$ is set to 10. Similar trends could be observed when the values of $K$ are set to 20, 30, and 40.

From Fig. 4, we can observe that the best settings of $\lambda_{cp}$ change over different datasets and reflect the datasets’ unique properties. Two representative datasets are JingDong and DC, where the continuous-time user preferences are more obvious on JingDong, while DC is more likely to be affected by personalized user behaviors. TaFeng and TaoBao tend to show the balance of both continuous-time and personalized information of users. These findings suggest that it is necessary to select appropriate $\lambda_{cp}$ according to the property of each dataset.

We also study the impacts of the user and element perspectives on different datasets. Specifically, we first fix the continuous-time probability importance $\lambda_{cp}$ as its best configuration and then change the value of the user perspective importance $\lambda_{up}$ in [0.0, 0.05, 0.1, 0.3, 0.5, 0.7, 0.9, 0.95, 1.0]. Experimental results on all the datasets are depicted in Fig. 5, where $K$ is set to 10.

From Fig. 5, we conclude that different datasets depict varied importance of the user perspective and element perspective. Specifically, JingDong and TaoBao are more likely to be influenced by the user perspective, while TaFeng pays more attention to the element perspective. DC keeps a balance of the user and element perspective. Therefore, choosing suitable $\lambda_{up}$ on different datasets is also essential for satisfactory prediction performance.

We further conduct the ablation study to validate the effectiveness of the Attention mechanism in the User Message Encoder (AUME), the Attention mechanism in the Element Message Encoder (AEME), and the Gated Updating mechanism in the Memory Updaters (GUMU). Specifically, we use the average pooling operation over the related elements in each user-set interaction when computing the user’s message and denote the model as CTTSP w/o AUME. This indicates that CTTSP w/o AUME does not distinguish the importance of different elements to the user. CTTSP w/o AEME is implemented by encoding the message of each element according to the information of the interacted user and the element itself, while the information of other elements in the same user-set interaction is ignored. We employ Gated Recurrent Units (GRU) in [15] to replace the GUMU component for both users and elements, and denote the model as CTTSP w/o GUMU. Experimental results of the variants on JingDong and TaoBao are shown in Fig. 6, where $K$ is set to 10.

From Fig. 6, we can observe that CTTSP achieves the best performance when it uses all the three components, and removing any component would lead to worse results. In particular, the AUME component encodes the user’s message by learning the importance of different elements. The AEME component captures the intra-set relationships of elements when encoding the message of each element. The GUMU component adaptively selects the encoded message and historical memories according to the gated updating mechanism with fewer parameters than GRU, which may reduce the training difficulty [48].

We validate the efficiency of the proposed set-batch algorithm by comparing the running time of our CTTSP with CTTSP w/o set-batch. It is worth noticing that the set-batch algorithm can create time-consistent batches during the preprocessing phase in advance, and thus does not introduce extra cost in the training and evaluation process. Moreover, there is no need to predetermine the number of batches as it is automatically provided by the set-batch algorithm for different datasets. In the experiments, the set-batch algorithm creates 1,349, 2,079, 12,652, and 9,266 batches on JingDong, DC, TaFeng, and TaoBao, respectively. This can significantly improve the model efficiency since the model has to chronologically deal with 15,195, 42,905, 73,302, and 225,989 user-set interactions (see Table III) without the set-batch algorithm. We report the running time of each epoch in the training and evaluation process in Table II.

From Table II, we could observe that the proposed set-batch algorithm enables our CTTSP to be efficiently executed in a mini-batch manner and achieves 3.5$\times$ speedups in training and 3.0$\times$ speedups in evaluation on average. We also compare the convergence of CTTSP and CTTSP w/o set-batch. The results show that the set-batch algorithm leads to faster and more stable convergence since it enables CTTSP to be trained in a mini-batch manner rather than processing interactions one by one, which can reduce the variance of the parameter updates [49].

We further report the evaluation time of different methods on JingDong and DC in Fig. 7, where the x-axis is scaled by a logarithmic function with base 2. The results on all the datasets are shown in the Appendix. The model complexity of CTTSP comes from the Continuous-Time User Preference Modelling and Personalized User Behavior Learning components, which is relatively higher than the baselines. However, we also observe that CTTSP obtains the best performance with acceptable increments in computational complexity. Therefore, we conclude that CTTSP can achieve a good trade-off between efficiency and effectiveness.

We show the interpretability of our approach by conducting experiments on the JingDong dataset.