Cascading Residual Graph Convolutional Network for Multi-Behavior Recommendation

Following the common approach used in existing recommendation methods (He et al., 2020; Jin et al., 2020; Gao et al., 2021), we associate each user and item with an ID embedding. Specifically, let $\boldsymbol{P}\in\mathbb{R}^{M\times d}$ and $\boldsymbol{Q}\in\mathbb{R}^{N\times d}$ be the embedding matrices for the user and item embedding initialization, where $M$ and $N$ denote the number of users and items, respectively; and $d$ denotes the embedding size. Formally, given the one-hot embedding matrix $\boldsymbol{ID}^{\mathcal{U}}$ and $\boldsymbol{ID}^{\mathcal{I}}$ for users and items, the embeddings are initialized as:

where $\boldsymbol{e}_{u}^{0}$ and $\boldsymbol{e}_{i}^{0}$ are the initialized user $u$’s and item $i$’s embeddings, respectively. $\boldsymbol{ID}_{u}^{\mathcal{U}}$ ($\boldsymbol{ID}_{i}^{\mathcal{I}}$) is user $u$’s (item $i$’s) one-hot vector. It is worth mentioning that the embedding matrices $\boldsymbol{P}$ and $\boldsymbol{Q}$ are the only learnable parameters in our model.

The goal of cascading residual blocks is to extract user preferences from individual behaviors and also capture the cascading relations of user preferences among behaviors to comprehensively learn user preferences. The main idea is to take the basic features as the initialized user and item embeddings, and then continuously refine them by leveraging the behavioral features learned from each type of behavior. In the next, we will describe the residual block sequence in detail from its two functionalities.

Single behavior modeling. This part is to learn user preferences from a single behavior (i.e., behavioral features). In recent years, Graph Convolutional Networks (GCNs) (Ying et al., 2018; Wang et al., 2019; Liu et al., 2021, 2022; Wu et al., 2020) have shown a strong ability in learning from graph-structured data, and have demonstrated good recommendation performance. In order to mine the behavioral features contained in the historical interaction data, we employ neighborhood aggregation, which is an essential component in GCN. To be more specific, inspired by the recent advances of GCN-based recommendation (He et al., 2020), we aggregate the information from neighbors without nonlinear transformation. The information aggregated from neighbors intuitively reflects the user’s interests in the current behavior based on learning from high-order connectivity. The neighborhood aggregation for updating user node embeddings is formulated as follows:

where AGG denotes the aggregation function, which aggregates the information from neighboring nodes of the user $u$; and $\boldsymbol{e}_{i}^{(l-1)}$ denotes the item embedding of neighboring node of the user $u$ from the (l-1)-th layer. Here $e_{u}^{(l)}$ denotes the user embedding in the l-th layer, and $N_{u}$ denotes the set of items that are interacted with by the user $u$. The embeddings of item nodes are updated in the same way. For simplicity, the aggregation function in standard GCN (Kipf and Welling, 2017) is adopted in our implementation, namely:

where $\frac{1}{\sqrt{\left\lvert N_{u}\right\rvert}\sqrt{\left\lvert N_{i}\right\rvert}}$ denotes the normalization coefficient, $\boldsymbol{e}_{u}^{(l-1)}$ (${\boldsymbol{e}_{i}^{(l-1)}}$) denotes the user (item) outputs from the (l-1)-th layer, $e_{u}^{(l)}$ and $e_{i}^{(l)}$ are the final output of the GCN (i.e., behavioral features). when $l=1$, $e_{u}^{0}$ and $e_{i}^{0}$ denote the input of the GCN, respectively. For the convenience of the description below, we define the final output of GCN as $e^{\prime}_{u}$ and $e^{\prime}_{i}$ (i.e., $e^{\prime}_{u}=e_{u}^{(l)},e^{\prime}_{i}=e_{i}^{(l)}$).

In this part, we exploit the neighborhood aggregation of GCN to learn the user preferences (i.e., behavioral features) from each behavior. Remind that in our model, we assume that only a partial preference of users can be observed from a single behavior. In the next, we will introduce how to use these behavioral features to refine user preferences in detail.

Cascading effect modeling. As discussed above, different behaviors often reflect different aspects of user preferences toward an item. More importantly, the behaviors interacting with items in a certain order reveal user preferences at different degrees. We aim to continuously refine user preferences by integrating all behavioral features and exploiting the connections between different behaviors. We achieve the goal by answering two questions: 1) how to integrate the behavioral features learned from different behaviors? and 2) how to explore the connection between different behaviors?

For the first question, in each block, we can fuse the behavioral features learned in this block with the input (i.e., the output of the previous block) to preserve the features from the previous block. Therefore, we design a residual (i.e., short-cut) connection to refine the input embedding of each behavior. This connection directly connects the feature embeddings learned from the previous block (the input feature of the block) with the one learned from the behavior data in this block. The summation method is then used to merge the two feature embeddings as output. Because the numeric value of features after the GCN learning may be of a different range from the input of the block, the direct summation may cause one feature embedding takes a dominant role in the generated results, making the other one negligible, i.e., when the numeric values of two embeddings are different in the order of magnitude. To avoid this problem, we take a normalization operation on the behavioral features before summation. For simplicity, we adopt $L_{2}$ normalization in our model:

After normalization, we fuse the behavioral features learned in the current block with the one output from the previous block via the residual connection, namely,

where $\boldsymbol{e}_{u_{in}}$ and $\boldsymbol{e}_{i_{in}}$ are the input user and item embeddings of the current block, which are also the output of the previous block. $\boldsymbol{e}_{u_{out}}$ and $\boldsymbol{e}_{i_{out}}$ denote the output user and item embedding of the current block, respectively.

With the designed residual block, the second problem can be easily addressed by connecting the residual blocks in the order of behaviors, as shown in Fig. 2. In this structure, the output of the previous residual block is taken as the input of the next block to deliver the extracted behavioral information from one behavior to the next one. The information delivery between behaviors can bring us two benefits: firstly, from the perspective of learning user preferences, it can continuously refine the embeddings to model user preferences more accurately; secondly, for tackling the data sparsity problem, it can make better use of data that has not been converted into target behaviors to learn user preferences and alleviate the problem of cold-start users to some extent. Concretely, the embeddings are learned and refined in the cascading residual blocks as follows:

where B is the number of the behavior, $\boldsymbol{e}^{B-1}$ denotes the input of the B-th residual block (i.e., the output of the (B-1)-th residual block), $\boldsymbol{\tilde{e}}^{B}$ denotes the normalization behavioral features learned from the B-th behavior, and $\boldsymbol{e}^{0}$ represents the initialized user and item embedding (i.e., basic features). Based on this design, we implement message delivery in different behavior residual blocks from the embedding level.

Through the above design, the behavioral features are fused into the basic features in an incremental form to refine the user and item embeddings. With the cascading residual blocks, our model explicitly takes the cascading effects between different behaviors into the embedding learning process. Meanwhile, the residual design can ensure that the information can be well preserved and delivered to the next behavior even when the current behavior has no interaction data. Thus, this helps alleviate the data sparsity and cold start issues.

Multi-task learning (MTL) (Tang et al., 2020) is a kind of joint-training paradigm for different-yet-related tasks. In MTL, the performance of each task is improved by updating shared parameters or shared models. As for CRGCN, each residual block learns a type of behavioral feature, and all residual blocks share basic features through a cascading structure. To ensure effective learning of CRGCN, we take the output of each residual block as a prediction task for the current behavior. Thanks to the delivery of information in the cascading structure, during the training of the current task, it can not only train the current residual block but also train the previous ones.

Loss function. We design a loss function for each behavior to supervise the learning process of behavioral features. As shown in Fig. 2, our CRGCN model can obtain each user’ embedding set $\{\boldsymbol{e}_{u}^{1},\boldsymbol{e}_{u}^{2},\cdots,\boldsymbol{e}_{u}^{B}\}$ and each item’ embedding set $\{\boldsymbol{e}_{i}^{1},\boldsymbol{e}_{i}^{2},\cdots,\boldsymbol{e}_{i}^{B}\}$ after learning for each behavior, where $B$ denotes the number of behaviors. We then obtain the relevance scores $y_{ui}$ of user-item interaction by calculating the inner product of both as follows:

It is necessary to ensure that the score of the observed user-item pair is higher than that of the unobserved one. Given the first type of behavior as an example, the loss function is formulated as follows:

where $O=\{(u,i,j)|(u,i)\in\mathcal{R}^{+},(u,j)\in\mathcal{R}^{-}\}$ is defined as positive and negative sample pairs, and $\mathcal{R}^{+}$ ($\mathcal{R}^{-}$) denotes the sample that has been observed (unobserved) in the current behavior. Here $\sigma(\cdot)$ denotes the sigmoid function. The loss function for other behaviors is similar. We then can get the set of loss functions $\mathcal{B}=\{\mathcal{L}_{1},\cdots,\mathcal{L}_{b},\cdots,\mathcal{L}_{B}\}$, where $b$ is the b-th behavior. Based on MTL, we treat the learning of each behavior as a task. The final loss is an aggregation of all the losses across different behaviors. It is formulated as follows:

where $\boldsymbol{\Theta}$ represents all trainable parameters in our model and $\beta$ is the coefficient that controls the strength of the $L_{2}$ normalization to prevent over-fitting.

The direct optimization of the loss function will learn the parameters of multiple tasks. Specifically, it updates the initialized embeddings (i.e., basic features) from the perspective of multiple tasks, directly and indirectly, since initialized embeddings are the main learnable parameters in our model.

Training. We implement our model on Pytorch¹¹1https://pytorch.org/ and adopt Adam (Kingma and Ba, 2015) for optimization. The mini-batch training strategy is also used to speed up the training process. To generate a mini-batch, we sample the interaction data of different behaviors on a user-by-user basis to ensure that each user is trained. Specifically, given a user in a batch, a positive-negative pair is sampled for each behavior. The sampling is in the form of a triple $(u,i,j)$, where $u$ represents the user, $i$ is the positive sample, and $j$ is the negative one. Take one type of behavior as an example, where $i$ is a data sample randomly from the observed interaction data. When user $u$ has no interaction data under this behavior, a default triple (i.e., $(0,0,0)$) is returned to keep the training running properly.

In order to avoid the over-fitting problem, two widely-used dropout strategies are adopted in experiments (van den Berg et al., 2018; Wang et al., 2019; Jin et al., 2020): message dropout and node dropout. Specifically, message dropout is used to drop out the information in the embedding, and node dropout is used to randomly drop out nodes in the graph.

Our CRGCN model does not introduce any trainable parameters other than the ones in user and item embedding initialization. Thus, CRGCN has the same trainable parameters as the basic MF (Rendle et al., 2009) model, demonstrating a big advantage in space complexity. The computing complexity of our model is analyzed in the following. The time cost of our model is mainly from computing the adjacency matrix, graph convolution, and BPR loss. Let $|E|$ be the number of edges in the user-item interaction graph, $B$ denotes the number of behavior types, $n$ is the number of epochs, $b$ denotes the size of each training batch, $d$ represents the embedding size, and $L$ represents the number of GCN layers. In the process of learning the adjacency matrix, the computational complexity is $\mathcal{O}(2|E|B)$. In the Graph convolution process, the computational complexity is $\mathcal{O}(2|E|nBLd\frac{|E|}{b})$. The computational complexity for BPR Loss is $\mathcal{O}(2|E|nBd)$. Due to the number of GCN layers in our model is 1 (i.e., $L=1$), the total computing complexity of CRGCN is $\mathcal{O}(2|E|B+2|E|nBd\frac{|E|}{b}+2|E|nBd)$. Since the number of behaviors in multi-behavior tasks is usually very small ($B=4$ in Tmall and Jdata dataset, and $B=3$ in Beibei dataset). Thus, the computing complexity of CRGCN is similar to LightGCN, which is $\mathcal{O}(2|E|+2|E|nLd\frac{|E|}{b}+2|E|nd)$. Compared with other multi-behavior recommendation models, our model enjoys a big advantage in the computation complexity.

Three public real-world datasets have been adopted for experiments: Tmall²²2https://tianchi.aliyun.com/dataset/dataDetail?dataId=649, Beibei³³3https://www.beibei.com, and Jdata⁴⁴4https://jdata.jd.com/html/detail.html?id=8.

• •

  Tmall. This dataset is collected from Tmall⁵⁵5https://www.tmall.com/, one of the largest e-commerce platforms in China. It contains 41,738 users and 11,953 items with 4 types of behaviors, i.e., view, collect, cart, and buy. On the Tmall platform, users can buy the item directly after viewing, or add it to the cart before purchasing, or they may just click on the collection instead of the buy behavior.

• •

  Beibei. This dataset is collected from Beibei⁶⁶6https://www.beibei.com/, the largest infant product retail e-commerce platform in China. This dataset contains 21,716 users and 7,977 items with three types of behaviors, including view, cart, and buy behavior data within the period from 2017/06/01 to 2017/06/30. On the Beibei platform, users’ shopping process is carried out according to the process of view, cart, and finally buy.

• •

  Jdata. This dataset is collected from JD⁷⁷7https://www.jd.com/, a comprehensive online retailer in China and one of the most popular and influential e-commerce websites in the Chinese e-commerce field. This dataset contains 93,334 users and 24,624 items with 4 types of behaviors, i.e., view, collect, cart, and buy behavior data within the period from 2018/02/01 to 2018/04/15. The behavior is similar to that of Tmall.

For the three datasets, we followed the previous work to merge the duplicated user-item interactions by keeping the earliest one (Gao et al., 2021; Jin et al., 2020). The statistical information of the three datasets used in our experiments is summarized in Table 1.

We adopt the widely used leave-one-out strategy for evaluation (He et al., 2020; Gao et al., 2021; He et al., 2017), which means for each user, the test set is comprised of one positive item and all the items that she has not interacted with before. In the training stage, the last positive item for each user is selected to construct the validation set for hyper-parameter tuning. In the evaluation stage, all the items in the test set are ranked according to the predicted scores by recommendation algorithms. We sort the items by predicting user preferences for all the items that do not appear in the training set, and the top-$K$ ranked items will be used for evaluation. Two popular evaluation metrics in recommendation HR@K and NDCG@K are adopted to evaluate the performance:

• •

  HR@K: Hit Ratio (HR) is a commonly used metric to measure whether the positive test item is recommended in the top $K$ items in the ranking list.

• •

  NDCG@K: Normalized Discounted Cumulative Gain (NDCG) takes the position of correctly recommended items into consideration by assigning a higher score to the hit at a higher position.

We compare our CRGCN model with several competitive recommendation models, including two single-behavior methods and six multi-behavior models. We briefly introduce these methods as follows.

Single-behavior model:

• •

  MF-BPR (Rendle et al., 2009). MF-BPR makes recommendations based on a single behavior and has been widely used as a baseline to examine the performance of newly proposed models. BPR is a widely used optimization strategy, which assumes that the predicted scores of positive samples are higher than those of negative samples.

• •

  LightGCN (He et al., 2020). It becomes a new standard for CF models by exploiting a single user-item interaction behavior in recommendation. LightGCN leverages the GCN technique to exploit the high-order connectives in the user-item bipartite graph for recommendation. In particular, it removes the feature transformation and non-linear activation components in traditional GCN models to simplify the model structure and achieves a significant performance improvement over its counterpart.

Multi-behavior model:

• •

  R-GCN (Schlichtkrull et al., 2018). R-GCN differentiates the relations between nodes via edge types in the graph and designs different propagation layers for different types of edges to model the relation information. This model can adapt to the task of multi-behavior recommendation.

• •

  NMTR-NCF (Gao et al., 2021). It is a deep learning model for multi-behavior recommendation. NMTR-NCF develops a neural network model to capture the complicated and multi-type interactions between users and items. It sequentially passes the interaction score of the current behavior to the next and also adopts multi-task learning to jointly optimize shared parameters.

• •

  NMTR-GCN. This is a modified NMTR model which uses single-layer GCN to replace the Neural Collaborative Filtering (NCF) module (He et al., 2017) in NMTR-NCF.

• •

  MBGCN (Jin et al., 2020). This model constructs a unified multi-behavior graph to learn user preferences through the user-item propagation layer and employs learnable parameters to assign weights for different behaviors during layer aggregation. In addition, it also exploits the high-order item-item relations to enhance the item embedding learning.

• •

  GNMR (Xia et al., 2021a). This model designs a relation aggregation network to model interaction heterogeneity. It attempts to explore the dependencies among different types of behaviors via recursive embedding propagation over the multi-behavior interaction graph.

• •

  S-MBRec (Gu et al., 2022). This model consists of supervised and self-supervised learning tasks. It uses multiple GCNs to learn the user and item embeddings from each behavior and adopts a star-style contrastive learning strategy, which constructs a contrastive view pair for the target and each auxiliary behavior.

We implemented our CRGCN model in Pytorch⁸⁸8https://pytorch.org/. The source code of our implementation is released ⁹⁹9The source codes are available at https://github.com/MingshiYan/CRGCN.. In our experiments, the mini-batch size of all models is set to 1024, and the embedding size is fixed to 64 (He et al., 2020). For all the models using pair-wise learning loss (Gao et al., 2021), we randomly sampled 4 negative samples for each positive sample (He et al., 2017; Gao et al., 2021). In addition, we used the grid search to tune the learning rate in the range of $[1e^{-2},3e^{-3},1e^{-3},1e^{-4}]$ and tuned the regularization weight (i.e., $\beta$) in the range of $[1e^{-2},1e^{-3},3e^{-4},1e^{-4}]$. For the other hyper-parameters in the baselines, we carefully tuned them according to their original papers. Furthermore, we adopted an early stop strategy in the training stage, that is, the training process will be stopped when HR@20 on the validation set does not increase within 20 epochs. Note that the NMTR-NCF (Gao et al., 2021) model needs the behaviors to be happening in a certain order; we strictly followed the strategy reported in the original paper on the Tmall dataset, i.e. only view and buy behavior are used.

The residual block is a core design in our model to learn user preferences by exploiting the multi-behavior in sequence. In particular, user preferences extracted from a behavior are fed into the GCN module of the next behavior to learn more accurate user preferences. In this process, we introduce two special designs: 1) $L_{2}$ normalization to balance the feature embeddings learned from previous behaviors and the one learned from current behaviors, and 2) a short-cut connection to preserve the features learned from previous behaviors. To analyze the effectiveness of both designs, we carry out experiments on the following two variants of our model as competitors: 1) removing the short-cut connection in the residual block; 2) removing the $L_{2}$ normalization from CRGCN.

The experimental results on Tmall, Beibei, and Jdata datasets are reported in Table 5. From the results, we can see that the performance drops sharply after removing the short-cut connection (the first row in Table 5). This demonstrates the importance of the residual design, which can well preserve the features extracted from previous behaviors and integrate them into the next behaviors to refine user preferences. After removing the $L_{2}$ normalization, the performance has also greatly decreased. This is because, without normalization, the value of the features learned from GCN might have deviated far from the feature values passed from the residual block of the previous behavior (e.g., in different orders of magnitude). As a result, this will largely weaken the effects of the features passed from the short-cut connection in the network. To further validate the effects of $L_{2}$ normalization, we conduct another experiment to replace it with learnable weights (denoted as CRGCN-$LW$) for feature fusion. The experimental results are shown in Table 6. Compared with the direct fusion (i.e., CRGCN-$plain$), the use of learnable weights can yield slight improvement, while there is still an enormous gap compared to our model with $L_{2}$ normalization. This validates the importance of ensuring the feature values are in the same numerical range before feature fusion. In a nutshell, the above experimental results can well validate the effectiveness of our designs in the residual block.

In this section, we study the effects of the number of GCN layers on the model performance. For simplicity, we use the same number of layers for different behaviors. The experimental results on Tmall, Beibei, and Jdata datasets are shown in Fig. 3, in which CRGCN_(0l), CRGCN_(1l) (our model), and CRGCN_(2l) represent GCN with 0, 1, and 2 layers, respectively. In particular, when the layer number of the GCN is 0, our CRGCN model degenerates into multi-task learning with shared embeddings.

By comparing the results of CRGCN_(0l) and CRGCN_(1l) in Fig. 3, we find out that the use of GCN to learn user preferences from behaviors can greatly improve the model performance. Besides, the performance of the model decreases with the increase of GCN layers, which can be seen from the results of CRGCN_(1l) and CRGCN_(2l) on Tmall and Beibei datasets. In previous work like LightGCN (He et al., 2020) or NGCF (Wang et al., 2019), the best performance is often obtained when stacking 2 or 3 layers, as stacking more layers can exploit higher-order neighboring information to learn better user preferences. However, in our model, the best performance is achieved by using only one layer. This is because our model applies the GCN model to learn user preferences from multiple behaviors in a cascading way. The embedding learned from a GCN module (based on behavior) is passed to the next GCN for refinement. And we assume that the behavior that performs the latter can express more accurate user preferences. For example, the view behavior only expresses a general interest of a user towards an item. It is not sure whether the user is really interested in an item yet before the user gets more details of the item. And the number of interactions based on the view behavior is significantly larger than other behaviors (see Table 1). In other words, the items in the latter behaviors can better reflect a user’s preference (i.e., buy-¿collect-¿view). When stacking more layers on the graph of view behavior, it may introduce noisy information into the learning process, which will negatively affect the subsequent embedding learning based on the latter behaviors, which can be confirmed in the results of Jdata dataset.

To validate this viewpoint, we perform an additional experiment. In this experiment, we change the number of GCN layers for different behaviors, and each time we make the change for only one behavior. The behavior modeling order is view-¿collect-¿cart-¿buy for Tmall and Jdata datasets, and view-¿cart-¿buy for Beibei dataset, respectively. For ease of presentation, we use a list to represent the number of GCN layers in the corresponding behavior. For example, in the Tmall dataset, $[2,1,1,1]$ indicates that there are 2 GCN layers for view and 1 GCN layer for all other behaviors. The same definition is used for Beibei and Jdata datasets. The experimental results are shown in Table 7. Generally, the earlier the behavior of using more layers, the worse the performance. In addition, with the use of more layers in the last behavior (i.e., buy behavior), the performance can be further improved (see T₅ over T₁, B₄ over B₁, and J₅ over J₁). The best performance is achieved when using two GCN layers on the buy behavior, which is also the target behavior. The results can well support our explanation for the results in Fig. 3. In addition, this also verifies the benefits of using GCN to exploit higher-order neighbors in the graph to learn user preferences. However, it is better to confirm that the neighbors are indeed positively related. This is also one of the reasons that stacking more layers may cause performance degradation¹⁰¹⁰10Another reason is the over-smoothing problem, which is an inherent problem for GCN models.. Because after a few hops, it is hard to differentiate the relevance of high-order neighbors.

To verify the effectiveness of multi-task learning in CRGCN, we compare CRGCN with the one using the prediction loss of the target behavior (i.e., buy behavior) for training (denoted as CRGCN_(sing)) in experiments. All the other parts are kept the same as CRGCN. The experimental results on Tmall, Beibei, and Jdata datasets are shown in Fig. 4.

From the results, we can observe that the performance of CRGCN is consistently better than that of CRGCN_(sing) in terms of both HR@K and NDCG@K metrics, indicating that multi-task learning can indeed significantly improve the prediction accuracy for the target behavior. The reason for this is that multi-task learning can jointly train the outputs of all residual blocks at the same time, making good use of each behavior to learn user preferences. This can not only learn better embeddings from the interaction data of each behavior, but also facilitate the continuous refinement of user preferences with a cascading structure by using the multi-task learning framework.

In this work, we mainly focus on studying the potential of our model in exploiting the cascading effects of multi-behavior in embedding learning. Therefore, we treat different tasks equally in the loss function for simplicity. Intuitively, different behaviors may have different effects on the target behavior. Thus, we carry out experiments here to analyze the impact of loss function on different tasks with different weights. Specifically, we test different combinations of weight settings and we did not exhaust all the possibilities. The experiment results are reported in Fig. 5.

From the results, we can see that the equal setting indeed cannot achieve the best results. Better results can be achieved by assigning different weights to different tasks. In general, assigning higher weights to latter behaviors can yield relatively better performance, which is expected because the latter behaviors are closer to the target behaviors. But still, it needs to carefully tune the weights for the optimal performance. Because this is not our main focus in this study, and the simple equal setting can already achieve impressive improvement over the most recently proposed models, we did not carefully tune the weights of different tasks for the best performance. This experiment can already verify that the importance of different tasks should be different in the multi-task learning for better performance. We would like to leave the exploration of automatically learning the best setting in the future.