A social recommendation model based on adaptive residual graph convolution networks

Cold-start recommendation models

In the development of recommendation algorithms, the cold-start problem has always been one of the directions that researchers focus on. When the number of user-item interactions is too small, the recommender system will reach a cold start state when it cannot effectively make personalized recommendations for the user. For this phenomenon, Generative Adversarial Recommendation (GAR) (Chen et al., 2022) uses generative adversarial modeling to generate user interaction data, and distinguishes between generated and real data in the form of fine-tuning during recommendation ranking, thus mitigating the cold-start problem. In difference, Huang et al. (2023) think that this model is not effective in mitigating the variability between hot and cold items, and they propose the Aligning Distillation (ALDI) model, which reduces these differences by tailoring the rating alignment and identifying alignment losses, and using a weighting structure to ensure that the model learns accurately with respect to the information. For the cold-start problem in large-scale online recommendation, Huang et al. (2025) proposed the large language model (LLM) simulator framework, which reduces the number of candidate recommendation users by coupling filters, and uses a LLM to simulate the interaction of cold-start users, which not only successfully alleviates the cold-start problem, but also reduces the complexity of the model. On this background, Zhang et al. (2025) further analyzes the effectiveness of LLM for the cold-start problem in large-scale online recommendation, which aims to provide new insights for the related workers. The above methods effectively mitigate the cold-start problem in recommendation through generative models or LLM, but generative models tend to make the recommendation of the model too polarized, while LLM have the problem of excessive complexity. In contrast, SocialGCNRI builds a heterogeneous graph to enrich the user-item interaction information by means of user social information, which not only can effectively alleviate the occurrence of the cold start phenomenon, but also ensures that only the user-item and user social matrices will be used in the process of building the heterogeneous graph, so that the complexity of the model can be ensured to be within the controllable range.

De-biasing algorithms on recommendations

GNN greatly improve the accuracy and robustness of recommendation models by modeling users and items, but may amplify item bias during graph aggregation, which makes the model’s recommendations result in a long-tail phenomenon. Noting this kind of problem, Chen et al. (2020a) defines seven types of bias in recommendation, and detailed the role of different loss functions for removing bias. In contrast, Zhou et al. (2023) thinks that the way of modifying the loss function does not completely solve the problem of bias in the model, and they propose a novel graph aggregator, the adaptive popularity debiasing aggregator (APDA), to learn the weights of each edge and the aggregation popularity bias, and use the weight scaling mechanism and residual connection to eliminate the bias. We also believe that the use of aggregators is one of the ways to address the problem of bias, and in SocialGCNRI, we propose an adaptive residual map convolutional network to remove bias, and use a multilayer perceptron (MLP)-based aggregator to further mitigate the emergence of long-tail phenomenon in the model.

De-noising algorithm on recommendation

The impact of uncertainties such as mis-touchs, false comments, sample bias, and so on during user interactions makes it inevitable that user log files will contain noisy data. It is worth noting that noise in recommendation algorithms is very similar to the Sybil attack, which is an attack in which a malicious user gains undue influence by creating a large number of false identities and using those identities to participate in system operations, both of which cause the model to react adversely by injecting false information. The presence of noisy data often leads to large fluctuations in model performance, thus reducing the accuracy of recommendations. To address this problem, more and more scholars have began to design denoising algorithms to mitigate the negative impact of noisy data on model performance (Wang et al., 2021; Joorabloo, Jalili & Ren, 2022). In order to extract effective features in implicit interactions, the Stacked Discriminative Denoising Auto-Encoder based Recommender System (SDDRS) (Wang et al., 2019a) designs a stacked discriminative denoising auto-encoder to remove noisy data from interactions, effectively combining implicit interaction information with rating information. In the multi-modal recommendation task, collaborative denoised graph contrastive learning (CDGCL) (Xu et al., 2024) designs a multi-strategy denoising module to filter out irrelevant interaction information as a means of accurately and precisely reflecting the user’s true interests. In summary, different ways of denoising the raw data can effectively improve the accuracy of recommendation.

Social recommendation with graph neural networks

In traditional recommender systems, the interaction data between users and items are often sparse, and this characteristic limits the accuracy of the recommendation results. To alleviate this phenomenon, researchers have proposed social recommendation algorithms based on the social influence theory, which take the social information between users as supplemental information to alleviate the limitations of traditional recommendation algorithms. Most of the early social recommendation models used matrix factorization (MF) techniques and fused social information into the recommendation model through various strategies with a view to improving the recommendation performance (Tang et al., 2016; Zhang et al., 2018; Yang et al., 2016; Parvin et al., 2019). For example, SocialMF (Jamali & Ester, 2010) cleverly incorporates social influences into the recommendation model by considering user feature vectors as weighted combinations of their friends’ feature vectors. On the other hand, Social Bayesian Personalized Ranking (SBPR) (Zhao, McAuley & King, 2014) constructs a Bayesian framework aimed at filtering out more similar friends for the user, thus skillfully integrating social information into the collaborative filtering process. Although social recommendation models based on matrix factorization overcome some of the shortcomings of traditional recommendation to a certain extent, they are still deficient in capturing complex social network structures and utilizing node attribute information.

In recent years, more and more researchers have used GNN techniques to solve problems among social recommendations (Yu et al., 2018; Zhao et al., 2019). The GNN-based social recommendation learns target node embedding by aggregating neighbor information in the user-item interaction graph and social network graph (Salamat, Luo & Jafari, 2021). GraphRec (Fan et al., 2019) combines social information with GNN for the first time, and utilizes GNN technology to enrich the attribute information of user nodes by analyzing their first-order neighbor relationships. DiffNet (Wu et al., 2019a) designs a hierarchical propagation mechanism to realize the dynamic propagation of social influence in social networks, and as a result captures a multilevel representation of user information in different graphs. The light graph convolution network for social recommendation (SocialLGN) (Liao et al., 2022) employs light graph convolution operation to extract attribute information about user nodes in different graphs. In addition, the model is designed with a specialized fusion component for combining the extracted social information with other features of the user. The robust social recommendation based on contrastive Learning and dual-stage graph neural network (CLDS) (Ma et al., 2024) utilizes comparative learning techniques to extract deep features of users and items, and capture the influences in social networks to improve the performance of graph neural networks in social recommendation tasks.

The above methods utilizes a GNN approach to capture users’ preferences for different items, which significantly improves the model performance, but cannot effectively capture the higher-order connections between nodes. Different from them, we design a graph convolution network based on adaptive residuals, by adaptively adjusting the weight of the user’s initial embedding to continuously update the user’s attribute information, we can more accurately infer the user’s preference for different items and improve the model accuracy.

Overall framework of the SocialGCNRI

The overall framework of SocialGCNI is shown in Fig. 1, which mainly consists of embedding layer, filter layer, residual graph convolutional layer and prediction layer. When the user-item interaction graph and the user social graph are inputted into the model, it goes through a series of processing steps to finally generate a set of recommended items for the target user.

Taking the target user as an example, SocialGCNRI first generates the user’s ID embedding through the embedding layer. This embedding is used as an input to the filtering layer, where the FFT is used to filter the noisy data in the user interaction sequence, and the dropout operation is used afterwards to prevent over-fitting. Subsequently, in the residual graph convolution layer, an adaptive residual graph convolution operation is used in the user interaction graph and the user social graph to further extract the user’s preference representations, and in the prediction layer the predicted score of user $u_a$ for item $i_b$ is computed.

Embedding layer

At the embedding layer, we project the high-dimensional one-hot representations of the user and the project into a fixed-length low-dimensional dense representation: $E_u\in {\mathbb{R}}^{n\times d}$ and $E_i\in {\mathbb{R}}^{m\times d}$, respectively.

(1) $$E_u=\left[e_{u_1},e_{u_2},...,e_{u_n}\right],E_i=\left[e_{i_1},e_{i_2},...,e_{i_m}\right]$$where $E_u$ is a matrix consisting of n user elements and d is a hyper-parameter denoting the length of a single user embedding vector. $E_i$ is a matrix consisting of m item elements and d is a hyper-parameter denoting the length of a single item embedding vector. Specifically, given a one-hot representation of the target user $u_a$, the embedding layer performs indexing and outputs the transpose of the a-th row of the user embedding matrix $E_u$. Similarly, given a one-hot representation of the target item $i_b$, the embedding layer performs indexing and outputs the transpose of the b-th row of the item embedding matrix $E_i$.

Filter layer

Social recommendation algorithms based on graph convolutional networks (GCN) predict user preferences by analyzing the user’s interaction history and the influence of social friends. However, the user’s interaction history generates noisy data due to a series of misoperations such as user’s mis-touch, mis-submission, and mis-entry, which makes the model unable to accurately predict the user’s preference. To alleviate the impact of this noisy data on recommendation accuracy, we employ the FFT in the field of signal processing to eliminate the noisy data (Zhou et al., 2022). Specifically, we apply the FFT after the embedding layer to transform the vectors into the frequency domain, perform noise attenuation through a filter, then use the inverse FFT to transform the noise-attenuated data back into vectors again, and finally use the Dropout operation to prevent overfitting. We will describe the operation of the filtering layer from the user’s point of view, and for the item embedding, we will perform the same operation to obtain the filtered embedding representation.

Residual graph convolutional layer

The propagation mechanism in GNN mines the relationships of nodes in the graph through information transfer between nodes, and uses this as a basis for accurately capturing user preferences. Most of the current recommendation algorithms based on GCN use LightGCN to accomplish the information propagation between nodes in the graph, and this graph convolutional algorithm removes linear transformations and nonlinear activation operations, which greatly reduces the computational complexity and simplifies the traditional graph convolutional network architecture (He et al., 2020). However, the simple propagation process makes the convolutional layer fall into the smoothing problem prematurely and fails to extract the higher-order relationships among nodes effectively. Inspired by GCNII (Chen et al., 2020b), in order to alleviate the problem of node representations falling into the smoothing problem as they are diluted by the neighbor information during the propagation process, we design an adaptive residual graph convolutional network performed in heterogeneous graphs to mine the node information in the graphs more effectively.

Prediction layer and model optimization

Datasets

We employ the LastFM and Ciao datasets, which are commonly used in social recommendation, to evaluate the performance of SocialGCNRI as well as the benchmark model. These datasets vary greatly in number and sparsity, and the specific statistics are shown in Table 1. LastFM is a widely used music recommendation datasets, which includes user music preference networks and social network. The Ciao datasets is derived from the famous online shopping platform Ciao, which contains a large number of product reviews and ratings from consumers around the world. We consider the movie part of the datasets, which includes users’ movie preferences and social networks. In the data preprocessing, in order to effectively extract the user-item interaction information, we delete the data nodes in the datasets with less than 20 interactions to constitute the normal datasets, and call the data nodes with less than 20 interactions as the cold-start data nodes, so as to construct the cold-start datasets.

Evaluation metrics

We use Precision@k, Recall@k, and Normalized Discounted Cumulative Gain (NDCG@k) to evaluate model performance. These metrics are described in detail as:

Precision@k calculates the weight of correct recommendations among all recommendations to evaluate the quality of the recommendation results, which is defined as:

(19) $$Precision@k=\frac{TP@k}{TP@k+FP@k}$$where TP@k denotes the number of recommendation items selected by the user, and FP@k denotes the number of recommendation items not selected. With this evaluation, we can visualize the accuracy of the model.

Recall@k measures the proportion of the recommender system that includes items of interest to the user in the first K items it recommends, which is defined as:

(20) $$Recall@k=\frac{R(u)@k\cap T(u)@k}{T(u)@k}$$where R(u)@k denotes the top K items recommended for the user. T(u)@k denotes the items that are actually of interest to the user as determined by the test datasets. Recall@k is used to calculate the proportion of user-interested items in the first K recommended items among all the items, and a higher value indicates that the recommender system is able to capture the user’s interest more effectively.

NDCG@k considers the relevance of the recommendation items and their position in the recommendation list, which is defined as:

(21) $$NDCG@k=\frac{DCG@k}{IDCG@k}$$where DCG@k denotes the weighted accumulation of the top k items in the recommendation list, and IDCG@k denotes the DCG values of the top k items ideally sorted according to relevance from highest to lowest. NDCG@k uses the normalized scores of IDCG@k to DCG@k to assess the overall quality of the top-k items in the recommendation list.

Baseline models

We use mainstream baseline models under different types as a contrast to evaluate the performance of the SocialGCNRI.

SBPR (Zhao, McAuley & King, 2014): This is a Bayesian personalized ranking algorithm based on similar friends in social networks, which is mainly used to solve the problem of data sparsity and single-class collaborative filtering in recommender systems.

DiffNet (Wu et al., 2019a): This model uses a graph neural network to model the recursive social diffusion process of each user, capturing the diffusion of influence hidden in higher-order social networks during user embedding.

NGCF (Wang et al., 2019b): It extends the idea of collaborative filtering to the field of graph neural networks, and designs a novel propagation mechanism to fuse the higher-order neighbor embedding information of nodes.

LightGCN (He et al., 2020): A light recommendation model that removes linear operations and nonlinear activation functions from NGCF, greatly simplifying model complexity.

SocialLGN (Liao et al., 2022): A social recommendation model that incorporates social information into the composition of LightGCN. It designs a graph fusion component to compute the embedded representations from different perspectives of the user.

DSL (Wang, Xia & Huang, 2023): A social recommendation model for contrastive learning. It designs a cross-view to filter out noisy social influences based on the interaction preferences of different users, thus improving the model accuracy.

CLDS (Ma et al., 2024): A recommendation model based on two-stage comparative learning. It uses a graph aggregation algorithm to mitigate the noise in the user-item interaction graph, and compares the user interaction representation with the user social representation to enhance the accuracy and robustness of the recommendation model.

Experiment setup

Following the strategy described in recent experiments (Long et al., 2021), we divide the datasets into training, testing, and validation sets in the ratio of 8:1:1. We use the Python framework to build the SocialGCNRI model, and the model optimizer is Adam. For the hyper-parameters in the model, we set the Dropout to 0.5, the learning rate lr to 0.01, the number of iterations epoch to 10,000 (terminate the training early if the model has no metrics growth for 30 consecutive times), the batch size to 100, the item embedding dimensions d to $\{32,64,128,256\}$, and the number of graph convolution layers to $\{2,3,4\}$. To ensure the fairness of the experimental data, we adopt the same parameter settings for the other baseline models.

Overall performance

Tables 2 and 3 show the performance of our method using the Precision@k, Recall@k, and NDCG@k evaluation metrics on both datasets compare to the other baseline models under normal conditions and cold start, respectively, where the k value is set to {10, 20}. The experimental results for some of the baseline models are derived from the values given by SocialLGN.

From the overall experimental results, it can be seen that SocialGCNRI achieves the optimal performance metrics in 18 out of the 24 evaluated metrics, which demonstrate that SocialGCNRI possesses a favorable recommendation performance. In the experimental comparison of various baselines, it can be found that the performance metrics of SBPR in both standard and cold-start situations are much smaller than those of the other baseline models (DiffNet, NGCF, LightGCN, SocialLGN, DSL, CLDS), which illustrates that the graph neural network-based recommendation model is able to more accurately capture the user’s personalization than the traditional MF model preferences. In the recommendation model based on graph neural networks, DSL uses contrastive learning to mitigate the noisy information in the network connections, but it does not consider the interaction between the corresponding nodes, which makes the cross-views biased with information. SocialLGN incorporates social information based on LightGCN, and designs a method to fuse user interaction information and social information, but it ignores the link between friendships and preferences, which makes SocialLGN underperform in cold starts although it achieves good performance in normal datasets. CLDS combines comparative learning and social information to construct the core information of social networks, and uses a heterogeneous graph neural network aggregation method to reduce the noisy data in the user interaction network, this method achieves good recommendation performance in different network environments, but the complex network architecture makes CLDS increase time loss when facing large data or complex networks. In contrast, SocialGCNRI significantly enhances information quality through the application of the FFT algorithms. Moreover, the model designs an adaptive residual graph convolution mechanism, which is integrated into a heterogeneous GNN to deeply mine and analyze the complex interactions among users. In different network environments, SocialGCNRI has shown excellent recommendation performance, which fully proves its wide applicability and high efficiency in the real world application scenarios.

Ablation study and analyses

The core innovative components of the SocialGCNRI model are two:

• (1)

  The use of FFT and filter to process the original data for denoising.

• (2)

  The proposal of an adaptive residual graph convolutional network to capture higher-order connections between users and items in the graph.

To justify these components, we set up three variants for comparison to show the impact of each component on the model. Variant-F denotes the SocialGCNRI model with filtering operations such as FFT removed, Variant-G denotes the SocialGCNRI model with adaptive residual graph convolution operations removed, and Variant-P denotes the SocialGCNRI model after removing the two core components. Tables 4 and 5 show the experimental results of SocialGCNRI and its three variants on the normal and cold-start datasets, respectively (the bold font indicates optimal performance).

We can see that all the performance metrics of the Variant-G model are improved to a certain extent compared with Variant-P, indicating that the user social relationship and item association relationship can be used to improve the recommendation performance by removing the noisy data. In addition, the Variant-F model, which includes an adaptive residual graph convolution algorithm, also exhibits a great improvement in performance compared to the Variant-P model, which shows that adaptive residual graph convolution algorithm can capture the higher-order connections between users and items more effectively. However, there is no significant difference between Variant-F and Variant-G in terms of recommendation performance, which indicates that the two core components have the same importance for recommendation performance improvement. SocialGCNRI employs FFT to filter out the noisy data of social relations and user interactions, and uses an adaptive residual graph convolutional algorithm to further extract the effective information of the nodes in the graph and accurately capture the user’s preferences, which demonstrates the optimal performance in comparison experiments on both datasets.

Imapct of the number of convolutional layers

In this section, we take SocialLGN as a control (which uses LightGCN algorithm for the graph convolutional layers of the model), and analyze the effect of different number of convolutional layers in SocialGCNRI on the performance of the model by using Precision@k, Recall@k and NDCG@k as the evaluation metrics. Figure 2 shows the experimental results under the normal datasets, and Fig. 3 shows the cold start experimental results under the datasets.

As can be seen in Figs. 2 and 3, the performance of the SocialGCNRI model rises solidly as the number of convolutional layers increases. It can be further found that the SocialGCNRI reaches its optimal performance at layers = 4 and is much larger than at layers = 2, which indicates that our proposed adaptive residual graph convolution algorithm effectively mitigates the graph smoothing phenomenon and deepens the number of convolutional layers. The same can be seen in the comparison with SocialLGN, the performance of the two graph convolution algorithms is basically equal when the number of layers = 2. When the number of layers = 4, the overall effect of the adaptive residual graph convolution algorithm is much better than that of LightGCN, and this discrepancy is even more significant in the cold-start datasets. We think the possible reason for this is that, the increase in adaptive residual connectivity allows the nodes in the graph to always incorporate a certain amount of their own information during the convolution operation, which greatly slows down the emergence of the smoothing phenomenon in the graph, and makes the model more effective in capturing the deeper connections between the nodes.

Impact of hyperparameters on recommendation performance

During the training process of the model, different hyperparameter settings can directly affect the performance of the model. We evaluate the impact of key hyperparameters such as learning rate (lr) and weight decay coefficient (decay) on the recommendation performance of the SocialGCNRI model in this section. The experimental results are shown in Fig. 4.

The weight decay coefficient is an important parameter to regulate the strength of the $L_2$ regularization penalty. As this coefficient increases, the penalty for larger weights increases, driving the model weights towards smaller values. However, over-increasing the coefficient may lead to underfitting of the model, meaning that the model is too simplified to capture the complex structure behind the data. Conversely, if the weight decay coefficients are too small, the weights are not penalized enough and the model may be at risk of overfitting. Therefore, selecting an appropriate weight decay coefficient is crucial for the generalization ability of the model, which is directly related to the performance of the model. In this section of experiments, we set the size of the weight decay coefficient coefficients to {1e−1, 1e−2, 1e−3, 1e−4, 1e−5}, and analyze the effect of different sizes of weight decay coefficients on the model performance through the experiments conducted on Lastfm datasets. From the experimental results shown in Fig. 4, it can be seen that the SocialGCNRI model exhibits the best performance when the weight decay coefficient is set to 1e−4.

The learning rate refers to the magnitude of the model weight update during the optimization process, and the difference in the size of the learning rate value will directly affect the final performance of the model. Too small a learning rate makes the training process slow, which may cause the model to fall into local minima and reach only sub-optimal solutions. While a higher learning rate allows for fast convergence, the training process may be unstable and prone to overfitting. In our experiments, we set the size of the learning rate to {1e−1, 1e−2, 1e−3, 1e−4} and analyze the effect of different learning rate sizes on the model performance. From the experimental results shown in Fig. 4, it can be seen that the model exhibits the best performance when the learning rate is 1e−3.