Corruption-Aware Multi-View Metric Learning for Unseen-User Session Retrieval

1. Introduction

Clickstream records combine the order of user interactions with recurring navigation transitions. Their representations can support next-item recommendation, session classification and comparisons between complete visits, but these tasks need not reward the same information. A model that predicts the next event accurately may capture local regularities without preserving behavior shared across a user’s separate visits. Session-based recommendation (SBR) primarily ranks a user’s next item [1]; retrieving another related visit calls for an objective and evaluation centered on sessions themselves.

Sequential, attention-based and graph encoders provide complementary technical foundations. Gated recurrent units (GRUs) regulate the retention of ordered context [2], while the Transformer uses attention to combine information across positions [3]. NARM combines recurrent modeling with attention to session intent [4]. Graph neural networks (GNNs) instead propagate information through relationships between nodes [5], and gated graph networks incorporate recurrent updates into this propagation [6]. For clickstreams, a transition graph aggregates repeated navigation links, whereas a sequential encoder preserves event order.

A retrieval model also needs a learning relation that determines which representations should be close. SimCLR learns from augmented views of an instance [7], supervised contrastive learning defines positives through labels [8], and GraphCL applies augmentation-based learning to graphs [9]. Our setting uses independently recorded visits of the same training user as positives. This trains similarity around recurring cross-session behavior rather than an immediate next-item label.

Recurrent, attention-based and graph recommendation methods have advanced item ranking [10,11,12], including the use of cross-session context and similar-session retrieval [13,14]. Our earlier work examined graph embeddings for browsing-behavior clustering [15], event frequency–inverse session frequency weighting [16], and aging-based weighting for session classification [17]. The present study shifts the endpoint to a direct question: can the representation of one complete session retrieve another session of the same user when that user was excluded from model fitting? User identifiers define partitions and positive pairs but never enter the encoder.

We propose a corruption-aware multi-view metric-learning framework combining a GRU with a weighted directed session graph. Parallel branches project their outputs into a common normalized space, and normalized-average fusion yields a candidate-independent session vector. Cross-session contrastive training uses both intact and perturbed inputs. Sequence truncation and edge deletion separately control the information available to each branch; combined damage tests whether learning the views jointly helps when neither is intact. A raw-event deletion control additionally rebuilds all representations after missing observations.

Behavioral matching and identity-supervised embeddings are established foundations [18,19,20]. Our methodological contribution integrates cross-session positives, ordered and directed-transition views, and corruption-aware training in one retrieval-oriented design. An original aggregation graph and a later gated-graph extension instantiate this framework. Independent encoders, fixed-score late fusion, matched supervision and training-regime controls distinguish the effects of the learning relation and joint representation from the effects of individual components.

The original research questions concern clean retrieval relative to count-based similarity, complementarity within the jointly trained model, cross-session versus same-session supervision, performance under view damage, and cross-origin temporal segmentation. Additional controls examine independently trained alternatives and the stability of the gated extension on frozen new partitions. The study uses a common Coffee Shop application setting to vary these factors without changing page semantics or the source application.

Mean reciprocal rank (MRR) measures how early the designated positive appears [21], while Recall@K measures whether it falls within the first K candidates. Candidate-pool size is part of the retrieval task: sampled metrics need not preserve full-collection method rankings [22]. We therefore use matched lists at multiple scales, repeated user-disjoint fits and paired user-level intervals. The resulting evidence identifies combined view corruption as a setting in which joint learning helps relative to independent late fusion, while retaining the clean-retrieval trade-off.

The following sections review related work, specify the methodology and data protocol, report the experiments, discuss their implications, and conclude with practical uses and future research.

2. Related Works

Session-based recommendation (SBR) conventionally infers the next item from the interactions observed in the current session, often without a persistent user profile [1]. A recent survey further distinguishes anonymous, personalized, and social session recommendation and organizes modern methods around sequential and graph encoders [23]. GRU4Rec established recurrent neural networks as a strong neural formulation of this task [10], while SASRec and BERT4Rec transferred self-attention and bidirectional masked-item training to sequential recommendation [11,24]. These methods learn useful sequence representations, but their principal evaluation target is item ranking. Our target is instead representation retrieval across complete sessions: both the query and the relevant object are sessions, and the test users are absent from training.

Personalized SBR explicitly carries information across a known user’s sessions. HGRU4Rec uses a hierarchical recurrent state to transfer cross-session user context and predicts the next item [13]. More recent personalized graph models likewise combine a current session with historical sessions for next-item recommendation. This setting is an important neighbor of ours, but not an interchangeable baseline: it assumes historical context for the same test user as model input and optimizes item prediction, whereas our encoder receives one session, consumes no user identifier, and is evaluated by retrieving another session for an unseen user.

Beyond sequential encoders, SR-GNN represents each session as a directed graph of item transitions and uses gated graph propagation for next-item prediction [12]. Subsequent work has introduced global item-transition context and higher-order hypergraph relations [25,26]. MCV-SBR is especially relevant: it formalizes multiple within-session connectivity views and searches their combinations for anonymous next-item recommendation [27]. We also retain more than one structural view, but use a directed weighted graph alongside the original ordered sequence rather than treating graph construction as a replacement for order. More importantly, our optimization and evaluation units are cross-session pairs, not a session prefix and its next item.

Recent graph-based SBR has increased both temporal and structural granularity. LS-TGNN separates long- and short-term temporal graph signals [28], whereas GraphFine combines position-aware graphs, segmented co-occurrence hypergraphs, and multi-view intent readout [29]. These models reinforce the value of complementary structural views, but still optimize anonymous next-item recommendation. Our endpoint is complete-session retrieval for users excluded from model fitting.

Contrastive sequential recommenders differ in both augmentation and positive-pair construction. CL4SRec augments interaction sequences to provide an auxiliary contrastive signal for next-item prediction [30]. DuoRec uses dropout-based model augmentation and additionally selects sequences sharing a target item as positive examples [31]; it is therefore not limited to two augmented copies of one session. DHCN maximizes mutual information between two hypergraph-derived channels as an auxiliary objective for SBR [26]. These approaches motivate examining the learning signal explicitly. Our label-free control pairs augmentations of one session, whereas cross-session supervision pairs independently recorded sessions from the same training user. The latter is weakly supervised metric learning, not self-supervised learning. The historical comparison also changes loss weighting and batch construction and therefore compares training packages. The matched control in Table 7 separately evaluates positive-pair identity under a common objective and input schedule; its same-session arm retains user-grouped sampling.

Recent work has also diversified contrastive augmentation. SR-MACL constructs multi-layer aggregation augmentations for SBR [32], while high-order graph approaches commonly retain next-item prediction and add a self-supervised structural objective. This makes the matched same-session augmentation control essential: without it, gains from same-user, different-session positives could be misattributed to generic contrastive regularization.

Complementary representations and noise handling have also been developed together for recommendation. CGSNet couples graph-based and self-attention representations through a contrastive objective [33]. GraphFusionSBR combines knowledge-graph, hypergraph and line-graph channels with denoising and cross-channel self-supervision for next-item prediction [34]. These approaches establish that multi-view learning and noise-aware graph modeling are useful design principles. We apply them to a different learning relation: independently recorded visits from the same training user define similarity, and the output ranks candidate sessions rather than items. Controlled sequence, edge and raw-event interventions then distinguish the value of complementary information from sensitivity to the way that information is lost.

A related line of work addresses incomplete inputs. Modality dropout exposes a multimodal model to missing inputs during training [35], and later work has studied fusion architectures and the train–test modality mismatch directly [36,37]. A sequence and its graph are derived from the same clickstream, rather than from independent sensors. We adapt incomplete-view training to controlled sequence and transition perturbations in session retrieval. We evaluate clean and corrupted performance against clean training, distinguishing the historical regime-specific checkpoint selection from the common-validation and forward-budget controls in Table 8. Building on these principles, our framework integrates cross-session weak supervision, ordered and directed-graph clickstream views, and corruption-aware optimization for user-disjoint session retrieval. The temporal protocol additionally enforces cross-origin positive pairs.

Within clickstream behavior analysis, our earlier systematic mapping study organized web-user behavior mining around clickstream preprocessing, representation, clustering, classification, and application objectives [38]. Subsequent studies examined graph embeddings for clustering browsing behavior [15], frequency- and uniqueness-based representations with predictive deep learning [39], EF–ISF weighting across embedding methodologies [16], and aging-based weighting for session classification [17]. Those studies motivate the present focus on persistent behavior but differ in method and endpoint. Building on these representation studies, the present work learns a corruption-aware sequence/graph metric space for retrieving sessions of users unseen during training, extending the focus from weighting, clustering and closed-label classification to cross-session similarity.

Session matching also contributes to recommendation. INSERT retrieves similar historical sessions from the current and other users to improve next-item recommendations in short sessions [14]. This distinction matters: using retrieved sessions as model context and evaluating whether a complete session retrieves a designated session of an unseen user answer different questions. Likewise, MCV-SBR studies combinations of connectivity views for next-item recommendation [27]. These established principles motivate the retrieval-oriented integration evaluated here.

The wider graph-learning literature clarifies the architectural choices in session encoders. GraphSAGE learns representations through feature aggregation [40], whereas graph attention networks learn attention weights over neighborhoods [41]. Analysis of GNN expressive power further shows that the aggregation rule affects which graph structures can be distinguished [42]. These architectural foundations motivate the aggregation choices; the implemented retrieval comparators are specified in the baseline protocol. Within SBR, TAGNN conditions attention on the candidate target item [43]; our encoder instead produces a fixed session vector before candidate-session scoring.

Recent work extends the sources of information available to session models. MGCOT combines the current session graph, similar-session graphs, and global item relationships through multi-graph co-training [44]. GCNext incorporates item features into an unsupervised graph-embedding extension [45]. A data-centric survey organizes how side information is encoded and injected into SBR models [46]. These approaches enrich next-item modeling with information beyond an isolated event sequence. Our study focuses instead on two views derived from the same clickstream and evaluates transfer through held-out-user session matching.

Contrastive objectives also differ in the signal they preserve. Self Contrastive Learning directly promotes uniformity among item representations without requiring positive/negative constructions or augmentations [47]. In music recommendation, negative-feedback-informed contrastive learning uses skipped tracks to shape item rankings [48]. Our positive relation is cross-session user membership, and our perturbations target input views rather than explicit preference feedback. These distinctions make the supervision source and endpoint central to comparing contrastive methods.

Another emerging direction augments graph or session models with language-model semantics. LLM-DMsRec aligns inferred semantic intent with graph-based structural intent [49], while SPRINT selectively invokes a language model during training and uses a lightweight intent predictor at inference [50]. These works illustrate a separate route to richer session context; the present model uses neither textual intent profiles nor language-model features. Finally, empirical comparisons of SBR algorithms have found that nearest-neighbor heuristics can remain competitive with neural approaches [51]. This motivates retaining inexpensive comparison methods alongside architecture-focused neural experiments.

Behavioral re-identification provides a direct foundation for the present task. De Smedt et al. derive sequence fingerprints from page visits for session stitching [19], while SCEmNet learns supervised cookie similarity from multiple URL-sequence representations through Siamese convolutional networks and pairwise fusion [20]. Vamosi, Reutterer, and Platzer learn recurrent sequence embeddings with triplet loss and evaluate user re-identification with disjoint training and test users [18]. These studies establish both behavioral matching and identity-supervised sequence similarity. Our work extends this line through parallel sequence and directed-graph representations trained together under view perturbations, focusing on how the source of supervision and the availability of each view affect session retrieval. Recent evidence on browsing fingerprints also motivates retaining frequency-based comparators and considering linkage privacy [52].

Graph-based identity matching offers a further architectural connection. HGNN+Cross-Att represents device logs as hierarchical graphs, uses GRU-based neighborhood aggregation, and compares the resulting node representations through cross-attention for pairwise classification [53]. Our sequence branch instead encodes the ordered session alongside a separate directed-transition graph branch. Their normalized fusion produces a session vector before any candidate is considered, enabling a common cosine-scoring rule across candidate pools. The architectural distinction is candidate-independent encoding: one session representation can be reused across the candidate pool. This comparison concerns representation and matching design; empirical comparisons in this study use the retrieval baselines specified in Methodology, not complete implementations of the reviewed cross-device matching systems.

Taken together, this literature motivates studying identity-supervised session retrieval and view-dependent robustness within a single learning design. Our contribution couples cross-session positives, parallel sequence and directed-graph encoders, and corruption-aware training in a candidate-independent metric representation. The accompanying controls examine whether the useful retrieval signal comes from cross-session supervision, a dominant individual view, or joint learning beyond independent encoders and late-score fusion. This connects the proposed design to an explicit empirical question: under which input conditions does learning the two views together add value? The Coffee Shop study answers this question through matched supervision, independent-encoder and training-regime controls, linking the integrated design to identifiable sources of retrieval improvement.

3. Methodology

The pipeline separates data preparation, representation learning and held-out retrieval. Figure 1 shows parallel sequence and graph branches, rather than successive graph-building stages. User identifiers define partitions and training positives but never enter the encoders. The original aggregation graph and the later gated graph are alternative branches. Validation determines checkpoint selection under the stated policy; test ranking uses frozen weights. The diagram’s preprocessing stage denotes deterministic parsing; vocabulary fitting follows the user split and uses training users only. Its dashed held-out path denotes reuse of the same encoder, not a bypass of representation learning.

3.1. Problem Definition and Retrieval Task

Let the dataset consist of user-session pairs, as defined in (1):

$$\mathcal{D}={\left\{(u_i,s_i)\right\}}_{i=1}^N,s_i=(x_{i,1},\dots ,x_{i,T_i}),$$

(1)

where N is the number of sessions, $u_i$ is the user associated with session $s_i$, and $x_{i,t}$ denotes the event at position t in a session of length $T_i$. User identifiers define data partitions, training pairs, retrieval relevance, candidate exclusions and user-level statistical clusters; they are not provided as encoder inputs. Users are partitioned into mutually disjoint training, validation, and test sets, denoted by ${\mathcal{U}}_{tr}$, ${\mathcal{U}}_{va}$, and ${\mathcal{U}}_{te}$, respectively.

For a test query session q from an unseen user $u_q$, the candidate set contains one designated positive session p, where $u_p=u_q$ and $p\ne q$, together with $M-1$ sessions from other users. Relevance is therefore operationalized as shared recorded user membership, rather than an independently annotated similarity of navigation goals. A different-user session is treated as a negative even if its navigation resembles the query. The resulting scores measure cross-session user linkage under this relevance definition, not general semantic similarity between browsing sessions. Candidates are ranked in descending order of the cosine similarity defined in (2):

$$sim(q,c)={\displaystyle \frac{z_q^{\top }{z}_c}{{\parallel z_q\parallel }_2{\parallel z_c\parallel }_2}},$$

(2)

where $z_q$ and $z_c$ are the learned embeddings of the query and candidate sessions, respectively.

For temporal pseudo-sessions, we additionally require $origin\left(q\right)\ne origin\left(p\right)$, where $origin(·)$ identifies the published sequence from which a pseudo-session was derived. This constraint prevents fragments of the same published sequence from forming a positive pair.

3.2. Representation Models

The model family separates event order from aggregated transition structure. The following subsections describe the original sequence and graph views, their fusion, and the later gated-graph extension used in stronger comparisons.

3.2.1. Sequential Encoder

Each event is mapped through a train-only vocabulary and embedding table. A GRU encodes at most the last $L=128$ events. In (3), $h_{i,T_i}$ denotes the final valid hidden state after encoding the retained suffix, not a state computed from the discarded prefix; $T_i$ remains the original session length defined in (1). The final valid hidden state is projected and normalized, as defined in (3):

$$z_i^{\left(s\right)}=norm(W_s{h}_{i,T_i}+b_s).$$

(3)

3.2.2. Directed Session-Graph Encoder

For session $s_i$, nodes are event/page identifiers. A directed edge $(a,b)$ is weighted by the number of observed consecutive transitions. The adjacency matrix is row-normalized. Initial learned node embeddings are updated using inbound and outbound aggregation, as defined in (4):

$$h_v^{(\ell +1)}={\varphi }_{\ell }\left([h_v^{(\ell )}\parallel \sum _u{A}_{uv}{h}_u^{(\ell )}\parallel \sum _w{A}_{vw}{h}_w^{(\ell )}]\right).$$

(4)

In the original implementation, each update applies a linear transformation, Gaussian error linear unit (GELU) [54], and layer normalization [55] to the concatenated states and messages. In (4), ${\varphi }_{\ell }$ denotes this transformation at layer ℓ, ∥ denotes concatenation, A is the row-normalized transition matrix defined above, and K is the number of propagation layers, set to two in the reported configuration (Section Training and implementation strategy). In (5), $h_v^{\left(K\right)}$ is the state of node v after the final propagation layer and ${\pi }_{i,v}$ is the visit-frequency weight assigned to node v in session $s_i$; nodes that are not visited in the session receive no readout weight. The operator $norm(·)$ denotes the same output normalization applied to the branch outputs in (3) and (5) and to the fused representation in (6). The graph representation is visit-frequency weighted, projected, and normalized, as defined in (5):

$$z_i^{\left(g\right)}=norm\left(W_g\sum _v{\pi }_{i,v}{h}_v^{\left(K\right)}+b_g\right).$$

(5)

3.2.3. Normalized Multi-VIEW fusion

The primary representation uses a normalized average. Later fusion and alignment controls characterize alternatives without selecting a replacement from test scores, as defined in (6):

$$z_i=norm\left({\displaystyle \frac{z_i^{\left(s\right)}+z_i^{\left(g\right)}}{2}}\right).$$

(6)

Co-trained sequence and graph readouts are reported to expose negative transfer. Extracting a branch from a jointly trained model is distinct from training an independent single-view model.

3.2.4. Gated-Graph Extension and Adapted Neural Encoders

The preceding subsections describe the original architecture. The later extension retains the GRU and normalized-average fusion but replaces the graph branch with two gated propagation steps. Node embeddings have 64 dimensions; transformed inbound and outbound messages are concatenated and passed to a GRUCell. Readout concatenates a visit-frequency-weighted global state with an attention-weighted state over visited nodes, then projects to 32 normalized dimensions. It is an SR-GNN-style adaptation, not a reproduction of the original next-item model.

The separate SR-GNN-style and SASRec-style encoders are likewise adapted to the same cross-session metric task. Their retrieval results should not be interpreted as reproductions of published recommendation benchmarks. Table 1 specifies the implemented adaptations of the source architectures [11,12]. SASRec-style encoders add learned positional embeddings to page embeddings and use pre-normalized, causal Transformer layers with padding masks and GELU feed-forward networks. Last-valid-state or non-padding mean pooling is followed by layer normalization, a linear projection, and L2 normalization. The standalone SR-GNN-style encoder uses the gated graph readout described above; its attention is conditioned on the frequency-weighted global state rather than a last-item target, and unvisited nodes are masked before softmax. The gated multi-view extension was developed after earlier test comparisons were inspected. Here, “gated” refers to GRUCell graph propagation, not to a learned gate between the two views.

3.3. Dataset and Preprocessing

The Coffee Shop dataset [56] provides an in-depth, single-application setting with recurring users and navigation sequences. Published sequences average approximately 146.5 events; these published boundaries are not verified activity sessions. Item codes contain user, page, day code and hour, but no event-level dwell time or verified binary target. The models use page order and transitions, not a duration encoder.

The parsed source contains 296,100 published sequences, 43,390,766 events, 96,618 observed users and 46 page identifiers. Users are partitioned 80%/10%/10% for training/validation/test. Main runs use up to 4,000 training and 800 validation users, five partitions and three initializations. Candidate pools contain 100 or 1,000 sessions with one designated positive. The pooled main evaluation contains 22,741 raw users and 27,582 split-user units.

Only users with at least two eligible sessions can supply a query and a different positive. Splits hash the UTF-8 string seed + "\0" + user_id using eight-byte BLAKE2b, interpret the digest as an unsigned big-endian integer, and divide by $2^{64}$. Thresholds 0.8 and 0.8 + 0.1 determine training and validation; the remainder is test. Vocabulary fitting uses training data only. Training and validation pairs follow source order up to their budgets. Main partition seeds are clickstream-final-split-1 through clickstream-final-split-5, initialization seeds are 41–43, and candidate-list seeds are 41–45. A user’s partition can change across split seeds, so repeated users are kept together in the relevant statistical analyses.

Temporal pseudo-sessions never cross a published boundary. A day-code change, same-day hour regression, or inactivity gap of at least three hours starts a new segment; segments with fewer than two events are removed. A two-hour policy tests sensitivity using the same rule otherwise. Training, validation and test positive pairs must come from different published origins. The two-hour policy retains 945,537 of 966,183 segments after excluding 20,646 singletons; the three-hour policy retains 884,805 of 902,813 after excluding 18,008. Changing the threshold can change eligible users and candidates, so policy comparisons represent end-to-end sessionization sensitivity.

3.4. Training and Implementation Strategy

Table 1 distinguishes the encoder implementations. All outputs are 32-dimensional and L2-normalized. Sequence inputs retain at most the last 128 events; graph inputs use the full eligible session unless the equal-history control is specified. Models use eight epochs, AdamW [57], learning rate ${10}^{-3}$, weight decay ${10}^{-4}$, gradient-norm clipping at 5 and contrastive temperature 0.15. Main batches contain up to 64 users and two sessions per user. The earliest epoch attaining minimum validation loss is retained unless a fixed-epoch protocol is explicitly specified.

For reproducible input schedules, source sessions are shuffled with random.Random(100 + epoch). Training condition selection uses random.Random(epoch * 10000 + batchindex) and validation uses random.Random(900000 + batchindex). Candidate seeds construct evaluation tasks rather than additional trained models.

The tuned SASRec search evaluates layers {1, 2}, heads {1, 2, 4}, widths {32, 64}, dropout {0, 0.1, 0.2} and last-state/mean pooling: 72 configurations plus the historical reference. Feed-forward width is twice the embedding width within the grid. Split 1, initialization 41, 4,000 training users and 800 validation users are used; each validation user has 1,000 candidates with seed 314159. Maximum clean validation user-macro MRR over epochs 1–8 selects the configuration, breaking ties by earlier epoch and then configuration ID. The selected two-layer, one-head, width-64 mean-pooling model attains validation MRR 0.6330 at epoch 8. Architecture and epoch are frozen for the five-split test matrix. The historical reference uses width 32 and feed-forward width 128. Test scores do not select the tuned configuration.

3.5. Cross-session supervision and matched control

A mini-batch samples B training users and two different sessions per user. For normalized representations $z_i$, we use a supervised contrastive objective [8], with user membership defining positives, as defined in (7):

$${\mathcal{L}}_{sup}=-{\displaystyle \frac{1}{2B}}\sum _i{\displaystyle \frac{1}{\left|P\right(i\left)\right|}}\sum _{p\in P\left(i\right)}\log {\displaystyle \frac{\exp (z_i^{\top }{z}_p/\tau )}{{\sum }_{a\ne i}\exp (z_i^{\top }{z}_a/\tau )}},$$

(7)

where $P\left(i\right)$ contains the other session of the same batch user. The objective is applied to sequence, graph, and fused representations. This is weakly supervised metric learning, not self-supervised learning.

The historical label-free package pairs two augmented copies of one session, with other source sessions treated as distinct instances. It averages the sequence, graph and fusion contrastive losses equally. Batches contain 64 source sessions and 128 augmented inputs; independent draws select among the six non-clean sequence, edge and combined conditions at 25% or 50%. The 8,000 training and 1,600 validation sessions come from the same user-pair pools as weak training. User IDs affect selection and partitions, but not instance-positive labels. Validation minimizes the same SSL objective. Because weighting and batch construction also differ, this comparison concerns training packages.

A separate matched control uses the original architecture and a symmetric cross-bank objective. Each batch contains 64 users with two distinct sessions, forming 128 clean and 128 corrupted inputs. Same-session positives select the anchor’s own counterpart; cross-session positives select the counterpart of that user’s other session. Both directions use the same 128-entry denominator and are averaged. The fused loss has weight 1 and each branch loss 0.125. Inputs, initial weights, corruption schedules, optimizer updates and forward counts are matched; final epoch 8 is evaluated without checkpoint selection. The positive permutation is the intended treatment difference, also changing which bank entry is negative. Same-session sampling remains user-grouped. This five-split, three-initialization control is distinct from the historical SSL package and has not been repeated for the gated architecture.

3.6. Corruption-Aware Training and Evaluation

Each session’s corrupted copy receives one of seven uniformly sampled conditions: clean, sequence truncation at 25% or 50%, directed-edge deletion at 25% or 50%, or combined damage at a matched rate. These are adaptations of established cropping and edge perturbations [9,30]. Their role here is to train and evaluate sensitivity to the availability of each clickstream view. Equation (8) combines clean and corrupted fusion losses with clean-branch supervision.

$$\mathcal{L}=\frac{1}{2}({\mathcal{L}}_{f,clean}+{\mathcal{L}}_{f,corr})+\frac{1}{4}\frac{{\mathcal{L}}_{s,clean}+{\mathcal{L}}_{g,clean}}{2}.$$

(8)

Clean-only training uses $L_{f,c}+0.25(L_{s,c}+L_{g,c})/2$. Independently trained branches use $0.75L_c+0.5L_r$; standalone neural baselines use $(L_c+L_r)/2$. Historical clean/corrupted regimes use their own validation corruption settings. The common-validation control selects both regimes by the clean-plus-corrupted fusion objective, and a further control averages two clean forward losses before one update to match the corruption regime’s 126 training forwards and 63 updates per epoch. Matching forwards does not equate FLOPs. Alternative fusion heads and the alignment control use the common selector; the alignment term is excluded from checkpoint selection in both arms.

Sequence damage keeps the newest max(1, round(L * (1 - rate))) tokens after the last-128 restriction, using Python’s ties-to-even rounding. The graph and page counts are unchanged. Edge deletion hashes str(session_id) + "\0" + str(a) + "\0" + str(b) + "\0" + str(rate) with eight-byte BLAKE2b. A directed edge type and its full count survive if the unsigned digest divided by $2^{64}$ is at least the rate. Masks are deterministic per session/rate, unweighted by edge frequency, and need not be nested across rates. Surviving counts are row-normalized; the transposed matrix supplies inbound messages, not separately normalized inbound probabilities. Unknown page contributions accumulate at the shared unknown index. With no surviving edges, messages are zero but self-state transformations and page-frequency pooling remain. Queries and candidates share the condition, not identical masks. Thus page counts are invariant to these interventions, transition/graph-only methods to sequence-only damage, and sequence-only methods to edge damage.

The raw-event control instead deletes min(N-1, floor(r*N)) events before feature extraction at rates 0.25 and 0.50. BLAKE2b ranking of source-sequence IDs and event positions, with seed b6-event-drop-v1, defines nested masks. All views are rebuilt from the ordered survivors; newly adjacent survivors form transitions. Frozen models use the historical candidate lists. Legacy encoders use six CPU threads and tuned SASRec four to match replay settings. This synthetic mechanism changes page counts as well as sequence and graph inputs. A separate history control retrains the original model with every view limited to the same last 128 events; its reference is the common-validation full-history model, not historical main checkpoints.

3.7. Baselines and Ablation Rationale

Random ranking establishes chance performance: with one positive among M candidates, expected MRR is $H_M/M$ and expected Recall@K is $\min (K,M)/M$. The empirical control permutes retained lists using NumPy PCG64 with master seed 4203 and a deterministic SHA-256-derived stream for each split, candidate size and candidate seed. It has no model initialization. Page-frequency and directed-transition cosine test direct navigation summaries. SASRec-style and SR-GNN-style metric encoders test attention and graph mechanisms under the same retrieval endpoint, not their original recommendation tasks [11,12]. HGRU4Rec and MCV-SBR remain task-neighbor literature rather than implemented numerical baselines [13,27].

Independent sequence and graph models remove the unused branch and retain the original encoder configuration. Late fusion averages their cosine scores with fixed weights 0.5/0.5, avoiding coordinate averaging across independently learned spaces. Ordered candidate lists match the joint model. Per-branch schedules match, but the two independently trained models do not have the same total optimization budget as one jointly trained model. Co-trained readouts instead hold the checkpoint fixed. Together, these controls distinguish within-model complementarity from comparisons against independently optimized alternatives.

A training-anchor neighborhood comparator maps each session to similarities with 8,000 training sessions, keeps its k largest similarities, normalizes the profile and uses profile cosine for retrieval. A validation search over page/transition counts and k in {50, 100, 500} selects transition counts with k=100. Source-order ties are deterministic and zero profiles score zero. Anchors remain fixed while query/gallery features receive the intervention. This is a session-retrieval neighborhood control, not a reproduction of a next-item session-kNN algorithm.

Fixed-MLP, embedding-gate and quality-gate fusion variants use the original encoders and common-validation training design. A separate alignment variant adds 0.25 times a symmetric sequence-to-graph cross-entropy loss using clean same-session diagonal positives. Other sessions, including another visit by the same user, remain off-diagonal in this auxiliary term. The loss reuses clean embeddings. Both variant studies repeat five splits and three initializations; no test-best variant replaces the average-fusion reference.

3.8. Retrieval Metrics and Statistical Analysis

MRR averages the reciprocal rank of the designated positive [21]; Recall@1 and Recall@10 measure first-rank and top-ten success. Up to 5,000 eligible query users are sampled for each candidate seed. Eligible users are sorted, shuffled with Python random.Random(candidateseed), and truncated to the query budget. Published query/positive pairs are sampled without replacement within user. For temporal sessions, a uniformly selected query is paired with a uniformly selected different-origin session. Negatives are uniform test-session draws, rejecting the query user’s sessions and duplicate indices. Sorted negative indices and the positive are shuffled together. The RNG is consumed sequentially, so different candidate sizes need not use identical positives even with the same seed. Method comparisons reuse identical lists within each task.

Primary summaries pool repeated observations within each raw user before averaging users equally. Paired differences use matched observations before rounding and common user resamples. Pointwise 95% percentile intervals use 10,000 NumPy PCG64 resamples, seed 42, and sorted endpoints 249 and 9749 (zero-based). They are conditional on fitted models and observed partitions, not full retraining uncertainty or simultaneous confidence bounds. Zero bootstrap tail counts are not exact zero p-values; an interval containing zero does not establish equivalence. Across-fit standard deviations and timing standard deviations are separate descriptive quantities.

Historical neural comparisons retain an equal split-user mean over 27,582 units rather than the equal-raw-user mean over 22,741 people. Their MRR ratio bootstrap resamples raw users with all split appearances, preserving the split-user denominator; their earlier Recall intervals resample split-user units separately and retain cross-split dependence limitations. This convention is explicitly marked wherever retained. Scores from different estimands are never subtracted to manufacture paired effects. Fixed-pair one-split extensions average three initializations within each of 1,000 users. For candidate-scale tests, these same query/positive pairs use nested pools of 1,000, 5,000, 10,000 and all eligible sessions; the full pool excludes the query and other same-user sessions. Ties follow deterministic sequence order. Sampled scores are not substitutes for full-collection performance [22].

The original study repeats five splits and three initializations. Additional neural, supervision and ablation experiments were developed after earlier test inspection. The gated extension was subsequently frozen before 45 replication fits, using split seeds coffee-b4-replication-20261001-1 through coffee-b4-replication-20261001-5, initializations 41–43, candidate seeds 41–45 and fixed training/evaluation rules. Its paired bootstrap uses 10,000 draws, seed 20261001 and NumPy linear-interpolated percentiles, rather than the earlier sorted-endpoint convention. The scale and budget extension fixes candidate seed 46 on the first three new partitions. Both gated training regimes share the common validation selector. The protocol was frozen locally, not externally preregistered. Approximately 46–48% of repeated-session users in proposed replication test partitions also appeared in earlier test partitions; this indicates potential exposure, not that every user was queried. Repartitioning tests stability within Coffee Shop without creating an independent application-level dataset. Scale and budget replication use the first three new partitions and three initializations, pooling 2,929 distinct query users. Figure 2 summarizes the evaluation hierarchy.

4. Experiments and Results

The experiments test three connected claims: cross-session positives provide a useful retrieval signal, joint sequence–graph training can add value beyond independent encoders, and the resulting benefit depends on which information remains available. Matched supervision and independent-encoder comparisons address the first two claims; intervention, training and replication controls delimit the third. Historical and frozen-partition results retain their own populations and estimands. Unless stated otherwise, brackets denote pointwise 95% intervals; a paired interval containing zero is not evidence of equivalence.

Tables contain the quantitative evidence; the text explains its implication. Repeated controlled studies take precedence over developmental pilots. Sensitivity displays use named protocols and a symmetric set of conditions, not test-selected winning cases. Full internal analysis inventories are not treated as additional independent evidence.

4.1. Retrieval Quality and Ranking Depth

We first establish what the learned representation retrieves before examining why it helps. Table 2 places original fusion alongside direct navigation summaries and historical neural encoders. Its improvement over transition cosine is visible in MRR and top-ten recall, but not uniformly in first-rank accuracy. The historical SR-GNN comparison is much closer. Table 4 gives paired intervals, so small score differences are not interpreted from marginal means alone.

The historical attention configuration is not the strongest attention baseline. Validation tuning raises SASRec’s clean MRR to 0.8819 at 100 candidates and 0.7311 at 1,000, compared with original fusion’s 0.8072 and 0.6066. This motivates evaluating the proposed design through matched controls and input conditions, rather than claiming a uniformly superior encoder. Empirical random ranking agrees with its analytic expectation within 1.25 Monte Carlo standard errors across the six metric/size combinations.

Figure 3 makes the ranking-depth distinction visible: first-rank success and finding a relevant session within ten results are different properties. Its pointwise intervals share raw-user resampling draws; they are not simultaneous confidence bands. The figure uses retained historical ranks. Replay reproduced all but one of 750,000 SR-GNN ranks; that near-tied query changes pooled MRR by less than one millionth.

4.2. Does Joint Learning Add Value Beyond Independent Encoders?

The principal architectural question is not whether fusion beats a weak branch extracted from its own checkpoint, but whether training the views together improves on independently trained encoders and their late-score combination. Table 3 answers this question on identical candidate tasks, alongside the stronger, validation-tuned attention comparator.

Joint fusion improves over independent late fusion and both independent branches under combined view damage at both severities and candidate sizes. Clean and edge-only retrieval favor late fusion. Under sequence-only damage, joint fusion beats late fusion but not the unchanged independent graph. The benefit therefore comes from how the trained views interact with the available information, not simply from increasing the number of encoders.

Table 4 checks whether this pattern is confined to MRR. Its joint-versus-late-fusion block uses a symmetric clean/50%-damage grid, including conditions that favor either method. The combined-damage improvement appears at both the first rank and the top-ten cutoff; the clean disadvantage also remains visible. The historical block resolves the small neural differences introduced above.

Table 5 supplies the original model’s corruption profile and absolute retrieval levels. Transition cosine is unchanged by sequence-only damage, whereas page counts are unchanged by every view-level intervention. Consequently, intact page counts exceed fusion under 50% combined damage at both candidate sizes and under 50% edge damage at 1,000 candidates. Their invariance is a property of the intervention, not a separate demonstration of resilience to missing events.

The training-anchor retrieval adaptation provides a complementary non-parametric control. Original fusion’s paired MRR intervals against it are positive in all fourteen condition/size tasks; nevertheless, the anchor’s clean MRR at 1,000 candidates is below direct transition cosine. The gated extension shows the same directional pattern against tuned SASRec as original fusion: clean and edge-only inputs favor the attention model, while sequence and combined damage favor the multi-view model. These comparisons concern the implemented retrieval adaptations, not the original papers’ next-item scores.

4.3. Why Does Cross-Session Supervision Help?

The learning relation should match the evaluation endpoint: a second recorded visit is a different target from an augmented copy of the current visit. The historical package comparison in Table 6 motivates this distinction but does not isolate it, because objective weighting also changes. Its strongest label-free output is the graph, not label-free fusion. The same table distinguishes co-trained readouts from the independent models evaluated above.

The matched experiment in Table 7 holds the architecture, initial weights, objective, input schedule and final epoch fixed while changing the positive relation. Cross-session positives improve all three metrics in every evaluated condition/size task, with positive paired intervals. Thus the value of cross-session supervision is not inferred solely from comparing two differently weighted training packages. The result remains specific to the common cross-bank formulation and its user-grouped sampling.

Directed structure supplies much of the co-trained retrieval signal, but its longer input history could otherwise explain part of the apparent advantage. Rebuilding every view from the last 128 events reduces clean fusion MRR at 1,000 candidates from 0.6059 to 0.5920. Fusion nevertheless retains a paired gain over its co-trained graph: +0.0305 [0.0291, 0.0319] with full graph history and +0.0340 [0.0327, 0.0354] with matched history. At 100 candidates the corresponding gains are +0.0288 [0.0276, 0.0301] and +0.0306 [0.0293, 0.0318]. Equalizing history therefore changes absolute quality without removing the within-checkpoint fusion benefit. This does not replace an independently trained, history-matched single-view comparison.

4.4. Training and Fusion Choices

A corruption-training effect could be confused with a different checkpoint-selection rule or a larger computation budget. Table 8 separates the original regime-specific selection from common-validation and matched-forward controls. The historical comparison retains all fourteen paired intervals, including its clean cost. With a common selector the original model’s clean difference changes sign, whereas the combined-damage gain remains positive even after matching forward counts. Robustness is therefore not explained solely by the original selection mismatch.

Changing only the clean selector changes the selected epoch in 12 of 15 fits. Duplicate clean forwards in the budget control add no augmentation and do not imply equal runtime. Historical Recall comparisons also favor corruption training in every corrupted task; clean Recall@10 at 100 candidates has an interval containing zero. These distinctions prevent turning the original clean-cost estimate into a universal architectural property.

Table 9 examines whether a more flexible fusion head or explicit alignment is an automatic improvement. The displayed sensitivity grid covers clean input and all three severe interventions at both candidate sizes, rather than selecting only favorable conditions. Quality gating helps clean and sequence-corrupted retrieval, fixed-MLP helps combined damage, and alignment improves clean/edge retrieval while worsening sequence/combined retrieval. The descriptive seed ranges show training variation separately from paired confidence intervals. No variant is selected on these test outcomes.

These results support a design-level explanation: complementary inputs, their joint objective and model selection interact. They do not establish that learned gates or alignment are generally ineffective. Earlier single-split pilots served development; the repeated controlled experiments, not additional listings of pilot scores, support the reported conclusions.

4.5. From View Damage to Missing Events

Representation-specific perturbations answer which view supplies usable information. Missing logs ask a different question because all views must be reconstructed from incomplete observations. Table 10 therefore removes raw events before rebuilding the sequence, graph and counts, using the same surviving observations for every method.

All methods degrade, including the previously invariant counts. Under 50% deletion at 1,000 candidates, original fusion and gated fusion trail transition cosine by paired MRR differences of −0.0033 [−0.0048, −0.0019] and −0.0017 [−0.0032, −0.0002]. Gated fusion exceeds SR-GNN by +0.0016 [0.0007, 0.0024]; original fusion’s intervals against SR-GNN, tuned SASRec and page cosine include zero. Thus the combined-view result identifies a useful operating condition, not a universal missing-event advantage. These intervals remain conditional on fitted models and one nested deletion-mask schedule.

4.6. Temporal Granularity and Retrieval Scope

Cross-origin temporal pairing tests whether the result relies on the published sequence boundary. Query and positive must originate from different published sequences, so splitting one sequence cannot create an artificially easy positive. Table 11 compares both inactivity thresholds without selecting a threshold on test performance.

Both policies give a positive fusion-minus-transition MRR interval at 100 candidates. At 1,000 candidates, first-rank and top-ten effects have opposite signs: fusion improves top-ten recall but not first-rank success. The three-hour MRR interval includes zero; it does not establish equivalence. This separates useful shortlist retrieval from a claim of uniformly better top-one identification. Segmentation counts, singleton exclusions and pairing eligibility are specified in Methodology.

4.7. Stability Under Frozen Repartitioning and Larger Candidate Pools

The gated extension was developed after earlier test inspection. Its settings were subsequently frozen before new partition runs, allowing us to ask whether its observed pattern persists when the user assignment changes. Table 12 retains the historical comparison and reports all new gated-minus-SR-GNN paired endpoints. The new partitions favor gated fusion in clean MRR and under edge/combined damage, while sequence-only damage favors SR-GNN. Most Recall contrasts agree, but Recall@10 under 25% combined damage at 100 candidates includes zero.

The within-model controls in Table 13 distinguish this external comparator result from training and readout effects. Corruption training retains a clean cost in the new gated fits and improves the corrupted tasks. Fusion also improves on its own graph readout except under severe sequence truncation. These controls use the same common selector, making them more informative than comparing unrelated historical clean-cost estimates. The new partitions reuse the application and overlap previously exposed users; they test same-application stability, not an independent new population.

Table 14 and Figure 4 extend the question from sampled candidates to the full eligible collection. Fixed query/positive pairs are retained within each scale experiment. The historical corpus contains 29,028 sessions before same-user exclusions. The new-partition graph-damage advantage over SR-GNN persists as pools grow, but transition cosine leads clean full-corpus retrieval and intact page counts lead under heavy view corruption. The historical clean SR-GNN advantage is not reproduced as a nonzero difference in the new full-corpus interval.

Increasing the candidate pool therefore changes both absolute difficulty and the strongest alternative. The contribution is a repeatable graph-damage benefit relative to the graph encoder within the evaluated application, rather than dominance over every baseline at every retrieval scale. Shading in the scale figure spans partition means, not confidence intervals.

4.8. Training Budget and Computational Cost

Table 15 tests the amount of training data needed for useful retrieval. Original-model budgets retain both candidate sizes and include the small-user regimes; the gated extension is shown before and after repartitioning. The clean transition references are 0.7575 and 0.5946 MRR at 100 and 1,000 candidates, respectively; under 50% combined damage they are 0.2200 and 0.0757. The original model first exceeds transition cosine at 2,000 users for clean 100-candidate retrieval and at 4,000 users for clean 1,000-candidate retrieval. Even its 500-user budget gives a positive paired difference under combined damage at 1,000 candidates.

Figure 5 shows that the gated budget trend recurs across new partitions. Nested budgets preserve the vocabulary and 800 validation users, but more users also mean more optimization updates. These curves measure the specified training-budget procedure, not isolated sample efficiency or saturation at 4,000 users.

Table 16 quantifies representation and training costs; Table 17 separately quantifies ranking a resident candidate bank. Measurements use a 16-inch MacBook Pro, Apple M5 Pro, 24 GB memory, macOS Tahoe 26.6, Python 3.12.14 and PyTorch 2.13.0, with four CPU threads and no GPU/MPS acceleration. Encoding includes shared collation and forward computation for 10,000 pre-parsed sessions, but excludes parsing, disk I/O and concatenation. Three warmed repeats measure runtime variation, not initialization uncertainty.

Training timings use three fresh seed-41 trajectories per method on the same 4,000/800-user split, 63 updates per epoch and method-specific objectives. They include batching, perturbation, collation, losses, backward and optimizer operations; loading, initialization, logging and checkpoint I/O are excluded. Eight-epoch validation is timed separately and ranges from 2.0103 to 3.9315 seconds. Original fusion contains 10,980 unused alternative-head parameters, which explains its stored/gradient-connected count difference.

Dense page and transition vectors require 0.00912 ± 0.00015 and 0.02245 ± 0.00015 ms/session to construct from pre-parsed dictionaries; raw parsing and count extraction are excluded. Neural encoding has a higher construction cost, while candidate-independent vectors allow one encoding to be reused across comparisons. Neither these measurements nor the resident-bank timings establish end-to-end deployment latency. They make the cost of the evaluated design explicit without conflating model construction, training and retrieval.

5. Discussion

The study connects behavioral metric learning to a concrete multi-view training design for unseen-user session retrieval. Identity-supervised sequence embeddings and behavioral fingerprints already establish that recurring behavior can define similarity [18,19,20], while graph-based matching provides a structural alternative [53]. Here, ordered events and directed transitions enter parallel encoders whose outputs are trained together under clean and perturbed inputs. The resulting candidate-independent vector supports cosine ranking without a candidate-conditioned encoding pass. The methodological contribution is the retrieval-oriented integration of cross-session supervision and corruption-aware joint sequence–graph learning; the accompanying controls identify how supervision and complementary views contribute to its performance.

The matched-supervision comparison provides direct evidence for the learning relation: independently recorded visits supply a useful signal for retrieving another session of an unseen user. It complements the historical label-free package comparison by holding architecture, objective weighting and input schedule fixed. Same-session sampling still uses user-grouped batches, and the paired experiment concerns the original architecture. The matched result therefore identifies the effect of the implemented cross-session relation under this shared training design.

The view controls reveal a more specific role for joint learning than clean accuracy alone suggests. Directed transitions dominate the co-trained readouts, yet fusion improves over that graph readout even when all views share the last-128 history budget. Independently trained encoders are stronger controls than extracted readouts: late fusion wins on clean and edge-only inputs, whereas joint fusion exceeds it and both independent branches under combined damage. Thus a weak co-trained sequence readout can still participate in a useful joint representation, but its standalone score cannot establish that sequence modeling is intrinsically weak.

Training and selection choices also matter. Common-validation and matched-forward controls preserve the combined-corruption benefit while changing the original architecture’s clean-cost estimate. Explicit alignment and learned fusion alternatives shift sensitivity across conditions instead of yielding one uniformly better variant. These findings support studying the interaction among supervision, views and optimization, rather than attributing every difference to the encoder alone. Potential explanations such as increased sequence reliance under alignment remain interpretations, not directly measured mechanisms.

The stronger attention baseline and simple count controls define the practical comparison. Tuned SASRec leads original fusion on clean retrieval, and intact page counts remain strong under heavy view corruption. Rebuilding every view after raw-event deletion changes this ordering and removes the count baseline’s artificial invariance. This distinction is useful for applications: a representation-level intervention models a different failure from missing events in the logging stream. The model should therefore be assessed under the anticipated data-loss mechanism, not chosen from a favorable test condition. Competitive inexpensive baselines are consistent with earlier empirical SBR findings [51].

Frozen repartitioning strengthens the evidence for the gated extension’s graph-damage benefit relative to SR-GNN. Candidate-scale and temporal tests further show that retrieval depth, eligibility and pool size affect conclusions. The common application setting holds page semantics fixed while these learning and evaluation choices are varied. Together, these experiments connect the proposed learning design to three concrete findings within Coffee Shop: the value of cross-session positives, joint learning beyond independent late fusion under combined view damage, and the stability of the gated extension’s graph-damage benefit across repartitioning and candidate scales.

Despite these strengths, several limitations must be acknowledged. Evidence comes from one application with 46 page identifiers; repeated partitions do not establish transfer to other applications. The gated architecture and later controls followed test inspection, and new partitions overlap potentially exposed users. Bootstrap intervals are conditional on observed fits and are pointwise; historical Recall panels retain their stated split-user dependence limitation. Synthetic view perturbations and event deletion do not cover all production failures. Equal-history controls concern jointly trained readouts, and session linkage does not establish downstream recommendation utility or privacy protection.

6. Conclusions

We proposed a corruption-aware sequence–graph metric-learning framework for retrieving sessions of users excluded from model fitting. Cross-session positives align representations with recurring behavior across visits, while parallel sequence and directed-graph views provide complementary information under controlled input damage. Matched supervision, independent encoders, training-regime controls and frozen repartitioning provide a coherent empirical basis for this design.

The central result is the value of joint training under combined view corruption: at 1,000 candidates and 50% damage, original fusion reaches MRR 0.1846 versus 0.1638 for independent late fusion and 0.0953 for tuned SASRec. Cross-session positives are also supported by the matched training control, and the gated extension’s graph-damage advantage over SR-GNN persists across new partitions and candidate scales. These benefits coexist with stronger clean alternatives and a different ranking under raw-event loss; they identify the conditions in which the proposed design is useful within the evaluated application.

In practice, the encoder could support mobile-application or web-usage analytics by retrieving related navigation histories for an analyst investigating recurring journeys. Retrieved sessions could also supply context to personalization or recommendation workflows, with downstream utility evaluated separately. These are prospective uses, not demonstrated deployments; cross-session linkage requires appropriate consent, access controls and privacy assessment.

Future work will examine independently trained encoders under matched history budgets, empirically grounded logging-loss mechanisms, and retrieval with multiple relevant sessions. Integrating session similarity into analytics or recommendation workflows would connect the present endpoint to operational value, while deployment studies should measure end-to-end latency, resource use and linkage risks.