betaFeedback

WorksComputer Science

Item Representations Matter: Bridging Hard Semantic IDs and Soft Prototype Mixtures for Generative Retrieval

Abstract

Modern recommender systems rely on generative retrieval techniques to predict the next item either as discrete codes or as a continuous vector. On the one hand, Semantic IDs (SIDs) give discrete models shared parameters and pretrained semantic structure, but discretizing items into hard codes discards some information from the original content embeddings. On the other hand, continuous models avoid quantization, yet typically use flat item lookup tables with no explicit parameter tying across items. We ask whether a continuous recommender can introduce shared structure without making it a discrete bottleneck. We propose CAP-Mix, a flow recommender that represents each item as a soft mixture of shared prototypes plus an item-specific vector. The assignments, prototypes, and item vectors are trained jointly, and the soft representation is retained at inference. Pretrained information is optional: SID responsibilities can serve as a prior over assignments, while a full content embedding can initialize the item-specific vector without changing the initial flat table. In matched comparisons on three datasets, CAP-Mix improves over a flat table on the two sparse Amazon datasets and yields a small gain on Steam when trained without pretrained information. Given only an offline SID, it outperforms a hard table built from the same tokenizer by 4.45-14.90% in HR@5. Given the full content embedding, it matches or improves a strong flat table while hard assignments regress on the sparse Amazon datasets. Overall, averaged across six benchmarks, CAP-Mix improves HR@5 and NDCG@5 by 6.9% and 13.6% relative to the best evaluated baseline for each dataset and metric, while delivering 1.4-161x the inference throughput of the discrete baselines in our experiments.

Introduction

Generative retrieval techniques enable modern recommender systems to perform large-scale next-item retrieval by learning the next-item distribution and generating recommendations from it, using either discrete tokens (Rajput et al., [25]) or continuous item embeddings (Li et al., [17]). Either way, a recommender needs an item representation table (or lookup table) as input, i.e., the map from a catalog to the representations it generates or scores against, and how that map is built is a lever in its own right, open to external information. Traditionally, it is flat: one independently parameterized vector per item, with no explicit parameter tying between item rows. Recently, discrete methods have replaced that default, whereas continuous methods have retained it.

Discrete models tokenize each item embedding into codes and emit those codes autoregressively ([7, 25]) or by masked diffusion ([26]). They owe much of their strength to those codes being Semantic IDs (SIDs) (Singh et al., 2024). A residual quantizer ([16] (van den Oord et al. 2017; Tong et al. 2026)) turns each item’s pretrained content embedding into a tuple of codes, so the item vocabulary becomes a clustering ([13]). Two things follow: items sharing a code share the parameters attached to it, so their gradients are aggregated through the shared codeword, introducing explicit cross-item coupling and thereby pooling training signal across items; and because the codes are quantized from a content embedding, that grouping imports semantic structure. However, tokenization has two costs: committing each item to a single codeword at each level generally introduces reconstruction error, and distinct items may also collide on the same code tuple. A recent line of work makes the tokenizer itself adaptive by regularizing it (Wang et al., 2024), coupling it to the recommender [21], or relaxing the assignment so gradients pass through it [17, 8], but recommendation is still organized around emitting discrete codes, and both costs remain: they stem from tokenization itself, not from when the tokenizer is fit.

Continuous models instead represent each item as a vector in Rd\mathbb{R}^{d} and retrieve those nearest to the one they predict [22, 17] (Wang et al. 2023). They do not tokenize and are free to seed the content embedding straight into their item table, so semantic structure reaches them without any codes. What they do not obtain automatically is explicit cross-item parameter sharing: every item row remains independently parameterized. This raises our central question: can a continuous generative recommender obtain adaptive cross-item parameter sharing without converting items into discrete tokens?

A simple way to use an SID in a continuous recommender is to replace its flat lookup table with a hard SID table whose assignments are frozen. If the tokenizer assigns item ii the code ci(s)\mathbf{c}_i^{(s)} at level ss, then its embedding is xi=∑sC(s)[ci(s)]+ri\mathbf{x}_i = \sum_s C^{(s)}[\mathbf{c}_i^{(s)}] + \mathbf{r}_i, where C(s)C^{(s)} contains the codeword vectors and the item-specific vector ri\mathbf{r}_i can be initialized from the original content embedding. This preserves continuous retrieval while transferring the SID’s parameter sharing: items with the same code update a shared vector. However, our diagnostic comparison (Appendix § 12, Table 6) shows that, without content embeddings, semantic assignments outperform matched random assignments, indicating that the imported structure is useful. When the full content embedding initializes ri\mathbf{r}_i, by contrast, frozen hard semantic assignments hurt, whereas random assignments remain near the flat baseline. These observations suggest that sharing can help, but that a frozen semantic partition can become restrictive when its underlying continuous representation is already available. This motivates shared structure that adapts jointly with the recommender while retaining item-specific degrees of freedom.

scenarioitem tableBeautyIndustrialSteam
FROM SCRATCHFLAT5.772.758.29
FROM SCRATCH+ HARD RQ-SID+0.52%+9.82%+0.36%
FROM SCRATCH+ RANDOM SID−1.73%+0.73%+0.12%
PCA-TEXTFLAT, TRAINABLE6.693.818.13
PCA-TEXTFROZEN−18.24%−20.21%−14.15%
PCA-TEXT+ HARD RQ-SID−3.89%−7.61%+0.74%
PCA-TEXT+ RANDOM SID+0.30%−1.84%+0.86%

Table 6. Item-table variants for a continuous flow recommender. The flat table of each block is absolute test HR@5 ↑; every other cell is its % change relative to it. A hard SID beats random codes from scratch, but with the full content embedding the ordering reverses and, on the sparse catalogs, both fall below the trainable flat table.

Following these observations, we propose CAP-Mix, a flow recommender whose item table is a co-adaptive mixture of shared prototypes plus an item-specific vector. Rather than selecting one codeword per level, an item softly mixes over all of them, so the grouping is differentiable and the ranking objective moves it continuously instead of by discrete reassignment, while the item-specific vector keeps it from being reduced to the group it lands in. We call this a prototype-mixture item table:

xi=γS∑s=1SAi(s)C(s)+ri,∑k=1KAi(s)[k]=1,(1)\mathbf{x}_i = \frac{\gamma}{S}\sum_{s=1}^{S} A_i^{(s)} C^{(s)} + \mathbf{r}_i,\qquad\sum_{k=1}^{K} A_i^{(s)}[k] = 1, \tag*{(1)}

with C(s)C^{(s)} the KK shared prototypes of level ss, Ai(s)A_i^{(s)} the weights item ii places on them, ri\mathbf{r}_i the item’s own vector, and γ>0\gamma> 0 a scale factor, all learned with the flow in a single stage.

Empirically, we evaluate CAP-Mix across six public benchmarks (Table 2), where CAP-Mix improves average HR@5 ↑ and NDCG@5 ↑ by +6.9% and +13.6%, respectively, relative to the strongest evaluated baseline (FlowRec, TIGER, or MaskGR) for each dataset and metric, while delivering 1.4–161× the inference throughput ↑ of the evaluated discrete baselines (Table 3).

Beauty HR@5 ↑Beauty NDCG@5 ↑Indus. HR@5 ↑Indus. NDCG@5 ↑Steam HR@5 ↑Steam NDCG@5 ↑ML-1M HR@5 ↑ML-1M NDCG@5 ↑Yelp HR@5 ↑Yelp NDCG@5 ↑Office HR@5 ↑Office NDCG@5 ↑
FlowRec6.27p ±0.184.03 ±0.033.62p ±0.022.04 ±0.038.28s ±0.335.37 ±0.3015.36p ±0.2010.14 ±0.122.98p ±0.051.86 ±0.032.90p ±0.021.67 ±0.02
TIGER3.51s ±0.072.54 ±0.052.05p ±0.031.34 ±0.028.43i ±0.105.01 ±0.0312.59s ±0.408.47 ±0.281.29p ±0.070.80 ±0.041.52p ±0.010.98 ±0.01
MaskGR5.06i ±0.133.28 ±0.123.46p ±0.032.24 ±0.038.64p ±0.005.57 ±0.0115.64s ±0.4010.23 ±0.282.99s ±0.041.87 ±0.032.29s ±0.021.53 ±0.01
CAP-Mix6.79p ±0.064.73 ±0.043.79p ±0.012.34 ±0.038.69i ±0.295.57 ±0.1917.25p ±0.1311.71 ±0.113.18p ±0.022.03 ±0.023.22p ±0.012.28 ±0.01
Δ (%)+8.3%+17.4%+4.7%+4.5%+0.6%0.0%+10.3%+14.5%+6.4%+8.6%+11.0%+36.5%

Table 2. Table 2 Main results, HR@5 ↑ and NDCG@5 ↑ (mean±std, ×100). For each model–dataset pair, both metrics come from one run selected by their validation geometric mean; s marks scratch, i offline SID, and p PCA-text. Bold/underline mark best/second; Δ compares CAP-Mix with the best baseline.

baselinehot-parameter ratio ↑\uparrowMFLOP/query ratio ↑\uparrowthroughput ratio ↑\uparrow
TIGER0.9–10.0×23–265×1.9–7.1×
MaskGR1.4–5.4×3.7–2,654×1.4–161×

Table 3. Inference efficiency across five datasets (min–max from unrounded values). Hot-parameter ratio ↑\uparrow and MFLOP/query ratio ↑\uparrow are baseline/CAP-Mix; throughput ratio ↑\uparrow is CAP-Mix/baseline.

Preliminaries

Flow-based generative retrieval for recommender systems

Flow matching [20] learns to transform samples from a simple source distribution psourcep_{\mathrm{source}} into samples from a target distribution pdatap_{\mathrm{data}}. It learns a velocity field vθ(x,t)v_{\theta}(\mathbf{x},t) that tells each sample how to move at time tt. Let I\mathcal{I} be the item catalog, H=(i1,…,im)H = (i_1,\ldots,i_m) a user’s interaction history, and im+1i_{m+1} the next item. A flow-based generative recommender can be decomposed into three components. First, the item encoder Eθ:I→RDE_{\theta}:\mathcal{I}\to\mathbb{R}^{D} maps each item ii to an embedding xi\mathbf{x}_i. Applied elementwise to HH, it yields (xi1,…,xim)(\mathbf{x}_{i_1},\ldots,\mathbf{x}_{i_m}). Second, the flow starts from a source x0\mathbf{x}_0 and follows the learned velocity field vθ(x,t)v_{\theta}(\mathbf{x},t) toward a predicted next-item embedding by integrating from t=0t=0 to t=1t=1. Writing vv for the exact velocity field, explicit Euler approximates this transport using NN evaluations of the learned field:

x^1=x0+∫01v(xt,t) dt≈x0+h∑n=0N−1vθ(x^tn,tn),tn=nh,h=1/N.(2)\hat{x}_1 = x_0 + \int_0^1 v(x_t,t)\,\mathrm{d}t \approx x_0 + h \sum_{n=0}^{N-1} v_\theta(\hat{x}_{t_n},t_n), \qquad t_n = nh,\qquad h = 1/N. \tag*{(2)}

Here, x^tn\hat{x}_{t_n} denotes the numerical state at time tnt_n, with x^t0=x0\hat{x}_{t_0}=x_0. Depending on the architecture, the encoded history may determine the source, condition the velocity field, or both. Third, the decoder Dθ(x^1,H)∈Δ∣I∣−1D_\theta(\hat{x}_1,H)\in\Delta^{|\mathcal{I}|-1} converts this endpoint into a distribution over the catalog by scoring it against the item table X=[xi]i∈I∈R∣I∣×D\mathbf{X}=[\mathbf{x}_i]_{i\in\mathcal{I}}\in\mathbb{R}^{|\mathcal{I}|\times D}. Figure 1(a) illustrates this complete encoder–flow–decoder path. During training, the target endpoint is the next-item embedding x1=xim+1\mathbf{x}_1=\mathbf{x}_{i_{m+1}}. For a source x0\mathbf{x}_0 and target x1\mathbf{x}_1, conditional flow matching commonly uses the straight path and regresses the conditional velocity

A general flow-based retrieval pipeline and CAP-Mix item encoder

Figure 1. (a) A general flow-based retrieval pipeline has three components, and the item table is shared across them: the encoder builds it, the flow is trained to land on one of its rows, and the decoder retrieves against it. (b) CAP-Mix mainly changes the encoder of the pipeline: an attention block over the SS level tokens maps each item’s short feature fi∈RDff_i \in\mathbb{R}^{D_f} to a soft assignment Ai(s)A_i^{(s)} over the KK prototypes of level ss, which then blends the rows of that level’s codebook C(s)C^{(s)}. Adding a trainable identity vector rir_i yields the item embedding xi∈RDx_i \in\mathbb{R}^{D}. Nothing is quantized or frozen, so the clustering is shaped by the training objective and the assignments are kept soft during training and inference.

xt=(1−t)x0+tx1,v⋆=x1−x0,LCFM=Et∼U[0,1]∥vθ(xt,t)−v⋆∥22.(3)\mathbf{x}_t=(1-t)\mathbf{x}_0+t\mathbf{x}_1,\qquad\mathbf{v}^{\star}=\mathbf{x}_1-\mathbf{x}_0,\qquad\mathcal{L}_{\mathrm{CFM}}=\mathbb{E}_{t\sim U[0,1]}\left\|\mathbf{v}_\theta(\mathbf{x}_t,t)-\mathbf{v}^{\star}\right\|_2^2. \tag*{(3)}

The same item table therefore embeds the history, defines the flow’s training targets, and supports retrieval. Existing flow-based recommenders ([22, 17]) focus primarily on the transport, whereas we study how the item-table parameterization can enable sharing across items.

Semantic IDs

A Semantic ID (SID) represents an item by an ordered tuple of codes, typically obtained by applying residual quantization to a pretrained content embedding ([25, 13]). Given LL codebooks Q(ℓ)∈RK×DQ^{(\ell)}\in\mathbb{R}^{K\times D}, residual quantization decomposes the content embedding ei\mathbf{e}_i into selected codewords and a final residual εi\boldsymbol{\varepsilon}_i:

SID⁡(i)=(ci(1),…,ci(L)),ei=∑ℓ=1LQ(ℓ)[ci(ℓ)]+εi,ci(ℓ)∈{1,…,K}.(4)\operatorname{SID}(i)=\left(c_i^{(1)},\ldots,c_i^{(L)}\right),\qquad\mathbf{e}_i=\sum_{\ell=1}^{L}Q^{(\ell)}[c_i^{(\ell)}]+\boldsymbol{\varepsilon}_i,\qquad c_i^{(\ell)}\in\{1,\ldots,K\}. \tag*{(4)}

The SID retains the selected indices but not εi\boldsymbol{\varepsilon}_i. Methods differ in how they obtain these assignments: RQ-KMeans selects the nearest centroid ([13]), RQ-VAE learns its quantization space through reconstruction ([16]), and RQ-GMM assigns items using posterior mixture probabilities (Tong et al., 2026). Regardless of the fitting procedure, the SID used at inference is hard: each level selects one codeword, whose index becomes that level’s code. Items that share a code reuse its parameters, thereby pooling recommendation gradients across their interactions. Deriving the codes from content embeddings also transfers pretrained semantic structure.

Recent methods remove the need for a separately pretrained, frozen tokenizer by adapting it jointly with the recommender ([17, 8] (Wang et al. 2026)), but their deployed IDs remain hard and discard the residual εi\boldsymbol{\varepsilon}_i. SIDs therefore share parameters through discrete code assignments at the cost of quantizing the item representation. Flat-table continuous recommenders avoid quantization but learn each item embedding independently. Our goal is to combine adaptive sharing with trainable continuous representations.

Method: CAP-Mix

Following § 2.1, CAP-Mix uses a continuous flow to predict a next-item embedding and a catalog decoder to model p(i∣H)p(i\mid H). Its main contribution is the item encoder EθE_\theta, which replaces a flat item table with a prototype-mixture parameterization. This representation learns soft item groupings for cross-item sharing while retaining an item-specific vector, and can incorporate pretrained SIDs or content embeddings when available. Figure 1 provides an overview.

Prototype-mixture item representations

CAP-Mix maintains SS shared codebooks C(s)∈RK×DC^{(s)}\in\mathbb{R}^{K\times D}, whose KK rows are DD-dimensional prototype vectors. For item ii, Ai(s)∈ΔK−1A_i^{(s)}\in\Delta^{K-1} is a soft assignment over the prototypes in codebook ss, and ri∈RD\mathbf{r}_i\in\mathbb{R}^{D} is an item-specific vector. The item embedding is then

xi=ri+γS∑s=1SAi(s)C(s),Ai(s)[k]≥0,∑k=1KAi(s)[k]=1,(5)x_i = r_i + \frac{\gamma}{S}\sum_{s=1}^{S} A_i^{(s)}C^{(s)}, \qquad A_i^{(s)}[k] \ge0,\qquad\sum_{k=1}^{K} A_i^{(s)}[k] = 1, \tag*{(5)}

where Ai(s)C(s)∈RDA_i^{(s)}C^{(s)} \in\mathbb{R}^{D} is a convex mixture of the prototypes, γ>0\gamma> 0 controls the contribution of the shared component, and 1/S1/S keeps its scale stable as SS changes.

Cross-item sharing and item-specific memorization. Consider a differentiable objective L(X)L(X) whose dependence on the codebooks and item-specific vectors is only through the composed item table XX, and let gi=∇xiLg_i = \nabla_{x_i}L. Differentiating Equation (5) gives

∇C(s)[k]L=γS∑i∈IAi(s)[k]gi,∇riL=gi.(6)\nabla_{C^{(s)}[k]}L = \frac{\gamma}{S}\sum_{i\in I} A_i^{(s)}[k]g_i,\qquad\nabla_{r_i}L = g_i. \tag*{(6)}

The prototype channel aggregates recommendation gradients across items by their assignment weights, providing parameter sharing that can improve generalization. Meanwhile, rir_i receives the unrestricted gradient gig_i, preserving item-specific memorization and uniqueness even when assignments coincide. Appendix § 11 derives the resulting coupling under fixed assignments.

Relation to flat and hard item tables. Equation (5) contains flat and hard item tables as special cases: γ=0\gamma= 0 yields the flat xi=rix_i = r_i, while fixed one-hot Ai(s)A_i^{(s)} selects one prototype per codebook as in a hard SID lookup. Additionally setting ri=0r_i = 0 gives the fully quantized case and discards item information not captured by the selected codewords. CAP-Mix instead keeps assignments soft and retains rir_i for item-specific flexibility.

Learning soft assignments. Each item has a learned low-dimensional feature fi∈RDff_i \in\mathbb{R}^{D_f}. We derive one token per codebook from fif_i and process the SS tokens jointly with a lightweight attention block:

zi(s)=Win(s)fi+p(s),(hi(1),…,hi(S))=Attn⁡(zi(1),…,zi(S)),z_i^{(s)} = W_{\mathrm{in}}^{(s)}f_i + p^{(s)},\qquad(h_i^{(1)},\ldots,h_i^{(S)}) = \operatorname{Attn}(z_i^{(1)},\ldots,z_i^{(S)}),
ϕs(fi)=Wout(s)hi(s),Ai(s)=softmax⁡(ϕs(fi)).(7)\phi_s(f_i) = W_{\mathrm{out}}^{(s)}h_i^{(s)},\qquad A_i^{(s)} = \operatorname{softmax}(\phi_s(f_i)). \tag*{(7)}

Here, Win(s)fi+p(s)W_{\mathrm{in}}^{(s)}f_i+p^{(s)} is a codebook-specific affine projection, hi(s)h_i^{(s)} is its contextualized output, and Wout(s)W_{\mathrm{out}}^{(s)} maps this output to KK assignment logits. This parameterization has three properties. First, because Df<DD_f < D, fif_i serves as an assignment bottleneck: it stores compact information for selecting shared prototypes, while detailed item-specific information remains in rir_i. Second, attention lets the assignments interact: it is bidirectional across codebooks by default and, when an offline residual SID provides a level ordering, causally masked to respect that ordering. Third, no arg max or straight-through estimator is used: the assignments remain soft and differentiable during training and inference, and all representation parameters are learned jointly with the recommender.

Using optional pretrained information

Pretrained information is optional: CAP-Mix can learn entirely from recommendation interactions or incorporate an offline SID or a full content embedding when either is available.

From scratch. CAP-Mix requires neither a tokenizer nor content embeddings. All representation parameters are randomly initialized and learned solely from recommendation interactions. The resulting item groupings are therefore induced by the recommendation objective rather than imported from pretrained content information.

Offline Semantic ID. An offline residual tokenizer supplies both a distribution ρi(t)∈ΔK−1\rho_i^{(t)} \in\Delta^{K-1} over codes at each depth tt and the level ordering induced by its residual construction. We follow this ordering with SS parallel causal chains of depth TT, sharing the tokenizer prior at each depth across chains:

Ai(s,t)=softmax⁡(ϕs,t(fi)+αtlog⁡(ρi(t)+ϵρ)),xi=ri+γS∑s,tAi(s,t)C(s,t).(8)A_i^{(s,t)} = \operatorname{softmax}\left(\phi_{s,t}(\mathbf{f}_i) + \alpha_t \log\left(\rho_i^{(t)} + \epsilon_\rho\right)\right), \qquad\mathbf{x}_i = \mathbf{r}_i + \frac{\gamma}{S} \sum_{s,t} A_i^{(s,t)} C^{(s,t)}. \tag*{(8)}

Here, the sum ranges over s∈{1,…,S}s \in\{1,\ldots,S\} and t∈{1,…,T}t \in\{1,\ldots,T\}, and αt≥0\alpha_t \ge0 is a learned trust parameter. Because ϵρ>0\epsilon_\rho> 0 gives the prior full support, for any finite αt\alpha_t the learned logits can realize any distribution in the interior of the simplex. The assignments therefore remain soft and differentiable. Equation (5) is recovered when T=1T = 1. Appendix § 10 gives the pooling derivation and causal attention structure.

Full content embedding. Let eˉi∈RD\bar{\mathbf{e}}_i \in\mathbb{R}^D be the PCA-projected and coordinatewise-standardized content embedding. We initialize the item-specific vector from this embedding and set every prototype to zero:

ri←eˉi,C(s)←0.(9)\mathbf{r}_i \leftarrow\bar{\mathbf{e}}_i, \qquad C^{(s)} \leftarrow0. \tag*{(9)}

Both ri\mathbf{r}_i and C(s)C^{(s)} remain trainable after initialization. By Equation (5), xi=eˉi\mathbf{x}_i = \bar{\mathbf{e}}_i initially, so CAP-Mix and the flat content-initialized baseline begin from the same unquantized item embeddings. The prototype channel then learns cross-item sharing from this common starting point.

Flow backbone and decoder

We build on the FlowRec backbone [17], retaining its behavior encoder, velocity field, and base flow objective while replacing its item encoder and decoder. Appendix § 8 provides the full specification. A behavior encoder BθB_\theta maps the mm most recent item embeddings to a history-dependent source, while the next-item embedding supplies the target:

x0=Bθ(Eθ(i1),…,Eθ(im)),x1=Eθ(im+1).(10)\mathbf{x}_0 = B_\theta(E_\theta(i_1), \ldots, E_\theta(i_m)), \qquad\mathbf{x}_1 = E_\theta(i_{m+1}). \tag*{(10)}

We train vθv_\theta on the straight interpolant using the conditional flow-matching loss in Equation (3). Following FlowRec, we also form the one-step endpoint estimate

x~1=xt+(1−t)vθ(xt,t).(11)\tilde{\mathbf{x}}_1 = \mathbf{x}_t + (1-t)v_\theta(\mathbf{x}_t,t). \tag*{(11)}

Decoder. For a query u∈RD\mathbf{u} \in\mathbb{R}^D, the decoder combines dot-product scores against the shared item table with a history-dependent co-visitation prior through log-linear pooling:

Dθ(u,H)[i]=softmax⁡i∈I(uTxi+wlog⁡g~(i∣H)).(12)D_\theta(\mathbf{u},H)[i] = \operatorname{softmax}_{i \in\mathcal{I}}\left(\mathbf{u}^{\mathsf{T}}\mathbf{x}_i + w\log\tilde{g}(i \mid H)\right). \tag*{(12)}

The prior g~(i∣H)\tilde{g}(i \mid H) favors items that frequently co-occur with the items in the user’s recent history. We compute it once from the training interactions before model training and keep it fixed. The trust w≥0w \ge0 controls its influence. Setting w=0w = 0 defines the no-prior ablation with a pure dot-product decoder. Appendix § 10 gives the complete construction.

Training objectives and inference

Base flow objective. Using the decoder in Equation (12), we apply next-item classification losses to the behavior source and the one-step endpoint:

Lsrc=−log⁡Dθ(x0,H)[im+1],Lalign=−log⁡Dθ(x~1,H)[im+1].(13)\mathcal{L}_{\mathrm{src}} = -\log D_\theta(\mathbf{x}_0,H)[i_{m+1}], \qquad\mathcal{L}_{\mathrm{align}} = -\log D_\theta(\tilde{\mathbf{x}}_1,H)[i_{m+1}]. \tag*{(13)}

Together with the conditional flow-matching loss, the inherited FlowRec objective is

Lflow=Lsrc+λcfmLCFM+λalignLalign.(14)\mathcal{L}_{\mathrm{flow}} = \mathcal{L}_{\mathrm{src}} + \lambda_{\mathrm{cfm}}\mathcal{L}_{\mathrm{CFM}} + \lambda_{\mathrm{align}}\mathcal{L}_{\mathrm{align}}. \tag*{(14)}

Here, Lsrc\mathcal{L}_{\mathrm{src}} makes the history-dependent source predictive of the next item, while Lalign\mathcal{L}_{\mathrm{align}} applies the same supervision to the one-step endpoint estimate. The weights λcfm\lambda_{\mathrm{cfm}} and λalign\lambda_{\mathrm{align}} are fixed throughout our experiments; their values are given in § 4.2.

Code matching. The item-level losses can be satisfied through the item-specific vectors rir_i alone, leaving the shared assignments uninformative for retrieval. We therefore train the predicted endpoint to recover the target item’s soft assignments, encouraging items retrieved in similar contexts to use compatible prototypes. Let A(s,t)∈R∣I∣×KA^{(s,t)} \in\mathbb{R}^{|\mathcal{I}|\times K} collect all item assignments for chain ss at depth tt, and let g~H=[g~(i∣H)]i∈I\widetilde{\boldsymbol{g}}_H = [\widetilde{g}(i \mid H)]_{i\in\mathcal{I}}. Here and below, ∑s,t\sum_{s,t} ranges over all SS chains and TT depths, with T=1T=1 outside the residual-SID setting. We define

πH(s,t)=sg⁡(A(s,t)⊤g~H),qH(s,t)=softmax⁡(x~1C(s,t)⊤+wlog⁡πH(s,t)).(15)\boldsymbol{\pi}_H^{(s,t)} = \operatorname{sg}\left(A^{(s,t)\top}\widetilde{\boldsymbol{g}}_H\right), \qquad q_H^{(s,t)} = \operatorname{softmax}\left(\widetilde{\boldsymbol{x}}_1\mathcal{C}^{(s,t)\top} + w\log\boldsymbol{\pi}_H^{(s,t)}\right). \tag*{(15)}

Here, πH(s,t)\boldsymbol{\pi}_H^{(s,t)} marginalizes the fixed item-space prior into code space. The stop-gradient operator sg⁡\operatorname{sg} prevents this computation from updating the assignments. The code-matching loss is

Lmatch=−1ST∑s,t⟨Aim+1(s,t),log⁡qH(s,t)⟩.(16)\mathcal{L}_{\mathrm{match}} = -\frac{1}{ST}\sum_{s,t}\left\langle A_{i_{m+1}}^{(s,t)}, \log q_H^{(s,t)}\right\rangle. \tag*{(16)}

Gradients still pass through the target assignment and, through qH(s,t)q_H^{(s,t)}, to the prototypes and flow model, allowing these components to co-adapt.

Maintaining prototype utilization. Because the item-specific channel can support retrieval even when assignments concentrate on only a few prototypes, we penalize catalog-wide utilization below a target KeffK_{\mathrm{eff}}:

A‾(s,t)=1∣I∣∑i∈IAi(s,t),Lbal=1ST∑s,t[log⁡Keff−H(A‾(s,t))]+,(17)\overline{A}^{(s,t)} = \frac{1}{|\mathcal{I}|}\sum_{i\in\mathcal{I}} A_i^{(s,t)}, \qquad \mathcal{L}_{\mathrm{bal}} = \frac{1}{ST}\sum_{s,t}\left[\log K_{\mathrm{eff}}-\mathcal{H}\left(\overline{A}^{(s,t)}\right)\right]_+, \tag*{(17)}

where H\mathcal{H} is entropy and [z]+=max⁡(z,0)[z]_+ = \max(z,0). Since exp⁡(H(A‾(s,t)))\exp(\mathcal{H}(\overline{A}^{(s,t)})) is the effective number of utilized prototypes, the loss vanishes once it reaches KeffK_{\mathrm{eff}}. The loss depends only on the catalog-wide marginal A‾(s,t)\overline{A}^{(s,t)}, leaving individual assignments free to be soft or sharp without forcing discretization.

Full objective. All trainable components are optimized jointly. Given weights λmatch,λbal≥0\lambda_{\mathrm{match}},\lambda_{\mathrm{bal}} \ge0,

L=Lflow+λmatchLmatch+λbalLbal.(18)\mathcal{L} = \mathcal{L}_{\mathrm{flow}} + \lambda_{\mathrm{match}}\mathcal{L}_{\mathrm{match}} + \lambda_{\mathrm{bal}}\mathcal{L}_{\mathrm{bal}}. \tag*{(18)}

Inference. After training, we materialize the item table X\mathbf{X} from Equation (5), retaining the learned soft mixtures without discretization. Given a history HH, we look up its item embeddings and compute the behavior source x0\mathbf{x}_0. Starting from x0\mathbf{x}_0, we numerically integrate the learned velocity field as in Equation (2) to obtain x^1\widehat{\mathbf{x}}_1. The decoder in Equation (12) then scores the catalog, and we return the top-kk items. Because the table is materialized once, the prototype-mixture encoder adds no per-query computation relative to a flat item table.

Experiments

Our experiments address three questions: (RQ1) when does a prototype-mixture item table improve over flat and hard SID alternatives under different levels of pretrained information; (RQ2) how does the complete CAP-Mix system compare with continuous and discrete generative recommenders in predictive performance and efficiency; and (RQ3) how do semantic initialization, the co-visitation prior, and target-item frequency affect the observed gains?

Setup

Setup

Datasets and preprocessing. We evaluate on six public benchmarks: Amazon Beauty (2014) ([24, 11]), Amazon Industrial & Scientific and Amazon Office (2023) ([12]), MovieLens-1M ([10]), Yelp-2022 (Yelp Inc., 2022), and Steam-2018 ([14]). All datasets are processed identically following prior work ([9, 25, 26]): iterative 5-core filtering, consecutive-repeat removal, chronological ordering, and leave-one-out splitting, with each user’s penultimate and final interactions used for validation and testing. Appendix § 7 reports dataset statistics, sources, metadata, and complete preprocessing details.

Evaluation protocol. All models are trained and evaluated on identical item sequences using full-catalog ranking without candidate sampling. We report HR@5 ↑ and NDCG@5 ↑ as three-seed means scaled by 100; Appendix § 14 additionally reports k∈{10,20}k \in\{10, 20\}. We use early stopping, select the checkpoint with the best validation performance, and evaluate only that checkpoint on the test split.

Information regimes. To separate content information from parameter-sharing benefits, we evaluate three regimes that differ in the pretrained information available. From scratch provides none: item representations are initialized randomly and learned from interactions. Offline SID provides the stored codes and posterior responsibilities of a balanced RQ-GMM (see Appendix § 9), but not the content embeddings from which they were computed. PCA-text provides the full content embeddings, projected through PCA to DD dimensions and kept trainable.

Implementation and model selection. All controlled item-table variants use the same D=128D=128 flow backbone, three-item histories, three Euler steps, and matched non-table hyperparameters. We encode item metadata once with frozen Qwen3-Embedding-4B (Zhang et al., 2025). In PCA-text, we initialize the trainable item-specific vectors with standardized DD-dimensional PCA projections of the content embeddings. CAP-Mix zero-initializes its prototypes, making its initial table identical to the flat baseline. We select configurations by the three-seed validation geometric mean of HR@5 ↑ and NDCG@5 ↑. Appendices § 7–§ 9 give the SID construction and remaining setup details.

RQ1: When do prototype mixtures help?

Our central hypothesis is that continuous item embeddings benefit from shared prototypes when that structure complements, rather than replaces, an item-specific continuous representation. We test this by holding the flow backbone and training protocol fixed while varying the item-table parameterization. Because the same table embeds histories, defines the flow targets, and supports retrieval, ranking differences measure the downstream utility of the learned item embeddings.

Item-table variants. The flat table uses xi=ri\mathbf{x}_i=\mathbf{r}_i. The hard SID table uses xi=ri+∑sC(s)[ci(s)]\mathbf{x}_i=\mathbf{r}_i+\sum_s\mathcal{C}^{(s)}[c_i^{(s)}], with trainable codewords and item-specific vectors but frozen one-hot assignments. CAP-Mix instead uses the prototype-mixture representation of Equation (5). All variants share the same backbone and non-table hyperparameters.

Information available to each variant. Table 1 compares the item-table variants under three settings. In from scratch, the flat and CAP-Mix tables are randomly initialized and learn only from interactions. In offline SID, the hard table uses the tokenizer’s stored codes as fixed assignments, whereas CAP-Mix uses its posterior responsibilities as the assignment prior in Equation (8); neither receives the original content embedding. In PCA-text, every variant initializes its item-specific vectors from the same PCA projection. The hard table uses the tokenizer’s fixed codes, whereas CAP-Mix initializes its prototypes to zero, making its initial table identical to the flat table.

datasetfrom scratch: FLATfrom scratch: CAP-Mixfrom scratch: vs. FLAToffline SID: HARDoffline SID: CAP-Mixoffline SID: vs. HARDPCA-text: FLATPCA-text: HARDPCA-text: CAP-MixPCA-text: vs. FLAT
Beauty5.77<br>ref.5.89<br>+2.08%+2.08%5.80<br>+0.52%6.32<br>+9.53%+8.97%6.69<br>+15.94%6.43<br>+11.44%6.79<br>+17.68%+1.49%
Industrial2.75<br>ref.2.88<br>+4.73%+4.73%3.02<br>+9.82%3.47<br>+26.18%+14.90%3.81<br>+38.55%3.52<br>+28.00%3.79<br>+37.82%−0.52%
Steam8.29<br>ref.8.35<br>+0.72%+0.72%8.32<br>+0.36%8.69<br>+4.83%+4.45%8.13<br>−1.93%8.19<br>−1.21%8.30<br>+0.12%+2.09%

Table 1. Table 1 Item tables across three information regimes. Each cell reports test HR@5 ↑ (top) and change from the dataset’s scratch FLAT anchor (bottom; ref.). The final Δ compares CAP-Mix with FLAT (scratch), HARD (offline SID), or FLAT (PCA-text). HARD uses the same tokenizer; all variants have matched backbones and non-table hyperparameters.

Prototype sharing helps without pretrained content. In from scratch, CAP-Mix improves HR@5 ↑ over the flat table by +2.08% on Beauty, +4.73% on Industrial, and +0.72% on Steam. Thus, shared prototypes learn useful cross-item structure from interactions alone, producing item embeddings that are more effective for next-item ranking than independently parameterized rows.

An offline SID is more useful as a prior than as a fixed assignment. The hard SID table exceeds the scratch anchor on all three datasets, confirming that the tokenizer carries useful information. Given the same tokenizer,

CAP-Mix improves HR@5 ↑ over the hard table by 4.45%–14.90%, showing that differentiable assignments use this information more effectively than frozen one-hot assignments.

Prototype sharing complements the full content embedding. In PCA-TEXT, content seeding already strengthens the flat table on the Amazon datasets. Starting from the same embeddings, CAP-Mix improves it by +1.49% on Beauty and +2.09% on Steam while essentially preserving its Industrial result (−0.52%). In contrast, the hard SID table changes HR@5 ↑ by −3.89% and −7.61% relative to the seeded flat table on the Amazon datasets. Thus, prototype mixtures add cross-item sharing while retaining the unquantized initialization improvement.

Across all three regimes, prototype mixtures improve how continuous item embeddings use the information available by introducing cross-item pooling without quantizing their representations.

RQ2: Comparison with generative recommenders

We compare CAP-Mix with continuous FlowRec (Li et al., [17]), autoregressive TIGER (Rajput et al., [25]), and masked-diffusion MaskGR (Shah et al., [26]) in all three information regimes, selecting one configuration per model and dataset by the validation geometric mean of HR@5 ↑ and NDCG@5 ↑. CAP-Mix and FlowRec use three-item histories; TIGER and MaskGR retain their released 120-token limit and decode one top-20 list with beam search. Appendix § 8 specifies the tokenizers, initializations, resulting item-level history lengths, and decoding protocol.

Table 2 reports the complete-system comparison at k=5k=5, with results at k=10k=10 and 2020 in Appendix § 14. CAP-Mix achieves the highest HR@5 ↑ on all six datasets and the highest or tied-for-highest NDCG@5 ↑ on all six. Averaged across datasets, it improves over the strongest evaluated baseline for each dataset and metric by +6.9% in HR@5 ↑ and +13.6% in NDCG@5 ↑. For CAP-Mix, validation selects PCA-TEXT on five of the six datasets and OFFLINE SID on Steam, suggesting that direct content initialization is generally preferable when the original embeddings are available.

Inference efficiency. At inference, CAP-Mix materializes the composed item embeddings once, so its soft assignments add no per-query computation. Table 3 shows that CAP-Mix consistently requires fewer MFLOP/query ↓\downarrow and achieves higher throughput ↑\uparrow than both discrete baselines across the five profiled datasets. The advantage is largest when the baselines generate multi-code SIDs and narrows for atomic-token configurations. The parameter advantage depends on catalog size: on Yelp, the continuous item table makes CAP-Mix slightly larger than TIGER. Appendix § 8 documents the measurement protocol, and Table 5 reports the full per-dataset measurements.

ML-1MSteamBeautyIndus.Yelp
∣I∣|I|3.4k4.1k12k25k111k
Hot params (M) ↓: table + backbone
CAP-Mix0.4+0.90.5+0.91.5+0.93.3+0.914.2+0.9
TIGER0.9+12.9 10×10\times0.3+12.9 9.1×9.1\times3.1+12.9 6.5×6.5\times0.3+12.9 3.1×3.1\times0.5+12.9 0.9×0.9\times
MaskGR0.4+6.8 5.4×5.4\times0.3+6.8 5.0×5.0\times0.2+6.8 2.8×2.8\times0.3+6.8 1.7×1.7\times14.2+6.8 1.4×1.4\times
MFLOP / query ↓
CAP-Mix6.46.68.612.234.0
TIGER195 30×30\times1,742 265×265\times199 23×23\times1,742 143×143\times1,747 51×51\times
MaskGR43.6 6.8×6.8\times17,435 2,654×2,654\times17,037 1,976×1,976\times10,399 855×855\times126 3.7×3.7\times
Queries/s ↑
CAP-Mix26,93428,75229,24027,8647,688
TIGER5,568 1/4.81/4.84,054 1/7.11/7.17,242 1/4.01/4.04,121 1/6.81/6.84,028 1/1.91/1.9
MaskGR5,634 1/4.81/4.8182 1/1581/158182 1/1611/161242 1/1151/1155,656 1/1.41/1.4
Train GPU-h ↓
CAP-Mix1.460.210.060.081.99
TIGER2.01 1.4×1.4\times0.20 1.0×1.0\times0.53 8.9×8.9\times1.08 13×13\times2.21 1.1×1.1\times
MaskGR2.06 1.4×1.4\times10 49×49\times17 286×286\times47 560×560\times7.59 3.8×3.8\times
Train examples/s ↑
CAP-Mix40,62353,33137,14931,40617,385
TIGER1,616 1/251/252,796 1/191/194,541 1/8.21/8.24,551 1/6.91/6.91,311 1/131/13
MaskGR5,525 1/7.41/7.45,547 1/9.61/9.61,344 1/281/285,552 1/5.71/5.75,995 1/2.91/2.9

Table 5. Inference and training cost at matched input and output: top-20 lists from 3 history items, with TIGER and MaskGR using beam search with width 20. Hot params are those a served model must hold, split as table + backbone (every backbone is constant across datasets). Subscripts give each baseline relative to CAP-Mix and are computed from unrounded measurements. Throughput is measured on one H200 with a batch size of 128 in FP32. Train GPU-h is the estimated cost of training the reported model, computed by dividing the optimizer-step count at the selected checkpoint by a separately measured training rate. the number of tokens per item. Hot params are the parameters a served model must hold, determined by which modules actually fire during an inference batch rather than by the checkpoint size: CAP-Mix materializes its item table xi\mathbf{x}_i once into [∣I∣,D][|I|, D] and discards the codebooks, assignment head, and item features, so it serves at the size of a flat table, whereas a generative decoder has nothing to fold away. MFLOP/query is counted with PyTorch’s flop formulas. Queries/s is wall-clock throughput on one H200 with a batch size of 128 in FP32, measured the same way for every model. We run three independent processes per cell; each contributes one steady-state estimate after warm-up, and we report the median of the three. Within a process we time the decode alone, excluding import and checkpoint load, over 100 batches for the baselines and a 12 s window for CAP-Mix.

RQ3: Robustness and diagnostics

Motivating controls. Appendix § 12 compares hard semantic assignments with random assignments matched in depth, codebook size, and codeword vectors. Without content initialization, semantic assignments win on all three datasets, confirming that they carry useful structure beyond parameter sharing. With PCA initialization, they underperform the flat and random controls on both Amazon datasets, showing that this structure can become restrictive when frozen.

Complementarity with the retrieval prior. Without the co-visitation prior, prototype sharing is beneficial in all regimes on both Amazon datasets and retains a +6.91% HR@5 ↑\uparrow advantage over hard SID on Steam (Table 7), confirming that prototype sharing and the prior are complementary.

datasetfrom scratch FLATfrom scratch CAP-Mixfrom scratch vs.offline SID HARDoffline SID CAP-Mixoffline SID vs.PCA-text FLATPCA-text HARDPCA-text CAP-MixPCA-text vs.
Beauty5.61<br>ref.5.67<br>+1.07%+1.07%5.76<br>+2.67%5.89<br>+4.99%+2.26%6.27<br>+11.76%6.27<br>+11.76%6.50<br>+15.86%+3.67%
Industrial2.64<br>ref.2.81<br>+6.44%+6.44%2.85<br>+7.95%3.21<br>+21.59%+12.63%3.62<br>+37.12%3.51<br>+32.95%3.68<br>+39.39%+1.66%
Steam8.28<br>ref.8.26<br>−0.24%−0.24%7.96<br>−3.86%8.51<br>+2.78%+6.91%8.10<br>−2.17%8.21<br>−0.85%8.14<br>−1.69%+0.49%

Table 7. Controlled results without the co-visitation prior. All values are test HR@5 ↑ (×100). Each variant’s cell gives its absolute score over its relative change from the from-scratch flat table. Each vs. column compares CAP-Mix with that regime’s baseline.

How do gains vary with item frequency? In the FROM SCRATCH regime, the frequency-stratified results are mixed. However, when pretrained tokenizer or content information is available, relative gains are larger for rare targets than for frequent ones in 11 of 12 dataset–comparison–metric combinations for HR@5 ↑\uparrow and NDCG@10 ↑\uparrow, consistent with transfer to less-observed items (Table 8).

scenariobaselinedataset and metricraremediumfrequentalllarger end
FROM SCRATCHFLATBeauty HR@5 ↑+0.2%−1.8%+4.1%+2.1%frequent
Beauty NDCG@10 ↑−3.3%−1.5%+2.9%+0.9%frequent
Industrial HR@5 ↑+5.9%+4.5%+4.4%+4.5%rare
Industrial NDCG@10 ↑+4.6%+1.8%+5.1%+4.5%frequent
OFFLINE SIDHARDBeauty HR@5 ↑+8.5%+8.8%+8.9%+8.8%frequent
Beauty NDCG@10 ↑+10.9%+6.6%+4.8%+6.1%rare
Industrial HR@5 ↑+49.7%+26.6%+10.9%+14.7%rare
Industrial NDCG@10 ↑+56.0%+32.3%+17.1%+20.8%rare
PCA-TEXTFLATBeauty HR@5 ↑+5.2%+3.6%−0.3%+1.4%rare
Beauty NDCG@10 ↑+4.2%+3.1%−0.4%+1.1%rare
Industrial HR@5 ↑+7.1%+2.6%−1.4%−0.3%rare
Industrial NDCG@10 ↑+9.0%+0.8%−2.5%−1.4%rare
PCA-TEXTHARDBeauty HR@5 ↑+10.7%+3.0%+5.4%+5.5%rare
Beauty NDCG@10 ↑+5.3%+3.2%+5.1%+4.6%rare
Industrial HR@5 ↑+15.3%+8.7%+6.9%+7.6%rare
Industrial NDCG@10 ↑+18.8%+9.7%+8.3%+9.0%rare

Table 8. Relative gains by target-item training frequency. Test users are grouped by their target item’s frequency in the training set. Entries are the relative improvement of CAP-Mix over the indicated baseline. Relative gains use unrounded scores and may differ slightly from calculations using displayed values.

Related Work

Discrete generative recommenders and semantic IDs. The discrete branch commonly replaces an atomic item identifier with a semantic ID (SID) by quantizing a pretrained content embedding ([13]). This is generally done through residual schemes that cluster either directly in the embedding space (RQ-KMeans and RQ-GMM ([7] (Tong et al. 2026))) or in a learned latent space (RQ-VAE ([16] (van den Oord et al. 2017))). A recommender then predicts the resulting tuple autoregressively, as in TIGER ([25]), OneRec ([7] (Zhou et al. 2025)), and MiniOneRec ([15]), or through masked discrete diffusion, as in MaskGR ([26]). SIDs provide two distinct benefits. The first, parameter sharing, arises because reusing codewords ties parameters across items and pools supervision from their interactions. The second, semantic transfer, comes from deriving the assignments from pretrained content embeddings, which places semantically related items under shared parameters. Together, these benefits improve generalization ([13] (Singh et al. 2024)). However, an SID exposes only hard code assignments and preserves a partition of the content space rather than its full continuous geometry.

Diffusion and flow recommenders. Continuous generative recommenders replace discrete token prediction with generation in a continuous space. DiffRec (Wang et al. (2023)) denoises a user’s interaction vector, whereas DreamRec (Yang et al. (2023)) and DiffuRec ([19]) diffuse a target item embedding for next-item prediction. FMRec ([22]) and FlowRec ([17]) use flow matching ([20]) to transport a source distribution to the target embedding, with FlowRec conditioning the source on the user’s history. These methods improve the generative dynamics while retaining a flat item table, thereby avoiding discretization into code sequences but forgoing the cross-item parameter sharing induced by shared SID codewords. CAP-Mix retains continuous generation while introducing that sharing through co-adaptive mixtures of prototypes.

Conclusion

We presented CAP-Mix, a flow-based recommender whose item table combines differentiable assignments over shared codebooks with an item-specific vector, all trained jointly with the recommendation objective. The shared codewords introduce explicit cross-item parameter coupling, while the item-specific vectors retain unrestricted per-item degrees of freedom. Across six public benchmarks, CAP-Mix improves average HR@5↑HR@5 \uparrow and NDCG@5↑NDCG@5 \uparrow relative to the strongest evaluated baselines, while providing higher throughput ↑\uparrow than the evaluated discrete baselines.

Dataset details

Sources. Most datasets are taken as RecBole atomic files (Zhao et al., 2021) from the RecSysDatasets1 distribution. Amazon’s Industrial & Scientific and Office are taken directly from the raw Amazon Reviews 2023 website2. Regardless of the source, all datasets are reduced to (user, item, timestamp) triples and then processed through the same code path.

Dataset#Users#Items#InteractionsAvg. lengthMedian inter./itemSparsity (%)Eff. rankVar. kept (%)
Amazon Beauty22,36312,101198,5028.9999.92721973.2
Amazon Industrial & Scientific51,32225,923417,4228.1999.96924073.5
Amazon Office223,99677,6551,810,0318.11199.99021375.0
MovieLens-1M6,0403,416999,611165.514695.15532666.0
Yelp-2022272,547111,2604,185,88515.41499.98627971.3
Steam25,2564,087325,32012.91899.68530467.6

Table 4. Datasets after iterative 5-core filtering. Avg. length is interactions per user, Median inter./item is the median number of interactions a catalog item receives, and sparsity is 1−#interactions/(#users⋅#items)1 - \#\text{interactions}/(\#\text{users}\cdot\#\text{items}). Eff. rank is exp⁡H(p)\exp H(p) over the normalized eigenvalue spectrum of the content embedding, out of 2560, and Var. kept is the share of that variance surviving the projection to DD.

Preprocessing. Every dataset follows the same procedure. First, we apply an iterative kk-core filter (k=5k = 5). Removing a low-count user can push an item below the threshold and vice versa, so we alternately drop users with fewer than kk interactions and items with fewer than kk interactions until a pass removes nothing. Second, each user’s interactions are sorted chronologically by timestamp. Third, we collapse consecutive repeats of the same item and then re-run the kk-core filter, iterating both to a fixed point. Iterating guarantees every surviving user has at least kk distinct items and therefore appears in all three splits. In our experiments, datasets require between 1 and 4 collapse-and-re-core rounds. We then assign dense user and item IDs. Finally, each user’s sequence (i1,…,in)(i_1,\ldots,i_n) is split using a leave-one-out scheme: the test instance is the full sequence with target ini_n, the validation instance is (i1,…,in−1)(i_1,\ldots,i_{n-1}) with target in−1i_{n-1}, and training uses (i1,…,in−2)(i_1,\ldots,i_{n-2}). All model families consume identical item sequences.

Text embedding. Every dataset has a deterministic per-item text template, filled from the item metadata and left empty where a field is missing: Amazon uses Title; Brand; Categories; Price, following TIGER [25]; MovieLens uses Title; Release year; Genres plus the most frequent community tags; Yelp uses Name; City, State; Categories; and Steam uses Title; Developer; Publisher; Genres; Tags. Each string is encoded once with a frozen Qwen3-Embedding-4B (Zhang et al., 2025) using last-token pooling, giving qi∈R2560\mathbf{q}_i \in\mathbb{R}^{2560}.

SID pretraining. The offline SIDs are produced by the balanced RQ-GMM of Appendix § 9. We fit 4 levels with K∈{256,512}K \in\{256,512\}, plus a fifth de-duplication digit that makes identifiers unique. The hard RQ-SID baseline consumes the resulting codes directly, while CAP-Mix consumes the per-level posterior responsibilities as the prior in Equation (8).

Evaluation. Evaluation ranks the target against the full catalog, with no candidate sampling and no filtering of previously seen items, so every model scores all ∣I∣|\mathcal{I}| items for every test user. We report hit rate and normalized discounted cumulative gain. Hit rate (HR@kk ↑\uparrow) is the fraction of users whose held-out item appears among the kk highest-ranked items. Normalized discounted cumulative gain (NDCG@kk ↑\uparrow) additionally rewards placing that item higher within the top kk. We report k∈{5,10,20}k \in\{5, 10, 20\}. The two generative baselines decode differently from CAP-Mix but are scored on the same ranked list: TIGER produces its top-20 by autoregressive beam search over code positions, and MaskGR by beam search over the positions it unmasks. Every number is a mean over three seeds, taken from the checkpoint with the best validation performance in each run.

Implementation details

Architecture and optimization. The history encoder is a bidirectional Transformer with rotary positions, RMSNorm, and pre-norm blocks (4 layers, 4 heads, and hidden dimension D=128D=128), reading the m=3m=3 most recent items as one token each. The time code φ(t)\varphi(t) is produced by passing a 128-dimensional sinusoidal embedding through a two-layer MLP with SiLU activations. The velocity field is a second two-layer SiLU MLP with hidden width 2D=2562D=256, applied to the concatenation of the modulated state and φ(t)\varphi(t). We use neither normalization nor FiLM conditioning:

vθ(xt,t)=MLP⁡([g(xt);φ(t)]),g(xt)={λ⊙xt,λj∼iidN(δ,δ2)during training,δxt,during evaluation,(19)v_\theta(\mathbf{x}_t,t)=\operatorname{MLP}([g(\mathbf{x}_t);\varphi(t)]),\qquad g(\mathbf{x}_t)=\begin{cases} \lambda\odot\mathbf{x}_t,&\lambda_j\mathrel{\overset{\mathrm{iid}}{\sim}}\mathcal{N}(\delta,\delta^2)\quad\text{during training},\\ \delta\mathbf{x}_t,&\text{during evaluation}, \end{cases} \tag*{(19)}

where δ=10−3\delta=10^{-3}. The modulation vector is redrawn for every call during training and replaced by its mean during evaluation. Item features have dimension Df=32D_f=32. The assignment head in Equation (7) uses a separate affine input projection and output projection for each codebook. With T=1T=1, the SS codebook tokens are processed jointly by a single-layer, single-head bidirectional self-attention block. With a residual SID, each of the SS chains contains TT tokens and is processed independently with causal attention following the tokenizer’s level order; the depth-tt prior is shared across chains. We optimize with AdamW at learning rate 10−310^{-3} and no weight decay, use dropout 0.3 on item embeddings and 0.5 on hidden states, and stop early with patience 50. Inference uses N=3N=3 Euler steps.

Hyperparameter search. We fix λcfm=10\lambda_{\mathrm{cfm}}=10 and λalign=1\lambda_{\mathrm{align}}=1, use Optuna’s TPE sampler (Bergstra et al., [3]; Akiba et al., [1]), and select configurations by the three-seed validation geometric mean of HR@5 ↑\uparrow and NDCG@5 ↑\uparrow. We independently sample λmatch\lambda_{\mathrm{match}} log-uniformly from [10−4,4][10^{-4},4], λbal\lambda_{\mathrm{bal}} log-uniformly from [10−4,1][10^{-4},1], and Keff/KK_{\mathrm{eff}}/K log-uniformly from [0.02,1][0.02,1]. We search S∈{1,2,4}S\in\{1,2,4\} in all settings; T=1T=1 by default, whereas T∈{1,2,3}T\in\{1,2,3\} is selected jointly with SS in the offline-SID setting.

PCA-text initialization. Within each run, we fit PCA on the catalog’s 2560-dimensional content embeddings and project them to D=128D=128. We then standardize each projected coordinate across the catalog to zero mean and unit variance, preventing any principal direction from dominating the initialization. For the continuous models, these standardized vectors initialize the trainable item-specific vectors ri\mathbf{r}_i. CAP-Mix initializes every prototype to zero, so Equation (5) gives the same initial item table as the flat PCA-initialized model. For TIGER and MaskGR, we apply the same fitted PCA projection and coordinatewise standardization to the RQ centroids and use the resulting vectors to initialize each level’s codeword embeddings. The de-duplication level has no centroid and remains randomly initialized.

Baseline implementations. We use MaskGR’s official implementation.3 Because its default hyperparameters differ from those reported in its paper, we train both configurations and select between them using the validation criterion from § 4.2. For TIGER, we use the implementation4 provided in GRID (Ju et al., [13]). We supply each with our own SIDs and interaction splits and otherwise keep the published training code untouched. We could not find an official implementation for FlowRec, so we use our own implementation following Li et al. [17] for the flow objective. For fair comparison, we use the same encoder, velocity field, and decoder as CAP-Mix. We fix m=3m=3 for CAP-Mix and FlowRec and do not tune it. TIGER and MaskGR use their released implementations’ maximum input length of 120 tokens. Because an item occupies one token per SID level, including the de-duplication level, the corresponding maximum number of history items varies with the validation-selected SID depth.

Generative baselines across the three scenarios. TIGER and MaskGR consume items as tokens, so a scenario is a choice of tokenizer and of how its token table is initialized. OFFLINE SID uses the RQ-GMM tuple. FROM SCRATCH uses an atomic tokenizer, one level assigning item ii, the token ii, so the token table is ∣I∣|\mathcal{I}| rows learned from interactions alone. PCA-TEXT uses the RQ-GMM tuple with the PCA-initialized codeword rows described above.

Measuring inference cost. All five dataset columns of Table 5 describe the same query: every model is given the m=3m=3 most recent items, which for a token-based baseline means an input sequence of length 3nh3n_h, where nhn_h is

Measuring training cost. Table 5 also reports training cost. Optimizer steps come from the checkpoint that produced the reported result; the rate is measured separately from the elapsed-time difference between training-only runs stopped at N1N_1 and N2N_2 steps, excluding validation. GPU-hours are estimated by dividing the selected checkpoint’s optimizer-step count by this rate. All cells use one H200 with identical dataloader-worker and CPU allocations, and we report examples/s to account for differences in effective batch size. GPU-hours are implementation-bound: for TIGER and MaskGR, we use the unmodified implementations.

Balanced RQ-GMM

Why the balanced variant. RQ-GMM (Tong et al., 2026) fits each residual level by soft EM [6], which places no constraint on how item mass is distributed over the KK components, and in some of our experiments a few components absorb most of the catalog. Because an item’s identifier is the LL-tuple (ci(1),…,ci(L))(c_i^{(1)}, \ldots, c_i^{(L)}), an unbalanced level shrinks the effective identifier space, so more items collide on the same tuple and the clustering the SID is meant to provide degrades. We therefore replace the soft EM by a hard-assignment classification EM, which imposes the constraint where the decision is actually made. The soft responsibility then plays no part in the fit at all: it survives only as a read-time quantity, the prior in Equation (23).

The quantizer. Let {qi}i=1N\{\mathbf{q}_i\}_{i=1}^{N} be the item embeddings and ei(1)=qi\mathbf{e}_i^{(1)}=\mathbf{q}_i. Level ss models the residual left by the levels above it with a KK-component diagonal Gaussian mixture whose means form that level’s codebook, and passes on ei(s+1)=ei(s)−μci(s)(s)\mathbf{e}_i^{(s+1)}=\mathbf{e}_i^{(s)}-\boldsymbol{\mu}_{c_i^{(s)}}^{(s)}. Writing ωk(s)\omega_k^{(s)} for the mixing coefficients, the cost of placing a residual e\mathbf{e} in component kk is its negative log-likelihood,

ψk(s)(e)=−log⁡ωk(s)+12∑j=1d[(ej−μk,j(s))2(σk,j(s))2+log⁡(σk,j(s))2],(20)\psi_k^{(s)}(\mathbf{e})=-\log\omega_k^{(s)}+\frac{1}{2}\sum_{j=1}^{d}\left[\frac{(e_j-\mu_{k,j}^{(s)})^2}{(\sigma_{k,j}^{(s)})^2}+\log(\sigma_{k,j}^{(s)})^2\right], \tag*{(20)}

up to a constant that does not depend on kk. Each level is fitted by a classification EM (Celeux and Govaert, [5]), which alternates between a hard assignment and a maximum-likelihood update, and it is the assignment step that carries the size constraint:

min⁡z∈{0,1}N×K∑i=1N∑k=1Kzikψk(s)(ei(s))s.t.∑kzik=1 ∀i,nmin⁡≤∑izik≤nmax⁡ ∀k,(21)\min_{\mathbf{z}\in\{0,1\}^{N\times K}}\sum_{i=1}^{N}\sum_{k=1}^{K}z_{ik}\psi_k^{(s)}(\mathbf{e}_i^{(s)})\quad\text{s.t.}\quad\sum_k z_{ik}=1\ \forall i,\qquad n_{\min}\le\sum_i z_{ik}\le n_{\max}\ \forall k, \tag*{(21)}

with nmin⁡=max⁡(1,⌊N/K⌋−1)n_{\min}=\max(1,\lfloor N/K\rfloor-1) and nmax⁡=⌊N/K⌋+1n_{\max}=\lfloor N/K\rfloor+1. Without the size bounds, Equation (21) separates per item and returns the maximum a posteriori (MAP) code; with them it is a transportation problem, which we solve exactly as a minimum-cost flow. This extends the constrained kk-means of Bradley et al. [4], who impose a minimum cluster size and solve the resulting assignment step as a minimum-cost flow. We add the upper bound nmax⁡n_{\max} and use the mixture cost Equation (20) in place of squared Euclidean distance, so the assignment remains an exact minimum-cost flow while the cost stays a likelihood.

The M-step is the maximum-likelihood update of a diagonal mixture under the hard partition Ck={i:zik=1}C_k=\{i:z_{ik}=1\},

μk(s)=1∣Ck∣∑i∈Ckei(s),(σk(s))2=1∣Ck∣∑i∈Ck(ei(s)−μk(s))2+ε,ωk(s)=∣Ck∣N,(22)\mu_k^{(s)}=\frac{1}{|C_k|}\sum_{i\in C_k}\mathbf{e}_i^{(s)},\qquad(\sigma_k^{(s)})^2=\frac{1}{|C_k|}\sum_{i\in C_k}(\mathbf{e}_i^{(s)}-\boldsymbol{\mu}_k^{(s)})^2+\varepsilon,\qquad\omega_k^{(s)}=\frac{|C_k|}{N}, \tag*{(22)}

with a covariance ridge ε=10−6\varepsilon=10^{-6} added to every variance so Equation (20) does not send the cost to infinity on coordinates without spread. Each level is initialized with one short run of unconstrained kk-means (kk-means++ seeding (Arthur and Vassilvitskii, [2]), at most 50 Lloyd steps (Lloyd, [23])) and iterated until the assigned cost ∑iψci(s)(s)(ei(s))\sum_i\psi_{c_i^{(s)}}^{(s)}(\mathbf{e}_i^{(s)}) changes by less than 10−410^{-4} relatively or fewer than 0.1% of items are reassigned, with a cap of 200 iterations. After reaching either stopping criterion or the iteration limit, we fix the resulting assignments, update the residuals, and fit the next level. Balance therefore holds by construction at every level: no code group differs from ⌊N/K⌋\lfloor N/K\rfloor by more than one, whatever the scale of the embedding. A final de-duplication digit, ranking the items inside each colliding LL-tuple, makes the full identifier unique.

Use as a prior. The hard RQ-SID baseline consumes the codes ci(s)c_i^{(s)} directly. CAP-Mix instead consumes the level-ss responsibility, the posterior over the KK components given the residual,

γi(s)=softmax⁡k(−ψk(s)(ei(s))),ρi(s)=softmax⁡k(−ψk(s)(ei(s))/τρ),(23)\gamma_i^{(s)}=\operatorname{softmax}_k\left(-\psi_k^{(s)}(\mathbf{e}_i^{(s)})\right),\qquad \rho_i^{(s)}=\operatorname{softmax}_k\left(-\psi_k^{(s)}(\mathbf{e}_i^{(s)})/\tau_\rho\right), \tag*{(23)}

where ρi(s)\rho_i^{(s)} is the tempered version that Equation (8) uses. Since ψ\psi sums over the dd embedding dimensions, its spread across components grows with dd, so τρ\tau_\rho also scales with dd. We use τρ=400\tau_\rho=400 at d=2560d=2560. The residual path in Equation (23) is the greedy one, ei(s+1)=ei(s)−μk∗(s)\mathbf{e}_i^{(s+1)}=\mathbf{e}_i^{(s)}-\boldsymbol{\mu}_{k^*}^{(s)} with k∗=arg max⁡kγi(s)[k]k^*=\operatorname*{arg\,max}_k\gamma_i^{(s)}[k]. Thus, the mode of γi(s)\gamma_i^{(s)} is not always the stored code ci(s)c_i^{(s)}, although they agree for most items. For example, on Beauty, they coincide for 92–94% of items at each level. Feeding the responsibility rather than the code is what lets the tokenizer prior carry its uncertainty.

The two priors

CAP-Mix injects external knowledge in two places: a tokenizer prior on which codes are assigned to an item (Equation (8)) and a co-visitation prior on which item to retrieve (Equation (12)). Both follow the same rule, which this appendix states once, justifies, and then instantiates in both settings.

The rule. Let qθ∝exp⁡(ℓ)q_\theta\propto\exp(\ell) be a softmax over a finite set with learned logits ℓ\ell, and let π\pi be a prior belief over that same set. Multiplying the two and renormalizing,

p∝exp⁡(ℓ)⋅πw,equivalentlylog⁡p=ℓ+wlog⁡π+const,(24)p \propto\exp(\ell)\cdot\pi^w,\qquad\text{equivalently}\qquad\log p=\ell+w\log\pi+\text{const}, \tag*{(24)}

so adding a scaled log-prior to the logits is equivalent to multiplying the two beliefs, with ww weighting the prior. This is log-linear pooling. The trust w≥0w\geq0 interpolates from discarding the prior (w=0w=0) to collapsing pp onto arg max⁡π\operatorname{arg\,max}\pi (w→∞w\to\infty).

Why not mix probabilities. What separates Equation (24) from the obvious alternative p=(1−β)qθ+βπp=(1-\beta)q_\theta+\beta\pi is that any finite ww leaves the hypothesis class unchanged. That is, provided the prior has full support, Equation (8) can be overridden by evidence: the learned logits can add an arbitrary vector, so every interior point of Δ\Delta stays reachable. The persistent prior therefore biases the parameterization and optimization without restricting the reachable distributions. To ensure full support, we add ϵρ\epsilon_\rho inside the log of Equation (8) and mix the graph prior with the uniform distribution in Equation (25). A prior that is exactly zero on an outcome removes it at any w>0w>0. In contrast, the alternative linear mixing at a fixed β>0\beta>0 restricts pp, since pk≥βπkp_k\geq\beta\pi_k no matter the learned evidence.

Instance 1: the tokenizer prior on codes. At depth tt, the learned evidence for chain ss is ℓ=ϕs,t(fi)\ell=\phi_{s,t}(f_i). The tokenizer supplies the same prior to every chain at that depth: the responsibility that the fitted quantizer places on each of its KK Gaussians for item ii, denoted γi(t)\gamma_i^{(t)}, (Appendix § 9). This is not a hand-built pseudo-count but an exact posterior under a fitted GMM generative model. It is read along a greedy residual path rather than the balanced assignment the quantizer was fitted with, so its mode need not be the stored code.

We use the tempered responsibility ρi(t)\rho_i^{(t)} defined in Equation (23) as the prior in Equation (8), with αt\alpha_t controlling its influence.

Instance 2: the co-visitation prior on items. Here the set is the catalog I\mathcal{I}, the evidence is the inner product ℓ=uTxi\ell=\mathbf{u}^{\mathsf{T}}\mathbf{x}_i against the shared item table, and the prior is π=g~(i∣H)\pi=\tilde{g}(i\mid H) with trust ww, yielding Equation (12). Equation (12) thus makes explicit a prior that a plain dot-product softmax leaves implicit. We build g~\tilde{g} once from the training sequences in three steps:

P=D−1C,D=diag⁡(C1);g^H=qHPKs∥qHPKs∥1;g~=(1−β)1∣I∣1+βg^H.(25)P=D^{-1}C,\qquad D=\operatorname{diag}(C\mathbf{1});\qquad\widehat{g}_H=\frac{q_H P^{K_s}}{\lVert q_H P^{K_s}\rVert_1};\qquad\tilde{g}=(1-\beta)\frac{1}{|\mathcal{I}|}\mathbf{1}+\beta\widehat{g}_H. \tag*{(25)}

First, CijC_{ij} counts how often items ii and jj occur in the same training sequence, and row-normalizing turns those counts into conditional frequencies: PijP_{ij} estimates how likely jj is to appear given that ii does, so every row is a distribution over the catalog and PP is the transition kernel of a random walk on the item graph. Second, we summarize the history by a recency-weighted distribution qHq_H, which puts mass only on items with which the user interacted, weighted according to recency: the item at age aa (most recent a=0a=0) gets weight ∝ηa\propto\eta^a, repeats accumulate, and the result is L1L_1-normalized. Applying the kernel KsK_s times lets that mass flow outward along co-occurrence edges as a KsK_s-step random walk, so g^H[j]\widehat{g}_H[j] is large when jj co-occurs strongly with what the user recently touched. Third, a raw g^H\widehat{g}_H can place zero mass on an unseen (context, item) pair, which would veto that item outright, however strong the evidence. Thus, to ensure full support, we temper it toward the uniform distribution. For 0≤β<10\leq\beta<1, this keeps log⁡g~\log\tilde{g} finite; β=0\beta=0 ignores the graph, whereas β=1\beta=1 trusts it fully but can contain zero-probability outcomes.

Only ww and β\beta are tuned; all other settings use fixed defaults that are identical everywhere and never searched: whole-sequence symmetric counts with no self-loops, η=0.5\eta=0.5, Ks=1K_s=1 (so only direct neighbors receive mass), and the same truncated history the encoder reads, which at m=3m=3 gives qH=(0.571, 0.286, 0.143)q_H=(0.571,\,0.286,\,0.143) from newest to oldest. The same log-prior is added to the training logits of both cross-entropies, so the model learns to complement the prior.

Gradient coupling induced by prototype sharing

Let V=∣I∣V=|\mathcal{I}|, and stack the item embeddings and item-specific vectors into X,R∈RV×DX,R\in\mathbb{R}^{V\times D}. For chain ss and depth tt, let A(s,t)∈RV×KA^{(s,t)}\in\mathbb{R}^{V\times K} and C(s,t)∈RK×DC^{(s,t)}\in\mathbb{R}^{K\times D}. To isolate the direct effect of prototype sharing, hold the assignments fixed and consider a loss component L(X)\mathcal{L}(\mathbf{X}) whose dependence on R\mathbf{R} and C(s,t)\mathbf{C}^{(s,t)} is only through X\mathbf{X}. Let G=∇XL\mathbf{G}=\nabla_{\mathbf{X}}\mathcal{L}.

X=R+γS∑s,tA(s,t)C(s,t),∇C(s,t)L=γSA(s,t)TG,∇RL=G.(26)\mathbf{X}=\mathbf{R}+\frac{\gamma}{S}\sum_{s,t}\mathbf{A}^{(s,t)}\mathbf{C}^{(s,t)},\qquad\nabla_{\mathbf{C}^{(s,t)}}\mathcal{L}=\frac{\gamma}{S}\mathbf{A}^{(s,t)\mathsf{T}}\mathbf{G},\qquad\nabla_{\mathbf{R}}\mathcal{L}=\mathbf{G}. \tag*{(26)}

Consider one gradient-descent step with learning rate η\eta, and let ΔX\Delta\mathbf{X} denote the resulting change in the item table. Equation (26) gives

ΔR=−ηG,ΔC(s,t)=−ηγSA(s,t)TG.(27)\Delta\mathbf{R}=-\eta\mathbf{G},\qquad\Delta\mathbf{C}^{(s,t)}=-\eta\frac{\gamma}{S}\mathbf{A}^{(s,t)\mathsf{T}}\mathbf{G}. \tag*{(27)}

Because the assignments are fixed, substituting these parameter updates into the composed table gives

ΔX=ΔR+γS∑s,tA(s,t)ΔC(s,t)=−ηG−ηγ2S2∑s,tA(s,t)A(s,t)TG=−η(IV+K)G,K=γ2S2∑s,tA(s,t)A(s,t)T,(28)\begin{aligned} \Delta\mathbf{X}&=\Delta\mathbf{R}+\frac{\gamma}{S}\sum_{s,t}\mathbf{A}^{(s,t)}\Delta\mathbf{C}^{(s,t)}\\ &=-\eta\mathbf{G}-\eta\frac{\gamma^2}{S^2}\sum_{s,t}\mathbf{A}^{(s,t)}\mathbf{A}^{(s,t)\mathsf{T}}\mathbf{G}\\ &=-\eta(\mathbf{I}_V+\mathbf{K})\mathbf{G},\qquad\mathbf{K}=\frac{\gamma^2}{S^2}\sum_{s,t}\mathbf{A}^{(s,t)}\mathbf{A}^{(s,t)\mathsf{T}}, \tag*{(28)} \end{aligned}

where IV∈RV×V\mathbf{I}_V\in\mathbb{R}^{V\times V} is the identity matrix. Consequently,

Kij=γ2S2∑s,t⟨Ai(s,t),Aj(s,t)⟩,(29)K_{ij}=\frac{\gamma^2}{S^2}\sum_{s,t}\left\langle A_i^{(s,t)},A_j^{(s,t)}\right\rangle, \tag*{(29)}

which couples item updates in proportion to assignment overlap, while the identity term IV\mathbf{I}_V preserves a direct item-specific update. This analysis isolates the direct representation path with fixed assignments, while the complete model additionally learns the assignments and contains losses that depend explicitly on the prototypes.

Diagnostic results

Table 6 separates the semantic information in the RQ-SID assignments from the parameter sharing induced by the codebook. The random control preserves the table structure, depth, codebook size, and codeword vectors while randomly permuting the item-to-code assignments.

In the FROM SCRATCH regime, the hard RQ-SID table improves HR@5 ↑ over the flat table on all three datasets, whereas matched random assignments yield smaller gains or a loss. This isolates useful semantic structure in the pretrained assignments beyond parameter sharing alone. With PCA-TEXT initialization, freezing the content embeddings causes losses ranging from 14.15% to 20.21%. On the two Amazon datasets, hard semantic assignments also underperform both the trainable flat table and the random-assignment control, suggesting

Full results

that a fixed semantic partition can conflict with the recommendation objective once the continuous content representation is available. This motivates using the tokenizer to initialize differentiable assignments that can be optimized jointly with the recommender. On Steam, PCA initialization itself reduces performance, while hard and random assignments produce similar gains below 1%; we hypothesize that the content embedding is less informative for next-item prediction on this dataset, causing its semantic partition to behave similarly to random sharing.

Removing the co-visitation prior. Table 7 repeats the scenario study with the co-visitation prior disabled for every variant. On Beauty and Industrial, CAP-Mix remains above the corresponding baseline in all three regimes. On Steam, it is essentially flat relative to the baseline in FROM SCRATCH and PCA-TEXT, but retains a +6.91% HR@5 ↑ advantage over the hard table in OFFLINE SID. These results show that the gradient-pooling benefit from our prototype mixtures is complementary to the retrieval prior.

Frequency stratification. We group test users by the training frequency of their target item, without splitting users whose targets have the same frequency. The resulting approximately equal-mass groups contain 22,363 Beauty users (rare: at most 6 interactions; medium: 7–22; frequent: more than 22) and 51,322 Industrial users (rare: at most 7; medium: 8–28; frequent: more than 28). Table 8 reports the relative gain within each group.

Full results

Table 9 summarizes all evaluation cutoffs for the validation-selected configuration of each model and dataset. Table 10–Table 15 then give the complete per-dataset results across all model families, initializations, and metrics.

Beauty HR@5Beauty N@5Beauty HR@10Beauty N@10Beauty HR@20Beauty N@20Indus. HR@5Indus. N@5Indus. HR@10Indus. N@10Indus. HR@20Indus. N@20
FlowRec6.27p±0.186.27^{p} \pm0.184.03±0.034.03 \pm0.039.52±0.229.52 \pm0.225.07±0.055.07 \pm0.0513.52±0.4113.52 \pm0.416.08±0.106.08 \pm0.103.62p±0.023.62^{p} \pm0.022.04±0.032.04 \pm0.035.54±0.045.54 \pm0.042.66±0.042.66 \pm0.048.03±0.048.03 \pm0.043.28±0.043.28 \pm0.04
TIGER3.51s±0.073.51^{s} \pm0.072.54±0.052.54 \pm0.054.92±0.094.92 \pm0.092.99±0.052.99 \pm0.056.90±0.216.90 \pm0.213.49±0.083.49 \pm0.082.05p±0.032.05^{p} \pm0.031.34±0.021.34 \pm0.023.25±0.033.25 \pm0.031.73±0.021.73 \pm0.024.61±0.014.61 \pm0.012.08±0.012.08 \pm0.01
MaskGR5.06i±0.135.06^{i} \pm0.133.28±0.123.28 \pm0.128.11±0.158.11 \pm0.154.27±0.124.27 \pm0.1212.10±0.1612.10 \pm0.165.29±0.095.29 \pm0.093.46p±0.033.46^{p} \pm0.032.24±0.032.24 \pm0.035.25±0.065.25 \pm0.062.82±0.022.82 \pm0.027.46±0.077.46 \pm0.073.38±0.013.38 \pm0.01
CAP-Mix6.79p±0.066.79^{p} \pm0.064.73±0.044.73 \pm0.049.75±0.069.75 \pm0.065.69±0.045.69 \pm0.0413.53±0.1713.53 \pm0.176.64±0.076.64 \pm0.073.79p±0.013.79^{p} \pm0.012.34±0.032.34 \pm0.035.77±0.025.77 \pm0.022.98±0.022.98 \pm0.028.36±0.088.36 \pm0.083.63±0.043.63 \pm0.04
Δ\Delta (%)+8.3%+17.4%+2.4%+12.2%+0.1%+9.2%+4.7%+4.5%+4.2%+5.7%+4.1%+7.4%
Steam HR@5Steam N@5Steam HR@10Steam N@10Steam HR@20Steam N@20ML-1M HR@5ML-1M N@5ML-1M HR@10ML-1M N@10ML-1M HR@20ML-1M N@20
FlowRec8.28s±0.338.28^{s} \pm0.335.37±0.305.37 \pm0.3013.54±0.3113.54 \pm0.317.06±0.297.06 \pm0.2920.61±0.3520.61 \pm0.358.84±0.308.84 \pm0.3015.36p±0.2015.36^{p} \pm0.2010.14±0.1210.14 \pm0.1222.94±0.0422.94 \pm0.0412.58±0.0512.58 \pm0.0532.68±0.1432.68 \pm0.1415.03±0.0915.03 \pm0.09
TIGER8.43i±0.108.43^{i} \pm0.105.01±0.035.01 \pm0.0313.28±0.6313.28 \pm0.636.57±0.196.57 \pm0.1920.46±1.0720.46 \pm1.078.36±0.248.36 \pm0.2412.59s±0.4012.59^{s} \pm0.408.47±0.288.47 \pm0.2819.03±0.3719.03 \pm0.3710.54±0.2810.54 \pm0.2827.20±0.6827.20 \pm0.6812.61±0.3612.61 \pm0.36
MaskGR8.64p±0.008.64^{p} \pm0.005.57±0.015.57 \pm0.0114.43±0.0514.43 \pm0.057.42±0.027.42 \pm0.0220.97±0.2320.97 \pm0.239.08±0.079.08 \pm0.0715.64s±0.4015.64^{s} \pm0.4010.23±0.2810.23 \pm0.2823.61±0.2923.61 \pm0.2912.79±0.2612.79 \pm0.2633.93±0.1733.93 \pm0.1715.39±0.2115.39 \pm0.21
CAP-Mix8.69i±0.298.69^{i} \pm0.295.57±0.195.57 \pm0.1913.94±0.3213.94 \pm0.327.25±0.207.25 \pm0.2020.82±0.4220.82 \pm0.428.99±0.238.99 \pm0.2317.25p±0.1317.25^{p} \pm0.1311.71±0.1111.71 \pm0.1124.71±0.3824.71 \pm0.3814.11±0.1714.11 \pm0.1733.98±0.3433.98 \pm0.3416.44±0.1516.44 \pm0.15
Δ\Delta (%)+0.6%0.0%−3.4%−2.3%−0.7%−1.0%+10.3%+14.5%+4.7%+10.3%+0.1%+6.8%
Yelp HR@5Yelp N@5Yelp HR@10Yelp N@10Yelp HR@20Yelp N@20Office HR@5Office N@5Office HR@10Office N@10Office HR@20Office N@20
FlowRec2.98p±0.052.98^{p} \pm0.051.86±0.031.86 \pm0.035.10±0.055.10 \pm0.052.54±0.032.54 \pm0.038.34±0.068.34 \pm0.063.35±0.043.35 \pm0.042.90p±0.022.90^{p} \pm0.021.67±0.021.67 \pm0.024.41±0.044.41 \pm0.042.15±0.022.15 \pm0.026.23±0.026.23 \pm0.022.61±0.022.61 \pm0.02
TIGER1.29p±0.071.29^{p} \pm0.070.80±0.040.80 \pm0.042.09±0.092.09 \pm0.091.06±0.041.06 \pm0.043.03±0.103.03 \pm0.101.30±0.041.30 \pm0.041.52p±0.011.52^{p} \pm0.010.98±0.010.98 \pm0.012.33±0.032.33 \pm0.031.25±0.001.25 \pm0.003.34±0.083.34 \pm0.081.50±0.021.50 \pm0.02
MaskGR2.99s±0.042.99^{s} \pm0.041.87±0.031.87 \pm0.035.10±0.075.10 \pm0.072.54±0.032.54 \pm0.038.24±0.068.24 \pm0.063.33±0.043.33 \pm0.042.29s±0.022.29^{s} \pm0.021.53±0.011.53 \pm0.013.40±0.033.40 \pm0.031.89±0.021.89 \pm0.024.88±0.034.88 \pm0.032.26±0.012.26 \pm0.01
CAP-Mix3.18p±0.023.18^{p} \pm0.022.03±0.022.03 \pm0.025.25±0.045.25 \pm0.042.70±0.032.70 \pm0.038.38±0.058.38 \pm0.053.48±0.033.48 \pm0.033.22p±0.013.22^{p} \pm0.012.28±0.012.28 \pm0.014.41±0.014.41 \pm0.012.66±0.012.66 \pm0.015.84±0.035.84 \pm0.033.02±0.013.02 \pm0.01
Δ\Delta (%)+6.4%+8.6%+2.9%+6.3%+0.5%+3.9%+11.0%+36.5%0.0%+23.7%−6.3%+15.7%

Table 9. Full cross-dataset results, HR@k ↑ and NDCG@k ↑ (mean±std, ×100). Each model and dataset uses the configuration selected by the validation geometric mean of HR@5 ↑ and NDCG@5 ↑; the same run supplies every cutoff. Superscripts denote s^{s} scratch, i^{i} offline SID, and p^{p} PCA-text. Bold = best, underline = 2nd per column, and Δ\Delta compares CAP-Mix with the strongest baseline.

Table 10. Beauty — full results. All families ×\times initializations. Bold = best, underline = 2nd per column within an initialization block; CAP-Mix shows Δ%\Delta\% vs. the best baseline. FlowRec has no offline SID variant, since a flat table has no codes to consume, so the row marked †{}^{\dagger} repeats its from scratch numbers.

beautymodelHR@5HR@10HR@20N@5N@10N@20
scratchFlowRec5.61±\pm0.028.01±\pm0.0510.90±\pm0.203.86±\pm0.024.63±\pm0.035.36±\pm0.06
TIGER3.51±\pm0.074.92±\pm0.096.90±\pm0.212.54±\pm0.052.99±\pm0.053.49±\pm0.08
MaskGR4.38±\pm0.166.48±\pm0.199.33±\pm0.092.99±\pm0.143.66±\pm0.144.38±\pm0.12
CAP-Mix5.89±\pm0.04 +4.99%8.28±\pm0.05 +3.37%11.30±\pm0.01 +3.67%4.21±\pm0.01 +9.07%4.98±\pm0.01 +7.56%5.75±\pm0.01 +7.28%
SIDFlowRec†{}^{\dagger}5.61±\pm0.028.01±\pm0.0510.90±\pm0.203.86±\pm0.024.63±\pm0.035.36±\pm0.06
TIGER3.48±\pm0.145.33±\pm0.158.00±\pm0.132.30±\pm0.142.89±\pm0.143.56±\pm0.14
MaskGR5.06±\pm0.138.11±\pm0.1512.10±\pm0.163.28±\pm0.124.27±\pm0.125.29±\pm0.09
CAP-Mix6.32±\pm0.10 +12.66%8.72±\pm0.08 +7.52%11.96±\pm0.10) −1.16%4.51±\pm0.05 +16.84%5.28±\pm0.03 +14.04%6.10±\pm0.00 +13.81%
PCAFlowRec6.27±\pm0.189.52±\pm0.2213.52±\pm0.414.03±\pm0.035.07±\pm0.056.08±\pm0.10
TIGER3.39±\pm0.095.45±\pm0.198.30±\pm0.182.24±\pm0.062.90±\pm0.093.62±\pm0.08
MaskGR5.05±\pm0.137.93±\pm0.0511.97±\pm0.133.26±\pm0.134.19±\pm0.105.22±\pm0.06
CAP-Mix6.79±\pm0.06 +8.29%9.75±\pm0.06 +2.42%13.53±\pm0.17 +0.07%4.73±\pm0.04 +17.37%5.69±\pm0.04 +12.23%6.64±\pm0.07 +9.21%
officemodelHR@5HR@10HR@20N@5N@10N@20
scratchFlowRec2.11±0.062.11 \pm0.063.09±0.073.09 \pm0.074.33±0.124.33 \pm0.121.40±0.031.40 \pm0.031.71±0.031.71 \pm0.032.03±0.052.03 \pm0.05
TIGER0.76±0.010.76 \pm0.011.09±0.021.09 \pm0.021.67±0.101.67 \pm0.100.48±0.020.48 \pm0.020.59±0.020.59 \pm0.020.74±0.020.74 \pm0.02
MaskGR2.29±0.022.29 \pm0.023.40±0.033.40 \pm0.034.88±0.034.88 \pm0.031.53±0.011.53 \pm0.011.89±0.021.89 \pm0.022.26±0.012.26 \pm0.01
CAP-Mix2.72±0.012.72 \pm0.01 +18.78%+18.78\%3.50±0.013.50 \pm0.01 +2.94%+2.94\%4.49±0.034.49 \pm0.03 −7.99%-7.99\%2.00±0.012.00 \pm0.01 +30.72%+30.72\%2.25±0.012.25 \pm0.01 +19.05%+19.05\%2.50±0.012.50 \pm0.01 +10.62%+10.62\%
SIDFlowRec†2.11±0.062.11 \pm0.063.09±0.073.09 \pm0.074.33±0.124.33 \pm0.121.40±0.031.40 \pm0.031.71±0.031.71 \pm0.032.03±0.052.03 \pm0.05
TIGER1.47±0.071.47 \pm0.072.26±0.112.26 \pm0.113.17±0.163.17 \pm0.160.95±0.040.95 \pm0.041.20±0.051.20 \pm0.051.43±0.071.43 \pm0.07
MaskGR2.39±0.012.39 \pm0.013.56±0.043.56 \pm0.044.88±0.054.88 \pm0.051.59±0.021.59 \pm0.021.96±0.021.96 \pm0.022.30±0.032.30 \pm0.03
CAP-Mix2.95±0.032.95 \pm0.03 +23.43%+23.43\%4.13±0.054.13 \pm0.05 +16.01%+16.01\%5.65±0.075.65 \pm0.07 +15.78%+15.78\%2.07±0.022.07 \pm0.02 +30.19%+30.19\%2.45±0.022.45 \pm0.02 +25.00%+25.00\%2.84±0.032.84 \pm0.03 +23.48%+23.48\%
PCAFlowRec2.90±0.022.90 \pm0.024.41±0.044.41 \pm0.046.23±0.026.23 \pm0.021.67±0.021.67 \pm0.022.15±0.022.15 \pm0.022.61±0.022.61 \pm0.02
TIGER1.52±0.011.52 \pm0.012.33±0.032.33 \pm0.033.34±0.083.34 \pm0.080.98±0.010.98 \pm0.011.25±0.001.25 \pm0.001.50±0.021.50 \pm0.02
MaskGR2.16±0.022.16 \pm0.023.24±0.013.24 \pm0.014.48±0.014.48 \pm0.011.42±0.011.42 \pm0.011.77±0.011.77 \pm0.012.08±0.012.08 \pm0.01
CAP-Mix3.22±0.013.22 \pm0.01 +11.03%+11.03\%4.41±0.014.41 \pm0.01 0.00%0.00\%5.84±0.035.84 \pm0.03 −6.26%-6.26\%2.28±0.012.28 \pm0.01 +36.53%+36.53\%2.66±0.012.66 \pm0.01 +23.72%+23.72\%3.02±0.013.02 \pm0.01 +15.71%+15.71\%

Table 15. Amazon Office — full results. Conventions as in Table 10.

Table 11. Industrial & Scientific — full results. Conventions as in Table 10.

industrialmodelHR@5HR@10HR@20N@5N@10N@20
scratchFlowRec2.64±\pm0.004.04±\pm0.035.91±\pm0.091.49±\pm0.011.94±\pm0.012.41±\pm0.02
TIGER1.61±\pm0.052.60±\pm0.104.01±\pm0.131.05±\pm0.031.37±\pm0.051.72±\pm0.06
MaskGR2.36±\pm0.023.63±\pm0.025.47±\pm0.021.58±\pm0.011.99±\pm0.012.45±\pm0.01
CAP-Mix2.88±\pm0.01 +9.09%4.15±\pm0.07 +2.72%5.82±\pm0.05 −1.52%2.00±\pm0.00 +26.58%2.41±\pm0.02 +21.11%2.83±\pm0.02 +15.51%
SIDFlowRec†{}^{\dagger}2.64±\pm0.004.04±\pm0.035.91±\pm0.091.49±\pm0.011.94±\pm0.012.41±\pm0.02
TIGER2.01±\pm0.053.20±\pm0.034.62±\pm0.061.32±\pm0.031.70±\pm0.022.06±\pm0.02
MaskGR3.30±\pm0.055.19±\pm0.077.41±\pm0.072.14±\pm0.022.75±\pm0.033.31±\pm0.03
CAP-Mix3.47±\pm0.02 +5.15%5.17±\pm0.00 −0.39%7.50±\pm0.04 +1.21%2.29±\pm0.02 +7.01%2.84±\pm0.02 +3.27%3.43±\pm0.02 +3.63%
PCAFlowRec3.62±\pm0.025.54±\pm0.048.03±\pm0.042.04±\pm0.032.66±\pm0.043.28±\pm0.04
TIGER2.05±\pm0.033.25±\pm0.034.61±\pm0.011.34±\pm0.021.73±\pm0.022.08±\pm0.01
MaskGR3.46±\pm0.035.25±\pm0.067.46±\pm0.072.24±\pm0.032.82±\pm0.023.38±\pm0.01
CAP-Mix3.79±\pm0.01 +4.70%5.77±\pm0.02 +4.15%8.36±\pm0.08 +4.11%2.34±\pm0.03 +4.46%2.98±\pm0.02 +5.67%3.63±\pm0.04 +7.40%

Table 12. Steam — full results. Conventions as in Table 10.

steammodelHR@5HR@10HR@20N@5N@10N@20
scratchFlowRec8.28±\pm0.3313.54±\pm0.3120.61±\pm0.355.37±\pm0.307.06±\pm0.298.84±\pm0.30
TIGER7.94±\pm0.1713.18±\pm0.2421.20±\pm1.594.90±\pm0.076.59±\pm0.078.58±\pm0.38
MaskGR8.52±\pm0.1714.21±\pm0.1920.94±\pm0.055.58±\pm0.187.40±\pm0.199.11±\pm0.16
CAP-Mix8.35±\pm0.31 −2.00%14.15±\pm0.19 −0.42%21.09±\pm0.05 −0.52%5.16±\pm0.17 −7.53%7.02±\pm0.18 −5.14%8.77±\pm0.14 −3.73%
SIDFlowRec†{}^{\dagger}8.28±\pm0.3313.54±\pm0.3120.61±\pm0.355.37±\pm0.307.06±\pm0.298.84±\pm0.30
TIGER8.43±\pm0.1013.28±\pm0.6320.46±\pm1.075.01±\pm0.036.57±\pm0.198.36±\pm0.24
MaskGR8.64±\pm0.0914.43±\pm0.2420.64±\pm0.235.54±\pm0.077.40±\pm0.148.97±\pm0.13
CAP-Mix8.69±\pm0.09 +0.58%13.94±\pm0.24 −3.40%20.82±\pm0.04 +0.87%5.57±\pm0.04 +0.54%7.25±\pm0.20 −2.03%8.99±\pm0.23 +0.22%
PCAFlowRec8.10±\pm0.2413.45±\pm0.1120.70±\pm0.225.18±\pm0.236.88±\pm0.198.72±\pm0.22
TIGER8.22±\pm0.3113.58±\pm0.3318.65±\pm0.635.00±\pm0.076.72±\pm0.078.00±\pm0.17
MaskGR8.64±\pm0.0014.43±\pm0.0520.97±\pm0.235.57±\pm0.017.42±\pm0.029.08±\pm0.07
CAP-Mix8.30±\pm0.20 −3.94%14.28±\pm0.02 −1.04%21.50±\pm0.06 +2.53%5.07±\pm0.09 −8.98%6.99±\pm0.03 −5.80%8.81±\pm0.04 −2.97%
ml-1mmodelHR@5HR@10HR@20N@5N@10N@20
scratchFlowRec15.01±0.1215.01 \pm0.1222.73±0.1722.73 \pm0.1732.48±0.3032.48 \pm0.309.90±0.179.90 \pm0.1712.38±0.2012.38 \pm0.2014.84±0.2414.84 \pm0.24
TIGER12.59±0.4012.59 \pm0.4019.03±0.3719.03 \pm0.3727.20±0.6827.20 \pm0.688.47±0.288.47 \pm0.2810.54±0.2810.54 \pm0.2812.61±0.3612.61 \pm0.36
MaskGR15.64±0.4015.64 \pm0.4023.61±0.2923.61 \pm0.2933.93±0.1733.93 \pm0.1710.23±0.2810.23 \pm0.2812.79±0.2612.79 \pm0.2615.39±0.2115.39 \pm0.21
CAP-Mix17.48±0.2717.48 \pm0.27 +11.76%+11.76\%24.80±0.0924.80 \pm0.09 +5.04%+5.04\%34.01±0.2934.01 \pm0.29 +0.24%+0.24\%11.74±0.1911.74 \pm0.19 +14.76%+14.76\%14.10±0.1414.10 \pm0.14 +10.24%+10.24\%16.41±0.2016.41 \pm0.20 +6.63%+6.63\%
SIDFlowRec†15.01±0.1215.01 \pm0.1222.73±0.1722.73 \pm0.1732.48±0.3032.48 \pm0.309.90±0.179.90 \pm0.1712.38±0.2012.38 \pm0.2014.84±0.2414.84 \pm0.24
TIGER12.52±0.7012.52 \pm0.7018.91±0.6218.91 \pm0.6226.88±0.6626.88 \pm0.668.20±0.318.20 \pm0.3110.25±0.2910.25 \pm0.2912.26±0.3012.26 \pm0.30
MaskGR13.04±1.2213.04 \pm1.2220.09±1.3120.09 \pm1.3129.45±1.7529.45 \pm1.758.43±0.728.43 \pm0.7210.70±0.7410.70 \pm0.7413.05±0.8513.05 \pm0.85
CAP-Mix16.61±0.3116.61 \pm0.31 +10.66%+10.66\%24.25±0.0824.25 \pm0.08 +6.69%+6.69\%33.70±0.3133.70 \pm0.31 +3.76%+3.76\%11.26±0.1511.26 \pm0.15 +13.74%+13.74\%13.73±0.0813.73 \pm0.08 +10.90%+10.90\%16.11±0.1316.11 \pm0.13 +8.56%+8.56\%
PCAFlowRec15.36±0.2015.36 \pm0.2022.94±0.0422.94 \pm0.0432.68±0.1432.68 \pm0.1410.14±0.1210.14 \pm0.1212.58±0.0512.58 \pm0.0515.03±0.0915.03 \pm0.09
TIGER12.16±0.3112.16 \pm0.3118.43±0.1718.43 \pm0.1727.08±0.4027.08 \pm0.408.12±0.188.12 \pm0.1810.12±0.1510.12 \pm0.1512.30±0.0612.30 \pm0.06
MaskGR12.58±0.5512.58 \pm0.5519.81±0.5619.81 \pm0.5629.10±0.3929.10 \pm0.398.27±0.438.27 \pm0.4310.60±0.4210.60 \pm0.4212.95±0.3912.95 \pm0.39
CAP-Mix17.25±0.1317.25 \pm0.13 +12.30%+12.30\%24.71±0.3824.71 \pm0.38 +7.72%+7.72\%33.98±0.3433.98 \pm0.34 +3.98%+3.98\%11.71±0.1111.71 \pm0.11 +15.48%+15.48\%14.11±0.1714.11 \pm0.17 +12.16%+12.16\%16.44±0.1516.44 \pm0.15 +9.38%+9.38\%

Table 13. ML-1M — full results. Conventions as in Table 10.

yelpmodelHR@5HR@10HR@20N@5N@10N@20
scratchFlowRec2.79±0.022.79 \pm0.024.76±0.054.76 \pm0.057.76±0.077.76 \pm0.071.73±0.021.73 \pm0.022.37±0.022.37 \pm0.023.12±0.033.12 \pm0.03
TIGER0.26±0.010.26 \pm0.010.42±0.020.42 \pm0.020.73±0.100.73 \pm0.100.17±0.010.17 \pm0.010.22±0.010.22 \pm0.010.30±0.030.30 \pm0.03
MaskGR2.99±0.042.99 \pm0.045.10±0.075.10 \pm0.078.24±0.108.24 \pm0.101.87±0.031.87 \pm0.032.54±0.032.54 \pm0.033.33±0.043.33 \pm0.04
CAP-Mix3.07±0.023.07 \pm0.02 +2.68%+2.68\%5.14±0.025.14 \pm0.02 +0.78%+0.78\%8.26±0.028.26 \pm0.02 +0.24%+0.24\%1.93±0.021.93 \pm0.02 +3.21%+3.21\%2.60±0.012.60 \pm0.01 +2.36%+2.36\%3.38±0.013.38 \pm0.01 +1.50%+1.50\%
SIDFlowRec†2.79±0.022.79 \pm0.024.76±0.054.76 \pm0.057.76±0.077.76 \pm0.071.73±0.021.73 \pm0.022.37±0.022.37 \pm0.023.12±0.033.12 \pm0.03
TIGER1.27±0.081.27 \pm0.082.05±0.102.05 \pm0.102.95±0.182.95 \pm0.180.77±0.050.77 \pm0.051.02±0.061.02 \pm0.061.25±0.081.25 \pm0.08
MaskGR2.63±0.012.63 \pm0.014.37±0.054.37 \pm0.056.79±0.076.79 \pm0.071.65±0.011.65 \pm0.012.20±0.022.20 \pm0.022.81±0.032.81 \pm0.03
CAP-Mix3.13±0.023.13 \pm0.02 +12.19%+12.19\%5.18±0.025.18 \pm0.02 +8.82%+8.82\%8.32±0.018.32 \pm0.01 +7.22%+7.22\%1.99±0.011.99 \pm0.01 +15.03%+15.03\%2.64±0.012.64 \pm0.01 +11.39%+11.39\%3.43±0.013.43 \pm0.01 +9.94%+9.94\%
PCAFlowRec2.98±0.052.98 \pm0.055.10±0.055.10 \pm0.058.34±0.068.34 \pm0.061.86±0.031.86 \pm0.032.54±0.032.54 \pm0.033.35±0.043.35 \pm0.04
TIGER1.29±0.071.29 \pm0.072.09±0.092.09 \pm0.093.03±0.103.03 \pm0.100.80±0.040.80 \pm0.041.06±0.041.06 \pm0.041.30±0.041.30 \pm0.04
MaskGR2.53±0.022.53 \pm0.024.26±0.044.26 \pm0.046.60±0.046.60 \pm0.041.59±0.011.59 \pm0.012.14±0.012.14 \pm0.012.73±0.022.73 \pm0.02
CAP-Mix3.18±0.023.18 \pm0.02 +6.71%+6.71\%5.25±0.045.25 \pm0.04 +2.94%+2.94\%8.38±0.058.38 \pm0.05 +0.48%+0.48\%2.03±0.022.03 \pm0.02 +9.14%+9.14\%2.70±0.032.70 \pm0.03 +6.30%+6.30\%3.48±0.033.48 \pm0.03 +3.88%+3.88\%

Table 14. Yelp-2022 — full results. Conventions as in Table 10.

References

  1. [1]Takuya Akiba, Shotaro Sano, Toshihiko Yanase, Takeru Ohta, and Masanori Koyama. Optuna: A next-generation hyperparameter optimization framework. In Proceedings of the 25th ACM SIGKDD International Conference on Knowledge Discovery & Data Mining, 2019. doi: 10.1145/3292500.3330701. https://doi.org/10.1145/3292500.3330701.
  2. [2]David Arthur and Sergei Vassilvitskii. k-means++: the advantages of careful seeding. In Proceedings of the Eighteenth Annual ACM-SIAM Symposium on Discrete Algorithms, SODA ’07, page 1027–1035, USA, 2007. Society for Industrial and Applied Mathematics. ISBN 9780898716245. https://dl.acm.org/doi/10.5555/1282838.1283494.DOI
  3. [3]James Bergstra, Rémi Bardenet, Yoshua Bengio, and Balázs Kégl. Algorithms for hyper-parameter optimization. In J. Shawe-Taylor, R. Zemel, P. Bartlett, F. Pereira, and K. Weinberger, editors, Advances in Neural Information Processing Systems, volume 24. Curran Associates, Inc., 2011. https://proceedings.neurips.cc/paper_files/paper/2011/file/86e8f7ab32cfd12577bc2619bc635690-Paper.pdf.
  4. [4]Paul S. Bradley, Kristin P. Bennett, and Ayhan Demiriz. Constrained k-means clustering. Technical Report MSR-TR-2000-65, Microsoft Research, 2000. https://www.microsoft.com/en-us/research/publication/constrained-k-means-clustering/.
  5. [5]Gilles Celeux and Gérard Govaert. A classification EM algorithm for clustering and two stochastic versions. Computational Statistics & Data Analysis, 14(3):315–332, 1992. doi: 10.1016/0167-9473(92)90042-E. https://doi.org/10.1016/0167-9473(92)90042-E.
  6. [6]A. P. Dempster, N. M. Laird, and D. B. Rubin. Maximum likelihood from incomplete data via the EM algorithm. Journal of the Royal Statistical Society: Series B, 39:1–38, 1977. http://web.mit.edu/6.435/www/Dempster77.pdf.DOI
  7. [7]Jiaxin Deng, Shiyao Wang, Kuo Cai, Leijian Ren, Qigen Hu, Weifeng Ding, Qiang Luo, and Guorui Zhou. OneRec: Unifying retrieve and rank with generative recommender and iterative preference alignment, 2025. https://arxiv.org/abs/2502.18965.
  8. [8]Junchen Fu, Xuri Ge, Alexandros Karatzoglou, Ioannis Arapakis, Suzan Verberne, Joemon M. Jose, and Zhaochun Ren. Differentiable semantic ID for generative recommendation. In Proceedings of the 49th International ACM SIGIR Conference on Research and Development in Information Retrieval, SIGIR ’26, page 369–379, New York, NY, USA, 2026. Association for Computing Machinery. ISBN 978400725999. doi: 10.1145/3805712.3809641. https://doi.org/10.1145/3805712.3809641.
  9. [9]Shijie Geng, Shuchang Liu, Zuohui Fu, Yingqiang Ge, and Yongfeng Zhang. Recommendation as language processing (RLP): A unified pretrain, personalized prompt & predict paradigm (P5). In Proceedings of the 16th ACM Conference on Recommender Systems, RecSys ’22, page 299–315, New York, NY, USA, 2022. Association for Computing Machinery. ISBN 9781450392785. doi: 10.1145/3523227.3546767. https://doi.org/10.1145/3523227.3546767.
  10. [10]F. Maxwell Harper and Joseph A. Konstan. The MovieLens datasets: History and context. ACM Trans. Interact. Intell. Syst., 5(4), December 2015. ISSN 2160-6455. doi: 10.1145/2827872. https://doi.org/10.1145/2827872.
  11. [11]Ruining He and Julian McAuley. Ups and downs: Modeling the visual evolution of fashion trends with one-class collaborative filtering. In Proceedings of the 25th International Conference on World Wide Web, WWW ’16, page 507–517, Republic and Canton of Geneva, CHE, 2016. International World Wide Web Conferences Steering Committee. ISBN 9781450341431. doi: 10.1145/2872427.2883037. https://doi.org/10.1145/2872427.2883037.
  12. [12]Yupeng Hou, Jiacheng Li, Xiangjun Fu, Zhankui He, An Yan, Xiusi Chen, and Julian McAuley. Bridging language and items for retrieval and recommendation: Benchmarking LLMs as semantic encoders. In Maria Liakata, Viviane P. Moreira, Jiajun Zhang, and David Jurgens, editors, Proceedings of the 64th Annual Meeting of the Association for Computational Linguistics (Volume 1: Long Papers), pages 3251–3265, San Diego, California, United States, July 2026. Association for Computational Linguistics. ISBN 979-8-89176-390-6. doi: 10.18653/v1/2026.acl-long.147. https://aclanthology.org/2026.acl-long.147/.
  13. [13]Clark Mingxuan Ju, Liam Collins, Leonardo Neves, Bhuvesh Kumar, Louis Yufeng Wang, Tong Zhao, and Neil Shah. Generative recommendation with semantic IDs: A practitioner’s handbook. In Proceedings of the 34th ACM International Conference on Information and Knowledge Management (CIKM), 2025. doi: 10.1145/3746252.3761612. https://doi.org/10.1145/3746252.3761612.
  14. [14]Wang-Cheng Kang and Julian McAuley. Self-Attentive Sequential Recommendation. In 2018 IEEE International Conference on Data Mining (ICDM), pages 197–206, Los Alamitos, CA, USA, November 2018. IEEE Computer Society. doi: 10.1109/ICDM.2018.00035. https://doi.ieeecomputersociety.org/10.1109/ICDM.2018.00035.DOI
  15. [15]Xiaoyu Kong, Leheng Sheng, Junfei Tan, Yuxin Chen, Jiancan Wu, An Zhang, Xiang Wang, and Xiangnan He. MiniOneRec: An open-source framework for scaling generative recommendation, 2025. https://arxiv.org/abs/2510.24431.
  16. [16]Doyup Lee, Chiheon Kim, Saeh oon Kim, Minsu Cho, and Wook-Shin Han. Autoregressive image generation using residual quantization. In Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition (CVPR), 2022. https://openaccess.thecvf.com/content/CVPR2022/html/Lee_Autoregressive_Image_Generation_Using_Residual_Quantization_CVPR_2022_paper.html.arxiv.org/abs/2203.01941
  17. [17]Jialei Li, Yang Zhang, Yimeng Bai, Shuai Zhu, Ziqi Xue, Xiaoyan Zhao, Dingxian Wang, Frank Yang, Andrew Rabinovich, and Xiangnan He. UniGRec: Unified generative recommendation with soft identifiers for end-to-end optimization, 2026a. https://arxiv.org/abs/2601.17438.
  18. [19]Zihao Li, Aixin Sun, and Chenliang Li. DiffuRec: A diffusion model for sequential recommendation. ACM Trans. Inf. Syst., 42(3), December 2023. ISSN 1046-8188. doi: 10.1145/3631116. https://doi.org/10.1145/3631116.
  19. [20]Yaron Lipman, Ricky T. Q. Chen, Heli Ben-Hamu, Maximilian Nickel, and Matthew Le. Flow matching for generative modeling. In The Eleventh International Conference on Learning Representations, ICLR 2023, Kigali, Rwanda, May 1-5, 2023. OpenReview.net, 2023. https://openreview.net/forum?id=PqvMrD0Jt9t.arxiv.org/abs/2210.02747
  20. [21]Enze Liu, Bowen Zheng, Cheng Ling, Lantao Hu, Han Li, and Wayne Xin Zhao. Generative recommender with end-to-end learnable item tokenization. In Proceedings of the 48th International ACM SIGIR Conference on Research and Development in Information Retrieval, SIGIR ’25, page 729–739, New York, NY, USA, 2025a. Association for Computing Machinery. ISBN 9798400715921. doi: 10.1145/3726302.3729989. https://doi.org/10.1145/3726302.3729989.
  21. [22]Feng Liu, Lixin Zou, Xiangyu Zhao, Min Tang, Liming Dong, Dan Luo, Xiangyang Luo, and Chenliang Li. Flow matching based sequential recommender model. In Proceedings of the Thirty-Fourth International Joint Conference on Artificial Intelligence, IJCAI ’25, 2025b. ISBN 978-1-956792-06-5. doi: 10.24963/ijcai.2025/346. https://doi.org/10.24963/ijcai.2025/346.
  22. [23]S. Lloyd. Least squares quantization in PCM. IEEE Transactions on Information Theory, 28(2):129–137, 1982. doi: 10.1109/TIT.1982.1056489. https://doi.org/10.1109/TIT.1982.1056489.
  23. [24]Julian McAuley, Christopher Targett, Qinfeng Shi, and Anton van den Hengel. Image-based recommendations on styles and substitutes. In Proceedings of the 38th International ACM SIGIR Conference on Research and Development in Information Retrieval, SIGIR ’15, page 43–52, New York, NY, USA, 2015. Association for Computing Machinery. ISBN 9781450336215. doi: 10.1145/2766462.2767755. https://doi.org/10.1145/2766462.2767755.
  24. [25]Shashank Rajput, Nikhil Mehta, Anima Singh, Raghunandan Hulikal Keshavan, Trung Vu, Lukasz Heldt, Lichan Hong, Yi Tay, Vinh Q. Tran, Jonah Samost, Maciej Kula, Ed H. Chi, and Maheswaran Sathiamoorthy. Recommender systems with generative retrieval. In Advances in Neural Information Processing Systems, 2023. https://openreview.net/forum?id=BJ0fQU32w.arxiv.org/abs/2305.05065
  25. [26]Kulin Shah, Bhuvesh Kumar, Neil Shah, and Liam Collins. Masked diffusion for generative recommendation, 2025. https://arxiv.org/abs/2511.23021.

Paper details

vlnc:W_zky5ws82
Version
v1 · latest
Published
Fresh — added to the Hub within the last 30 days
Added
License
CC BY 4.0
Usage

views · 0

downloads · 0

A view counts once per browser per day, a download each time the PDF is requested.

  • Computer Science

Not recorded for this paper

View statement
Looking for related papers…
Contents