Prototypical Graph Contrastive Learning for Recommendation

Abstract

Data sparsity caused by limited interactions makes it challenging for recommendation to accurately capture user preferences. Contrastive learning effectively alleviates this issue by enriching embedding information through the learning of diverse contrastive views. The effectiveness of contrastive learning in uncovering users’ and items’ latent preferences largely depends on the construction of data augmentation strategies. Structure and feature perturbations are commonly used augmentation strategies in graph-based contrastive learning. Since graph structure augmentation is time consuming and can disrupt interaction information, this paper proposes a novel feature augmentation contrastive learning method. This approach leverages preference prototypes to guide user and item embeddings in acquiring augmented information. By generating refined prototypes for each user and item based on existing prototypes to better approximate true preferences, it effectively alleviates the over-smoothing issue within similar preferences. To balance feature augmentation, a prototype filtering network is employed to control the flow of prototype information, ensuring consistency among different embeddings. Compared with existing prototype-based methods, ProtoRec achieves maximum gains of up to 16.8% and 20.0% in recall@k and NDCG@k on the Yelp2018, Douban-Book, and Amazon-Book datasets.

1. Introduction

Recommender systems can discover users’ preferences towards items and recommend potentially related items to users, which is an important method for alleviating the problem of information overload [1]. As user–item interaction data continue to grow, traditional shallow models such as matrix factorization (MF) [2] and collaborative filtering (CF) [3] often struggle to capture complex high-order relationships. Graph neural networks (GNNs) [4], on the other hand, address this limitation by learning collaborative information between nodes based on existing interaction graphs and leveraging multi-layer structures to explore potential relationships in higher-order neighborhoods. However, the performance of GNNs heavily relies on the quality of the interaction graph. In recommendation tasks, the quality of the interaction graph is often constrained by several factors. First, data sparsity [5] caused by the limited number of user–item interactions poses a significant challenge. Second, noise introduced by user misoperations or short-term behavioral preferences further impacts the graph’s reliability. Third, the lack of interaction records for certain long-tail items results in their under-representation. These issues not only weaken the expressive power of interaction graphs but also present substantial challenges for GNN-based recommendation methods.

To address the aforementioned issues related to data sparsity [6], contrastive learning (CL) demonstrates strong adaptability by extracting latent features from unlabeled data. It aims to optimize the distribution of the embedding space by constructing positive and negative sample pairs, bringing samples with similar features closer together while pushing dissimilar samples apart. This enhances the model’s representation capability for sparse data and further improves recommendation performance [7]. In graph-based contrastive learning, the primary methods for constructing contrastive views include structural augmentation and feature augmentation [8]. Structural augmentation is a strategy for constructing contrastive views by adding or removing nodes and edges in the user–item interaction graph [9]. Due to the large scale of the data, it is challenging to accurately remove noisy data or add effective interactions. As a result, existing structural augmentation methods typically adopt a random dropout approach. While removing noise or adding valid interactions can improve model performance to some extent, the dropout of critical nodes or edges may introduce additional noise. In more severe cases, such actions could disrupt the connectivity of the interaction graph, thereby undermining the ability of GNNs to capture high-order information. Ref. [10] indicates that various dropout strategies in graph structure have minimal impact on recommendation performance. Feature augmentation is a strategy that adds random noise or generates perturbations in the embedding space [11]. This approach modifies embeddings without altering the original graph structure to construct contrastive views. However, introducing excessive noise can make it difficult for the model to distinguish between meaningful feature information and irrelevant noise, thereby hindering its ability to preserve the core preference information of the features. Graph-based contrastive learning still faces the over-smoothing problem caused by deep graph convolution due to the application of graph neural networks on different views [12].

To address the limitations and challenges of graph-based contrastive learning in recommendation mentioned above, this paper proposes a simple yet effective method called ProtoRec, which employs prototype-based feature augmentation-guided contrastive views. ProtoRec distinguishes itself from existing methods that rely on random noise-based augmentation strategies by employing clustering methods to identify preference prototypes within the embedding space. By guiding all users and items to semantically construct potential neighborhood relationships and learning preference information, ProtoRec effectively addresses the challenge of distinguishing noise from meaningful features, thereby enhancing their latent representations [13,14,15]. Compared to existing prototypical contrastive learning approaches that utilize only a small amount of prototype information, ProtoRec refines prototype features for each user and item during training, ensuring the diversity of augmented information and preventing excessive similarity among embeddings within the same preference group. Furthermore, ProtoRec adopts a single-view propagation strategy, avoiding the over-smoothing problem caused by extensive and deep usage of graph convolution, while also reducing the overall complexity of the model. Our contributions can be concisely summarized as follows:

• A novel preference prototype-based feature augmentation contrastive learning recommendation framework is proposed.
• A preference learning module is proposed to enrich prototype information, along with a prototype filtering network to regulate feature augmentation, improving the model’s stability.
• Compared with existing prototype-based methods, ProtoRec achieves maximum gains of up to 16.8% and 20.0% in recall@k and NDCG@k on three real-world datasets. Additional experiments were performed to further analyze the rationale behind ProtoRec.

The remainder of this paper is organized as follows: Section 2 reviews and summarizes the fundamental methods of GNNs. In Section 3, we present and analyze the proposed novel prototype-based graph contrastive learning recommendation method in detail. Section 4 conducts extensive experiments to evaluate the effectiveness of our approach in terms of recommendation performance, uniformity, ablation studies, and parameter analysis. Section 5 discusses related work from the perspectives of GNNs and CL. Finally, Section 6 concludes the paper and discusses future works.

2. Preliminaries

As a foundational method of recommender systems [4,16], graph-based collaborative filtering can recommend items to users with potential preferences based on observed feedback. Specifically, let us define a user set $\mathcal{U}=\{u_1,u_2,...,u_M\}$ consisting of M users and an item set $\mathcal{I}=\{i_1,i_2,...,i_N\}$ consisting of N items. To represent the observed feedback between users and items, we define the user–item interaction matrix $\mathbf{R}\in {\mathbb{R}}^{M\times N}$, where ${\mathbf{R}}_{ij}=1$ denotes feedback between user $u_i$ and item $v_j$, while ${\mathbf{R}}_{ij}=0$ indicates no feedback. Then, the adjacency matrix $\mathbf{A}\in {\mathbb{R}}^{(M+N)\times (M+N)}$ can be represented as

$$\mathbf{A}=\left[\begin{array}{cc}\mathbf{0}& \mathbf{R}\\ {\mathbf{R}}^{\mathbf{T}}& \mathbf{0}\end{array}\right]$$

(1)

In GNN-based recommendation, the initial embeddings of users and items, denoted as ${\mathbf{E}}^{\left(\mathbf{0}\right)}\in {\mathbb{R}}^{(M+N)\times d}$, are typically generated using the Xavier method. The exploration of latent preference between users and items based on the observed interaction graph is achieved by iteratively applying the function $f_{propagate}(·)$ for L layers to aggregate neighborhood information between nodes, and the function $f_{readout}(·)$ to summarize and generate the final embedding representations. The two-stage functions for aggregating information can be specifically expressed as

$$\begin{array}{cc}\hfill & {\mathbf{E}}^{\left(\mathbf{l}\right)}=f_{propagate}(\overline{\mathbf{A}},{\mathbf{E}}^{(\mathbf{l}-\mathbf{1})})\hfill \\ \hfill & \mathbf{E}=f_{readout}\left([{\mathbf{E}}^{\left(\mathbf{0}\right)},{\mathbf{E}}^{\left(\mathbf{1}\right)},...,{\mathbf{E}}^{\left(\mathbf{L}\right)}]\right)\hfill \end{array}$$

(2)

where $\overline{\mathbf{A}}={\mathbf{D}}^{-{\displaystyle \frac{1}{2}}}(\mathbf{A}+\mathbf{I}){\mathbf{D}}^{-{\displaystyle \frac{1}{2}}}$ represents the symmetrically normalized adjacency matrix. $(\mathbf{A}+\mathbf{I})$ denotes the adjacency matrix $\mathbf{A}$ added to the identity matrix $\mathbf{I}$ to achieve self-connections and maintain self-information during propagation. $\mathbf{D}$ is the diagonal matrix, where ${\mathbf{D}}_{ii}={\sum }_j{(\mathbf{A}+\mathbf{I})}_{ij}$ represents the non-zero instance counts in row i.

3. Methodology

In this section, the specific implementation method of ProtoRec is elaborated, detailing how ProtoRec learns graph information and the methods for prototype generation and feature augmentation. The model framework of ProtoRec is illustrated in Figure 1.

3.1. Graph Neural Network Backbone

Graph neural networks can learn neighborhood information of nodes, generating embeddings for users and items with potential preferences. They propagate node information to high-order neighborhoods through layer-wise propagation. Specifically, in ProtoRec, LightGCN [4] is adopted as the fundamental framework for the GNN module to learn the interaction information between users and items. Compared to LightGCN, ProtoRec combines the extracted prototype information to design a feature augmentation module and a single-view prototype contrastive learning method to optimize the recommendation performance of the entire model. The performance improvement of LightGCN primarily stems from its efficient aggregation of neighborhood information. As the number of propagation layers increases, the stacking of feature transformations and nonlinear activations exacerbates the over-smoothing of embeddings and significantly increases model complexity, making it unsuitable for real-time recommendation on large-scale data [4,17]. Therefore, LightGCN eliminates these two components during the aggregation process. The l-th embedding propagation layer is represented as

$${\mathbf{E}}^{\left(\mathbf{l}\right)}=\overline{\mathbf{A}}·{\mathbf{E}}^{(\mathbf{l}-\mathbf{1})}$$

(3)

To enrich the embeddings of users and items and mitigate the impact of over-smoothing, a weighted sum function is employed to aggregate embeddings from different layers to obtain the final embedding:

$$\mathbf{E}={\displaystyle \frac{1}{L}}\sum _{l=1}^L{\mathbf{E}}^{\left(\mathbf{l}\right)}$$

(4)

where $\mathbf{E}\in {\mathbb{R}}^{(M+N)\times d}$ represents the final embedding of GNN. To facilitate subsequent calculations, the embedding matrix $\mathbf{E}$ is split into $e^{\left(u\right)}\in {\mathbb{R}}^{M\times d}$ and $e^{\left(i\right)}\in {\mathbb{R}}^{N\times d}$, representing user and item embeddings, respectively. The steps shown in Equations (3) and (4) correspond to the “GCNs” module in Figure 1. The probability prediction score ${\widehat{y}}_{ui}$ for the interaction between user u and item i is represented in inner product form as ${\widehat{y}}_{ui}=e_u^{\left(u\right)T}{e}_i^{\left(i\right)}$. To encourage observed interaction probabilities to be higher than unobserved ones, ProtoRec employs Bayesian Personalized Ranking (BPR) [18] loss as its optimization objective. Formally, the BPR loss is represented as

$${\mathcal{L}}_{bpr}=\sum _{(u,i^{+},i^{-})\in \mathcal{O}}-log\left(\sigma ({\widehat{y}}_{u{i}^{+}}-{\widehat{y}}_{u{i}^{-}})\right)$$

(5)

where $log(·)$ and $\sigma (·)$ denote the logarithm and sigmoid functions, respectively. User u along with its corresponding positive item $i^{+}$ and negative item $i^{-}$ belong to interaction set $\mathcal{O}=\left\{(u,i^{+},i^{-})\right|{\mathbf{R}}_{u{i}^{+}}=1,{\mathbf{R}}_{u{i}^{-}}=0\}$. Equation (5) corresponds to the “BPR” module in Figure 1.

By optimizing the BPR loss, ProtoRec can effectively learn the neighborhood information of nodes and predict whether there is a latent preference between users and items. However, just as users in daily life often have interests in certain categories of items (electronics, cosmetics, clothing, etc.), users and items belonging to the same category are mutually associated. Next, we extract preference prototypes from embeddings of numerous users and items and construct latent neighborhood relationships.

3.2. Prototype Generation and Feature Augmentation

As shown in the “K-means” module of Figure 1, to select representative preference prototypes from the dataset, ProtoRec runs the K-means clustering algorithm at each epoch to extract k cluster centers as prototypes for each category in the initialized user and item embedding spaces [19]. Although prototypes may be less accurate in the early stages of training, as the model gradually converges, the extracted prototypes progressively align with the correct clusters, ensuring feature distinctiveness while avoiding unnecessary model complexity. Unlike other methods [20,21] that extract prototypes separately for users and items, ProtoRec aims to classify all nodes with potential preferences into one category. Therefore, when implementing the K-means algorithm, users and items are considered as a whole, effectively controlling the number of prototypes. Thus, the preference prototypes proposed at each epoch are as follows:

$$\mathbf{P}=kmeans\left({\mathbf{E}}^{\left(\mathbf{0}\right)}\right)$$

(6)

where $\mathbf{P}\in {\mathbb{R}}^{k\times d}$ represents the preference prototypes, and $kmeans(·)$ denotes the deployed K-means algorithm. The number of clustering centers k, serving as the basis for prototype information, is controlled through parameter tuning. In the embedding space, the clustering centers evenly partition the dataset into different categories, thereby meeting the requirements of the subsequent feature refinement module.

Although the K-means algorithm effectively extracts representative prototypes, learning the same prototype for nodes of the same class can lead to over-smoothing. As shown in Figure 2, using preference levels to measure the relationship between nodes and existing prototypes and exploring refined preferences for each user and item is an alternative method. Inspired by the self-attention mechanism, the dot product similarity $\mathbf{E}·{\mathbf{P}}^T$ between the GNN embeddings $\mathbf{E}$ and the prototypes $\mathbf{P}$ extracted by K-means is calculated as the preference scores, and a sigmoid function is deployed to normalize the preference scores. The preference scores predict the probability of the association between embeddings and prototypes, with values ranging from 0 to 1. To eliminate the influence of irrelevant prototypes, interactions with a probability below 0.5 are masked. The threshold should be set to evenly divide the probability range. Finally, the refined prototype embedding is computed by preference scores:

$${\mathbf{P}}_r=sigmoid(\mathbf{E}·{\mathbf{P}}^T)·\mathbf{P}$$

(7)

where ${\mathbf{P}}_r\in {\mathbb{R}}^{(M+N)\times d}$ represents the refined preference prototype matrix for each user and item. Equation (7) corresponds to the “Refinement” module in Figure 1.

Due to the complexity and time-consuming nature of generating more-uniform embeddings through graph structure perturbations, ProtoRec migrates the augmentation scheme to the embedding space. In formal terms, the augmentation strategy can be represented as $\mathbf{G}=\mathbf{E}+{\mathbf{P}}_r$. As shown in Figure 3, taking any user u as an example, the embedding learned through the GNN is denoted as $e_u^{\left(u\right)}$, which is added to the corresponding prototype $p_{r,u}^{\left(u\right)}$, making the learned embedding closer to the preferred prototype and obtaining augmented embedding $g_u^{\left(u\right)}$. This can be understood as users consciously selecting their preferred categories. Since directly adding prototype information to embeddings may lead to uneven embeddings and misguide representation learning, ProtoRec employs a prototype filtering network (PFN) to balance feature augmentation. Structurally, the PFN consists of linear transformation functions $f_t(·)$ and $f_s(·)$ for enhancing model fitting, and a self-gating module $f_{gate}\left(x\right)=x·sigmoid\left(f_s\left(x\right)\right)$ for controlling feature augmentation. The process of optimizing the prototype information ${\mathbf{P}}_r$ through PFN and augmenting the embedding $\mathbf{E}$ can be represented as

$$\mathbf{G}=\mathbf{E}+f_{gate}\left(f_t\left({\mathbf{P}}_r\right)\right)$$

(8)

where $\mathbf{G}\in {\mathbb{R}}^{(M+N)\times d}$ represents the final embedding after feature augmentation. Equation (8) is shown in the “PFN” module of Figure 1. For convenience, $\mathbf{G}$ is split into user embeddings $g^{\left(u\right)}$ and item embeddings $g^{\left(i\right)}$. To better learn the consistency of embeddings between different augmentation views, ProtoRec employs InfoNCE [22] loss as the optimization objective for contrastive learning, which is represented as

$${\mathcal{L}}_{cl}^{\left(u\right)}=\sum _{i\in \mathcal{B}}-log{\displaystyle \frac{exp((e_i^{\left(u\right)}·g_i^{\left(u\right)})/\tau )}{{\sum }_{j\in \mathcal{B}}exp((e_i^{\left(u\right)}·g_j^{\left(u\right)})/\tau )}}$$

(9)

where the hyperparameter $\tau$ is the temperature coefficient used to control the smoothness of the distribution. $\mathcal{B}$ represents the set of samples in a batch used for loss computation. $exp(·)$ and $log(·)$ represent the exponential function and the logarithmic function, respectively. ${\mathcal{L}}_{cl}^{\left(i\right)}$ is represented in the same way. The final CL loss is denoted as ${\mathcal{L}}_{cl}={\mathcal{L}}_{cl}^{\left(u\right)}+{\mathcal{L}}_{cl}^{\left(i\right)}$.

3.3. Optimization

To enhance recommendation performance, ProtoRec adopts a jointly optimized strategy for the objective function:

$$\mathcal{L}={\mathcal{L}}_{bpr}+{\lambda }_1·{\mathcal{L}}_{cl}+{\lambda }_2·{\left|\right|\mathrm{\Theta }\left|\right|}^2$$

(10)

where $\mathrm{\Theta }$ represents the collection of all parameters, and ${\lambda }_1$ and ${\lambda }_2$, respectively, denote the weight coefficients controlling the CL loss and the $L_2$ regularization term. The calculation process of $\mathcal{L}$ is shown in the “Optimization” module in Figure 1.

3.4. Algorithm Complexity

In this section, ProtoRec is decomposed into several modules to discuss complexity. Let E denote the edge numbers. M, N, and d represent user and item numbers and embedding size, respectively. In each epoch, K-means is executed to extract k prototypes with I iterations costs $\mathcal{O}\left(I\right(M+N\left)kd\right)$. The complexities for constructing the interaction graph and executing L layers of LightGCN in ProtoRec are $\mathcal{O}\left(2\right|E\left|\right)$ and $\mathcal{O}\left(2\right|E\left|Ld\right)$, respectively. The time complexities for constructing the relationship graph between nodes and prototypes, as well as for reorganizing prototypes based on different weights, are $\mathcal{O}\left(\right(M+N\left)k\right)$ and $\mathcal{O}\left(\right(M+N\left)kd\right)$, respectively. Deploying the linear transformation function in the PFN module requires $\mathcal{O}\left(2d^2\right)$. Let $\mathcal{B}$ and H denote the batch size and the node numbers per batch, respectively. Therefore, the time complexities for BPR loss and CL loss are $\mathcal{O}\left(2\mathcal{B}d\right)$ and $\mathcal{O}(\mathcal{B}d+\mathcal{B}Hd)$, respectively. To better understand the training process of ProtoRec and the implementation of each module, Algorithm 1 presents the pseudocode of ProtoRec. It clearly demonstrates the execution steps of the K-means algorithm and graph-based recommendation, making it easier to comprehend the complexity of ProtoRec.

Algorithm 1 Prototypical Graph Contrastive Learning for Recommendation (ProtoRec)

1: Input: adjacency matrix $\overline{\mathbf{A}}$, training dataset $\mathcal{X}$, number of clusters k 2: Output: user and item embeddings {$e^{\left(u\right)},e^{\left(i\right)}$} for recommendation 3: Initialize: Random initialize user and item embeddings matrix ${\mathbf{E}}^{\left(0\right)}$ 4: while Not Convergence do 5:     Extract k cluster prototypes $\mathbf{P}$ using the K-means algorithm in Equation (6) 6:     for batch in Dataload($\mathcal{X}$) do 7:         Obtain user u, positive item $i^{+}$, and negative item $i^{-}$ from batch 8:         Compute embedding $\mathbf{E}$ using GNNs by Equations (3) and (4) 9:         Refine prototypes ${\mathbf{P}}_{\mathbf{r}}$ and augment features $\mathbf{G}$ using Equations (7) and (8) 10:         Compute the total loss $\mathcal{L}$ by Equation (10) and back propagation 11:     end for 12: end while

4. Experiments

In this section, a wide range of experimental studies are conducted to validate the proposed model ProtoRec’s effectiveness in recommendation. Several key research questions are answered:

• RQ1: How does ProtoRec perform in top-k recommendation compared to other baselines?
• RQ2: How uniform are the embeddings learned by ProtoRec?
• RQ3: How do the key components influence ProtoRec, and how is the performance of the proposed variants?
• RQ4: How do various hyperparameter settings impact ProtoRec’s performance?
• RQ5: How robust is ProtoRec to different types of noise?

4.1. Experimental Settings

4.1.1. Datasets and Metrics

As shown in

Table 1. Detailed information about all datasets. The symbol “#” represents the total number of entities (users, items, and interactions) in the dataset.

Dataset	#Users	#Items	#Interactions	Density
Yelp2018	31,668	38,048	1,561,406	0.00130
Douban-Book	13,024	22,347	792,062	0.00272
Amazon-Book	52,463	91,599	2,984,108	0.00062

, three real-world datasets, Yelp2018, Douban-Book, and Amazon-Book, are utilized to evaluate ProtoRec and other baseline methods. The observed interaction counts for all three datasets are very sparse, and the datasets are divided into training, validation, and test sets in a ratio of 7:1:2. To better demonstrate top-k recommendation performance, recall@k and NDCG@k are employed as evaluation metrics, where $k\in \{20,40\}$. Recall@k is used to measure the proportion of relevant items that are recalled in the top-k recommendations in the test set. NDCG@k further considers the ranking position of the recommendations, with higher-ranked relevant items contributing more to the metric:

$$Recall@k={\displaystyle \frac{TP@k}{TP@k+FN@k}}$$

(11)

$$NDCG@k={\displaystyle \frac{DCG@k}{IDCG@k}}$$

(12)

where $TP$ and $FN$ represent true positive and false negative, respectively. DCG and IDCG are defined as follows:

$$DCG@k=\sum _{i=1}^k{\displaystyle \frac{re{l}_i}{lo{g}_2(i+1)}}$$

(13)

$$IDCG@k=\sum _{i=1}^{\left|REL\right|}{\displaystyle \frac{1}{lo{g}_2(i+1)}}$$

(14)

and $re{l}_i$ is defined as the relevance of the i-th recommended item, typically taking a value of 0 or 1. All baseline methods were tuned using grid search within the value ranges provided in the original papers, and the training was conducted separately on each dataset to find the optimal parameter combinations.

4.1.2. Baselines

Selecting popular baselines from the corresponding fields as comparison models is involved in the construction according to ProtoRec:

• Graph-based collaborative filtering methods.

• LightGCN [4] is the primary choice for the graph convolutional network backbone in current recommendation models, capable of capturing collaborative information in interaction graphs in a lightweight manner.
• DirectAU [23] optimizes embedding alignment and uniformity through a loss function and theoretically reveals the rationality of this approach for optimizing recommendation performance.

• Self-supervised learning methods.

• LightGCL [12] constructs perturbed views through random singular value decomposition and employs a dual-view approach for CL.
• SGL [5] proposes random strategies to drop nodes and edges in the graph for CL.
• SimGCL [10] introduces a feature augmentation method constructed by adding uniform noise to learned embeddings.
• SCCF [24] decomposes the contrastive learning loss into two processes, making embeddings more compact and more dispersed, thereby enhancing the ability of contrastive learning to capture high-order connectivity information.
• RecDCL [25] integrates batch-wise contrastive learning to enhance the robustness of representations and feature-wise contrastive learning to eliminate redundant solutions in user–item positive samples, thereby optimizing the uniformity of embeddings.
• AdaGCL [26] dynamically reconstructs the interaction graph and denoises the data based on the learned embeddings, and it constructs contrastive learning using the embeddings learned from both processes.

• Prototype-based recommendation methods.

• ProtoAU [21] utilizes prototypes to optimize the alignment and uniformity of embeddings and constructs contrastive learning across different views.
• NCL [20] constructs contrastive schemes in both semantic and structural aspects based on extracted prototypes.

4.2. Performance Comparison (RQ1)

As shown in

Table 2. Performance comparison of different models.

Dataset	Metric	LightGCN	ProtoAU	NCL	SGL	LightGCL	DirectAU	RecDCL	SCCF	AdaGCL	SimGCL	ProtoRec
Yelp2018	recall@20	0.0592	0.0611	0.0669	0.0676	0.0684	0.0704	0.0690	0.0701	0.0710	0.0721	0.0722
	ndcg@20	0.0482	0.0503	0.0547	0.0556	0.0561	0.0583	0.0560	0.0580	0.0585	0.0596	0.0598
	recall@40	0.0981	0.1020	0.1097	0.1120	0.1110	0.1141	0.1122	0.1139	0.1152	0.1179	0.1188
	ndcg@40	0.0630	0.0657	0.0709	0.0723	0.0721	0.0748	0.0733	0.0745	0.0752	0.0768	0.0773
Douban-Book	recall@20	0.1485	0.1500	0.1635	0.1740	0.1574	0.1640	0.1664	0.1711	0.1713	0.1774	0.1788
	ndcg@20	0.1248	0.1265	0.1387	0.1516	0.1371	0.1413	0.1526	0.1539	0.1542	0.1561	0.1566
	recall@40	0.2101	0.2144	0.2264	0.2382	0.2075	0.2188	0.2183	0.2285	0.2312	0.2412	0.2431
	ndcg@40	0.1431	0.1450	0.1571	0.1701	0.1512	0.1571	0.1578	0.1596	0.1617	0.1744	0.1750
Amazon-Book	recall@20	0.0381	0.0391	0.0444	0.0467	0.0497	0.0503	0.0491	0.0510	0.0504	0.0515	0.0519
	ndcg@20	0.0298	0.0309	0.0344	0.0367	0.0390	0.0401	0.0399	0.0405	0.0400	0.0411	0.0413
	recall@40	0.0627	0.0655	0.0731	0.0761	0.0796	0.0805	0.0798	0.0807	0.0801	0.0808	0.0819
	ndcg@40	0.0391	0.0408	0.0452	0.0478	0.0503	0.0505	0.0503	0.0506	0.0506	0.0521	0.0526

, the performance of all baseline methods was compared across three datasets. All CL-based models outperformed LightGCN because they capture richer and more uniform embeddings by learning the consistency of embeddings from different augmented views. Similar to the objective of CL, DirectAU achieved superior performance by directly optimizing the alignment and uniformity of embeddings, surpassing some CL methods (SGL, NCL). ProtoRec’s performance was better than other prototype-based recommendation methods (ProtoAU, NCL) because it constructs feature augmented views through prototypes, enabling users and items to learn more effective preference information. The diversity of prototype information also guides more uniform distribution of embeddings. As a feature augmentation method, ProtoRec demonstrated a slight performance advantage over SimGCL while outperforming other graph structure-augmented contrastive learning methods (LightGCL, RecDCL, AdaGCL). This is likely because disrupting the integrity of interaction information can lead to insufficient training for certain nodes. Additionally, because feature augmentation does not require the extra reconstruction of large graphs, ProtoRec also achieved improvements in time efficiency. ProtoRec achieved the best performance across all three datasets, validating the effectiveness of the prototype-based feature augmentation.

When facing issues such as data sparsity and noise, LightGCN, which relies solely on graph neural network methods, requires more iterations to fit the data. In contrast, contrastive learning methods like SGL and NCL achieve more stable performance by capturing embedding diversity. DirectAU’s research on improving embedding uniformity further validates the relationship between mitigating data sparsity and enhancing embedding uniformity. LightGCL, by using a low-rank approach, can extract important information from sparse data, while methods like ProtoRec alleviate data sparsity by extracting preference prototypes that guide embedding learning of rich features. ProtoRec leverages extracted prototype information to guide users and items in learning latent preferences within the embedding space, optimizing the differentiation between positive and negative samples in contrastive learning. The application of the prototype filtering network (PFN) reduces the impact of noise, while the single-view contrastive scheme improves training efficiency, resulting in excellent recommendation performance.

4.3. Uniformity Study (RQ2)

To clearly demonstrate the uniformity of the embeddings learned by the baseline models, we used t-SNE to reduce the dimensions of 2000 randomly sampled user embeddings and plotted them in the upper half of each image. The lower half of each image shows the corresponding Gaussian kernel density estimation curves to illustrate the density estimates from different angles. As shown in Figure 4, each row is ordered based on the recommendation performance of the models. From left to right, the darker regions in the upper part of the figure decrease, and the curves in the lower part become smoother (indicating more uniformly learned features). This indicates a positive correlation between uniformity and recommendation performance. Both overly clustered and overly uniform feature distributions can hinder performance improvement.

As shown in Figure 4a,c, compared to ProtoRec and SimGCL, LightGCN, SGL, and NCL learned more clustered embedding features, with density curves exhibiting steeper trends. This phenomenon is caused by the over-smoothing issue from stacking graph convolutional networks, resulting in overly similar embeddings. Additionally, the structural perturbations in SGL make it difficult to train some nodes, also affecting the embedding distribution. As shown in Figure 4b, all baseline models learned uniform embeddings because they could effectively capture the latent relationships between users and items in the small dataset. Intuitively, ProtoRec, by guiding users and items to learn prototypes, generates clustered distributions within the same prototype, while the use of graph convolutional networks also leads to over-smoothing. However, ProtoRec alleviates the over-smoothing problem by constructing refined prototypes, guiding users and items to learn more diverse and enriched preference information. Unlike SimGCL, which adds uniform noise to the embeddings, ProtoRec purposefully directs embeddings to learn from prototypes, achieving a uniform embedding distribution.

4.4. Ablation Study (RQ3)

In this section, we present several variants of ProtoRec to evaluate their recommendation performance. As shown in

Table 3. Performance comparison of different variants and ablation studies.

Dataset	Yelp2018		Douban-Book		Amazon-Book
Method	Recall@20	NDCG@20	Recall@20	NDCG@20	Recall@20	NDCG@20
ProtoRecdbscan	0.0716	0.0591	0.1727	0.1482	0.0518	0.0412
ProtoRechc	0.0718	0.0592	0.1732	0.1492	0.0514	0.0409
ProtoRecgmm	0.0719	0.0593	0.1731	0.1486	0.0515	0.0413
ProtoReca	0.0689	0.0568	0.1706	0.1513	0.0472	0.0374
ProtoRecl	0.0723	0.0597	0.1783	0.1553	0.0516	0.0411
ProtoRecc	0.0722	0.0593	0.1774	0.1544	0.0511	0.0405
w/o-SIG	0.0721	0.0594	0.1754	0.1543	0.0513	0.0406
w/o-PFN	0.0643	0.0530	0.1473	0.1266	0.0427	0.0343
ProtoRec	0.0722	0.0598	0.1788	0.1566	0.0519	0.0413

, the variant ProtoRec_a uses the prototype-augmented embeddings for recommendation and performs contrastive learning with the embeddings learned by the first layer of the GNN, still achieving good performance. The variant ProtoRec_l extends the prototype augmentation scheme to each layer of the GNN. While it achieves better performance on some metrics in the Yelp2018 dataset, it comes at the cost of increased complexity. The variant ProtoRec_c replaces the Euclidean distance in the K-means algorithm with cosine similarity. Although different similarities are used to divide the clustering results and extract prototypes, good recommendation performance is still achieved. To investigate whether ProtoRec can adapt to different clustering algorithms, we replaced K-means with alternative clustering methods such as DBSCAN, hierarchical clustering, and Gaussian mixture models. The impact of these methods on the recommendation performance is shown in the table as ProtoRec_dbscan, ProtoRec_hc, and ProtoRec_gmm. Across the three datasets, these variations still demonstrate good performance compared to ProtoRec. Although different clustering methods were employed, they all successfully extracted prototype information from the embedding space. ProtoRec effectively transformed this information into useful augmentation, thereby maintaining the stability of the model.

To explore the impact of certain modules in ProtoRec on recommendation performance, we present the results of ablation studies in Table 3. w/o-SIG examines the impact of adding irrelevant information in the prototype refinement module. Performance is slightly lower than ProtoRec across the three datasets. Although the model assigns less weight to this irrelevant information during training, directly removing these connections reduces the impact of noise. w/o-PFN removes the prototype filtering network (PFN), resulting in a significant drop in recommendation performance across all datasets. This is because assigning excessive weight to the prototype information can mislead the knowledge learned by the GNN. The PFN helps maintain a balance between the knowledge acquired by the GNN and the prototype information by adjusting the weight.

4.5. Hyperparameter Analysis (RQ4)

We conducted experiments to analyze the impact of key parameters on ProtoRec to determine their optimal values. Some parameters were set according to convention in all experiments. The batch size was 2048; the embedding size was 64. The regularization coefficient ${\lambda }_2$ was typically set to a small value to avoid excessive penalization. Based on mainstream baseline methods and experimental tests, ProtoRec uses a value of 1 ×${10}^{-4}$ across different datasets to achieve the most stable training results. All parameters were adjusted using a grid search strategy. The possible value ranges for all parameters were obtained from related work, and a generally optimal value was set. The search was conducted around this value until the optimal value was found. The search stopped when the performance began to decline in a particular direction.

The impact of L. The number of graph convolutional layers L is tuned within {1, 2, 3, 4, 5}, and the performance of ProtoRec varies significantly across different layer settings. Smaller values result in underfitting, while larger values lead to over-smoothing and increased complexity. The experimental results show that the optimal values for L on the three datasets are 2, 3, and 4, respectively.

The impact of ${\lambda }_1$. The parameter ${\lambda }_1$ is utilized to control the weight of InfoNCE on overall optimization objective. As shown in the first image of Figure 5, Figure 6 and Figure 7, ${\lambda }_1$ has a significant impact on recommendation performance. On large-scale datasets, ProtoRec focuses more on optimizing the CL loss, requiring a larger value for ${\lambda }_1$. Conversely, on small-scale datasets, ProtoRec tends to prioritize optimizing the BPR loss, often necessitating a smaller value for ${\lambda }_1$. It is recommended to search this parameter within the range of 0 to 1 with a step size of 0.1. The search process can be terminated when performance starts to decline, as there is generally only one peak optimal solution. Therefore, the optimal values of ${\lambda }_1$ on the Yelp2018, Douban-book, and Amazon-book datasets are 0.3, 0.1, and 1.0, respectively.

The impact of $\tau$. The temperature coefficient $\tau$ adjusts the similarity distribution in InfoNCE. As the value of $\tau$ decreases, the distribution becomes sharper, enhancing the discriminative power of positive samples. Conversely, as the value of $\tau$ increases, the distribution becomes smoother, improving generalization ability. The impact of $\tau$ on different datasets is illustrated in the second images of Figure 5, Figure 6 and Figure 7. Both large and small values of $\tau$ can lead to a sharp decline in performance. Although the temperature coefficient $\tau$ can take on very large values, smaller values often yield the optimal solution in ProtoRec. Therefore, it is advisable to test values within the range of 0 to 1 with a step size of 0.1. A sharp performance decline is typically observed near the optimal value, and parameter tuning can be stopped when this phenomenon occurs. Hence, the optimal value across all datasets is 0.2.

The impact of k. The parameter k is used to control the prototype numbers extracted by K-means. Exceeding the appropriate number of prototypes can partition the data into clusters with overlapping features. Conversely, insufficient prototypes may impede the accurate extraction of the data’s underlying preferences. Due to ProtoRec’s strong fitting capability, smaller values of k are often sufficient to extract appropriate prototypes. The third images of Figure 5, Figure 6 and Figure 7 illustrate the impact of k values ranging from 0 to 120 on recommendation performance. The curves show a gradual decline in performance as the number of prototypes increases (even reaching several thousand), and ProtoRec becomes increasingly time-consuming. ProtoRec does not have strict requirements on the number of prototypes. During grid search, a relatively large interval can be used for exploration. It is recommended to search within the range of 0 to 120 with a step size of 20. The search can be stopped when increasing the number of prototypes no longer results in significant performance improvement. Therefore, the optimal numbers of prototypes k are around 20, 20, and 70 for the three datasets, respectively.

4.6. Robustness Study (RQ5)

To evaluate the robustness of ProtoRec under different types of data noise, we added noise to both the graph structure and embedding distributions at noise ratios of {0.1, 0.2} and conducted extensive experiments on the Yelp2018 dataset. The “noise ratio” is used to control the degree of different types of noise added. In edge noise, we randomly discard edges in the interaction graph with a probability determined by the noise ratio, simulating data sparsity. In feature noise, the noise ratio controls the intensity of uniform noise added to each dimension of the embeddings, allowing us to evaluate the model’s generalization ability. Experiments were also carried out with the baseline methods SimGCL and NCL for comparison, with the results shown in Figure 8. The performance degradation due to feature noise is lower than that caused by edge noise across all methods, indicating that adding noise to the graph structure affects the model’s ability to learn neighborhood information. As the noise ratio increases, the performance degradation becomes more apparent. ProtoRec outperforms SimGCL and NCL in all experiments, demonstrating its strong adaptability to various types of noise. The robustness of ProtoRec can be attributed to the contrastive learning framework and prototype-enhanced information, which enable it to extract users’ and items’ latent preferences from substantial noise and effectively optimize the embedding representations by leveraging the differences between positive and negative samples.

5. Related Work

5.1. Graph-Based Collaborative Filtering

Graph-based collaborative filtering outperforms traditional recommendation methods by leveraging an interaction graph to effectively represent user–item relationships and provide more reliable embeddings for neighborhood learning. Graph convolutional networks (GCNs) [27] provide a straightforward and practical approach for capturing collaborative information in complex graph structures, being the primary framework for recommendation models such as NGCF [28] and GCMC [29]. These methods based on GCNs learn neighborhood information of nodes layer by layer from interaction graphs, but face challenges related to the complexity and over-smoothing issues induced by deep convolution [30]. Similar to SGC [17], LightGCN [4] simplifies the model by removing redundant feature transformations and nonlinear activation components. Due to its lightweight and easy-to-implement nature, LightGCN replaces GCN as a recommendation framework and integrates with methods such as contrastive learning [31,32] and diffusion models [33,34] to achieve multitask objectives, providing a novel approach for subsequent research [35].

5.2. Graph Contrastive Learning for Recommendation

Contrastive learning presents a solution to the sparsity issue in recommendation by leveraging its self-supervised nature to extract features from vast amounts of unlabeled data [36,37]. Influenced by research in other domains [38], certain studies construct suitable contrastive views by perturbing the structure of interaction graphs. SGL [5] employs a random strategy to discard nodes and edges from the interaction graph, maximizing consistency among embeddings across different views. LightGCL [12] adopts a strategy of random singular value decomposition to reconstruct the adjacency matrix, effectively preserving crucial graph structural information and offering a low-rank solution for optimizing the contrastive learning paradigm. Despite the effectiveness of graph structure perturbation, it may lead to certain nodes failing to learn useful neighborhood information, thus misguiding feature learning. Therefore, some methods different from structure augmentation have started to emerge. SimGCL [10] adds uniform noise in the embedding space to achieve feature augmentation, reducing the negative effects of graph structure perturbations. AdaGCL [26] employs variational autoencoder to generate a graph during training, mitigating the influence of noisy interaction in the original graph. Nonetheless, frequent graph generation raises concerns regarding complexity.

5.3. Prototype-Based Contrastive Learning

Compared to random augmentation strategies, prototype-based contrastive learning emphasizes extracting prototype information that represents preference groups from the embeddings of learned neighborhood information. This prototype information serves as an optimization target for embedding learning, thereby improving recommendation performance. NCL [20] constructs a structural neighbor contrastive loss function using embeddings learned at different aggregation layers of the GCN. It further employs a clustering method to capture prototype information, which is then used to design a semantic neighbor contrastive loss function as an additional optimization objective. ProtoAU [21] focuses on reconstructing the interaction graph to generate contrastive views. By ensuring the uniformity and consistency of embeddings, it incorporates prototype information to further improve embedding quality. PGCL [14] optimizes the contrastive learning loss function by re-weighting the negative sample weights according to the distance between the prototypes of positive and negative samples, thereby ensuring a clear semantic distinction between them. Unlike NCL and ProtoAU, which directly use clustering results as prototype information to optimize the loss function, ProtoRec leverages a prototype refinement module to generate unique preference prototypes for each user and item based on clustering information, significantly enriching the embedding in the augmentation strategy. Moreover, instead of applying fixed weights to all data through parameter tuning as in existing methods, ProtoRec introduces a prototype filtering network that dynamically adjusts feature augmentation weights during training, further optimizing the uniformity and consistency of embeddings. ProtoRec adopts a single-view framework, reducing the frequency of graph convolution network operations, thereby significantly improving the overall efficiency of the model.

6. Conclusions

In this work, we propose ProtoRec, an efficient recommendation model based on a prototype-based graph contrastive learning scheme. By utilizing feature augmentation to guide the embedding learning of users and items, ProtoRec uncovers latent preferences, thereby achieving significant improvements in recommendation performance and embedding uniformity. Firstly, ProtoRec employs the K-means algorithm to extract latent preference prototypes for users and items. Next, ProtoRec refines the prototype information for each user and item based on the existing prototypes and their relationship weights with the users and items. Finally, ProtoRec utilizes a simple yet effective feature augmentation scheme to construct contrastive learning. The effectiveness of this method is demonstrated by the significant recommendation capabilities achieved on real-world datasets. On the Yelp2018, Douban-Book, and Amazon-Book datasets, ProtoRec achieved the best performance on the recommendation metrics recall and NDCG. Compared to other prototype contrastive learning methods, it achieved up to a 20% performance improvement and demonstrated superior robustness to noise. In future work, we will explore how to provide more accurate and valuable prototype information for recommendation models through supervised learning while developing adaptable feature augmentation strategies to mitigate potential performance degradation caused by an excessive increase in the number of prototypes.