Towards Robust Neural Graph Collaborative Filtering via Structure Denoising and Embedding Perturbation

Before presenting the proposed approach, we first introduce the notations used throughout the article in Table 1. Following conventions, we use bold capital letters for matrices, bold lowercase letters for vectors, and calligraphic letters for sets. The user set and item set are denoted by \(\mathcal {U}\) and \(\mathcal {I}\), respectively. The interaction matrix of existing user-item interactions is \(\mathbf {R} \in \lbrace 0,1\rbrace ^{|\mathcal {U}| \times |\mathcal {I}|}\), where \(|\mathcal {U}|\) and \(|\mathcal {I}|\) represent the number of users and items, respectively. The entry \(r_{u,i} = 1\) if there exists an observed interaction between user \(u\) and item \(i\), and \(r_{u,i} = 0\) otherwise. In other words, we mainly consider learning the user preferences from the implicit feedback in this article. By default, we use \(u\), \(v\) to indicate users and \(i\), \(j\) to indicate items. The user embedding matrix and item embedding matrix are denoted as \(\mathbf {E}_u\) and \(\mathbf {E}_i\), respectively. We use superscript to denote the layer of the embeddings. Note that neural graph collaborative filtering typically learns the initial embeddings \(\mathbf {E}^{(0)}\) for users/items, and the aggregated result of the \(l\)th layer is denoted as \(\mathbf {E}^{(l)}\).

As a fundamental component in recommender systems, collaborative filtering (CF) aims to model user preferences based on observed feedback. Based on the interaction matrix \(\mathbf {R}\), neural graph collaborative filtering first constructs a user-item interaction graph \(\mathbf {G}\), whose corresponding adjacency matrix \(\mathbf {A}\) can be defined as:This adjacency matrix \(\mathbf {A}\) is usually used as the input for the neural graph collaborative filtering.

In general, neural graph collaborative filtering is built upon GNNs [16, 49], obtaining the high-level representations for users and items based on the message aggregation of low-level representations. The aggregation process can be formulated as the following two stages:where \(\mathcal {N}_{u}\) denotes all the neighbors of user \(u\) in the interaction graph \(G\) and \(L\) denotes the number of GNN layers. Here, \(\mathbf {e}_{u}^{(0)}\) denotes the direct embedding of user \(u\), which is also the parameter to be learned. For each user \(u\), the aggregation function \(f_{\text{aggregate}}\) generates its high-level embedding \(\mathbf {e}_{u}^{(l)}\) of the \(l\)th layer by aggregating all the neighbors’ embeddings of the \((l-1)\)-th layer. After the same operation of \(L\) layers, we have all layers’ embeddings for user \(u\) as \([\mathbf {e}_{u}^{(0)}, \mathbf {e}_{u}^{(1)}, \ldots , \mathbf {e}_{u}^{(L)}]\). Then, the readout function \(f_{\text{readout}}\) summarizes all layers’ embeddings to form the final high-level embedding. Generally speaking, the \(sum\) function (i.e., \(\mathbf {e}_{u}=\mathbf {e}_{u}^{(0)}+\cdots +\mathbf {e}_{u}^{(L)}\)) and \(concatenation\) function (i.e, \(\mathbf {e}_{u}=(\mathbf {e}_{u}^{(0)}\Vert \cdots \Vert \mathbf {e}_{u}^{(L)})\)) are usually used in practice.

In the following, we take LightGCN [16] as an example to facilitate understanding. Specifically, LightGCN discards the feature transformation and the non-linear activation layer in the aggregation function and conducts message aggregation as:where \(\mathcal {N}_{u}\) and \(\mathcal {N}_{i}\) represent the one-hop neighbors of user \(u\) and item \(i\), respectively. In addition, it can be expressed with the matrix calculation form as follows:Here, \(\mathbf {D}\) is the degree matrix of \(\mathbf {A}\) that serves the purpose of normalization, \(\mathbf {E}^{(l)}\) denotes the embeddings for users and items after \(l\) layers’ aggregation operation of GNN, and \(\mathbf {E}^{(0)}\) denotes the learnable embeddings of users and items.

After propagating \(L\) layers, LightGCN utilizes the weighted sum function as the readout function to combine the embeddings of all layers and calculate the final embeddings as follows:where \(\mathbf {e}_u\) and \(\mathbf {e}_i\) denote the final representations of user \(u\) and item \(i\), respectively. Then, the inner product between them is calculated to predict the preference score of user \(u\) towards item \(i\):

This module mainly aims to identify some suspicious edges in the existing interaction graph and reduce their negative impact on message propagation. We next show how we denoise the interaction graph between users and items, which mainly consists of the following two steps: (1) cleanness score computation, (2) interaction denoising.

Previous studies have mainly been organized to alleviate the negative impact of noisy samples in recommender systems from the perspective of sample selection or re-weighting in the graph structure space. Here, we propose to further enhance the robustness of the model by first adding noisy perturbations in the latent embedding space and then applying contrastive learning to learn more robust embeddings. The process is depicted in Figure 2.

Overall, the training loss of our method iswhere \(\lambda _{1}\) and \(\lambda _{2}\) are hyper-parameters to control the strengths of the contrastive loss in the embedding space and the regularization loss with Frobenius norm on the embedding matrices, respectively. \(\Theta = \mathbf {E}^{(0)} = (\mathbf {E}_{u}^{(0)}, \mathbf {E}_{i}^{(0)})\) includes the model parameters to be learned. The entire training process is carried out in an end-to-end manner, and the training pseudocode is summarized in Algorithm 1. First, we construct the denoised graph \(\tilde{G}\) based on the original interaction graph \(G\). This process does not generate gradient, and all subsequent learning losses are calculated based on the denoised graph \(\tilde{G}\). Then, we compute the BPR loss \(\mathcal {L}_{\text{BPR }}\) and the contrastive learning loss \(\mathcal {L}_{cl}\), which are to be jointly optimized.

We compare the overall performance of all the methods on different datasets. The comparison results of clean datasets (the original datasets without additional noisy interactions), noisy datasets with 10% noisy interactions, and 20% noisy interactions are shown in Tables 4, 5, and 6, respectively.

First, from Table 4, we can observe that RocSE achieves the best performance on all clean datasets and outperforms the state-of-the-art method SimGCL with a noticeable margin on the Amazon Books dataset (e.g., up to 8.25% relative improvement). Compared with NGCF and LightGCN, DeCA performs comparably, and T-CE has better performance on Yelp and Amazon datasets, but drops on other two datasets. The other three methods SGL, NCL, and SimGCL all utilize contrastive learning as an auxiliary task, which makes a significant improvement in performance. These three methods construct the views of contrastive learning in different ways. SGL augments different interaction graphs with edge dropping; NCL constructs views by using structure neighbors and semantic neighbors in the interaction graph; SimGCL builds different views by adding random representation noise. These different strategies also achieved different effects on different datasets. For example, NCL has considerable performance on ML-1M and Yelp, but drops on Amazon. A possible reason is that NCL is more suitable for datasets with denser interactions where user (item) neighbors are more informative. SGL has a good improvement in each dataset compared to the LightGCN baseline, and the overall performance of SimGCL is the best among three methods. The probable reason is that constructing a contrastive view by adding random noise in the embedding space can make the representations of users and items more uniform. It is worth noting that the second part (embedding space perturbation) of our work is similar to SimGCL, which also introduces noises for representations. The main difference of our method is that it mimics the attacking behavior by using the existing user/item embeddings as perturbations and further considers denoising in the structure space.

Second, Tables 5 and 6 show the results where extra noisy interactions are injected into the training data. We can first observe that RocSE still achieves improvements on all the datasets compared to the existing neural graph collaborative filtering methods. For example, on the Amazon dataset, RocSE improves the best competitor (SimGCL) by up to 14.32% and 19.61% on the NDCG@10 metric when 10% and 20% noise are randomly injected, respectively. Additionally, RocSE achieves higher relative improvements in nearly all the cases when noises are injected compared to the clean setting, and the relative improvements are further enlarged with more noises. This means that our RocSE is more robust compared to the existing methods when there are more noises in the data. Moreover, observing the performance of RocSE across the datasets, we find that RocSE tends to be more effective on sparser and larger datasets, which are more common in the real world. We conjecture that there are two possible reasons for this observation. First, denser datasets contain more reliable information, making them more robust against noises. This is also supported by the observation that all the methods perform relatively better on the ML-1M dataset, which is extremely denser (at least around \(30\times\) denser than the other three datasets). Second, for a large and sparse interaction graph, noisy interactions may have a greater impact on the neighbor nodes. Considering the case when most of the edges for a given node are noisy interactions, it would be extremely difficult to make correct predictions for this given node. As to the existing methods, we can also observe that contrastive learning mitigates the effect of noise to a certain extent. For example, SimGCL, NCL, and SGL all outperform LightGCN with a relatively large margin. Among them, SimGCL also seems to be more effective under the interference of noise compared with SGL and NCL. But still, they are less effective than RocSE.

To more intuitively show the negative impact of noisy interactions, we compare the performance degradation of all methods after adding noises. As shown in Table 7, we summarize the drop points and drop rates of the NDCG@10 metric for all the compared methods after adding 10% and 20% noisy interactions. By comparing the results, we can easily find that almost all methods, especially LightGCN and NGCF, have a cliff-like decline of their performance with the increase of additional noisy interactions. Specifically, when adding 20% noisy interacions, both NGCF and LightGCN have a more than 20% performance drop on Yelp, Amazon Books, and Gowalla. An important reason may be that the message-passing mechanism of GNN exacerbates the negative effects of noisy interactions, which is also why we need to pay close attention to the model robustness of GNN-based collaborative filtering. With a dual denoising scheme, our proposed method successfully maintains performance degradation below 3% on all datasets, which is far better than the other methods in the latter three datasets. T-CE performs relatively well in terms of performance degradation on the ML-1M dataset. The probable reason is that the backbone CDAE [55] used by T-CE is more stable for dense datasets (e.g., ML-1M) compared with LightGCN. Still, the performance of T-CE significantly drops for sparse datasets.

We next further examine whether RocSE can truly identify noisy interactions. For this purpose, we test whether the trained model can successfully distinguish noisy interaction samples by calculating the prediction scores (i.e., Equation (6)) for noisy and clean interactions separately. The prediction score for the interaction reflects how well the model adapts to the interaction, and a higher prediction score indicates that the model has higher confidence considering the corresponding interaction as a clean sample. The results of LightGCN and RocSE on datasets with 20% noisy interactions are shown in Figure 3, where the blue boxes and orange boxes represent clean and noisy samples, respectively. As can be seen from the figure, compared with LightGCN, the prediction scores of clean samples and noise samples by RocSE have a more obvious difference, which indicates that our method can distinguish noise samples from clean samples more effectively. For example, on the Amazon-20% dataset, the prediction scores of our method for the additional noisy interactions are kept in a very low range, which is consistent with the excellent performance of RocSE in Table 6.

In summary, to answer RQ1 , the proposed RocSE outperforms the state-of-the-art neural graph collaborative filtering methods, and such improvements are further enlarged when there are injected noisy interactions in the training data. Furthermore, RocSE performs especially better compared to the existing methods when the datasets are large and sparse, which is the usual case in practice.

In this part, we analyze the impact of four important hyper-parameters (i.e., \(\tau\), \(\lambda _{1}\), \(\epsilon\), and \(\theta\)) in RocSE. For simplicity, we only show the Recall@10 and NDCG@10 results on datasets with 20% noisy interactions, and the results are similar in other cases.

Finally, we evaluate the efficiency aspect of the proposed method. We compare the actual training time of the proposed RocSE with LihgtGCN and SGL. The results are shown in Table 10, where all the results are collected on an Intel(R) Xeon(R) Silver 4110 CPU and a GeForce RTX 2080 GPU.

As shown in Table 10, we count the training time of every single epoch, the number of epochs to converge under the same early stopping strategy, and the total training time for all methods. We also calculate the multiple of RocSE’s training time compared to LightGCN. We can observe from the table that the training time per epoch of our method is surprisingly reduced compared to SGL. The reason is that there is no reliance on graph structure augmentation to construct comparative learning views in our method. Compared with the LightGCN, although the training time in each epoch is three times slower, RocSE only takes 42% and 21% extra training time on the larger Yelp-20% and Amazon-20% datasets. This is mainly due to the faster convergence speed of our method. Considering the benefit brought in the effectiveness and robustness aspects, such extra computational cost is affordable in practice.

In summary, to answer RQ4 , although additional denoising and perturbation modules are adopted, the proposed RocSE only incurs affordable extra computational cost compared with LightGCN. It runs even faster than SGL.

Compared to early studies [1, 13] that propagate user preferences on the graph with random walks, neural graph collaborative filtering has received more recent attention [46]. Different from traditional collaborative filtering methods, neural graph collaborative filtering methods model users’ preferences by utilizing the graph structure information of user-item interactions. Generally, it employs the recent progress of graph neural networks (e.g., GCN [23]) to learn the complex relations within the user-item interactions [6, 16, 27, 29, 37, 42, 49, 50, 54, 60, 62, 64, 68]. For example, NGCF [49] obtains high-level collaborative signals of users and items with the message propagation in the user-item graph. LCF [64] removes noises and improves the efficiency of graph convolution for the recommendation. LightGCN [16] discards transformation matrices and nonlinear activation functions in GCN, making it more simple and more effective. EGLN [60] proposes to simultaneously learn the user/item embeddings and the graph structure in a mutual way. More recently, some self-supervised learning methods for neural graph collaborative filtering have emerged. In particular, some methods consider contrastive learning as an auxiliary task and have achieved remarkable results. For example, SGL [54] constructs different contrastive learning views by performing random dropout augmentation on the graph structure. NCL [26] designs a prototypical contrastive objective to capture the correlations between a user/item and its prototype. SimGCL [63] directly adds random uniform noise to the representation for data augmentation. In addition to the above work, GNN-based recommender systems have also been applied in some other scenarios. For example, GNNs have been used to model social network and user interactions in social recommendation [7, 32, 61], to model the graph transformed from the sequence of user behaviors in sequential recommendation [2, 3, 19], and to model the hypergraph of high-order item relations in session-based recommendation [45, 57].

Despite the effectiveness of recent neural graph collaborative filtering methods, the robustness aspect remains largely unexplored, especially considering that GNNs themselves are shown to be vulnerable to adversarial attacks [59, 69, 70, 71] and there exist ubiquitous noisy interactions in the feedback of recommender systems. In this work, we mainly focus on improving the robustness of neural graph collaborative filtering against noises and meanwhile maintaining its effectiveness.

Existing recommender systems are typically trained with implicit feedback (e.g., viewing a movie or clicking a picture) due to the large volume. Generally, we view the existing historical interactions in implicit feedback as positive samples, while unobserved interactions as negative samples. However, previous studies [20, 28, 53] have noted the prevalence of noisy interactions (named false-positive interactions) in the observed interactions, which cannot reflect the actual user satisfaction. For example, in E-commerce, a large portion of click behaviors of users are triggered by curiosity, which does not directly indicate a positive user perception of the products. Most implicit interactions are easily influenced by the first impression of the users and other factors [5, 48] such as caption bias [18] and position bias [22]. Moreover, Wen et al. [53] have proved the detrimental effect of such false-positive interactions on the user experience of online services. However, unobserved interactions may attribute to the unawareness of users, because the items are simply not exposed to them. As a result, there are also potential positive samples (false-negative interactions) in unobserved interactions that are mixed with truly negative interactions [35, 38]. EGLN [60] has tried to solve this problem based on enhanced graph learning.

In a nutshell, directly using implicit feedback without considering the noise factor tends to obtain a sub-optimal recommender system, which is unable to understand the real preferences of users [47, 58]. In this work, we mainly consider the false-positive samples as noisy interactions in the user-item graph.

Recently, significant attention has been dedicated to the robustness of recommender systems due to their vulnerable property to noisy interactions [11, 12, 24, 47, 51, 52, 65]. To build more robust recommender systems, some auto-encoder methods [24, 41, 55] introduce denoising techniques by corrupting the interactions of users with random noises and then trying to reconstruct the original one with auto-encoders. However, some methods have been dedicated to directly reducing the negative impact of noisy interactions in implicit feedback that can be categorized into sample selection methods [11, 52, 65] and sample re-weighting methods [47, 51]. Sample selection methods tend to denoise implicit feedback by selecting clean and informative samples only. For example, WBRP [11] considers that missing interactions of popular items are likely to be true negative examples and thus assigns them higher sampling probabilities. IR [52] interactively generates pseudo-labels for user preferences based on the difference between labels and predictions to discover noise-positive and noise-negative examples. Sample re-weighting methods tend to distinguish noisy interactions from clean data based on loss values and predictions in the training process. For example, T-CE [47] tries to assign lower weights to high-loss samples, especially in the early stage. DeCA [51] considers that different models tend to make similar predictions on truly clean interactions and develops an ensemble method by minimizing the KL-divergence between two model predictions. Although these methods achieve promising results, they usually depend on specific models or loss values and are sub-optimal or not applicable to neural graph collaborative filtering, as they do not consider the noise diffusion. More recently, denoising has received close attention. For example, SGCN [4] reduces the negative effects of noise via a stochastic binary mask. SGL [54] enhances the robustness against interaction noises with self-supervised learning by employing graph structure augmentations. However, they only consider augmenting the structure of the interaction graph with dropping/masking operations, while not considering how to improve the robustness of neural graph collaborative filtering in a more comprehensive perspective.

Compared with previous studies [47, 51, 52], our RocSE is tailored for enhancing the robustness of neural graph collaborative filtering. Considering that the message-passing scheme of GNNs may be more vulnerable to noisy interactions, we conduct structural denoising on the interaction graph and directly affect the information propagation of noisy interactions in GNNs to mitigate the negative effects of noise diffusion. Unlike existing methods [4, 54] for building robust models, we not only utilize edge dropping as a hard structure denoising strategy but also consider re-weighting interaction edges as a soft strategy. Different from References [47, 51], which identify the noisy interactions by considering loss value or disagreement of different models, we conduct structure denoising based on the similarity computed upon the neighborhood, which is simple yet has been proved to be effective. To the best of our knowledge, this work is also the first work that attempts to enhance model robustness from a dual perspective of graph structure denoising and embedding space perturbation for neural graph collaborative filtering.

In the beginning of each training epoch, we re-calculate the weight of all observed interactions for structure denoising based on Equations (7)–(11).

Step 1.1: First, we calculate the embeddings for cleanness score in Equations (15) and (16), which is equivalent to calculate \({\bf E}^{(1)}\) and \({\bf E}^{(2)}\) as below:

The adjacency matrix \(\mathbf {A}\) is a sparse matrix with \(2 * |\mathcal {E}|\) elements, \(\mathbf {E}^{(0)}\) is the initial embedding matrix with embedding size \(d\). The complexity of Step 1.1 is \(\mathcal {O}(2|\mathcal {E}|d) + \mathcal {O}(2|\mathcal {E}|d) = \mathcal {O}(4|\mathcal {E}|d)\).

Step 1.2: Then, we calculate the cleanness score for all observed interactions based on Equations (9)–(10).

The complexity of Equations (9) and (10) is \(\mathcal {O}(3d)\) and \(\mathcal {O}(1)\), respectively. So, the whole complexity of Step 1.2 is \(\mathcal {O}(2|\mathcal {E}|d) + \mathcal {O}(|\mathcal {E}|) = \mathcal {O}(|\mathcal {E}|(3d+1))\).

Step 1.3: Next, we calculate the final denoised weight for all observed interactions based on Equation (11). The complexity of this step is \(\mathcal {O}(|\mathcal {E}|)\).

In conclusion, the complexity of structure denoising in each epoch is \(\mathcal {O}(4|\mathcal {E}|d) + \mathcal {O}(|\mathcal {E}|(2d+1)) + \mathcal {O}(|\mathcal {E}|)=\mathcal {O}(|\mathcal {E}|(6d+2))\), and the whole training complexity of it is \(\mathcal {O}(7|\mathcal {E}|ds+2|\mathcal {E}|s)\).

Before training starts, we need to compute the original adjacency matrix of the interaction graph; besides, in each training epoch, we need to re-calculate the adjacency matrix of denoised graph with denoised weights.

Step 2.1: Calculate the adjacency matrix of interaction graph \(\mathbf {A}\). As \(\mathbf {A}\) is a sparse matrix with \(2*|\mathcal {E}|\) elements, so the complexity is \(\mathcal {O}(2|\mathcal {E}|)\).

Step 2.2: Calculate the denoised adjacency matrix \(\hat{\mathbf {A}}\). Since the hard strategy in the structure denoising process may directly drop some observed interactions, assuming that we have dropped \(1-\rho ^{\prime }\) interactions, then \(\hat{\mathbf {A}}\) is a sparse matrix with \(2 * \rho ^{\prime } * |\mathcal {E}|\) elements, so the complexity is \(\mathcal {O}(2 \rho ^{\prime }|\mathcal {E}|)\).

In conclusion, we calculate Step 2.1 once before training and calculate Step 2.2 once in each training epoch, so the whole complexity of this part is \(\mathcal {O}(2|\mathcal {E}|) + \mathcal {O}(2 \rho ^{\prime }|\mathcal {E}|s) = \mathcal {O}(2|\mathcal {E}| + 2 \rho ^{\prime }|\mathcal {E}|s)\).

In the training process, we obtain the node representation with graph convolution.

Step 3.1: First, we need to calculate the node representation for BPR loss in Equation (12). As our calculation is based on the denoised graph, whose adjacency matrix \(\hat{\mathbf {A}}\) is a sparse matrix with \(2 * \rho ^{\prime } * |\mathcal {E}|\) elements, so the complexity of graph convolution after \(L\) GNN layers is \(\mathcal {O}(2\rho ^{\prime }|\mathcal {E}| Ld)\)

Step 3.2: Then, we also need to calculate the node representation after embedding perturbation for contrastive learning loss in Equation (17). Ignoring the time consumption of the embedding shuffle operation, the graph convolution process is the same as Step 3.1. As we need two random contrastive views, so the complexity is twice that of Step 3.1: \(\mathcal {O}(4\rho ^{\prime }|\mathcal {E}| Ld)\).

As we need to compute the node presentation in each training batch, so the whole computing time is \(s * \frac{|\mathcal {E}|}{B}\). In conclusion, the complexity of this part is \(\mathcal {O}(2\rho ^{\prime }|\mathcal {E}| Lds\frac{|\mathcal {E}|}{B}) + \mathcal {O}(4\rho ^{\prime }|\mathcal {E}| Lds\frac{|\mathcal {E}|}{B})= \mathcal {O}(6\rho ^{\prime }|\mathcal {E}| Lds\frac{|\mathcal {E}|}{B})\).

We calculate the BPR loss as the main supervised loss function based on Equation (12). As the time consumption is mainly in calculating the inner product of interaction embeddings(\(\mathcal {O}(d)\)), and there are \(|\mathcal {E}|\) positive interaction samples and \(|\mathcal {E}|\) negative interactions, so the time complexity is \(\mathcal {O}(2|\mathcal {E}|ds)\).

We implement InfoNCE Loss as our contrastive learning loss function. The time complexity of calculating positive pairs in numerator is \(\mathcal {O}(|\mathcal {E}|ds)\); as we only consider the negative pairs in a mini batch, so the time complexity of calculating negative pairs in denominator is \(\mathcal {O}(|\mathcal {E}|Mds)\), where \(M\) is the number of nodes in a training batch. In conclusion, the complexity of this part is \(\mathcal {O}(|\mathcal {E}|ds + |\mathcal {E}|Mds)\).