{'fraction_non_alphanumeric': 0.04267412209284464, 'fraction_numerical': 0.012289164029616885, 'mean_word_length': 4.62953995157385, 'pattern_counts': {'":': 0, '<': 0, '<?xml version=': 0, '>': 0, 'https://': 0, 'lorem ipsum': 0, 'www.': 0, 'xml': 0}, 'pii_count': 0, 'substrings_counts': 0, 'word_list_counts': {'cursed_substrings.json': 6, 'profanity_word_list.json': 0, 'sexual_word_list.json': 0, 'zh_pornsignals.json': 0}}
TimeKit: A Time-series Forecasting-based Upgrade Kit for Collaborative Filtering

Recommender systems are a long-standing research problem in data mining and machine learning. They are incremental in nature, as new user-item interaction logs arrive. In real-world applications, we need to periodically train a collaborative filtering algorithm to extract user/item embedding vectors and therefore, a time-series of embedding vectors can be naturally defined. We present a time-series forecasting-based upgrade kit (TimeKit), which works in the following way: it i) first decides a base collaborative filtering algorithm, ii) extracts user/item embedding vectors with the base algorithm from user-item interaction logs incrementally, e.g., every month, iii) trains our time-series forecasting model with the extracted time- series of embedding vectors, and then iv) forecasts the future embedding vectors and recommend with their dot-product scores owing to a recent breakthrough in processing complicated time- series data, i.e., neural controlled differential equations (NCDEs). Our experiments with four real-world benchmark datasets show that the proposed time-series forecasting-based upgrade kit can significantly enhance existing popular collaborative filtering algorithms.


I. INTRODUCTION
Recommender systems, personalized information filtering (IF) technologies, can be applied to many services, ranging from E-commerce, advertising, and social media to many other online and offline service platforms [1]- [3]. One of the most popular recommender systems, collaborative filtering (CF), provides personalized preferred items by learning user and item embeddings from user-item interactions [4]- [10].
However, most of collaborative filtering methods do not consider the practical point that real-world applications require re-training them periodically -existing collaborative filtering methods consider one-time training only as in Fig. 1 (a). Let A be a base collaborative filtering algorithm which produces the embedding vectors, denoted {e Last where U (resp. V ) is a set of users (resp. items), at its last layer. In general, A calculates the dot-product values of the embedding vectors for recommendation. In real-world environments, we need to train A periodically as new user-item interactions are incremental. As a result, one may naturally construct the timeseries of user/item embedding vectors. Owing to the recent advancements in time-series forecasting, We propose forecasting future user/item embedding vectors which describe latent   Fig. 1 (b)). The key in forecasting the future embedding vectors is understanding the underlying dynamics which causes the behavioral drift -in other words, user behavioral patterns change over time. To address this, we resort to recent time-series forecasting technologies. We will show that our proposed method can drastically enhance existing popular collaborative filtering algorithms, both older MF and newer GCN-based models. Therefore, we call it as a time-series forecasting-based upgrade kit of collaborative filtering (TimeKit).
Our proposed approach will predict the future interactions better than existing methods when the future embedding vectors are correctly predicted. However, this forecasting task is challenging. We found that time-series of user embedding vectors can be better processed by gated recurrent units (GRUs) and those of item embedding vectors can be better processed by neural controlled differential equations (NCDEs [11]) -after analyses, we found that in general, item embedding vectors are more sensitive to small errors than user embedding vectors and are more challenging to forecast (cf. Fig. 2). NCDEs can be used to forecast item embedding vectors, which requires more accuracy. Therefore, a specific combination of GRU and NCDE shows the best performance in our experiments in many cases. NCDEs are considered as a continuous analogue to RNNs and written as follows: where z(t) is a vector at time t, and X is a continuous path taking values in a Banach space. The theory of the controlled differential equation (CDE) had been developed to extend the stochastic differential equation and the Itô calculus far beyond the semimartingale setting of X [12], [13]. For instance, a prevalent example of the path X is a Wiener process, in which case Eq. (1) reduces to a stochastic differential equation. In CDEs, however, the path X does not need to be such semimartingale or martingale processes. These CDEs are actively utilized in financial markets to predict future financial environments influenced by uncertainties. NCDEs are technologies to parameterize such CDEs and learn from data. In addition, Eq. (2) continuously reads the values dX(t) dt and integrates them over time. In this regard, NCDEs are equivalent to continuous RNNs and show the state-of-theart performance in many time-series tasks and datasets. The reasons of our adopting NCDEs are as follows: 1) There are several existing results showing that differential equation-based models extrapolate (forecast) better than RNNs for the data in the field of social science, physical science, finance, and so forth [14]- [18]. Recall that the concept of CDEs were initially created to describe the uncertainties in financial markets. We conjecture that this is likely to be the case in our work as well (because our work also deals with human behavioral patterns). 2) How to define the CDE function f in Eq. (1) is critical in terms of forecasting accuracy and easiness of trainingnote that f is a neural network parameterized by θ f . We use only Lipschitz operators for designing f to make the problem of finding the optimal parameter θ * f well-posed (see the discussion in Section III-D). We do experiments with 4 real-world datasets. Since solving a novel task, we define some baselines and compare our method with them. Our upgrade kit enhances the base algorithm by up to 68.46% for Recall@20 and up to 68.75% for NDCG@20. Our contributions are summarized as follows: 1) We reduce the collaborative filtering (CF) problem to a time-series forecasting of embedding vectors and design an upgrade kit of CF algorithms, called TimeKit. 2) Our experimental results show that the reduction cannot be fulfilled in the best form with standard time-series forecasting methods only (e.g., GRU) since the forecasting task is challenging, but our specific model design based on NCDEs enables the reduction. Fig. 4, the base algorithms make a variety of latent dynamics, but our proposed method, TimeKit, still learns all kinds of the dynamics well. 4) Our experimental results show that our proposed TimeKit can be used for existing popular collaborative filtering algorithms and significantly improves them in all cases. 5) Traditional matrix factorization (MF)-based models may outperform advanced CF models (e.g. LightGCN) just by applying TimeKit, retaining their advantages -lower time and space complexity.

II. RELATED WORK AND PRELIMINARIES
In this section, we review recommender systems, dynamic embedding, and neural controlled differential equations (NCDEs).
A. Recommender Systems a) Collaborative Filtering: Traditional collaborative filtering recommender systems have focused on matrix factorization (MF) techniques [19]. Typical MF-based methods include BPR [9] and WRMF [7], and these MF-based methods simply learn relationships between users and items via dot-products. Therefore, they have limitations in considering potentially complex relationships between users and items inherent in user-item interactions [6]. To overcome these limitations, deep learning-based recommender systems, e.g., autoencoders [20], [21] and GCNs [22]- [28], have been proposed to effectively learn more complicated relationships between users and items [2], [29], [30].
Recently, recommender systems using GCNs [2], [29], [30] are gathering much attention. GCN-based methods can effectively learn the behavioral patterns between users and items by directly capturing the collaborative signals inherent in the user-item interactions [29]. Typical GCN-based methods include GC-MC [30], PinSage [2], and NGCF [29]. In general, GCN-based methods model a set of user-item interactions as a user-item graph and perform the following three steps: (Step 1) Initialization Step: They randomly set the initial embedding e 0 of all user u and item v, denoted as follows: where D denotes the embedding size, u ∈ U is a user, and v ∈ V is an item.

(Step 2) Propagation
Step: First of all, this propagation step is iterated K times, i.e., K layers of embedding propagation. The embedding of a user node u (resp. an item node v) in i-th layer is updated based on the embeddings of u's (resp. v's) neighbors N u (resp. N v ) in (i − 1)-th layer as follows: where σ denotes a non-linear activation function, e.g., ReLU, and W i ∈ R D×D is a trainable transformation matrix. There also exist some other variations: i) including the selfembeddings, i.e., N u = N u ∪ {u} and N v = N v ∪ {v}, ii) removing the transformation matrix, and/or iii) removing the non-linear activation, which is in particular called as linear propagation [31], [32].

(Step 3) Prediction
Step: The preference of user u to item v is predicted using the dot-product between the user u's and item v's embeddings in the last layer K, i.e., e K u and e K v , as follows:r However, GCN-based methods have two limitations: i) training difficulty of using non-linear activation and ii) oversmoothing problem as the number of layers increases, i.e., too similar embeddings of nodes in the last layer [25], [31]- [34].

(Step 3 ) Alternative Prediction
Step: Recently, LR-GCCF [31], LightGCN [32], and LT-OCF [35], which are GCN-based recommender systems to alleviate the problems, have been proposed. First, to alleviate the former problem, they remove non-linear activation functions. To mitigate the latter problem, they utilize the embeddings from all layers for prediction. After that, they perform residual prediction [31], [32], which predict each user's preference to each item with the multiple embeddings from the multiple layers, as follows: and w i is a coefficient.
In summary, we experiment with various models with different characteristics, and these can be characterized by, as shown in Table I, the propagation and prediction types.
b) Sequential Recommender Systems: We note that our TimeKit aims at a different task from the sequential recommendation as presented in Table II. The sequential recommendation is, given a sequence of items visited by a user, to predict one next item [36]- [38]. While our main goal is to reduce the classical collaborative filtering to a timeseries forecasting, the sequential recommendation typically makes a time point-wise future item recommendation given a sequence of purchased items of a user. We forecast the future user/item embeddings, which allow us to predict items that a target user will buy during a certain future period, i.e., time region-wise recommendation. Furthermore, the input is a sequence of embeddings (rather than a raw sequence of useritem interactions unlike the sequential recommendation).

B. Dynamic Embedding
One similar problem is dynamic embedding where data arrives incrementally and we want to calculate their embedding vectors [39]- [41]. However, this sort of problem is different from our research since many of them have large model sizes for solving general downstream deep learning tasks. For instance, dynamic graph embedding methods consider the situation that graphs arrive incrementally and we want to embed those graphs over time into vectors to solve graph pattern classification problems. Another example is dynamic word embedding where we consider texts changing over time. On the contrary, our goal is to design a lightweight upgrade kit that can be readily integrated into existing collaborative filtering algorithms.

C. Neural Controlled Differential Equations
Neural controlled differential equations (NCDEs) are greatly inspired by neural ordinary differential equations (NODEs) and therefore, we first describe NODEs. NODEs solve the following integral problem to calculate z(T ) from z(0) [42]: where f (z(t), t; θ f ), which we call ODE function, is a neural network to approximateż def = dz(t) dt . To solve the integral problem, NODEs rely on ODE solvers, e.g., the explicit Euler method, the Dormand-Prince (DOPRI) method, and so forth [43]. We note that the integral problem in Eq. (7) uses the concept of Riemann integral.
Instead of the backpropagation method, the adjoint sensitivity method is used to train NODEs for its efficiency and theoretical correctness [42]. After letting a z (t) = dL dz(t) for a task-specific loss L, it calculates the gradient of loss w.r.t model parameters with another reverse-mode integral as follows: As shown in Eq. (2), on the other hand, NCDEs are written as dt . Therefore, NCDEs are considered as a continuous analogue to RNNs and are suitable for processing time-series data.
NCDEs use the Riemann-Stieltjes integral, as shown in Eq. (2). To solve it, existing ODE solvers can also be used in NCDEs. Regardless of the integral problem type, existing ODE solvers can be used onceż(t) can be properly modeled and calculated. ODE solvers discretize time variable t and convert an integral into many steps of additions [44], i.e., update z(t + s) from z(t). For instance, the fourth-order Runge-Kutta (RK4) method uses the following method: where s, which is usually smaller than 1, is a pre-determined step size, t+s; θ f ). The Dormand-Prince(DOPRI) method is one of the most advanced solvers, which decides the step-size s every step on its own. In other words, it is an adaptive step-size solver. NODEs and NCDEs use RK4 or DOPRI in many cases.

III. PROPOSED METHOD
We describe our method in detail in this section. We first explain the overall workflow in our method, followed by detailed model and training method designs.

A. Overall Workflow
The detailed workflow in our method to forecast future embedding vectors is as follows - Fig. 3 shows how to create a time-series of embedding vectors and how we forecast: 1) Let U (resp. V ) be a set of users (resp. items). Given a long history of user-item interactions and its time span where D i is a set of interactions during the period of (t i−1 , t i ] and t M (resp. t M +1 ) is the last time-point of our training/validating (resp. testing) data. We note that  Fig. 3. The overall workflow of creating the time-series of embedding vectors and forecasting. We do not train a recommendation model, e.g., LightGCN, from scratch every period, but incrementally after reusing the most recently trained parameters, e.g., initial embeddings in the case of LightGCN. We use all past data on or before each t i to avoid overfitting on new items. t 1 ), we incrementally train a recommendation algorithm A which produces user and item embedding vectors. In most algorithms, user and item embedding vectors are the only trainable parameters, e.g., the initial embeddings of LightGCN, where no other parameters are trained. When training for (D i , t i ), we initialize user and item embedding vectors with those trained for (D i−1 , t i−1 ), and further train with ∪ i j=1 D j -in other words, we consider all the previous interactions on or before t i and incrementally train the parameters while maintaining a single vector space across [0, T ]. Since we do not randomly initialize user and item embedding vectors every time but initialize with the previously trained one, one embedding vector space can be maintained. Moreover, it can bring benefits, e.g., training efficiency, because the initialized parameters are already somehow good.
be a time-series of embedding vectors produced in the above way, e.g., if residual prediction is not used as in Eq. (5). Using our timeseries forecasting method, we forecast future embeddings, E M +1 -we use the symbol of "ˆ" to denote predictions. 4) UsingÊ M +1 , we recommend items to users after calculating their dot-products.

B. Rationale behind Our Method
In real-world applications, we need to train a collaborative filtering algorithm A incrementally since new user-item interactions are accumulated everyday. One typical method is to retrain A and replace the previous model with the retrained model -one can also use only recent data when retraining A in order to reflect recent patterns. However, this typical use scenario does not fully exploit the time-series characteristic of the user and item embedding vectors over time.
In this work, we are not interested in designing such retraining-replacement methods but in forecasting future embedding vectors after capturing the hidden dynamics describ-  0  3  6  9  12  15  18  21  24  27  30  33  36  39  42  45  48  51  54  57  60 0  3  6  9  12  15  18  21  24  27  30  33  36  39  42  45  48  51  54  57  60  63 1 ing the evolutionary process of the embedding vectors. Psychologically, people's preferences on items are affected by various factors and fluctuate a lot over time. Therefore, understanding the user behavioral pattern drift 1 can be a key in real-world collaborative filtering applications. We conjecture that such hidden dynamics that defines the drift exists and our method is able to learn. As shown in Fig. 4, we found that those embedding vectors do not change randomly over time but are likely to change following a hidden dynamics. Therefore, we conjecture that by revealing the hidden dynamics, we may be able to better perform the collaborative filtering task. However, we found that forecasting future embedding vectors is a challenging extrapolation task. In particular, vanilla RNNs are insufficient for learning the complicated temporal patterns of the item embedding vectors. We also found that recent differential equation-based breakthroughs in processing complicated time-series data can enable our proposed recommendation concept.
A differential equation (or a governing equation) means an equation describingż def = dz(t) dt at any time t, e.g, the Navier-Stokes equation describing fluid dynamics [45], the Kermack-McKendrick equation describing infectious disease dynamics [46], and so on. Once a correct equation exists and can be learned, the time-evolving process of z(t) can be reproduced regardless of how far it does extrapolate. We attempt to approximate such a human behavioral dynamics for recommendation with NCDEs.

C. Embedding Forecaster
Our forecasting task is basically a many-to-one forecasting task, i.e., reading multiple recent embeddings for forecasting the very next embedding. Our task can be formally described as forecastingÊ i+1 after reading {(E i−r , t i−r )} R−1 r=0 at a certain time-point t i , i.e., reading recent R periods to forecast for the very next period. 1 The user behavioral pattern drift means that a user u's preference on an item v given a user-item interaction data D i collected by time t i is different from that given another data D j collected by t j , i.e., P r(v|u, be a time-series of embedding vectors for a user (or an item). For simplicity but without loss of generality, we describe how to forecastx i+1 from {(x i−r , t i−r )} R−1 r=0 since we apply the same forecasting method to each user and item -we note that we then can create M − R training samples for each user (or each item). To this end, we design GRU and NCDE-based time-series forecasting models.
a) GRU-based model: , we can use GRUs to predictx i+1 , which is a typical many-to-one forecasting task. In comparison with LSTMs, GRUs provide as high model capacity as that of LSTM but have a lower complexity [47]. The forecasting with GRUs can be written as follows: where Φ GRU is an output fully-connected layer parameterized by θ Φ GRU , and h is a hidden vector.
b) NCDE-based model: We also use the following NCDE-based method to forecast the future embedding vectors: where X is a continuous path in [t i−R+1 , t i ] created from {(x i−r , t i−r )} R−1 r=0 by the natural cubic spline interpolation algorithm, ξ CDE is an initial value generation layer, Φ CDE is an output layer. We use fully connected-layers to define ξ CDE and Φ CDE . The path created by the natural cubic spline is smooth and twice differentiable, which are required to calculate the gradients w.r.t. θ f . Therefore, it shows the best fit to NCDEs among available interpolation algorithms.
The key point is the following definition of the CDE function f : where F C i means the i-th fully connected layer and σ is a non-linear activation, such as hyperbolic tangent. We intentionally choose these operators to define f since they are all Lipschitz-continuous, which guarantees the following well-posedness of training θ f , whereas one can choose other advanced definitions for f [48]. The well-posedness 2 of NCDEs was already proved in [  of f can be fulfilled in our case. This makes our training problem for NCDEs well-posed. As a result, our training algorithm solves a well-posed problem so its training process is stable in practice.

D. Training Algorithm
We first note that we maintain two forecasting models: one for user embedding vectors and the other for item embedding vectors. Overall, our training method follows the standard multivariate time-series forecasting model training processminimizing the mean squared error (MSE) loss. Given a set of users (resp. items), we create a mini-batch of B users (resp. items) and train our model for them every iteration. We use the Adam optimizer with a learning rate λ. We use a validation set to update the best model.

IV. EXPERIMENTS
A. Experiments Environments 1) Datasets: For evaluation, we used the following four real-world datasets that are all publicly available to download: • Gowalla's data is from January to October of 2010.  Table III shows the detailed statistics of four datasets. 2) Base Recommendation Algorithms: Our proposed method does not assume any specific choice on the underlying recommendation algorithm. However, we choose to test with i) the conventional matrix factorization with the Bayesian personalized ranking loss (BPRMF), ii) NGCF, iii) LightGCN, and iv) LT-OCF 3 . BPRMF is one of the most classical collaborative filtering methods and is still widely used for many services, NGCF is a representative non-linear propagationbased method, and LightGCN and LT-OCF well represent recent research trends in graph-based collaborative filtering. We have chosen this specific set of base algorithms considering their diverse characteristics.
• NCDEs in Eq. (11) are a breakthrough in processing complicated dynamics. Among many differential equationbased time-series forecasting technologies, it shows the state-of-the-art performance in many real-world applications [50], [51].
Our method is marked with the naming convention of "[User embedding forecasting method]-[Item embedding forecasting method]," e.g., GRU-NCDE means that we use GRU in Eq. (10) for forecasting user embeddings, and the NCDE design in Eq. (11) for forecasting item embeddings. 4) Evaluation Methods: For all datasets, we split them into training/validating/testing sets. Setting a suitable period is crucial for the training of embedding vectors because a sufficient number of interactions must be guaranteed to find behavior dynamics. We set the period to a month for Gowalla and Netflix, which items are consumed frequently. Because books are not commonly consumed, for Amazon-book and Goodreads, we merge three months into one period to ensure that a sufficient number of interactions is guaranteed. In realword settings, there will be a model update cycle depending on the domain, and a period can be from one model update to next. The details of constructing data are as follows: • For Gowalla, 10 time periods are produced from ten months of data, as we use a month as one period. • For Amazon-book and Goodreads, we use two years of data into 8 periods by combining three months. • For Netflix, each period data consists of interactions in each month. One year of data is split into 12 periods.
We first train and validate the base collaborative filtering algorithms with the user-item interaction logs in and recommend for (t M , t M +1 ], denoted as "Original." Then, we upgrade them with time-series forecasting methods, denoted with each forecasting method, i.e., GRU-GRU, NCDE-NCDE, and GRU-NCDE. We train and validate the upgraded method in the seq-to-seq forecasting fashion. During the testing process, therefore, those upgraded methods read i=M −R+1 and forecast E M +1 with which we perform the collaborative filtering task. 5) Environmental Setting: Our software and hardware environments are as follows: UBUNTU 18.04 LTS, PYTHON 3.7.10, TORCH 1.9.0, CUDA 10.0, and NVIDIA Driver 450.102.04, i9 CPU, and NVIDIA RTX TITAN. The recommended ranges and the best configurations are as follows: a) Preprocessing to prepare embedding vectors: The learning rate is set to 1.0 × e −3 and train 500 epochs with a mini-batch size of 1024 or 2048 for all but one case -we use learning rate of 1.0 × e −4 when training Netflix using NGCF. In the case of NGCF, the weight decay is set to 1.0 × e −4 for Gowalla, Amazon-book, and Goodreads, and 1.0 × e −5 for Netflix. In other models, for Gowalla and Netflix, the optimal weight decay is 1.0×e −3 , whereas for other datasets, 1.0×e −4 . We set the number of layers to 3 for training NGCF, LightGCN and LT-OCF, i.e., K = 3 in Eq. (6). b) Forecasting: The best hyperparameters of our forecasting models are shown in Table IV. We train GRU and

B. Experimental Results
In this section, we answer several research questions (RQs). Herein, we focus on the two standard metric scores of recommendation: Recall@20 and NDCG@20. For the evaluations of the time-series forecasting, we refer to RQ3.
1) RQ1: How accurate is the proposed method in recommending for the future? For answering RQ1, we first compare our method with the original scores of the base algorithms -i.e., the base algorithms are trained with {(D i , t i )} M i=1 and recommend for (t M , t M +1 ]. Table V shows that our method outperforms the original base algorithms by large margins. Among various time-series forecasting methods, GRU-NCDE shows the best results in many cases, and GRU-GRU is the most effective in few cases.
For Gowalla dataset, LT-OCF shows the best scores and GRU-GRU significantly improves the scores by 31.57% for Recall@20 and 37.86% for NDCG@20. For other datasets, LightGCN is better than LT-OCF, and our TimeKit further improves LightGCN.
The biggest enhancements are obtained in Netflix for NGCF with GRU-NCDE. It improves NGCF by 68.46% and 68.75% for Recall@20 and NDCG@20 respectively, achieving the best scores among all methods for Netflix. In general, GRU-NCDE is the best upgrade method except for Gowalla.
For other cases, the improvement ratios are between 0.66% to 47.69%. Just adopting our upgrade kit, base algorithms' scores are considerably increased. Especially in the case of BPRMF with TimeKit, it even exceeds the original scores of Recall@20 NDCG@20 Recall@20 NDCG@20 Recall@20 NDCG@20 Recall@20 NDCG@20 Recall@20 NDCG@20   These results indicate that TimeKit greatly improves BPRMF, the space/time efficient model, to better capture complicated relationships between users and items than CF models.
2) RQ2: How accurate is the proposed method when we reduce the input information? In Table V, we used the full period of data. For answering RQ2, we remove the early 25% of periods from Amazon-Book and Goodreads, using only newer interactions -other datasets have a relatively short period of data and are excluded from this study. While filtering out the early 25%, we reconstruct the training/validating/testing sets and therefore, the direct comparison between Tables V and VI is not possible.
As shown in Table VI, our upgrade kit is still effective. Overall, GRU-NCDE is the best upgrade kit, leading to the biggest scores in all cases and achieving the improvement ratio of up to 58.75%. This result also implies that Timekit outperforms baseline algorithms that are trained with relatively recent interactions. 3) RQ3: How well does the proposed method extrapolate (or forecast) embedding vectors? Table VII summarizes the MSE values of our GRU-NCDE forecasting model, i.e., GRUbased models for user embeddings and NCDE-based models for item embeddings, which generally shows the best performance. In many cases, our testing MSEs are similar to those of training and validating, which means stable forecasting. In addition, the MSE values are one or two orders of magnitude smaller than the std. dev. of item embedding elements. From all these facts, we can know that our forecasting is reliable. 4) Sensitivity Analysis: How accurate is the proposed method when we change the hidden size? Fig. 5 shows the sensitivity analysis result. For various hidden size settings of our embedding forecasters, our method still shows better performances than base algorithms in all but one case. Even though the hidden size changes, TimeKit-applied BPRMF outperforms LightGCN's original scores in some cases, which proves the efficacy of TimeKit. 5) Empirical Training Complexity Analysis: What is the empirical training complexity of our upgrade kit? We analyze the empirical training overhead incurred by our method since we need to additionally train time-series forecasting models. As shown in Table VIII, the empirical space and time complexities of our proposed upgrade kit are not large. For  training our GRU or NCDE-based forecasting models for user embedding vectors, it requires just hundreds of megabytes for GPU memory and takes a few seconds for each epoch (except the NCDE-based model with DOPRI). However, all of our experimental results were obtained with RK4 as the performance enhancement by DOPRI is neglectable.

6) Case Study & Visualization:
We introduce some key observations from our experiments, which intuitively explains how our method works. In Fig. 6 (a), our method exclusively and correctly forecasts some family animations for User A and some romantic comedy films for User B, but two users show different patterns. User A suddenly watched lots of family movies in May, and this preference was reflected in the embedding (cf. Fig. 6 (b)). User B, on the contrary, does not show a strong preference on romantic comedy films during his/her training period but a consistent preference to some  . The dynamics of films' relative rating scores for User A. The relative rating score is the ratio of a single item's rating score (user-item dot-product value with TimeKit) to the average of all rating scores, which shows how much each film is preferred in comparison with the average. degree. However, the base algorithm cannot capture those differences because what they learn is not the dynamics how the distributions change but the "Total" distribution in Fig. 6 (a). Because of that difference, only our method correctly forecasts the phenomena that they show strong preferences on family and romantic comedy movies in December. Rating scores of the correct items are also the highest in December, as indicated in Fig 7.

V. CONCLUSIONS AND LIMITATIONS
We presented a novel upgrade kit, called TimeKit. Our goal is to forecast the future user/item embedding vectors, with which we will perform the collaborative filtering task. In other words, we reduce the collaborative filtering to the time-series forecasting task, owing to a recent technological breakthrough in dealing with complicated time-series data. In general, user/item embedding vectors are known to contain the hidden collaborative information for the recommendation. Therefore, we need to uncover the hidden dynamics to accurately forecast the future embedding vectors. NCDEs are a powerful concept in unveiling a hidden dynamics from timeseries and we resort to this technique. We conduct experiments with four benchmark datasets and four base collaborative filtering algorithms. All those base algorithms are significantly improved when being upgraded with TimeKit.
One limitation is that we need to collect time-series data during enough periods. In the real world, however, the model is incrementally updated as new interactions are added, and the time-series data occurs naturally. Moreover, user/item embeddings utilize less memory, making them less of a burden for capacity. Overall, our proposed method is lightweight and does not necessitate much training or a large memory.