Overcoming the cold-start challenge in recommender systems: A novel two-stage framework

2.1 Preprocessing

Important pre-processing processes for solving the cold-start issue in recommendation systems include cleaning the data, factorizing the matrix, and building the embedding vectors for both users and products. A cold-start issue arises when the system encounters new users or things without previous interaction data. These actions are critical to prepare the data and reducing this problem.

2.2 Matrix factorization

Matrix factorization is used to decompose the user-item interaction matrix RRR into two lower-dimensional matrices UUU and VVV. This step is crucial for extracting latent features from users and items.

• (1) User-item interaction matrix: Let R be the user-item rating matrix, where R i j represents the rating given by user i to item j . The goal is to approximate R using matrix factorization: R ≈ U V T ,

• where U is the user feature matrix and V is the item feature matrix.

• (2) Optimization objective: The objective of matrix factorization is to minimize the difference between the original matrix R and the product U V T

  (1) min U , V ∑ ( i , j ) ∈ K ( R i j − u i T v j ) 2 + λ ( ∣ ∣ U ∣ ∣ F 2 + ∣ ∣ V ∣ ∣ F 2 ) ,

  where K is the set of known user-item interactions, λ is a regularization parameter, and ‖ ⋅ ‖ F denotes the Frobenius norm.

2.3 Embedding vector construction

• (1) User and item embeddings: Embedding vectors for users and items can be constructed using the matrices U and V obtained from matrix factorization. These embeddings capture latent features that represent users’ preferences and items’ characteristics.

• For user i and item j :

  (2) e u i = U [ i , : ] ,

  (3) e v j = V [ j , : ] .

• (2) Dimensionality reduction: To reduce the complexity and improve computational efficiency, principal component analysis (PCA) can be applied to the embedding vectors

  (4) Y u = U P u ,

  (5) Y i = V P i ,

  where P u and P i are the principal component matrices for users and items, respectively. PCA helps to retain the most significant features while reducing dimensionality. By following these steps, the pre-processed data will be well-prepared for further analysis and model training, effectively addressing the cold-start problem in recommendation systems.

2.4 Hierarchical density-based clustering

The extracted features from the previous stage are fed into Hierarchical density-based spatial clustering of applications with noise (HDBSCAN) for key aspect detection and clustering similar users/items. HDBSCAN is applied to the training features to group similar features into clusters that represent different user/item profiles.

1. Core distance calculation: For each data point, the core distance is calculated as the distance to its minPts-th nearest neighbor.

   (6) core _ dist ( p ) = d ( p , k -th nearest neighbor ) .

2. Mutual reachability distance: The mutual reachability distance between two points p and q is defined as

   (7) mutual _ reachability _ dist ( p , q ) = max ( core _ dist ( p ) , core _ dist ( 1 ) , d ( p , q ) ) .

3. Construct an minimum spanning tree using the mutual reachability distances, which helps form a hierarchical structure of clusters.

4. Condensed hierarchical tree: Condense the hierarchical tree to retain only stable clusters and remove transient ones.

The HDBSCAN uses a silhouette score and a core distance from the centroid to generate a collection of clusters. By comparing an object’s similarity to its own cluster and other clusters, the silhouette score determines the efficacy of a clustering technique. It shows the degree to which the clusters are distinct. A higher silhouette score (which may take on values between − 1 and 1) suggests that the clusters are more clearly delineated. One way to measure the efficacy of a clustering method is via the silhouette score, which compares the degree to which individual data points are similar to their respective clusters. The two primary metrics used to determine the silhouette coefficient s(i) for each point i are the mean intra-cluster distances (a(i)) and the mean nearest-cluster distance (b(i)). The silhouette coefficient was calculated as

where a ( i ) is defined as

and b ( i ) is

The silhouette coefficient S for clustering is the mean of s ( i ) for all points:

where N is the count of points. Points that are near to 1 show that they are well-clustered, points that are close to 0 show that they are on the decision boundary, and points that are close to − 1 show that they may have been misassigned.

For every data point (i), the silhouette score determines how snugly it fits into its respective cluster. When the mean intra-cluster distances (a(i)) are less than the mean nearest-cluster distances (b(i)), we may say that point (i) is well-clustered and different from its nearby clusters and (s(i)) will be close to 1. If (a(i)) and (b(i)) are almost equal, then s(i) will be close to 0, indicating that point (i) is at the border between two clusters to make a choice. On the other hand, if (a(i)) is larger than (b(i)), then (s(i)) will be close to − 1 , suggesting that point (i) can be mistakenly allocated to an adjacent cluster instead of its present one. Returns true if the point should be categorized as an aspect and false otherwise. A log-based algorithm is used to categorize the aspects of each cluster. The entropy minimization is the basis of the algorithm. Each of the clusters undergoes this cyclic process.

This is the formula for the entropy of a set P :

In a Cartesian coordinate system, the neighborhood NB( x , y ) is located in the first quadrant, with P as the origin. Due to its orientation, the resultant point of interest is known as

The aspect descriptors are a series of binary numbers that characterize a smooth image patch (Sim) derived from a series of binary intensity tests. Here are the details of these binary tests:

In this case, Sim( x ) stands for the strength of Sim at the given position x . An array of binary tests constitutes a feature. Follow these steps to define the aspect vector:

2.5 Affinity matrix construction for CSRNet

After applying the HDBSCAN clustering algorithm to group users and items into clusters, the next step involves constructing an affinity matrix to incorporate new users or items into the existing clusters. This process includes calculating similarities and forming the final affinity matrix for the recommendation system.

The affinity matrix in the CSRNet is crucial for incorporating the relationships between users and items to enhance cold-start recommendations. By constructing the affinity matrix, the CSRNet model captures user–user and item–item similarities. This matrix is built using cosine similarity of embeddings derived from matrix factorization and hierarchical density-based clustering (HDBSCAN). It allows the model to effectively handle scenarios with limited user-item interaction data, ensuring that new users and items are appropriately integrated into existing clusters for accurate recommendations.

1. Step 1: Affinity matrix construction for existing users and items

   • (a) Similarity matrices: Compute the similarity matrices for users and items using cosine similarity:

   • User similarity:

     (16) Sim ( u i , u j ) = u i ⋅ u j ∣ ∣ u i ∣ ∣ ∣ ∣ u j ∣ ∣ .

     Item similarity:

     (17) Sim ( i i , i j ) = i i ⋅ i j ∣ ∣ i i ∣ ∣ ∣ ∣ i j ∣ ∣ .

   • (b) Affinity matrix: Construct the affinity matrix by combining the user and item similarity matrices:

     (18) A i j = Sim ( u i , u j ) × Sim ( i i , i j ) ,

     where A i j represents the affinity between user i and item j .

2. Step 2: Grouping new users and items

   • (a) Assign new users to existing clusters: For a new user u new , calculate its similarity to the centroids of the existing user clusters. Assign u new to the cluster with the highest similarity

     (19) Cluster ( U new ) = arg max k sim ( U new , C k ) ,

     where C k is the centroid of cluster k .

   • (b) Assign new items to existing clusters: For a new item i new , calculate its similarity to the centroids of the existing item clusters. Assign i new to the cluster with the highest similarity

     (20) Cluster ( i new ) = arg max k sim ( i new , C k ) ,

     where c k is the centroid of cluster k .

   • (c) Update user and item similarity matrices: After assigning new users and items to clusters, update the user and item similarity matrices to include these new entries.

   • For a new user u new and an existing user u j

     (21) Sim ( u new , u j ) = u new ⋅ u j ∣ ∣ u new ∣ ∣ ∣ ∣ u j ∣ ∣ .

     Similarly, for a new item i new and an existing item i j

     (22) Sim ( i new , i j ) = i new ⋅ i j ∣ ∣ i new ∣ ∣ ∣ ∣ i j ∣ ∣ .

   • (d) Construct the final affinity matrix: Incorporate the updated similarity values into the affinity matrix.

   • For a new user u new and an item i j

     (23) A new , j = sim ( U new , Cluster ( u j ) ) × sim ( i j , Cluster ( i j ) ) .

     For an existing user u i and an item i new

     (24) A i , new = sim ( U i , Cluster ( u i ) ) × sim ( i new , Cluster ( i new ) ) .

     For a new user u new and an item i new

     (25) A new , new = sim ( U new , Cluster ( u new ) ) × sim ( i new , Cluster ( i new ) ) .

2.6 Cold-start recommendation using transfer learning and Bi-GRU with attention

The proposed CSRNet architecture for addressing the cold-start problem in RSs is demonstrated using input data obtained from a pre-processed and enhanced dataset. Data are processed using a ResNet-50 backbone to extract complex features, and the training process is enhanced by using Batch Normalization to stabilize and accelerate it. Subsequently, a feature vector is created by decreasing the spatial dimensions of the feature maps through the utilization of a Global Average Pooling layer, resulting in a vector with just one dimension.

A dense layer of 1,024, units, activated using the Rectified Linear Unit (ReLU) function, is fed with this vector to understand complex feature relationships. Subsequently, a dropout layer is used with a dropout rate of 50% to alleviate overfitting. A single unit dense layer with sigmoid activation is used to classify user-item interactions at the end.

ResNet50 has 16 blocks that are left over. Here is a short explanation of ResNet50. Each of the many steps that make up ResNet50’s architecture comprises a varying number of residual blocks. First, the max-pooling and first convolutional layers; second, three residual blocks, with three convolutional layers each; and last, the final stage. The third stage involves four blocks of residual data, with four convolutional layers in each. The fourth stage involves six residual blocks, each with six convolutional layers in each. In the fifth stage, three sets of residuals, with three convolutional layers in each set are involved.

1. Each residual block consists of a convolution operation defined as:

   (26) y = ( x ⁎ W ) + b ,

   where x is an input tensor, W is a convolution kernel (filter), * is a convolution operation, b is the bias term, and y is the output tensor after convolution.

2. Residual connection

   (27) y = F ( x , { W i } ) + x ,

   where x is an input tensor (identity mapping), F ( x , { W i } ) is a function representing the residual block, typically a series of convolutions, batch normalization, and ReLU activations, and y is the output tensor after adding the input x and the function F ( x , { W i } ) .

where the variables X , μ , σ 2 , ε , are small constants to avoid division by zero, x ˆ a normalized input, γ and β are learnable parameters in the batch normalization layer. The ReLU function is defined as

After ResNet50, we optimized the model by adding batch normalization, a dense layer of 1,024, and a dropout of 50%. Finally, a dense layer with two output features represents the number of classes in the classification task. In the dense (1,024) layer, an L2 regularizer with 0.016 is taken as the kernel regularizer, and an L1 regularizer of 0.06 is taken as both an activity and a bias regularizer.

This study optimizes the CSRNet model, reduces the overfitting problem in the multi-layer network structure, and accurately and efficiently extracts features from user and item data using the attention mechanism module. The goal is to achieve efficient and accurate personalized recommendations by improving the recommendation algorithm’s performance. The CSRNet model leverages a GRU network to determine the hidden layer output gtg_tgt using the input rtr_trt and the hidden layer output g t − 1 g _ t − 1 g t − 1 from earlier in time. Equations (32)–(35) demonstrate the update of the GRU network’s internal unit, which consists of an update gate utu_tut and a reset gate vtv_tvt. The internal structure of the GRU network is as follows:

In this context, binary classification problems often include the sigmoid function, where w is the weight matrix and σ is the activation function in the gate calculation results. The model is able to control the amount of state information that is added to the current time depending on the preceding time by modifying the value of the update gate u t . More information is provided when the value is greater. The candidate set for the current state g ¯ t is controlled by the amount of information about the state entered from the previous time by the reset gate v t . Reducing the reset gate’s value means that less data from the prior instant is to be input into the candidate set.

As time goes on and the outside world exerts its constant pull, so do people’s interests and hobbies. Users’ interests and hobbies tend to cluster around certain times as well. Hence, relying only on the initial one-layer GRU is insufficient for simulating this shift in user interest.

Using the auxiliary loss function, the data extraction layer may extract the expression of interest features from the user interaction sequence. A layer of GRU with an attention mechanism must be added to the initial GRU network to represent the trend of evolution and the concentration of user interest. Incorporating GRU’s sequence learning capabilities with attention mechanism’s local activation ability allows us to model interest evolution as it actually occurs, with local activation performance simulating interest concentration and mitigating the effect of irrelevant interest on the model’s output.

The method of calculation of attention q t is illustrated in equation (36), where sq is the sum of the embedding vectors of the candidate goods, c is the matrix of model parameter, c ∈ R n G × n Q , where n G is the dimension size of the hidden layer and n Q is the dimension size of the embedding vectors of the candidate goods. The attention value q t can represent the correlation between the candidate goods and the input rt.

Currently, the majority of researchers disregard the disparities between dimensions when using the attention score qt to directly control the hidden layer’s update state instead of using the update gate ut. This research builds the GRU with the attention update gate (AUG-GRU) by integrating the attention mechanism with the update gate.

To minimize the effect of irrelevant input on the model, the update gate in the suggested AUG-GRU network keeps the original input’s dimensional information and scales the attention score to all the dimensions of the update gate. To rephrase, AUG-GRU is able to facilitate the model’s interest extraction in a more seamless manner and more effectively prevent interference caused by abrupt changes in interest. Equations (37) and (38) illustrate the transformation of AUG-GRU into GRU, with ut representing the original GRU’s update gate, ut denoting the redesigned AUG-GRU’s update gate, and g t ′ and g t − 1 ′ denoting the hidden layer states of AUG-GRU.

The use of a GRU network model to extract user sequence interest is the most significant enhancement of the suggested model, in contrast to the conventional recommendation system model. In doing so, we guarantee the correct extraction of users’ sequence characteristics by using a variant GRU structure with an attention mechanism, which allows us to better adjust to the trend of users’ interests as they evolve.

2.7 Proposed model architecture

The architecture presented in Figure 2 combines transfer-learned characteristics with GRU-based recommendations, specifically designed for personalized product recommendation in a multi-product environment. The input features begin with an affinity feature matrix processed through a ResNet-50 backbone to extract complex attribute-specific features. To prevent overfitting, a dropout layer is applied, followed by dense layers that learn intricate patterns in the data. These features are then fed into Bidirectional GRU (Bi-GRU) layers to capture sequential dependencies from both directions. A dense layer integrates the outputs of the Bi-GRU layers, which are further processed by an AUG-GRU layer to enhance feature extraction by focusing on relevant information. The final output layer provides robust and accurate cold-start recommendations, effectively addressing the cold-start problem by delivering high-quality personalized product recommendations even for new users and items.

Figure 2

Proposed model architecture for cold-start recommendation.

2.8 Proposed model algorithm

The CSRNet algorithm described above is a sophisticated approach for addressing the cold-start problem in recommendation systems. Using the strengths of transfer learning with ResNet-50 for feature extraction, the algorithm excels in capturing complex attribute-specific features. These features are then synergistically combined and fed into a Bi-GRU with AUG-GRU, known for its effectiveness in handling the cold-start problem. This approach ensures robust and accurate personalized recommendations even for new users and items, effectively mitigating the challenges posed by the cold-start scenario in a multi-product environment.

3.1 Dataset description

We assess our model’s efficacy in various cold-start settings using the publicly available dataset from the cold-start recommendation systems research community. The MovieLens-100k [27] dataset spans the 7 months from September 1997 to April 1998 and includes 100,000 ratings for 1,682 movies from 943 people. At least 20 films have been reviewed by each user here. The data from 85% of these users are utilized for training purposes, while the data from the remaining 15% are used for testing purposes alone. When it comes to recommendation algorithms, it is the public dataset that is utilized the most. The details of MovieLens-100k’s features are summarized in Table 2.

For the purpose of evaluating the model’s performance in user and item cold-start situations, we categorize things and users as either existing or new. The cold-start scenario is specifically broken down into the following four sections: (1) existing item recommendations for current users, (2) existing item recommendations for new users, (3) new item recommendations for current users, and (4) new item recommendations for new users.

3.2 Performance assessment

Metrics such as F1-Score, recall, precision, and accuracy provide a thorough evaluation of the model’s utility, and they are used to analyze the proposed work’s performance. The correctness of the model is quantified by its accuracy. A model’s recall measures how well it can detect real positives. A key aspect of precision is reducing the occurrence of false positives. To provide a performance indication, the F1-score balances recall and accuracy. All these metrics put together give you a good idea of how well the model worked in many circumstances highlighting strengths and areas for improvement. The accuracy, recall, precision and F1-score metrics in the proposed work can be computed using the following formulae:

where, TP represents True Positive, TN represents True Negative, FP represents False Positive, whereas FN represents False Negative (not identified).

MAE, represents the average absolute error

RMSE, is a measurement of the average Euclidean distance between t i and p i

Symmetric mean absolute percentage error (SMAPE) metric is to enhance the robustness of error evaluation. We introduce the SMAPE metric, which provides a normalized, scale-independent error measurement expressed as a percentage between 0 and 100%. SMAPE is defined as

The evaluation metrics used in this study, such as accuracy, precision, recall, F1-score, RMSE, and MAE, are justified as they provide a comprehensive understanding of the model’s performance across various dimensions. Accuracy measures the overall correctness of predictions, while precision and recall evaluate the model’s effectiveness in identifying relevant recommendations. The F1-score balances precision and recall. RMSE and MAE assess prediction error, which makes them crucial for analyzing performance in cold-start scenarios. These metrics ensure that CSRNet’s effectiveness is thoroughly evaluated from multiple perspectives.

3.3 Dataset pre-processing

MovieLens-100k roughly 8:2 splits the movies in the movie dataset between those that were out before 1997 and those that came out after 1998. The same holds true for the cold-start scenario; we randomly choose 80% of all users to be current users and the remaining 20% to be new users.

3.4 Matrix factorization and embedding vector construction

Matrix factorization in CSRNet breaks down the user-item interaction matrix R into two lower-dimensional matrices, U and V, respectively, to get insight into hidden preferences and traits. Using these matrices, we may build object and user embedding vectors, then reduce the matrices using PCA for efficiency. These embeddings form the basis for similarity matrices, crucial for constructing an affinity matrix that accurately integrates and predicts preferences for new users and items in the recommendation system.

3.5 CSRNet performance on MovieLens-100k

The performance of CSRNet on the MovieLens-100k dataset was evaluated with various epochs, parameter settings, and CSRNet setups as shown in Table 3. The CSRNet model, which adjusts the internal parameters for better training, is applied to the dataset. Through repeated iterations, the model effectively learns to extract relevant attributes and distinguish user preferences. The accuracy and loss metrics for each epoch demonstrate the model’s performance. The parameters used for training include 20 and 40 training epochs, a batch size of 32, a kernel size of 5, the Adam optimizer with a learning rate of 0.001, and a dropout rate of 0.50. Early stopping and learning rate reduction were enabled, data were shuffled, and the loss function used was Sparse Categorical Cross Entropy with ReLU and Softmax activation functions. The accuracy of recommendations for CSRNet across 20 and 40 epochs is shown in Figures 4 and 5.

Figure 3

Condensed Tree representation of HDBSCAN clustering algorithm representation for 10 clusters on an instance of MovieLens-100k dataset.

Figure 4

The performance of CSRNet model on the MovieLens-100k dataset for 20 epochs.

3.5.1 Performance of HDBSCAN on MovieLens-100k

Figure 3 illustrates a condensed tree representation of the HDBSCAN clustering algorithm applied to the MovieLens-100k dataset, showing the clustering structure for a minimum cluster size of 10 with the color bar indicating the number of points in each cluster. In CSRNet, this demonstrates the clustering stage where user and item embeddings are grouped to enhance recommendation accuracy. Each cluster represents users or items with similar latent features, identified based on their embeddings, with the λ value indicating the density threshold for clustering. This effective grouping allows CSRNet to better predict and recommend items, especially in cold-start scenarios with limited interaction data. The silhouette score of 0.9342 indicates excellent cluster cohesion and separation, validating the HDBSCAN algorithm’s effectiveness in enhancing CSRNet’s recommendation capabilities.

Figure 5

The performance of CSRNet model on the MovieLens-100k dataset for 40 epochs.

3.5.3 CSRNet cold-start recommendation analysis on MovieLens-100k dataset

Table 4 presents the CSRNet model’s cold-start recommendation performance on the MovieLens-100k dataset across four key scenarios: existing users with existing items, new users with existing items, existing users with new items, and new users with new items. The table reports RMSE, MAE, and the newly introduced SMAPE metric, which provides a normalized, percentage-based error measure. The results show that the model achieves its lowest error when recommending existing items to existing users (RMSE 1.1033, MAE 0.9047, SMAPE 30.16%), with error rates increasing moderately for new user and new item scenarios, peaking at 38.85% SMAPE when recommending new items to existing users. These results highlight CSRNet’s strong capability to handle cold-start conditions, maintaining acceptable prediction accuracy even in the most challenging cases where no prior user–item interactions are available.

Table 4

CSRNet cold start recommendation analysis on MovieLens-100k dataset

Type of Cold-start	RMSE	MAE	SMAPE (%)
Recommendation of existing items for existing users	1.1033	0.9047	30.16
Recommendation of existing items for new users	1.1084	1.0694	35.65
Recommendation of new items for existing users	1.3453	1.1655	38.85
Recommendation of new items for new users	1.4190	1.1320	37.73

Figure 6 illustrates the SMAPE values for CSRNet under four recommendation scenarios: (i) existing items to existing users, (ii) existing items to new users, (iii) new items to existing users, and (iv) new items to new users. As shown in Figure 6, SMAPE increases as user and item novelty increases, with the highest error when recommending new items to existing users, with the lowest SMAPE observed in the known-user and known-item case. This visual representation underscores the trade-off in prediction accuracy across cold-start scenarios.

Figure 6

SMAPE performance of CSRNet across cold-start scenarios on MovieLens-100k.

Figure 7 displays the distribution of the RMSE for CSRNet across trials while making recommendations for existing goods to new users. The y -axis shows RMSE values ranging from approximately 0.975 to 1.150, with the median values generally around 1.075–1.100, indicating consistent accuracy despite limited user- interaction data. The spread of the box plots, including interquartile ranges and whiskers, reflects the variability in performance, with some outliers present. From Figure 7, which demonstrates CSRNet’s robustness in handling the cold-start problem for new users, maintaining relatively low RMSE values and delivering reliable recommendations across multiple iterations.

Figure 7

CSRNet performance (RMSE) on the recommendation on existing item for the new user.

Using the MovieLens-100k dataset and 20 epochs, the CSRNet model’s performance on cold-start suggestions is shown in Figure 8, with an emphasis on MAE. The MAE values are shown on the y -axis, while the number of epochs is shown on the x -axis. Consistent declines of the training MAE (blue line) show that the model is learning well and lowering prediction errors with time. The orange line, which represents the validation MAE, shows that the performance on unknown data is constant as it first declines and then swings about 0.85. This trend suggests that CSRNet maintains robust generalization while effectively minimizing errors during training, thus showcasing its capability to handle cold-start scenarios by providing accurate recommendations even with sparse user-item interaction data.

Figure 8

Performance of MAE of CSRNet cold start recommendation on MovieLens-100k dataset.

3.5.4 ROC analysis

The ROC analysis shown in Figure 9, the proposed CSRNet model, as depicted in the graph, demonstrates its effective performance with a high true positive rate and low false positive rate, ideal for classification tasks in cold-start scenarios. The curve, which significantly ascends close to the upper left corner and maintains a position well above the diagonal line of no discrimination, indicates a strong discriminative ability with an AUC of 0.92. This performance underscores CSRNet’s capability to accurately differentiate between classes, managing to maintain both high sensitivity and specificity, crucial for providing reliable recommendations in environments where new users or items are frequently introduced without extensive historical interaction data.

Figure 9

ROC analysis of the proposed CSRNet model on test data.

3.6 Evaluate the proposed model’s performance on a MovieLens-100k SOTA methods

Table 5, shows the results of comparing the suggested CSRNet model to several SOTA approaches on the MovieLens-100k dataset. The metrics used include F1-score, recall, precision, NDCG@3, and Top@5 hit rate. The IRGAN model shows a moderate level of accuracy with a high recall of 79.0, an F1-score of 76.0, an NDCG@3 of 0.71, and a Top@5 hit rate of 88%. The MetaCS-DNN model exhibits balanced performance with a precision of 66.0, recall of 54.0, F1-score of 58.0, NDCG@3 of 0.73, and Top@5 of 89%. The frequent pattern approach achieves very high accuracy, with an F1-score of 71, recall of 76.3, precision of 89.45, NDCG@3 of 0.85, and Top@5 of 93%. The deep learning model shows lesser performance, with an F1-score of 40.98, recall of 32.60, precision of 55.16, NDCG@3 of 0.65, and Top@5 of 83%. Figure 10 illustrates a comparative analysis of precision, recall, F1-score, NDCG@3, and Top@5 across various models, with the proposed CSRNet outperforming others like IRGAN, MetaCS-DNN, frequent pattern approach, and the deep learning model across all metrics, highlighting its superior capability in handling recommendations efficiently. Specifically, the suggested CSRNet model achieves the best results compared to all other techniques, with a precision of 90.2, recall of 90.9, F1-score of 90.9, NDCG@3 of 0.91, and Top@5 hit rate of 97%. This comparison shows that CSRNet is both successful and resilient, making it an excellent candidate for recommendation systems, particularly those facing cold-start challenges.

Figure 10

Comparison of precision, recall and F1-score across the SOTA.

3.7 Computational complexity analysis

The computational complexity of CSRNet arises from four main components: matrix factorization, clustering, similarity computation, and deep learning. Matrix factorization has complexity O ( k × n u × n i ) , where n u and n i are the numbers of users and items, and k is the latent dimension. HDBSCAN clustering contributes O ( n log n ) on average ( O ( n 2 ) worst case), where n is the number of data points. Constructing user–user and item–item similarity matrices scales as O ( n u 2 + n i 2 ) . The deep learning pipeline (ResNet-50 + Bi-GRU + AUG-GRU) adds O ( E B ( f r + T H 2 ) ) per epoch, where E is the number of epochs, B is the batch size, T is the sequence length, and H is the hidden size. Overall, the system scales linearly with training iterations and batch size, but clustering and similarity steps require careful optimization for large datasets. Practical efficiency is ensured by GPU acceleration, precomputed embeddings, and efficient clustering libraries.