Improving Graph Collaborative Filtering from the Perspective of User–Item Interaction Directly Using Contrastive Learning

Abstract

Graph contrastive learning has demonstrated significant superiority for collaborative filtering. These methods typically use augmentation technology to generate contrastive views, and then train graph neural networks with contrastive learning as an auxiliary task. Although these methods are very effective, they do not consider using contrastive learning from the perspective of user–item interaction. As a result, they do not fully leverage the potential of contrastive learning. It is well known that contrastive learning can maximize the consistency of positive pairs and minimize the agreement of negative pairs. Collaborative filtering expects high consistency between users and the items they like and low consistency between users and the items they dislike. If we treat the items that users like as positive examples and the items they dislike as negative examples, contrastive learning can work very well with the goal of collaborative filtering. Based on the above understanding, we propose a new objective function called DCL loss, which improves graph collaborative filtering from the perspective of user–item interaction when Directly using Contrastive Learning. Extensive experiments have shown that when a model adopts DCL loss as its objective function, both its recommendation performance and training efficiency exhibit significant improvements.

1. Introduction

In the past few decades, a large amount of information has poured into people’s worlds, making it more and more difficult for people to find what they are interested in [1]. The recommendation system can filter out information that people are not interested in, and recommend information that people are interested in, so as to alleviate the information overload problem [1,2,3,4]. Therefore, recommender systems have become a hot topic in industry and academia. In a recommendation system, collaborative filtering is a classic algorithm. It uses historical user–item interactions to obtain users’ preferences, and then recommends related items to users [1,5,6,7]. Due to its simplicity and ease of use, collaborative filtering has been widely used and studied by a large number of researchers.

Initially, the matrix factorization technique was applied to collaborative filtering and achieved quite good recommendation performance [8,9]. But matrix factorization cannot leverage neighbor information, thus limiting its recommendation performance. The graph neural network can obtain neighbor information through the message-passing mechanism [10]. As a result, some researchers have applied graph neural networks to collaborative filtering to further improve recommendation performance. Although graph collaborative filtering is very effective, it still has two main shortcomings. One is the over-smoothing problem of graph neural networks. As the number of graph neural network layers increases, the node embeddings will become more and more similar, which affects the performance of the network [11]. At present, there is still no good solution to the over-smoothing problem. Therefore, graph neural networks are generally designed with 3–5 layers to achieve the best performance. The other is the problem of data sparsity. Data sparsity means that in the entire dataset, a specific user has interacted with very few items and has not interacted with many items. To alleviate the problem of data sparsity, researchers have introduced contrastive learning [12].

Graph contrastive learning integrates contrastive learning into graph neural networks to improve the performance of collaborative filtering [13]. It usually uses a graph neural network as the backbone and integrates contrastive learning as an auxiliary task to train the graph neural network. The overall framework of the current graph contrastive learning models is shown in Figure 1. During the model training stage, the joint loss function composed of BPR loss [14] and InfoNCE loss [15] is employed. The calculation process of BPR loss is illustrated in Figure 1c. BPR loss is a typical pair-wise loss function. It encourages increasing the discrimination between positive and negative examples by computing the dot product difference between them [16]. The auxiliary loss function ${\mathcal{L}}_{CL}$ refers to InfoNCE loss, which is commonly used in contrastive learning. Its calculation process is shown in Figure 1f. It is obtained by employing augmentation methods to capture different views of users and items, which are then used in the calculation of InfoNCE loss. These methods include stochastic augmentation (e.g., node/edge perturbation) on the user–item interaction graph, heuristic-based augmentation techniques (e.g., user clustering), etc. [17].

While the existing methods prove effective, they are still plagued by the inadequate exploitation of negative examples within the data. Specifically, there is a substantial quantity of items in a given user’s data that the user has not interacted with. Nonetheless, in the BPR loss function, for every instance of user–item interaction, only a single item which the user has not interacted with is chosen as a negative example. This consequently gives rise to a major shortcoming in graph contrastive learning, as it fails to harness the full potential of items that a particular user has not interacted with in the recommendation task. Even after hundreds of training epochs, a positive example pair only matches with a few hundred negative items. This remains vastly insufficient in terms of leveraging negative examples, thereby not only diminishing the model’s recommendation performance but also hampering its training efficiency.

We can observe that the current graph contrastive learning models perform the selection of positive and negative examples on two occasions. One is during the usage of BPR loss, and the other is during the application of contrastive learning. Actually, we can consider directly applying contrastive learning from the perspective of user–item interaction to enable the model to fully leverage negative examples. We regard the items that a user has interacted with as positive examples and the remaining items as negative examples. Then, we can directly use contrastive learning to train the model. This approach is feasible because contrastive learning can work very well with the goal of collaborative filtering. Collaborative filtering expects a high consistency between users and the items they like and a low consistency between users and the items they dislike. Contrastive learning can maximize the consistency of positive pairs and minimize the agreement of negative pairs [12,13].

In this paper, we investigate the training of graph collaborative filtering models directly using contrastive learning. The overall framework of the initially proposed scheme is illustrated in Figure 2. The objective function involved is ${\mathcal{L}}_{DCL\_N}$. The calculation process of ${\mathcal{L}}_{DCL\_N}$ is illustrated in Figure 2d. Positive and negative examples are selected from both user and item perspectives. For a user, all items that they have interacted with are regarded as positive examples and all items that they have not interacted with are regarded as negative examples. For an item, a model’s method of selecting positive and negative examples is the same as that of the user. By doing so, a model can fully leverage negative examples. Next, we conduct experiments on this scheme. The experimental results are decent, but there is still a noticeable gap compared to the current state-of-the-art graph contrastive learning models. On the one hand, this demonstrates the feasibility of training graph collaborative filtering models directly using contrastive learning. On the other hand, it also compels us to make improvements to this scheme. The slightly inferior performance of ${\mathcal{L}}_{DCL\_N}$ may be attributed to its insufficient and inadequate utilization of positive examples. Therefore, inspired by BPR loss [14], we select positive and negative examples based on each user–item interaction. The computation process of the improved objective function ${\mathcal{L}}_{DCL}$ is depicted in Figure 3. For each user–item interaction, the user and item involved in the interaction are considered positive examples of each other. For the user, we randomly select n items that it has not interacted with as negative examples. For the item, we randomly select n users who have not interacted with it as negative examples. Subsequently, the improved objective function ${\mathcal{L}}_{DCL}$ is constructed. This can ensure the full utilization of positive examples while adequately leveraging negative examples. In the end, we perform a lot of experiments. The experimental results show that when a model uses ${\mathcal{L}}_{DCL}$ as the objective function, both the recommendation performance and the training efficiency will be greatly improved.

In summary, the main contributions of this work are as follows:

• We propose selecting positive and negative examples from the perspective of user–item interaction, which can enable contrastive learning to effectively achieve the goal of collaborative filtering.
• We propose the objective function DCL loss, which significantly improves both the performance and training efficiency of the graph collaborative filtering models.
• We conduct extensive experiments on four benchmark datasets to demonstrate the superiority of DCL loss.

The remainder of this paper is organized as follows: In Section 2, we first provide a review of the related literature. In Section 3, we introduce graph collaborative filtering and graph contrastive learning. Section 4 provides a detailed introduction to the original objective function DCL_N loss and the improved objective function DCL loss. Extensive experimental research is presented in Section 5. We conclude this work in Section 6.

2. Related Work

2.1. Collaborative Filtering

The principle of collaborative filtering is that people tend to cluster together based on similarities, and items are grouped based on common characteristics. Initially, collaborative filtering directly obtains user similarity through a co-occurrence matrix. However, this approach results in the problems of a significant head effect and weak generalization ability. Matrix factorization is introduced to alleviate these issues by incorporating latent vectors [9]. BiasMF [18] introduces user and item bias into the matrix factorization technique to obtain the users’ intrinsic preferences for items. ConvNCF [19] initially produces an outer product between user and item vectors to obtain a two-dimensional matrix, which is subsequently fed into a convolutional network as an input to derive a preference score for the user towards the item.DMF [20] adopts row vectors from the user–item interaction matrix as user feature vectors and column vectors as item feature vectors, subsequently constructing a deep learning model for training. ENMF [21] employs an efficient neural matrix factorization model without sampling, utilizing all negative instances in each training iteration. But matrix factorization does not exploit high-order information, making its recommendation performance limited. Graph neural networks have the ability to aggregate information from neighborhood nodes. Therefore, they are being increasingly applied in this field. GC-MC [22] combines the graph convolution technique with the matrix factorization technique to obtain the local structure and the global structure of the bipartite graph. Pinsage [3] constructs item graphs based on item features and learns item representations through graph convolutional networks for web-scale recommendation. NGCF [8] applies a graph neural network to collaborative filtering, and concatenates the output of each layer as the final representation of the nodes.Multi-GCCF [23] designs a decomposer based on graph convolution to distinguish users’ intention to purchase items, and fuses different types of representations of nodes through a combiner. DGCF [24] decouples users’ intentions to purchase products to form different subgraphs, and concatenates the node sub-embeddings learned from different subgraphs to obtain the final embeddings. LightGCN [10] removes the feature transformation and nonlinear activation operations commonly used in graph neural networks, which greatly simplifies graph collaborative filtering. DHCF [25] uses hypergraphs to add features of items, so that the model can learn better node representations. HGCF [26] defines user and item embeddings into hyperbolic space, and encodes high-level node information through skip-GCN connection. HICF [27] proposes a new method in the hyperbolic space to alleviate the problem of a long tail effect. In addition, some researchers improve its performance by studying objective functions. UltraGCN [28] approximates the effect of infinite-layer graph convolutions by optimizing the proposed constraint loss. DirectAU [29] proposes a new loss function called DiretAU for collaborative filtering from the perspective of the alignment and uniformity of node vector distribution. However, the integration of these objective functions with graph neural networks does not lead to a significant improvement in recommendation performance.

2.2. Graph Contrastive Learning

Contrastive learning, an unsupervised learning methodology, has already demonstrated substantial potential in the domain of deep learning. In image processing, models like MoCo [30] and SimCLR [31] are notably recognized in contrastive learning applications, while in natural language processing, ConSERT [32] and SimCSE [33] are distinguished models within this learning paradigm. Integrating contrastive learning into Graph Neural Networks has also been proven to augment model capabilities. Currently, the realm of collaborative filtering is also witnessing numerous renowned graph-based contrastive learning models. They primarily focus on how to generate better contrastive views. SGL [13] generates views through three methods, such as node perturbation, edge perturbation, and random walk. NCL [34] believes that most graph contrastive learning models use random sampling to generate contrastive pairs, which cannot give full play to the performance of contrastive learning. Therefore, semantic neighbor nodes are constructed based on clustering to form the new different views of contrastive learning. SimGCL [35] believes that it is not necessary to generate different perspectives through graph augmentation technology, which is not only troublesome and time-consuming but also unnecessary. It can directly add noise to node representations to form different perspectives, but its network structure is still the same as that of SGL [13]. XSimGCL [12] further proves that graph augmentation technology is unnecessary, and further simplifies the structure of SimGCL [35], which improves the efficiency of training by about three times. HCCF [36] uses a hypergraph cross-contrast learning structure to capture local and global collaborative information. LightGCL [17] generates the views of contrastive learning in the process of singular value decomposition to obtain global language information. DCCF [37] proposes a disentangled contrastive learning method for recommendation that explores latent factors underlying implicit intent for interactions. AutoCF [38] proposes a new method to automatically perform data augmentation. SimRec [39] proposes a simple and effective collaborative filtering model that marries the power of knowledge distillation and contrastive learning. Figure 1 illustrates the framework of previous works, which employ distinct augmentation techniques in contrastive tasks. However, in recommendation tasks, their reliance on BPR loss as the objective function hinders the full utilization of negative data. Moving forward, Section 3 will provide an in-depth examination of several notable models within the domain of graph-based collaborative filtering, paving the way for the introduction of our study in Section 4.

3. Preliminary Examination

In this section, we first introduce the basic concepts, common notations, and objective function of graph collaborative filtering. Then, we clarify the specific methodology of the current graph contrastive learning by introducing the well-known model XSimGCL. Finally, we analyze the advantages and disadvantages of the current graph contrastive learning.

3.1. Graph Collaborative Filtering

Collaborative filtering is a very classic recommendation algorithm. Its principle is to obtain users’ preferences based on historical user–item interactions, so as to recommend items to target users. Graph collaborative filtering regards users and items as nodes and treats known interactions as edges to obtain a user–item bipartite graph. Then, each user (item) is assigned an initial embedding. Subsequently, user’s preference scores for all items are obtained by training the graph neural network. Finally, the items with high scores are recommended to the corresponding users [34].

Specifically, define $\mathcal{U}=\left\{u\right\}$ to represent the user set, $\mathcal{I}=\left\{i\right\}$ to represent the item set, and $R\in {\{0,1\}}^{\left|\mathcal{U}\right|\times \left|\mathcal{I}\right|}$ to represent the observed interaction matrix. If there is an interaction between user u and item i, then $R_{u,i}=1$, and if there is no interaction between user u and item i, then $R_{u,i}=0$. Let $\mathcal{G}=\{\mathcal{V},\mathcal{E}\}$ denote the user–item bipartite graph, where $\mathcal{V}=\{\mathcal{U}\cup \mathcal{I}\}$ is the set of nodes, and $\mathcal{E}=\left\{(u,i)\right|u\in \mathcal{U},i\in \mathcal{I},R_{u,i}=1\}$ is the set of edges. Then, each user (item) is assigned a d-dimensional embedding [10]. For example, user u is assigned the embedding ${\mathbf{e}}_u^{\left(0\right)}$, and item i is assigned the embedding ${\mathbf{e}}_i^{\left(0\right)}$. Next, these embeddings are concatenated together to form an initial embedding matrix ${\mathbf{E}}^{\left(0\right)}\in {\mathbb{R}}^{\left|N\right|\times d}$, where $\left|N\right|$ is the number of nodes. Namely, ${\mathbf{E}}^{\left(0\right)}$ is denoted as

$${\mathbf{E}}^{\left(0\right)}={\left(\begin{array}{c}{\mathbf{e}}_{u_0}^{\left(0\right)},{\mathbf{e}}_{u_1}^{\left(0\right)},\dots ,{\mathbf{e}}_{i_0}^{\left(0\right)},{\mathbf{e}}_{i_1}^{\left(0\right)},\dots \end{array}\right)}^T$$

(1)

Subsequently, the final embedding matrix $\mathbf{E}\in {\mathbb{R}}^{\left|N\right|\times d}$ for score prediction is obtained by training the graph neural network. Finally, users’ preference scores for items are obtained through dot product calculation. This can be summarized in the following paradigm:

$$\mathbf{E}=\mathit{f}(\mathcal{G},{\mathbf{E}}^{\left(0\right)}),y_{u,i}={\mathbf{e}}_u^T{\mathbf{e}}_i$$

(2)

where $\mathit{f}(·)$ represents the graph neural network model used [39], ${\mathbf{e}}_u$ is the final embedding of user u, ${\mathbf{e}}_i$ is the final embedding of item i, ${\mathbf{e}}_u$ and ${\mathbf{e}}_i$ are embeddings in $\mathbf{E}$, and $y_{u,i}$ is user u’s preference score for item i.

This method generally processes the dataset in the format of triplets. Let $\mathcal{O}=\left\{(u,i,j)\right|R_{u,i}=1,R_{u,j}=0\}$ represent the training dataset, where $R_{u,i}$ and $R_{u,j}$ represent the entry of the observed implicit feedback matrix R (namely, user u and item i have an edge, while user u and item j have no edge, on the user–item bipartite graph). The commonly used pair-wise function is BPR loss [14]. BPR loss is defined as

$${\mathcal{L}}_{BPR}=\sum _{(u,i,j)\in \mathcal{B}}-log\sigma ({\mathbf{e}}_u^T{\mathbf{e}}_i-{\mathbf{e}}_u^T{\mathbf{e}}_j)$$

(3)

where $\mathcal{B}$ is a subset of the training set $\mathcal{O}$, which denotes a mini-batch, and $\sigma$ represents the Sigmoid function.

3.2. Graph Contrastive Learning

Graph contrastive learning trains graph neural networks by integrating contrastive learning as an auxiliary task. The overall framework is shown in Figure 1. Here, we specifically use XSimGCL [12] to illustrate the process of graph contrastive learning. XSimGCL [12] uses LightGCN [10] as the backbone. LightGCN [10] obtains the final embedding matrix $\mathbf{E}$ by iteratively performing neighbor aggregation operation as follows:

$$\mathbf{E}=\frac{1}{L+1}\sum _{i=0}^L{\mathbf{E}}^{\left(i\right)}=\frac{1}{L+1}\sum _{i=0}^L{\mathbf{A}}^i{\mathbf{E}}^{\left(0\right)}$$

(4)

where ${\mathbf{E}}^{\left(\mathbf{i}\right)}$ represents the i-th-layer embedding matrix, $\mathbf{A}\in {\mathbb{R}}^{\left|N\right|\times \left|N\right|}$ is the regularized undirected adjacency matrix without self-connection, and L is the number of the network layers.

But XSimGCL [12] uses the representation-level noise perturbation technique to generate contrastive views. During the training process, the encoder used is defined as

$${\mathbf{E}}^{\prime }=\frac{1}{L}\sum _{i=1}^L{\left({\mathbf{E}}^{\left(i\right)}\right)}^{\prime }=\frac{1}{L}\sum _{i=1}^L\mathbf{A}{\left({\mathbf{E}}^{(i-1)}\right)}^{\prime }+{\mathsf{\Delta }}^{\left(i\right)}$$

(5)

where ${\mathbf{E}}^{\left(i\right)}=\mathbf{A}{\left({\mathbf{E}}^{(i-1)}\right)}^{\prime }$, ${\left({\mathbf{E}}^{\left(i\right)}\right)}^{\prime }$ is the embedding matrix of noise perturbation for ${\mathbf{E}}^{\left(i\right)}$ (namely, ${\left({\mathbf{E}}^{\left(i\right)}\right)}^{\prime }={\mathbf{E}}^{\left(i\right)}+{\mathsf{\Delta }}^{\left(i\right)}$). ${\mathsf{\Delta }}^{\left(i\right)}$ is random noise generated according to ${\mathbf{E}}^{\left(i\right)}$, and ${\mathsf{\Delta }}^{\left(i\right)}$ must satisfy the following conditions:

$${\mathsf{\Delta }}^{\left(i\right)}=\mathbf{X}\odot sign\left({\mathbf{E}}^{\left(i\right)}\right),\mathbf{X}\in R^d\sim U(0,1);{\parallel {\mathsf{\Delta }}^{\left(i\right)}\parallel }_2=\eta$$

(6)

where $\eta$ is a constant that controls the amount of noise added.

Then, the final embedding matrix ${\mathbf{E}}^{\prime }$ and the the K-th-layer noise-perturbed embedding matrix ${\left({\mathbf{E}}^{\left(K\right)}\right)}^{\prime }$ will be selected as two views for contrastive learning ($K\in [1,L]$). Next, the auxiliary loss ${\mathcal{L}}_{CL}$ is defined as

$${\mathcal{L}}_{CL}=\sum _{i\in \mathcal{B}}-log\frac{exp({\mathbf{z}}_i^{\prime T}{\left({\mathbf{z}}_i^{\left(K\right)}\right)}^{\prime }/{\tau }_1)}{{\sum }_{j\in \mathcal{B}}exp({\mathbf{z}}_i^{\prime T}{\left({\mathbf{z}}_j^{\left(K\right)}\right)}^{\prime }/{\tau }_1)}$$

(7)

where $\mathcal{B}$ is a mini-batch, i and j are the users/items included in $\mathcal{B}$, ${\mathbf{z}}_i^{\prime }$ and ${\left({\mathbf{z}}_i^{\left(K\right)}\right)}^{\prime }$ are $L_2$ normalization representations (namely, ${\mathbf{z}}_i^{\prime }=\frac{{\mathbf{e}}_i^{\prime }}{{\parallel {\mathbf{e}}_i^{\prime }\parallel }_2}$, ${\left({\mathbf{z}}_i^{\left(K\right)}\right)}^{\prime }=\frac{{\left({\mathbf{e}}_i^{\left(K\right)}\right)}^{\prime }}{{\parallel {\left({\mathbf{e}}_i^{\left(K\right)}\right)}^{\prime }\parallel }_2}$), ${\mathbf{e}}_i^{\prime }$ is the embedding in ${\mathbf{E}}^{\prime }$, ${\left({\mathbf{e}}_i^{\left(K\right)}\right)}^{\prime }$ is the embedding in ${\left({\mathbf{E}}^{\left(K\right)}\right)}^{\prime }$), and ${\tau }_1>0$ is the temperature coefficient used to adjust the magnitude of penalties applied to hard negative samples. The joint loss function is defined as

$$\mathcal{L}={\mathcal{L}}_{BPR}+\lambda {\mathcal{L}}_{CL}$$

(8)

where $\lambda$ is a hyperparameter, which is used to adjust the weight of contrastive learning in the whole learning process.

3.3. Further Analysis

The above paradigm of graph contrastive learning is very effective. In general, graph contrastive learning models have higher recommendation performance and training efficiency compared to graph neural network models. Some papers on graph contrastive learning explain that integrating contrastive learning can increase the uniformity of node embedding distribution, thereby further alleviating the pervasive popularity bias and promoting long-tail items [12,35]. The pervasive popularity bias in the recommendation system means that usually, the recommendation system will recommend popular items to users with a high probability, but will not recommend some relatively unpopular items. Adding contrastive learning can increase the spatial distance between users and popular items, thereby reducing the probability of recommending popular items and promoting long-tail items.

We believe that the superiority of graph contrastive learning models over graph neural network models lies in their ability to more fully leverage data. The objective function of the graph collaborative filtering models is BPR loss. They use the dataset in the format of triplets, which means that in each triplet, there is only one positive pair and one negative pair. However, we know that in collaborative filtering data, for a specific user, there are a large number of items that the user has not interacted with. Therefore, this raises the issue that using BPR loss as the objective function does not effectively utilize the negative examples in the data. Regarding the solution to this matter, we already mentioned it in the first section.By integrating contrastive learning, a new objective function called InfoNCE loss [15] is introduced. This allows the model to not only leverage the data from user–item interactions, but also handle relationships between users and users, as well as items and items. However, this still does not address the issue of negative examples not being fully utilized in the recommendation task. In graph contrastive learning, the main task still utilizes BPR loss as the objective function, and negative examples are still not fully utilized.

Abandoning BPR loss is necessary to address the issue of negative examples not being fully utilized. Moreover, it is possible to abandon BPR loss. InfoNCE loss and BPR loss serve a similar purpose as they both encourage increasing the discrimination between positive and negative examples. By using InfoNCE loss as the objective function, it allows the model to fully utilize negative examples and further alleviate the issue of data sparsity. Additionally, as mentioned in the first section, selecting positive and negative examples from the perspective of user–item interactions can align the purpose of contrastive learning with the goal of collaborative filtering. In the next section, we make appropriate adjustments to InfoNCE loss to replace the BPR loss used in different models. By doing so, we can fully unleash the potential of contrastive learning, further improving its recommendation performance and enhancing training efficiency.

4. Methodology

In this section, we provide a detailed introduction to the method of training graph collaborative filtering models directly using contrastive learning. We design two methods for selecting positive and negative examples from the perspective of user–item interactions. Based on these methods, we construct the original objective function DCL_N loss and the improved objective function DCL loss.

4.1. Encoder

We needed to obtain the final embeddings for both users and items through an encoder. The process is the same as traditional graph collaborative filtering models, and can be summarized by the following equation:

$$\mathbf{E}=Encoder(\mathcal{G},{\mathbf{E}}^{\left(0\right)})$$

(9)

where ${\mathbf{E}}^{\left(0\right)}$ is the initialized embedding matrix, and its specific expression is given by Equation (1), and $\mathcal{G}$ is the user–item bipartite graph. The $Encoder(·,·)$ utilizes the user–item bipartite graph and the randomly initialized embedding matrix ${\mathbf{E}}^{\left(0\right)}$ to obtain the final embedding matrix $\mathbf{E}$. This encoder can be the same as the BPRMF [14] algorithm, directly setting $\mathbf{E}={\mathbf{E}}^{\left(0\right)}$. It can also be directly encoded using the LightGCN [10] model, as shown in Equation (4). And this can also be performed similarly to XSimGCL [12] by adding noise at the node representation level for encoding, as shown in Equation (5). In conclusion, any effective model that has been proposed can be used as an encoder, whether it is a graph neural network model or a graph contrastive learning model.

4.2. DCL_N Loss

In Section 2.1, we mentioned that the dataset is in the form of triplets. However, as this type of dataset no longer met our requirements, we had to change the format of the dataset to adapt to our method. We attempted to construct the dataset through nodes on the user–item bipartite graph and train the network directly using contrastive learning. The overall framework is illustrated in Figure 2. Specifically, let dataset $\mathcal{O}=\mathcal{V}$, where $\mathcal{V}=\{\mathcal{U}\cup \mathcal{I}\}$ is the set of nodes on the graph. In each training, we will randomly select some nodes to form a new set as a mini-batch $\mathcal{B}=\{v_1,v_2,\dots ,v_b\}$. The selection of positive and negative examples is shown in Figure 2b,c. We use $S_{v_i}^{+}$ to represent the positive example set of node $v_i$, and use $S_{v_i}^{-}$ to represent the negative example set of node $v_i$. If $v_i\in \mathcal{U}$, then $S_{v_i}^{+}$ is the set of all items that the user $v_i$ has interacted with, $S_{v_i}^{-}$ is the set of all items that the user $v_i$ has not interacted with. If $v_i\in \mathcal{I}$, $S_{v_i}^{+}$ is the set of all users that the item $v_i$ has interacted with, $S_{v_i}^{-}$ is the set of all users that the item $v_i$ has not interacted with. Next, we define the DCL_N loss:

$${\mathcal{L}}_{DCL\_N}=-\frac{1}{\left|\mathcal{B}\right|}\sum _{v_i\in \mathcal{B}}log\left(\frac{{\sum }_{p\in S_{v_i}^{+}}exp({\mathbf{z}}_{v_i}^T{\mathbf{z}}_p/\tau )}{{\sum }_{q\in S_{v_i}^{-}}exp({\mathbf{z}}_{v_i}^T{\mathbf{z}}_q/\tau )}\right)$$

(10)

where ${\mathbf{z}}_{*}$ is the embedding after $L_2$ normalization of the embedding ${\mathbf{e}}_{*}$ (namely ${\mathbf{z}}_{*}=\frac{{\mathbf{e}}_{*}}{{\parallel {\mathbf{e}}_{*}\parallel }_2}$), ${\mathbf{e}}_{*}$ corresponds to the final embedding of the node ∗, ∗ refers to $\{v_i,p,q\}$), and $\tau$ is the temperature coefficient. The design of this loss function is referenced from paper [40].

It is worth noting that our method is quite different from the existing graph contrastive learning models. They require some augmentation techniques to generate contrastive views and select positive and negative examples from these different views. The specific process is shown in Figure 1, which we already introduced in detail in Section 1, so we will not reiterate it here. For the objective function DCL_N loss, the selection of positive and negative examples is based on user–item interactions on the graph. Users and items that have interactions with each other are considered positive pairs, while users and items that do not have any interactions are considered negative pairs.

We conducted an initial experiment. We used the LightGCN model as the encoder, adopted DCL_N loss as the objective function, and refer to it as LDCL_N. The overall framework of LDCL_N is shown in Figure 4. The experimental results are shown in

Table 1. Performance and training efficiency of different models.

Dataset	Metric	LightGCN	XSimGCL	LDCL_N
	Recall@10	0.1362	0.1504	0.124
	NDCG@10	0.0876	0.1102	0.0894
Gowalla	#Epoch	585	53	2
	Time/Epoch	5.55 s	7.64 s	10.24 s
	Total Time	54 min 6.75 s	6 min 44.91 s	0 min 20.48 s
	Recall@10	0.0730	0.0926	0.0734
	NDCG@10	0.0520	0.0681	0.0526
Yelp	#Epoch	753	49	5
	Time/Epoch	14.55 s	16.30 s	12.52 s
	Total Time	182 min 36.14 s	13 min 18.70 s	1 min 1.4 s

Bold font indicates the best results, min represents minutes, while s represents seconds.

. They indicate that LDCL_N achieves extremely high training efficiency and yields decent results. LDCL_N outperforms LightGCN in some metrics in terms of recommendation performance, but there is still a significant gap compared to XSimGCL.

Although we tried various methods to improve the performance of this method, the results were not satisfactory. This may be because the design of DCL_N loss is somewhat rough. We analyzed this rough issue based on Formula (10). For a node, the sum of all its positive pairs’ scores is placed in the numerator of Formula (10). However, if we do this, we cannot fully exploit the contribution of each positive pair. Inspired by BPR loss, we decided to select positive and negative examples based on each user–item interaction.

4.3. DCL Loss

We constructed our dataset by selecting positive and negative examples through edges on the user–item bipartite graph, ultimately yielding the DCL loss function. In the process of selecting positive examples, any interaction between a user and an item is deemed a positive pair. Conversely, when choosing negative examples, we adopted a dual perspective, considering both users and items. Specifically, for a user, we randomly selected n items from those they had not interacted with to serve as negative examples; similarly, for an item, we randomly picked n users who had not interacted with it to act as negative examples. To elaborate further, let dataset $\mathcal{O}=\left\{((u,i),S_{ϵ}^{u-},S_{ϵ}^{i-})\right|ϵ\in \mathcal{E},ϵ=(u,i)\}$, where $\mathcal{E}$ is the set of edges on the user–item bipartite graph, and $ϵ$ is an edge associated with user u and item i on the graph. The selection of positive and negative examples is shown in Figure 3b. When selecting positive examples, we consider user u and item i associated with edge $ϵ$ to be positive examples of each other. When selecting negative examples, we employ a random sampling method. Define $S_u^{-}$ as the set of all items that user u has not interacted with, and define $S_i^{-}$ as the set of all users who have not interacted with item i. For the user u associated with edge $ϵ$, we randomly select n items from the set $S_u^{-}$ to form the negative examples set $S_{ϵ}^{u-}$. For the item i associated with edge $ϵ$, we randomly select n users from the set $S_i^{-}$ to form the negative examples set $S_{ϵ}^{i-}$. n is a hyperparameter that needs to be tuned. It is worth noting that $S_{ϵ}^{u-}$ is not only related to the user u, but also related to the edge $ϵ$ it belongs to. That is to say, for each user u, the negative example set is not fixed. For each item i, the situation is the same.

We first define DCL_U loss from the perspective of users:

$$\begin{array}{c}\hfill {\mathcal{L}}_{DCL\_U}=-\frac{1}{\left|\mathcal{B}\right|}\sum _{((u,i),S_{ϵ}^{u-},S_{ϵ}^{i-})\in \mathcal{B}}log\frac{exp({\mathbf{e}}_u^T{\mathbf{e}}_i/\tau )}{exp({\mathbf{e}}_u^T{\mathbf{e}}_i/\tau )+{\sum }_{j\in S_{ϵ}^{u-}}exp({\mathbf{e}}_u^T{\mathbf{e}}_j/\tau )}\end{array}$$

(11)

Then, we define DCL_I loss from the perspective of items:

$$\begin{array}{c}\hfill {\mathcal{L}}_{DCL\_I}=-\frac{1}{\left|\mathcal{B}\right|}\sum _{((u,i),S_{ϵ}^{u-},S_{ϵ}^{i-})\in \mathcal{B}}log\frac{exp({\mathbf{e}}_i^T{\mathbf{e}}_u/\tau )}{exp({\mathbf{e}}_i^T{\mathbf{e}}_u/\tau )+{\sum }_{v\in S_{ϵ}^{i-}}exp({\mathbf{e}}_i^T{\mathbf{e}}_v/\tau )}\end{array}$$

(12)

Finally, DCL loss is defined by computing the sum of ${\mathcal{L}}_{DCL\_U}$ and ${\mathcal{L}}_{DCL\_I}$ as

$${\mathcal{L}}_{DCL}={\mathcal{L}}_{DCL\_U}+{\mathcal{L}}_{DCL\_I}$$

(13)

where $\mathcal{B}$ is a mini-batch, ${\mathbf{e}}_{*}$ represents the final embedding of node ∗ on the graph, ∗ refers to $\{u,i,v,j\}$, and $\tau$ is the temperature coefficient.

As can be seen from the definition of DCL loss, $L_2$ normalization has been removed. This is because users’ preference scores for items are directly calculated through vector dot product operations, as shown in Equation (2). Additionally, the positive example is added to the negative examples in order to stabilize the value of DCL loss. This is reflected in the computation of the denominator in Equations (11) and (12).

We were inspired by BPR loss to construct a new dataset and improve DCL_N loss according to the edges on the graph. Our primary aim within DCL loss was to optimize the exploitation of every positive pair, ensuring the comprehensive utilization of each user–item interaction. Consequently, we eliminated the procedure of summing the scores of positive pairs. A clear differentiation emerges between DCL_N loss and DCL loss, as illustrated in Equations (10) and (11). The former incorporates the summation of positive pair scores, which inadequately leverages positive data. Conversely, DCL loss omits this summation operation, instead focusing on augmenting the disparity between each positive pair and numerous negative pairs in every computational step. This adjustment rectifies the crude design element inherent in DCL_N loss. Furthermore, it ensures that the model harnesses both negative and positive data effectively.

DCL loss can be used as an alternative to BPR loss as the objective function for a model. For example, we utilized the structural frameworks of BPRMF and LightGCN as encoders, integrating DCL loss as the objective function to create new models named DCLMF and LDCL. The structures of these models are depicted in Figure 5. Moreover, DCL loss does not conflict with the current graph contrastive learning method, and can even be combined with the current graph contrastive learning models. They just apply contrastive learning from two different perspectives. For example, if we use XSimGCL as the encoder, then the joint loss function can be defined as

$$\mathcal{L}={\mathcal{L}}_{DCL}+\lambda {\mathcal{L}}_{CL}$$

(14)

where ${\mathcal{L}}_{CL}$ refers to Formula (7) mentioned in Section 3.2. The new model is referred to as XDCL.

In the subsequent experiments, XDCL demonstrates the superior performance. The overall structure of XDCL is depicted in Figure 6, consisting of two main components: one dedicated to recommendation tasks employing DCL loss as its objective function, and another designed for contrastive tasks utilizing InfoNCE loss. At its core, DCL loss is fundamentally akin to InfoNCE loss, yet their roles diverge. DCL loss serves as the primary loss function, derived from the original interaction data, with the purpose of amplifying the dot product scores of interacted user–item embeddings while suppressing those of non-interacted pairs. Conversely, InfoNCE loss operates as an auxiliary loss, necessitating augmentation techniques to procure varied views of users (or items), thereby enhancing consistency within the same user’s (or item’s) different views while diminishing consistency across disparate users’ views.

In DCL loss, two factors influence its performance. One is the size of $S_{ϵ}^{u-}$ ($S_{ϵ}^{i-}$), which refers to the number of negative instances, n. This parameter determines how many negative pairs DCL loss will differentiate the positive pair from during calculation. The other factor is the temperature coefficient, $\tau$, which plays a pivotal role in modulating the scale of similarity measurement between samples.

5. Experiment

In this section, we will demonstrate the superiority of DCL loss through a large number of experiments.

5.1. Datasets

To evaluate the performance of the proposed DCL loss, we used four public datasets to conduct our experiments: Yelp (https://www.yelp.com/dataset (accessed on 12 January 2024)), Amazon Books [41], Gowalla [42], and Alibaba iFashion [43]. These datasets differ in terms of domains, magnitude, and density. They are all real-world datasets. Specifically, for the Yelp and Amazon Books datasets, we excluded users and items that had fewer than 15 interactions to uphold the data’s integrity. The statistics of the datasets are summarized in

Table 2. Statistics of the datasets.

Datasets	#Users	#Items	#Interactions	Density
Yelp	45,478	30,709	1,777,765	0.00127
Amazon	58,145	58,052	2,517,437	0.00075
Gowalla	29,859	40,989	1,027,464	0.00084
Alibaba	300,000	81,614	1,607,813	0.00007

. For each dataset, we divided the data into a training set, a validation set, and a test set in an 8:1:1 ratio. The specific partitioning method is the same as that described in the NCL paper [34].

5.2. Baseline

We choose the following baseline models for performance comparison.

-

BPRMF [14] proposes pair-wise BPR loss for personalized ranking.

-

FISM [44] constitutes an item-oriented collaborative filtering model, wherein it consolidates the representations of a user’s historical interactions to embody their interests.

-

NGCF [8] preprocesses data into a bipartite graph structure and applies graph neural networks to collaborative filtering, thus capturing high-order information.

-

MultiGCCF [45] extends information propagation beyond the user–item bipartite graph, encompassing higher-order correlations among both users and items.

-

DGCF [24] decomposes user interests and uses graph neural networks on the subgraphs to obtain user sub-embeddings, which are concatenated to obtain the final user embedding.

-

LightGCN [10] removes feature transformation and nonlinear activation in graph neural networks, simplifying the graph neural networks while improving recommendation performance.

-

SGL [13] introduces contrastive learning into graph neural networks through graph augmentation techniques, further improving recommendation performance. We use SGL-ED as the comparative scheme.

-

NCL [34] employs structural neighbors and semantic neighbors, which are obtained by using a clustering algorithm for contrastive learning.

-

SimGCL [35] uses the noise perturbation technique to generate different views of contrastive learning, which not only improves performance recommendation but also increases training efficiency.

-

XSimGCL [12] adopts the noise perturbation technique for contrastive learning between cross-layers, further improving training efficiency.

5.3. Evaluation Metrics

We chose Recall@N and NDCG@N as evaluation metrics, where N was set to 10, 20, and 50. This is the same as the NCL [34] too.

5.4. Implementation Details

To ensure a fair comparison, the implementation details were kept consistent with those in the NCL paper. We used the unified open-source framework for recommendation systems RecBole (https://github.com/RUCAIBox/RecBole (accessed on 25 January 2024)) [46] to implement the models that were not included in the NCL paper. The Adam optimizer was chosen as the optimizer for all models. All the parameters were initialized using the default Xavier distribution. We set the batch size to 4096 and the embedding size to 64. The patience of early stopping was set to 10 epochs to prevent overfitting. In DCL loss, only the number n of negative examples and the temperature coefficient $\tau$ needed to be adjusted. We tuned the hyperparameter n in [16, 256] and $\tau$ in [0.01, 5]. When different models used DCL loss as the objective function, we tuned all hyperparameters to achieve the best performance. In order to thoroughly substantiate the reliability of experimental outcomes, each model was trained on every dataset for five iterations, with the final Recall@N and NDCG@N metrics being calculated as the average of these runs.

5.5. Experiment

5.5.1. Overall Performance

The experimental results are shown in

Table 3. Performance comparison of different models.

Dataset	Metric	BPRMF	FISM	NGCF	MultiGCCF	DGCF	LightGCN	SGL	NCL	SimGCL	XSimGCL	XDCL	Improv.
Yelp	Recall@10	0.0643	0.0714	0.0630	0.0646	0.0723	0.0730	0.0833	0.0920	0.0906	0.0920	0.0984	+6.95%
	NDCG@10	0.0458	0.0510	0.0446	0.0450	0.0514	0.0520	0.0601	0.0678	0.0663	0.0678	0.0752	+10.91%
	Recall@20	0.1043	0.1119	0.1026	0.1053	0.1135	0.1163	0.1288	0.1377	0.1373	0.1402	0.1443	+2.92%
	NDCG@20	0.0580	0.0636	0.0567	0.0575	0.0641	0.0652	0.0739	0.0817	0.0805	0.0825	0.0888	+7.24%
	Recall@50	0.1862	0.1963	0.1864	0.1882	0.1989	0.2016	0.2140	0.2247	0.2273	0.2287	0.2318	+1.35%
	NDCG@50	0.0793	0.0856	0.0784	0.0790	0.0862	0.0875	0.0964	0.1046	0.1041	0.1057	0.1116	+5.58%
Amazon	Recall@10	0.0607	0.0721	0.0617	0.0625	0.0737	0.0797	0.0898	0.0933	0.1015	0.1070	0.1167	+9.06%
	NDCG@10	0.0430	0.0504	0.0427	0.0433	0.0521	0.0565	0.0645	0.0679	0.0738	0.0792	0.0874	+10.35%
	Recall@20	0.0956	0.1099	0.0978	0.0991	0.1128	0.1206	0.1331	0.1381	0.1477	0.1534	0.1647	+7.36%
	NDCG@20	0.0537	0.0622	0.0537	0.0545	0.0640	0.0689	0.0777	0.0815	0.0880	0.0933	0.1020	+9.32%
	Recall@50	0.1681	0.0183	0.1699	0.1688	0.1908	0.2012	0.2157	0.2175	0.2309	0.2330	0.2493	+6.99%
	NDCG@50	0.0726	0.0815	0.0725	0.0727	0.0843	0.0899	0.0992	0.1024	0.1099	0.1144	0.1243	+8.65%
Gowalla	Recall@10	0.1158	0.1081	0.1192	0.1108	0.1252	0.1362	0.1465	0.1500	0.1512	0.1504	0.1537	+1.65%
	NDCG@10	0.0833	0.0755	0.0852	0.0791	0.0902	0.0876	0.1048	0.1082	0.1102	0.1102	0.1119	+1.54%
	Recall@20	0.1695	0.1620	0.1755	0.1626	0.1829	0.1976	0.2084	0.2133	0.2146	0.2157	0.2200	+1.99%
	NDCG@20	0.0988	0.0913	0.1013	0.0940	0.1066	0.1152	0.1225	0.1265	0.1282	0.1289	0.1309	+1.55%
	Recall@50	0.2756	0.2673	0.2811	0.2631	0.2877	0.3044	0.3197	0.3259	0.3265	0.3266	0.3330	+1.95%
	NDCG@50	0.1150	0.1169	0.1270	0.1184	0.1322	0.1414	0.1497	0.1542	0.1557	0.1560	0.1587	+1.73%
Alibaba	Recall@10	0.3030	0.0357	0.0382	0.0401	0.447	0.0457	0.0461	0.0477	0.0574	0.0575	0.0615	+6.95%
	NDCG@10	0.0161	0.0190	0.0198	0.0207	0.0241	0.0248	0.0248	0.0259	0.0312	0.0313	0.0337	+7.66%
	Recall@20	0.0467	0.0553	0.0615	0.0634	0.0677	0.0692	0.0692	0.0713	0.0849	0.0847	0.0898	+5.77%
	NDCG@20	0.0203	0.0239	0.0257	0.0266	0.0299	0.0307	0.0307	0.0319	0.0382	0.0382	0.0409	+7.06%
	Recall@50	0.0799	0.0943	0.1081	0.1107	0.1120	0.1144	0.1141	0.1165	0.1361	0.1357	0.1413	+3.82%
	NDCG@50	0.0269	0.0317	0.0349	0.0360	0.0387	0.0396	0.0396	0.0409	0.0484	0.0484	0.0511	+5.57%

Bold font indicates the best results.

. Since the recommended results for SimGCL and XSimGCL were not available in the NCL paper, we reproduced their code using RecBole [46]. The results of the other models were obtained from the NCL paper [34]. As shown in Table 3, NGCF, DGCF, and LightGCN are all models that directly use graph neural networks for recommendation. Among these models, LightGCN demonstrates the best overall recommendation performance. SGL, NCL, SimGCL, and XSimGCL are all graph contrastive learning models. Their differences lie in the methods used to generate contrasting views. SGL is the earliest graph contrastive learning model, but its recommendation results are not satisfactory. Among the graph contrastive learning models, XSimGCL achieves the best overall performance.

As shown in Table 3, XDCL (its structure is illustrated in Figure 6) achieves the best recommendation performance on all datasets. Additionally, the last column in Table 3 displays the percentage improvement in XDCL’s performance compared to the best existing models. We can observe that the maximum improvement reaches up to +10.91%. This is enough to illustrate the superiority of DCL loss.

5.5.2. The Recommendation Performance of Other Models Using DCL Loss as the Objective Function

To further illustrate the superiority of DCL loss. We compared the performance of BPRMF and DCLMF, LightGCN and LDCL, and XSimGCL and XDCL. The structures of these models are shown in Figure 5. The encoder of BPRMF is straightforward as it does not have a network structure. It directly trains the initialized embedding matrix ${\mathbf{E}}^{\left(0\right)}$. LightGCN is the best model in terms of overall recommendation performance in graph neural networks. XSimGCL has the best overall recommendation performance among graph contrastive learning models. Therefore, we utilized these three baseline models as encoders to demonstrate the superiority of DCL loss. The experimental results are given in

Table 4. Performance comparison of other models using DCL loss as the objective function.

Dataset	Metric	BPRMF	DCLMF	LightGCN	LDCL	XSimGCL	XDCL
Yelp	Recall@10	0.0643	0.0880 (+36.85%)	0.0730	0.0955 (+30.82%)	0.0920	0.0984 (+6.95%)
	NDCG@10	0.0458	0.0719 (+11.81%)	0.0520	0.0744 (+43.07%)	0.0678	0.0752 (+10.91%)
	Recall@20	0.1043	0.1241 (+18.98%)	0.1163	0.1418 (+21.92%)	0.1402	0.1443 (+2.92%)
	NDCG@20	0.0580	0.0823 (+41.89%)	0.0652	0.0811 (+24.38%)	0.0825	0.0888 (+7.24%)
	Recall@50	0.1862	0.1957 (+5.10%)	0.2016	0.2298 (+13.98%)	0.2287	0.2318 (+1.35%)
	NDCG@50	0.0793	0.1006 (+26.86%)	0.0875	0.1108 (+26.62%)	0.1057	0.1116 (+5.58%)
Amazon Books	Recall@10	0.0607	0.0972 (+60.13%)	0.0797	0.1108 (+39.02%)	0.1070	0.1167 (+9.06%)
	NDCG@10	0.043	0.0709 (+64.88%)	0.0565	0.0818 (+44.77%)	0.0792	0.0874 (+10.35%)
	Recall@20	0.0956	0.1387 (+45.08%)	0.1206	0.1581 (+31.09%)	0.1534	0.1647 (+7.36%)
	NDCG@20	0.0537	0.0837 (+55.86%)	0.0689	0.0961 (+39.47%)	0.0933	0.1020 (+9.32%)
	Recall@50	0.1681	0.2144 (+27.54%)	0.2012	0.2438 (+21.17%)	0.2330	0.2493 (+6.99%)
	NDCG@50	0.0726	0.1036 (+42.69%)	0.0899	0.1186 (+31.92%)	0.1144	0.1243 (+8.65%)
Gowalla	Recall@10	0.1158	0.1335 (+15.28%)	0.1362	0.1485 (+9.03%)	0.1504	0.1537 (+2.19%)
	NDCG@10	0.0833	0.0965 (+14.76%)	0.0876	0.1081 (+23.40%)	0.1102	0.1119 (+1.54%)
	Recall@20	0.1695	0.1920 (+13.27%)	0.1976	0.2121 (+7.33%)	0.2157	0.2200 (+1.99%)
	NDCG@20	0.0988	0.1132 (+14.51%)	0.1152	0.1263 (+9.63%)	0.1289	0.1309 (+1.55%)
	Recall@50	0.2756	0.2988 (+8.41%)	0.3044	0.3264 (+7.22%)	0.3266	0.3330 (+1.95%)
	NDCG@50	0.1150	0.1392 (+21.04%)	0.1414	0.1542 (+9.05%)	0.1560	0.1587 (+1.73%)
Alibaba iFashion	Recall@10	0.303	0.0346 (+14.19%)	0.0457	0.0534 (+16.84%)	0.0575	0.0615 (+6.95%)
	NDCG@10	0.0161	0.0189 (+17.39%)	0.0248	0.0291 (+17.33%)	0.0313	0.0337 (+7.66%)
	Recall@20	0.0467	0.0521 (+11.56%)	0.0692	0.0790 (+14.16%)	0.0847	0.0898 (+6.02%)
	NDCG@20	0.0203	0.0233 (+14.77%)	0.0307	0.0356 (+15.96%)	0.0382	0.0409 (+7.06%)
	Recall@50	0.0799	0.0854 (+6.88%)	0.1144	0.1265 (+10.57%)	0.1357	0.1413 (+4.12%)
	NDCG@50	0.0269	0.0300 (+11.52%)	0.0396	0.0451 (+13.88%)	0.0484	0.0511 (+5.57%)

Bold font indicates the greatest magnitude of performance enhancement.

.

From Table 4, we can observe that when a model uses DCL loss as the objective function, there is a significant improvement in its recommendation performance. The models between the two vertical lines have the same structural framework, but differ in their objective functions. We calculated the percentage improvement in the performance of the models using DCL loss compared to the previous models. The maximum improvement reached is 64.88%. The main objective function of BPRMF, LightGCN, and XSimGCL is BPR loss. Furthermore, there are some relationships among them. LightGCN introduces a graph neural network based on BPRMF. XSimGCL integrates contrastive learning into LightGCN. Therefore, they exhibit an increasing trend in their recommendation performance. And DCLMF, LDCL, and XDCL also have similar relationships, where their recommendation performance shows an increasing trend as well. So, DCL loss is a good alternative to BPR loss.

The hyperparameter configurations for DCLMF, LDCL, and XDCL are presented in

Table 5. Hyperparameter configurations for the models.

Dataset	Model	L	n	$\mathit{\tau }$	${\mathit{\tau }}_1$	$\mathit{\lambda }$	$\mathit{\eta }$	K
Yelp	DCLMF	-	256	0.2	-	-	-	-
	LDCL	3	256	0.05	-	-	-	-
	XDCL	3	256	0.05	0.15	0.2	0.005	2
Amazon	DCLMF	-	256	0.1	-	-	-	-
	LDCL	3	256	0.05	-	-	-	-
	XDCL	3	256	0.05	0.15	0.3	0.005	2
Gowalla	DCLMF	-	256	0.2	-	-	-	-
	LDCL	3	256	0.05	-	-	-	-
	XDCL	3	256	0.05	0.15	0.2	0.005	2
Alibaba	DCLMF	-	128	1	-	-	-	-
	LDCL	3	128	2	-	-	-	-
	XDCL	3	128	2	0.15	0.03	0.005	2

. Some hyperparameters are common to all models, while others are unique to certain models. For hyperparameters not applicable to a specific model, “-” is entered in the table.

5.5.3. Efficiency Comparison

We set the patience of early stopping to 10 during the training of a model. Therefore, we could record the number of training epochs and the total training time required for a model to reach the best recommendation performance on the validation set. We will compare the training efficiency from the following perspectives:

• The total training time required for a model to achieve the best performance.

When counting the training time, we did not consider the sampling time and the evaluation time. Our experiments were run on an Intel(R) Xeon(R) Gold 6230R CPU @ 2.10 GHz machine with an NVIDIA GeForce RTX 3090 GPU.

We analyzed the training efficiency based on Figure 7. From part (a), it can be observed that when a model utilizes DCL loss, the training time required for one epoch slightly increases. However, from part (b), it is evident that the total number of required training epochs significantly decreases in most cases. As a result, the overall training time is significantly reduced, as indicated in part (c). This means that the training efficiency is greatly improved in most cases. The improvement in training efficiency is related to the design of DCL loss. When a model utilizes DCL loss, it can not only leverage a large number of negative examples, but also accelerate the rate of performance improvement by adjusting the temperature coefficient $\tau$. As a result, the model requires significantly fewer epochs for training, reducing the overall training time.

Both DCL loss and BPR loss were constructed based on the edges of the user–item bipartite graph; hence, their time complexities are correlated with the number of edges in the graph. Assuming there are S edges in the graph, the dimensionality of node embeddings is d, and DCL loss selects n negative examples, the time complexity for computing DCL loss is $O(n·S·d)$, whereas the time complexity for BPR loss is $O(S·d)$. From this analysis, it is evident that the time complexity of DCL loss is n times that of BPR loss. However, in practical training scenarios, the computation time for DCL loss does not typically escalate to exactly n times that of BPR loss. This is because the computation of the dot products for n negative pairs can be expedited through parallel computing, significantly reducing the actual computation time for DCL loss. As clearly illustrated in Figure 7a, the time required for DCLMF to complete one epoch of training is merely two to three times that of BPRMF, far from being n times longer.

5.5.4. Ablation Experiment

From Formula (13), we can see that DCL loss was obtained by summing DCL_U loss and DCL_I loss. To prevent the different models from influencing the experiments, we chose the simplest encoder, $\mathbf{E}={\mathbf{E}}^{\left(0\right)}$, for conducting the experiments. Since the experimental results demonstrate similar performance across all datasets, we present the experimental results on the Gowalla and Amazon Books datasets. The experimental results are shown in Figure 8. From Figure 8, we can observe that DCL loss achieved the best performance. This proves the effectiveness of selecting positive and negative examples from both user and item perspectives simultaneously. Additionally, we can observe that DCL_I loss is trainable, but it performs the worst. This is because DCL_I only selects positive and negative examples from the perspective of the item, which fails to obtain better user representations and consequently leads to poorer recommendation results.

5.5.5. The Impact of the Number n of Negative Examples

Similar to the ablation experiments, in order to mitigate the impact of different models on the experimental results, we investigates the impact of the number n of negative examples using the DCLMF model. In the experiment, we not only measured the performance but also kept track of the number of epochs required for the model to achieve the best recommendation performance. We present the experimental results on the Gowalla and Amazon Books datasets. From Figure 9, it can be observed that n has a significant impact on recommendation performance. As n increases, the recommendation performance continues to improve. However, n has little impact on the efficiency of model training. For different choices of n, the number of epochs required for model training does not vary significantly. The reasonable range for the value of n is [16, 256]. The model demonstrates superior recommendation performance when n is set to 128 or 256.

5.5.6. The Impact of Temperature Coefficient $\tau$

We used the DCLMF model to study the impact of the temperature coefficient $\tau$. Similarly, we present the experimental results on the Gowalla and Amazon Books datasets. The experimental results are shown in Figure 10. As $\tau$ increases, the recommendation performance exhibits a trend of initially increasing and then decreasing. Moreover, $\tau$ has a significant impact on training efficiency. When $\tau$ is small, the model only needs to be trained for a few epochs to achieve the best recommendation performance. However, when $\tau$ is large, the model needs to be trained for several tens of epochs to reach the optimal recommendation performance. The appropriate range for the value of $\tau$ is [0.01, 5]. The model exhibits optimal recommendation performance when $\tau$ falls within the interval [0.05, 2].

6. Conclusions

We propose that graph collaborative filtering models can be trained directly using contrastive learning. We select positive and negative examples from the perspective of user–item interactions and construct a novel objective function called DCL loss. DCL loss is a choice to replace BPR loss, allowing the model to fully utilize negative examples. When existing models use DCL loss as the objective function, both their recommendation performance and training efficiency can be significantly improved. Based on our research, it is apparent that contrastive learning holds enormous potential in the field of graph collaborative filtering. So, further in-depth research and analysis are necessary to fully explore its capabilities.