Session recommendation based on traditional methods

Session-based recommendation (SBR) systems aim to predict the following item a user will interact with by analyzing short-term behavior sequences. Traditional SBR approaches fall into two main categories: co-occurrence-based methods [22] and Markov chain-based methods [6,23]. Co-occurrence methods leverage item-to-item similarity to recommend frequently co-appearing items but struggle to model sequential dependencies. In contrast, Markov chain models capture short-term preferences from recent clicks and effectively reflect immediate user intent. However, they often overemphasize the latest interactions and overlook long-term user preferences. These limitations have motivated the development of more advanced methods that provide a deeper understanding of user behavior and enhance recommendation performance.

Deep learning based session recommendation

Deep learning has recently driven significant advances in session-based recommendation (SBR). As a pioneering work, Hidasi et al. [10] first applied a recurrent neural network (RNN) to sequential recommendation, introducing the GRU4Rec model, which laid the foundation for future studies. Building on this, Li et al. [4] enhanced GRU4Rec with an attention mechanism to better capture representative item transitions. Parks et al. [5] further advanced the field by proposing STAMP, replacing RNN encoders with attention to jointly model users’ long-term preferences and short-term behaviors. In terms of model architecture innovation, Wang et al. [24] proposed SASRec, which employs self-attention to extract deep transition patterns in item sequences. Despite these developments, limitations remain. Most RNN—and CNN-based models emphasize direct transitions between adjacent items, often neglecting complex, latent relationships among non-adjacent items, such as cross-session dependencies or multi-hop neighbors [25,26]. This restricts their ability to capture user behavior patterns fully. Such architectural limitations become especially problematic in cross-session scenarios, where models may fail to reflect users’ valid preferences. Overcoming these challenges is, therefore, a key focus for future research in SBR.

Session recommendation based on graph neural networks

In recent years, graph neural networks (GNNs) have shown strong performance in capturing complex node relationships [27–29]. In the session-based recommendation (SBR) field, Wu et al. [15] pioneered the use of Graph Neural Networks (GNNs) by introducing SR-GNN, which reformulates the sequential recommendation task as a graph modeling problem. SR-GNN leverages a gated graph neural network (GGNN) to learn item representations and extract high-order information. Inspired by SR-GNN, various GNN-based models have been proposed. GC-SAN [30] combines GGNN with self-attention [31] to capture local item transitions and model long-term interests. NISER [32] utilizes normalization to enhance robustness in the presence of sparse and noisy data. S²-DHCN [33] adopts a dual-channel hypergraph network to model short-term interests and enhance hypergraph learning. CSRM [34] incorporates contextual factors (e.g., time, location) and attention to improve sequential modeling. SGNN-HN [13] addresses non-adjacent item relations and overfitting using star-shaped GNNs and highway networks. CoSAN [35] enhances session-awareness by utilizing neighborhood session embeddings and multi-head attention. GCE-GNN [36] constructs a global session graph by combining local and global session representations. Beyond recommender systems, graph-based models have also been applied in safety-critical dynamic system prediction tasks. For instance, Peng et al [37] proposed the Graph Time Neural Network (GTN), which integrates graph attention mechanisms with multi-scale time series analysis and auxiliary learning to enhance long-term prediction in train–bridge coupled systems. Similarly, Zhang et al. [38] introduced a self-evolving Graph Isomorphic Network (GIN) for multi-scenario safety assessment of railway bridges, demonstrating robust performance across both known and unseen scenarios. These studies provide new perspectives and inspire our work by showing how graph-based attention and self-evolutionary strategies can effectively address complex sequential dependencies and cross-scenario modeling. In the context of session-based recommendation, Int-GNN [39] represents an attempt to incorporate frequency-based signals to model user intent within sessions, achieving competitive performance. However, consistent with the challenges identified in other domains such as dynamic system prediction and cross-scenario safety assessment, Int-GNN still suffers from key limitations: it focuses only on single-session modeling, overlooks cross-session intent dynamics, and lacks effective strategies for handling data sparsity—one of the most common challenges in SBR. Building on the new perspectives provided by recent graph-based advances in other fields and addressing the specific shortcomings of Int-GNN, our study proposes a more robust and generalizable session-based recommendation model.

Contrastive learning recommendation

Contrastive Learning (CL) is a self-supervised paradigm that extracts supervisory signals from unlabeled data through pretext tasks. Its core idea is to learn robust representations by maximizing agreement between different augmented views of the same instance (positives) while minimizing similarity with views of other instances (negatives), typically optimized via contrastive loss. CL first achieved breakthroughs in computer vision with models such as SimCLR [40] and MoCo [41], and has since been extended to natural language processing [42] and audio processing [43].

Recently, CL has gained traction in recommender systems for alleviating data sparsity and improving representation learning. LightGCL [44] employs singular value decomposition (SVD) for global alignment, while SimGCL [45] demonstrates that injecting uniform noise into embeddings achieves strong performance at lower cost. Building on these foundations, the principles of CL—view-invariant representation and hardness-aware negative sampling—have been adapted to domain-specific challenges. For example, in knowledge-grounded dialogue (KGD) [46], entity-aware CL improves robustness by constructing positives with irrelevant noise and negatives with relevant noise, while in time series, TimesURL [47] leverages frequency-temporal augmentations and dual negative sampling to learn generalizable representations.

In session-based recommendation (SBR), CL has been applied to handle user anonymity and noisy interactions. SCL [48] simplifies CL by directly optimizing alignment and uniformity without complex augmentations, improving interpretability and efficiency. RecDCL [49] further introduces a dual framework with batch-wise and feature-wise objectives for enhanced robustness. However, most methods still rely on fixed augmentations and overlook adversarial and multi-perspective alignment. To address this, we propose Multi-Perspective Adversarial Contrastive Learning (MPACL), which builds tailored session views and employs adversarial training to generate challenging negatives, thereby distilling true user intent from noise and improving both robustness and discriminative power of session representations.

Methodological framework overview

The overall framework of GCACL-Rec is illustrated in Fig 1. First, all sessions and the current session are constructed into a global-level graph and a local-level graph, respectively. We also compute item occurrence counts across all sessions to obtain frequency-based item embeddings. The local graph is processed by a Position-aware GNN (P-GNN) to capture high-order local dependencies and generate local item embeddings. The global graph is processed by an MSGNN and, combined with the frequency embeddings, is further refined by a statistics-aware attention mechanism to emphasize high-frequency items, yielding global item embeddings. Next, a soft attention-based fusion module integrates global and local embeddings to learn a pairwise-aware session representation. Meanwhile, the frequency embeddings are passed through a Bidirectional GRU (Bi-GRU) to model both short—and long-term user preferences. Average pooling is followed by deriving a user preference embedding h_u, representing the user’s interest over the entire item set V. The fused item embeddings are also input into another Bi-GRU to capture temporal dependencies further. The original fused embeddings and Bi-GRU outputs are then combined using a gated GRU to retain informative features, resulting in the final item representation h_s. Additionally, GCACL-Rec introduces a multi-perspective adversarial contrastive learning strategy, which constructs multiple session views and maximizes their consistency via adversarial training. Finally, a hybrid prediction layer combining Neural Decision Forests (NDF) and Softmax is used to compute the score for each candidate item, predicting the following item the user is likely to click in the given session.

Download:

• PPT
  PowerPoint slide
• PNG
  larger image
• TIFF
  original image

Fig 1. Overall structure diagram of the GCACL-Rec model.

The diagram provides a high-level overview of the model architecture, aiding understanding before the detailed explanation.

https://doi.org/10.1371/journal.pone.0335176.g001

Local level graph neural network

To capture pairwise relationships between items within a session, we construct a local graph for each session, where denotes the set of item nodes in the current session and E_L represents the edges based on the item click sequence in session S. To better model item transition patterns, a self-loop is added to each item node to capture its self-state. Since the local graph is directed and item transitions are directional, edges are categorised into four types: r_in (transition from v_i to only), r_out (from to v_i), r_in−out (bidirectional transitions), and r_self (self-loops). This edge typing strategy allows the model to represent item interaction patterns within sessions more accurately.

Building on this, we introduce a positional embedding for each node to capture its position within the sequence. Specifically, the positional embeddings are generated as follows:

(1)

W_p is a trainable embedding matrix that maps each node’s position index to a high-dimensional space. The normalization function stabilizes the embedding values and reduces noise during propagation.

To capture node relationships more effectively, each node updates its features through multiple graph convolution layers, where each layer takes the output of the previous one as input:

(2)

Where A_ij is the normalized measure of the relation or relative position between nodes and , ensuring that the sum of weights over all neighbors of a node equals 1, r_ij denotes the connection type between and , is the feature representation of node at layer l–1, and the initial input is the positional embedding of node .

After the graph convolution, we use a Gated Recurrent Unit (GRU) to capture time-related patterns. GRUs are suitable for modeling sequences and managing long-term dependencies. The computation is defined as follows:

(3)

Where h_t is the hidden state at time t, and x_t is the node feature output from the graph convolution.

Finally, after processing through the graph convolution and GRU layers, a fully connected network is used to map and extract node features, producing the final node representations:

(4)

Where h_i denotes the feature output by the GRU, and W and b are learnable parameters.

Finally, the project feature representation obtained through local graph modeling is defined as , where represents the embedding of the i-th project in the local graph.

Global-level graph neural networks

To address the issue of insufficient item representation in Local-GNN session modeling caused by data sparsity, this study proposes constructing a global graph to integrate transition patterns across all sessions. Specifically, given a session set , we construct a global graph , where represents item nodes appearing in all sessions. In this paper, we use the term hypernodes consistently to denote auxiliary nodes that aggregate structurally or semantically similar sessions. Similarly, we use global graph to describe the integrated cross-session structure. To capture high-order item transitions across sessions, a set of hypernodes is introduced, each aggregating structurally or semantically similar sessions. For any node , its neighborhood includes both item nodes with direct transition relationships and connected hypernodes that introduce semantic associations across sessions. Unlike traditional GNNs that model only local structures based on adjacency matrices, we adopt a dynamic routing mechanism between nodes and hypernodes to enable bidirectional information exchange. This design effectively integrates local transition patterns with global semantics, providing a unified and efficient graph structure for modeling cross-session dependencies and representation learning.

Information propagation between nodes.

In this method, message passing between nodes considers both the current session representation and the weight assignment between a node and its neighbors. Specifically, for node and each of its neighbors , an attention score is calculated by combining the feature of with the semantic information of the current session, indicating the importance of . The calculation is as follows:

(5)

where denotes element-wise multiplication, and W₁ is a learnable weight matrix. This design allows the model to better capture the importance of neighbor nodes in the current session.

To ensure the comparability of weights when computing attention for node , the attention scores b_ij are normalized using Softmax:

(6)

Where denotes all neighbors connected to node . The normalized b_ij represents the attention weight of neighbor relative to other neighbors.

After computing and normalizing the attention weights, the updated representation is obtained by the weighted sum of all neighbor representations of node :

(7)

This process performs weighted aggregation of neighbor features, allowing neighbors more relevant to the current session to contribute more. The resulting representation combines both the node’s information and that of its neighbors, capturing richer semantic features in the graph.

Information propagation between hypernodes.

To effectively capture high-order graph information, we generate hypernodes through three complementary strategies: mean pooling preserves session-wide statistics, max pooling extracts dominant features, and random sampling (activated when hypernodes exceed three) enhances diversity. These hypernodes then undergo relative multi-head attention, facilitating position-aware multi-round interactions. The initial hypernode representations are defined as , where L is the number of hypernodes.

Given the hypernode representations at the t-th layer , we project them into query, key, and value vectors to capture interactions and relative positional information: , , and , where W^Q, W^K, and W^V are learnable parameter matrices. With H attention heads, each head has a dimension of d_k = d/H. In the h-th head, the relative attention score between hypernodes i and j is computed as follows:

(8)

Where R(i–j) represents the relative positional information between hypernodes i and j, derived from their index difference i–j, and are learnable bias vectors.

Then, is scaled and normalized using Softmax, and the weighted sum of the value vectors obtains the output:

(9)

With h attention heads, we compute outputs O⁽¹⁾,O⁽²⁾,...,O^(H) and concatenate them along the feature dimension. The concatenated result is then transformed by a learnable linear projection matrix W^O to obtain the updated hypernode representations P^(t).

(10)

where is a learnable projection matrix. Through multiple iterations, hypernodes exchange information under the guidance of relative positional encoding, leading to representations with enhanced global awareness.

The final hypernode representation p^(T) is considered the output that captures both high-order structural information and relative positional dependencies. It retains the local semantic information aggregated within each hypernode while integrating the influence of other hypernodes and their relative positions in the index space, resulting in a globally-aware and hierarchically-structured representation.

Cross-propagation.

In each propagation round, relying only on node-to-node or hypernode-to-hypernode interactions limits information exchange to shallow structures, making it difficult to integrate global context and local structure effectively. To address this, we design a cross-propagation mechanism that enables nodes to directly receive information from hypernodes, while hypernodes can also capture dynamic feedback from nodes.

Based on the previously obtained node representations and hypernode representations p^(t), we introduce a bidirectional propagation path between hypernodes and nodes to enhance global-local fusion. During hypernode updates, we first compute interaction results via relative multi-head attention (RMHA) among hypernodes and then integrate dynamic feedback from nodes. The update is given by:

(11)

where represents the connection matrix between nodes and hypernodes, this design ensures each iteration allows hypernodes to aggregate global semantic information while dynamically sensing connected node features, preventing semantic drift and enhancing representation consistency and timeliness.

In the node update phase, nodes receive messages not only from their neighbors but also from hypernodes to enhance global awareness. The update is computed as:

(12)

where is the node-to-neighbor adjacency matrix, W_x is a learnable projection matrix, and is an activation function.

The bidirectional propagation between hypernodes and nodes is repeated for T = 0, 1, ..., T − 1. The final node representation X^(T) combines neighbor and hypernode information, enabling nodes to retain local features while capturing global context for stronger representations.

Get global embedding.

In earlier sections, we introduced the MSGNN framework and discussed preliminary item representations in session sequences. However, item occurrences in sessions are often imbalanced, with high-frequency items better reflecting user interests. Explicitly incorporating item frequency into graph representation learning can increase the model’s attention to these items and improve recommendation performance. Specifically, we define a global frequency embedding matrix , where each is a learnable embedding for items appearing i times, capturing user preference signals. For each item in a session , we compute its frequency , retrieve the corresponding embedding from E_O, and construct the session’s frequency embedding matrix:

(13)

We design a statistic-aware attention mechanism to fuse the semantic and statistical features of items. Semantic features capture contextual information, while statistical features (e.g., frequency) reflect the importance of an item within a session. Simple concatenation or averaging may fail to capture their relative contributions; therefore, we introduce an adaptive weighting mechanism to balance the influence of both feature types dynamically.

To achieve this, we apply an attention-based mechanism to compute the contribution of the occurrence embedding relative to the item feature X^T, estimating the influence of statistical features in the current representation. The computation is as follows:

(14)

where and are learnable linear mapping parameters, and is the Sigmoid activation function.

Based on the attention weight computed above, we weight the semantic representation X^T of node i to generate the final item representation vector:

(15)

The resulting is the final global representation of node , combining its semantic features and statistical information within the session.

Conversational representation learning layer

With the help of G-GNN and L-GNN, we obtain both local and global embeddings of items. To effectively fuse local structural and global semantic representations, we introduce a soft attention-based weighted fusion mechanism. This mechanism dynamically adjusts the contribution of each semantic perspective based on contextual features. First, the local and global embeddings are concatenated along the feature dimension:

(16)

where denotes vector concatenation, is the local item embedding, and is the global embedding. Then, the soft attention mechanism computes the attention weights as follows:

(17)

Where q is an attention query vector that captures which items are more important in the current context. Finally, we obtain the session representation based on pairwise relations by linearly combining item embeddings with their attention weights.

(18)

The fused representation z_i captures both global semantic information and short-term dependencies from the local structure.

In sequential modeling, the order of items plays a key role in capturing user preferences. To address this, we introduce a Bidirectional Gated Recurrent Unit (BiGRU) (consistent with Eq (3), just performing forward and reverse calculations) to capture the dynamic evolution of context from the fused sequence . After processing each z_i with BiGRU, we obtain , which incorporates both past and future information, enabling the model to capture both short-term transitions and long-term dependencies.

Although the BiGRU output is expressive, its deep transformations may introduce redundancy or noise. To address this, we introduce a Gated Fusion GRU to dynamically balance the contributions of BiGRU outputs and the original inputs, highlighting significant changes while suppressing interference. Specifically, we first concatenate the two to compute the gating weights:

(19)

The gating coefficients control the distribution of weights of the information between the two sources, and the final fusion output is:

(20)

When g_i is large, more emphasis is placed on the dynamic modeling of BiGRU; when it is small, more of the original local–global fused features are preserved.

Ultimately, the final output sequence integrates temporal modeling with global structure and local context, serving as a key representation for contrastive learning and score prediction.

To model item frequency and the user interest it reflects, we have constructed the frequency-based embedding sequence and input it into a BiGRU to capture its temporal dynamics, yielding . This design extracts sequential dependencies to identify user attention patterns, enhancing the model’s ability to represent repeated clicks and frequent switches. The final frequency-aware user preference h_u is obtained by averaging the BiGRU output.

(21)

Prediction layer

This section describes how to score candidate items based on the representation of the learned session and the user’s preference. After obtaining the final session embedding h_s and global user preference h_u, we design a multi-branch prediction layer to combine user intent and item features for more accurate recommendations. The layer comprises two main components: a traditional softmax-based branch and a high-capacity neural decision forest (NDF) [21] branch, both of which contribute to the final prediction. The scoring method of the traditional branch is as follows:

(22)

Where and are the L2-normalized user preference and session representations, denotes the frequency distribution vector of the item, which captures user tendencies, and denotes the embedding of the initial feature of the item based on the session.

However, Most session recommenders use an encoder–predictor setup: the encoder turns a session into a vector, and a predictor scores items. A common linear dot-product predictor has low capacity and struggles with noisy or random clicks, bottlenecking even strong encoders. Recent work demonstrates that incorporating a high-capacity, tree-inspired module—alongside denoising the session vector and pruning to manage capacity—consistently improves accuracy. Following this, we utilize a global, context-aware encoder and replace the linear head with a Neural Decision Forest (NDF) that incorporates denoising, allowing the final decision boundary to better separate true next-item intent from noise. The concatenated feature from h_u and h_s is first processed with James-Stein shrinkage to reduce variance from small sample sizes:

(23)

where z_ij is the j-th feature value, m is the batch size, and is the L2 norm of the j-th feature across the batch.

The adjusted vector z^(JS) is fed into the Neural Decision Tree (NDT) to compute the probability of the sample reaching each leaf node, which is then weighted by the corresponding leaf distribution to produce the final output:

(24)

Multiple NDTs are ensembled to form the NDF, and their outputs are averaged:

(25)

Where T is the number of trees, and is the output of the i-th tree.Finally, we fuse the softmax and NDF branches:

(26)

This hybrid design combines user preferences, item features, and high-capacity nonlinear modeling, improving performance and robustness in complex scenarios.

Model optimization

In this section, we present the optimization process of our model. Specifically, we define the learning objective as the cross-entropy loss function, which has been extensively used in recommendation systems:

(27)

Where y denotes the one-hot encoding vector of the ground truth item.

Multi-perspective comparison adversarial joint learning

We propose a joint optimization framework combining multi-view contrastive learning and adversarial training to enhance session representation learning. The model captures user behavior from two complementary perspectives: global session embedding h_s and user intent representation h_u, addressing data sparsity and behavioral diversity.

To improve consistency between these views, we introduce a contrastive learning task. Two positive sample views (s⁽¹⁾,v⁽¹⁾) and (s⁽²⁾,v⁽²⁾) are generated using augmentation strategies such as dropout, noise injection, and sequence shuffling. Normalized cosine similarity is used to measure alignment, and a dynamic temperature scaling mechanism is applied to stabilize gradients. For negative sampling, we employ hard negative mining by computing the cosine similarity between the anchor and all candidates in the batch, selecting the most similar ones as hard negatives to enhance the discriminative power of the contrastive loss.

Furthermore, to further improve representation discrimination, we introduce a Cross-view Shuffling strategy, which randomly shuffles the order of augmented views to create cross-sample negatives. This enhances sample diversity and reduces overfitting to specific patterns. We also retain Random Negative Sampling to ensure training stability. The final contrastive loss is defined as:

(28)

After contrastive learning, we introduce adversarial training to enhance model expressiveness and generalization. A GRU-based generator produces fake sequence embeddings from randomly initialized inputs, refined by a projection head to ensure semantic consistency. A GRU-based discriminator distinguishes between real embeddings h and generated embeddings . To improve training stability, we adopt Least Squares GAN (LSGAN) [50] as the loss function:

(29)

In this setup, the generator and discriminator form an adversarial game in the semantic space. Unlike traditional GANs, LSGAN uses a least squares loss to mitigate vanishing gradients and accelerate convergence. The generated embeddings also participate in contrastive learning to improve semantic alignment. The final objective jointly optimizes recommendation, contrastive learning, and adversarial training:

(30)

where L_r is the main recommendation loss, and μ, β control the task balance.

This adversarial setup, combined with multi-view contrastive learning, enhances the model’s discriminative power, generative capability, and generalization. The process of GCACL-Rec is detailed in Algorithm 1.

Algorithm 1. Training Process of GCACL-Rec

Datasets and preprocessing

To comprehensively evaluate the effectiveness of the proposed method, we conducted experiments on three real-world datasets: Diginetica, Tmall, and Retailrocket. Diginetica is from the CIKM Cup 2016 and contains five months of transaction logs from an e-commerce platform. Tmall is derived from the IJCAI-15 competition and consists of anonymized shopping logs. The RetailRocket dataset, released by an e-commerce company on Kaggle, includes six months of user browsing activities.

For data preprocessing, we follow a unified strategy used in prior work [15]. Sessions with only one item and items appearing fewer than five times are removed. For Tmall, sessions longer than 40 are also filtered out. Training samples are generated using sequence splitting: for a session , we construct subsequences like for both training and testing. Statistics of the preprocessed datasets are shown in Table 1.

Download:

• PPT
  PowerPoint slide
• PNG
  larger image
• TIFF
  original image

Table 1. Dataset statistics on Diginetica, Tmall, and RetailRocket.

https://doi.org/10.1371/journal.pone.0335176.t001

Evaluation indicators

Following the previous work [15,33], we use two relevance-based evaluation metrics: Precision@N (P@N) and Mean Reciprocal Rank@N (MRR@N) to assess model performance. P@N measures the proportion of correctly recommended items in the top-N list, while MRR@N calculates the average reciprocal rank of the correct item within the top-N positions. In this study, we set N = 10 and N = 20 for consistent evaluation across all compared methods.

Baseline models

To evaluate the model’s performance, we comprehensively evaluate the performance of GCACL-Rec with 14 baselines from 5 different types:

Parameter setup

To ensure a fair comparison, we adopt the following experimental settings: 10% of the training set is randomly selected as the validation set, and all models share the same hyperparameter configurations. Specifically, the latent vector dimension is set to d = 256, the batch size is 512, and cross-entropy is used as the loss function. The number of nodes in the neural decision forest is set to 128, and the depth of the tree is set to 4. All model parameters are initialized using a Gaussian distribution . The Adam optimizer [20] is applied with a learning rate of 0.0015, a decay rate of 0.5 every five epochs, and L2 regularization set to 10⁻⁶. Additionally, the maximum item occurrence count M is set to 300, the maximum session length N is 100, and the temperature parameter μ is 12.5. The number of hypernodes η is set to 4 and the contrastive learning weight is set to 0.1. All baseline methods are run using the best-performing settings reported in their original papers, and we report their best results.

RQ1-performance evaluation

As shown in Table 2, we compare the performance of GCACL-Rec with traditional methods across three widely used benchmark datasets(with the best results highlighted in bold). The results show that GCACL-Rec consistently outperforms all baselines on every dataset.

Download:

• PPT
  PowerPoint slide
• PNG
  larger image
• TIFF
  original image

Table 2. The performance of various models was compared using P@K and MMR@K metrics.

https://doi.org/10.1371/journal.pone.0335176.t002

We first compare two traditional recommendation methods: POP and FPMC. POP recommends the top-N most frequent items based on popularity and shows the weakest performance. FPMC combines first-order Markov chains with matrix factorization to utilize session context for recommendation. While it performs better than POP, it still fails to capture sequential patterns within sessions, leading to suboptimal results.

Compared with neural network-based session recommendation methods, traditional models show apparent limitations in modeling sequential dependencies. GRU4Rec was the first to apply gated recurrent units (GRU) to user behavior sequences, initiating the use of deep learning in session-based recommendation. Later methods, such as NARM and STAMP, introduced attention mechanisms to focus on key behaviors, significantly improving performance. However, they mainly capture explicit interactions while ignoring the implicit relationships between items. Subsequent Transformer-based approaches, such as SASRec and BERT4Rec, further advanced sequential modeling by leveraging self-attention to capture long-range dependencies. While SASRec employs an unidirectional encoder to predict the next item, BERT4Rec adopts bidirectional context through a masked prediction objective. However, both methods still face challenges in modeling higher-order item relations and session-level intent.

To overcome the limitations of traditional methods, recent research has shifted toward graph neural network (GNN) based modeling. SR-GNN employs gated graph neural networks to capture pairwise item transitions within sessions, but it often recommends semantically related yet incorrect items (e.g., predicting a charger instead of a phone case) due to the lack of higher-order dependency modeling. NISER normalizes item and session embeddings to reduce popularity bias, but under sparse sessions, it struggles to retain fine-grained sequential cues, leading to context-mismatched predictions. GCE-GNN extends graph modeling across sessions through session-level and global graphs, but it tends to overemphasize global co-occurrence while neglecting intra-session transitions. S²-DHCN leverages hypergraphs for high-order relations, yet without explicit transition direction, it fails to recover next-item flow, and under sparsity, high-order co-occurrence amplifies noise. COTREC enhances robustness with dual graph views and contrastive co-training, but struggles with nonlinear or complex user intents beyond its consistency objective. Int-GNN integrates item frequency and re-interaction intervals for intent inference, but becomes unstable in short or anonymous sessions where global statistics are insufficient.

Compared with the above baseline methods, the proposed GCACL-Rec demonstrates consistent advantages across all datasets and metrics. On average, GCACL-Rec outperforms the best baseline by 1.48% on Diginetica, 5.92% on Tmall, and 2.74% on RetailRocket. This gain mainly comes from two components: (i) a global, multi-scale graph with hypernodes that captures high-order item transitions within and across sessions, together with a relative multi-head attention mechanism that enhances cross-session propagation by modeling position-sensitive dependencies, thereby alleviating errors such as “associated but non-target” predictions; and (ii) multi-view adversarial contrastive learning coupled with a neural decision forest, which improves robustness under sparsity, mitigates popularity bias, and models nonlinear intent patterns more effectively. The performance differences across datasets can be attributed to their distinct characteristics (Table 1). Diginetica has shorter sessions, which reduces the benefit of high-order structural modeling, leading to relatively smaller improvements. By contrast, Tmall and RetailRocket are more sparse and contain larger item vocabularies, where the proposed global multi-scale graph and adversarial contrastive learning are more effective in alleviating sparsity and popularity bias, resulting in larger relative gains. Overall, GCACL-Rec addresses the key limitations observed in prior work—pairwise-only modeling, popularity bias under sparsity, missing transition direction, and instability in short or anonymous sessions—while achieving state-of-the-art results across benchmarks.

RQ2-Component ablation study

In this section, we analyze the contribution of each component in our model by developing four variant versions: w/o-MSGNN, w/o-RMA, w/o-MPACL, and w/o-NDF. We compare these variants with the original baselines and the full GCACL-Rec model on the Diginetica, Tmall, and RetailRocket datasets. Specifically, in w/o-MSGNN, we remove the multi-scale global graph and the multi-scale GNN module, using only the item view to model session data. In w/o-RMA, we replace the relative multi-head attention used in node-to-node propagation with standard attention. In w/o-MPACL, we remove the multi-view contrastive-adversarial joint learning module. In w/o-NDF, we remove the neural decision forest predictor and use a single softmax layer for computing the final score. The performance of GCACL-Rec and its four ablated variants is reported in Fig 2.

Download:

• PPT
  PowerPoint slide
• PNG
  larger image
• TIFF
  original image

Fig 2. Changes in GCACL-Rec model performance after ablation of individual components.

The left side of the figure displays the results of the baseline model, while the right side shows the results of our model. The four modules in the middle represent the results of ablating each component.

https://doi.org/10.1371/journal.pone.0335176.g002

As shown in Fig 2, GCACL-Rec consistently outperforms all four ablated variants and the original baseline across all three datasets, confirming the effectiveness of each component.

Among them, MSGNN is one of the core modules, enabling the propagation of cross-session information and the sharing of global context. Its removal leads to a noticeable drop in performance across all metrics, as it models hierarchical user behavior through multi-scale hypernodes (mean, max, and random sampling) and preserves complex item transition structures, enhancing representation quality. Similarly, replacing the relative multi-head attention (RMA) with standard attention results in performance degradation. RMA dynamically captures temporal dependencies between hypernodes via relative position encoding. Without it, the model struggles to distinguish between local and global dependencies, losing the ability to adaptively weight hypernode interactions. Removing the MPACL module also results in a noticeable decrease in performance. By combining multi-view contrastive learning and adversarial perturbation, MPACL helps capture diverse user interests and improves robustness against complex data distributions. Excluding the NDF module weakens the model’s ability to handle nonlinear patterns. NDF enhances high-order behavior modeling through an ensemble of neural decision trees, supported by James-Stein smoothing and dynamic pruning, which together balance expressiveness and generalization.

In summary, GCACL-Rec integrates hierarchical temporal modeling (MSGNN-RMA), multi-view enhancement (MPACL), and decision optimization (NDF) into a unified “representation–fusion–decision” framework. These components complement each other and work jointly during training, leading to significant improvements in session-based recommendation performance.

RQ3-Effectiveness study of MSGNN

In this section, we validate the overall effectiveness of our proposed global graph structure and multi-scale graph neural network (MSGNN) by constructing three structural variants: w/o-GCN, w/o-GAT, and w/o-GGNN. Specifically, in these variants, we modify the global graph computation method by replacing our original MSGNN module with classical GNN architectures—namely graph convolutional networks (GCN), graph attention networks (GAT), and gated graph neural networks (GGNN)—to encode the item graph and perform information propagation. All other components of the model remain unchanged. This allows us to evaluate the adaptability and performance differences of various GNNs in the context of graph modeling.

As shown in Fig 3, the GCN, GAT, and GGNN variants can capture some cross-session structural information and demonstrate a certain level of effectiveness. However, compared to our proposed global module, a performance gap remains across key metrics on all three datasets. For example, on the Tmall dataset, MSGNN outperforms GAT and GGNN by approximately 0.6% and 0.9% on P@20, respectively, and achieves improvements of 0.8%–1.1% on MMR@20. Similar trends are observed on the RetailRocket and Diginetica datasets, with especially notable gains in MMR. The key reason for this performance difference lies in the design of our global graph, which not only captures standard item transition structures but also introduces hypernodes and multi-scale aggregation to model higher-order, hierarchical relationships across sessions. Moreover, MSGNN enables multi-round bidirectional message passing between nodes, hypernodes, and among hypernodes themselves, significantly enhancing the expressive power of the global graph. In contrast, the alternative models lack this structural support; their message propagation is limited to shallow or static neighborhood connections, making it difficult to capture complex behavioral paths and latent semantic associations effectively.

Download:

• PPT
  PowerPoint slide
• PNG
  larger image
• TIFF
  original image

Fig 3. Performance of different GNN variants.

The figure illustrates the effectiveness of our multi-scale global graph design by comparing it with classical graph neural network (GNN) backbones.

https://doi.org/10.1371/journal.pone.0335176.g003

In summary, while traditional GNNs such as GCN, GAT, and GGNN demonstrate some modeling capacity in our cross-session global information modeling task, MSGNN—designed specifically for the proposed global graph structure—offers a better fit for multi-scale representation and consistently delivers more stable and superior recommendation performance.

RQ4-Effect of the number of super points

To investigate the impact of the number of hypernodes on the performance of the MSGNN model in the session-based recommendation, we conducted experiments on the Diginetica, RetailRocket, and Tmall datasets, varying the number of hypernodes in the set 2, 4, 6, 8, 10, 12. Fig 4 presents the results, with the left side showing changes in P@20 and P@10 and the right side showing trends in MMR@20 and MMR@10.

Download:

• PPT
  PowerPoint slide
• PNG
  larger image
• TIFF
  original image

Fig 4. Impact of the number of hypernodes on model performance on three datasets.

The figure shows how varying the number of hypernodes impacts accuracy (P@20/P@10) and diversity (MMR@20/MMR@10), demonstrating that using four hypernodes yields the best overall performance.

https://doi.org/10.1371/journal.pone.0335176.g004

When the number of hypernodes is set to 2, the model captures only coarse-grained semantics, such as global averages and local peaks. This limits its ability to aggregate useful information, resulting in lower performance across all metrics. With four hypernodes, the model achieves the best results on all datasets in both P@K and MMR@K, suggesting an effective balance between generalization and recommendation quality. This setting enhances information propagation without causing excessive aggregation. However, increasing the number of hypernodes beyond 4 (from 6 to 12) leads to performance degradation or instability. This may be due to overlapping semantics among hypernodes after multiple rounds of message passing, which introduces interference and reduces model expressiveness.

In conclusion, the number of hypernodes has a significant impact on the performance of MSGNN. Too few may lead to the under-representation of structural information, while too many can cause redundancy and noise. Setting the number of hypernodes to 4 offers the best trade-off for the effective session-based recommendation.

RQ5-Impact of model depth

To systematically evaluate the representational capacity of the model under different propagation depths, we conducted a series of joint ablation experiments by configuring both the local graph network (P-GNN) and the global graph network (Global-GNN) with 1 to 5 layers. These experiments were performed on the Diginetica, Tmall, and RetailRocket datasets, and the results are illustrated in Fig 5. In each experiment group, the local and global networks were kept at the same depth to ensure comparability.

Download:

• PPT
  PowerPoint slide
• PNG
  larger image
• TIFF
  original image

Fig 5. Impact of varying propagation depth on model performance.

The figure compares the performance of GCACL-Rec with different numbers of layers in both local and global GNNs, showing that a three-layer setting yields the best accuracy.

https://doi.org/10.1371/journal.pone.0335176.g005

Overall, the model exhibits relatively weak performance at shallow depths (e.g., one layer). As the number of layers increases, both recommendation accuracy (P@20, P@10) and mean reciprocal rank (MMR@20, MMR@10) improve steadily, reaching their peak at three layers. Specifically, on the Diginetica dataset, the three-layer model achieves the best results, with P@20 reaching 55.48 and MMR@20 reaching 19.81. Similarly, the three-layer configuration yields optimal results across the main metrics on both Tmall and RetailRocket datasets. Notably, when the model depth exceeds three layers, we observe slight fluctuations or even minor performance drops. This degradation can be attributed to the over-smoothing effect or noise accumulation introduced by excessively deep networks, which leads to homogenized node representations and diminished structural discriminability. Furthermore, deeper propagation may introduce redundant dependencies or cause gradient vanishing, thereby weakening the model’s ability to capture both local and global semantics effectively.

In summary, a three-layer propagation structure strikes a favorable balance between accuracy and diversity. It is sufficient to capture higher-order structural information while effectively preventing overfitting and representational degradation, thus delivering the best overall performance. Therefore, we adopt a three-layer architecture as the default setting in the final model to strike a balance between expressive power and computational efficiency.

RQ6-Sensitivity analysis

To validate the rationality of our chosen hyperparameters, we first conducted a sensitivity experiment on the learning rate. On the RetailRocket dataset, we tested four values of learning rate (lr) at 0.001, 0.0015, 0.002, and 0.025, and plotted the curves of Recall@20 and MRR@20 over epochs (in Fig 6). The results show that a smaller learning rate (0.001) ensures stable convergence but converges more slowly overall; moderate learning rates (0.0015 and 0.002) lead to rapid performance gains in the early epochs and eventually achieve higher Recall and MRR, with lr = 0.0015 performing best, reaching about 58.98 in Recall@20 and 32.52 in MRR@20. In contrast, a substantial learning rate (0.025) improves quickly in the early stage but exhibits significant fluctuations later, indicating instability in training. Thus, lr = 0.0015 strikes a good balance among convergence speed, final performance, and stability, making it the preferable choice.

Download:

• PPT
  PowerPoint slide
• PNG
  larger image
• TIFF
  original image

Fig 6. Impact of learning rate on model performance.

The figure shows the results on RetailRocket with different learning rates, where lr = 0.0015 yields the best accuracy.

https://doi.org/10.1371/journal.pone.0335176.g006

We further performed sensitivity analysis on the contrastive loss parameter μ, with results shown in Table 3. When μ = 0.10 and μ = 0.15, the model achieved superior and stable performance, with μ = 0.10 performing best (Recall@20 = 55.48, MRR@20 = 19.81). In contrast, when μ = 0.20 and μ = 0.25, performance dropped noticeably, with Recall@20 falling to around 53.74. This suggests that an overly large μ assigns excessive weight to the contrastive loss, thereby weakening the optimization of the primary recommendation task. Considering both performance and stability, μ = 0.10 is the optimal setting. Overall, the final parameter configuration (lr = 0.0015, μ = 0.10) was determined through extensive empirical validation and ensures consistent and strong performance on both Recall and MRR, thus supporting the soundness of our parameter choices.

Download:

• PPT
  PowerPoint slide
• PNG
  larger image
• TIFF
  original image

Table 3. Performance comparison under different μ values on Diginetica.

https://doi.org/10.1371/journal.pone.0335176.t003