Paper deep dive
VaLiDRec: Variable-Length LLM-Aligned Semantic IDs for Generative Recommendation
Shutong Qiao, Wei Yuan, Tong Chen, Hao Wang, Quoc Viet Hung Nguyen, Hongzhi Yin
Intelligence
Status: succeeded | Model: Gemma-4-26B-A4B | Prompt: intel-v1 | Confidence: 90%
Last extracted: 8/1/2026, 11:25:06 AM
Summary
The paper introduces VaLiDRec, a generative recommendation framework that utilizes variable-length, LLM-aligned semantic identifiers (SIDs) constructed directly from native LLM vocabulary tokens. By employing token importance estimation, semantic-quality-aware pruning, and collision-aware refinement, VaLiDRec creates compact SIDs that adapt to item semantic complexity. The framework incorporates graph-aware soft prompts to model user preferences and reformulates recommendation as parallel token-set prediction, eliminating the need for autoregressive decoding and beam search. Experiments demonstrate that VaLiDRec outperforms existing baselines in accuracy, zero-shot cold-start performance, and inference speed.
Entities (8)
Relation Signals (6)
VaLiDRec → uses → Variable-Length Semantic Identifiers
confidence 95% · VaLiDRec, a generative recommendation framework based on variable-length, LLM-aligned semantic identifiers.
VaLiDRec → constructs → Semantic Identifiers
confidence 93% · VaLiDRec constructs SIDs directly from informative native LLM vocabulary tokens
VaLiDRec → employs → Graph-Aware Soft Prompts
confidence 92% · VaLiDRec incorporates graph-aware soft prompts and reformulates recommendation as token-set prediction
Semantic Identifiers → arealignedwith → LLM
confidence 90% · LLM-aligned semantic identifiers
VaLiDRec → outperforms → LC-Rec
confidence 90% · 87.49× faster inference than LC-Rec
VaLiDRec → uses → LoRA
confidence 90% · fine-tunes the LLM with LoRA (Hu et al., 2022)
Cypher Suggestions (0)
No Cypher suggestions yet.
Abstract
Abstract:Generative recommendation commonly represents items using fixed-length semantic identifiers (SIDs) constructed through clustering and quantization. However, these artificial codes may overcompress item semantics, remain misaligned with pretrained LLM vocabularies, and require costly autoregressive decoding. In light of this, we propose VaLiDRec, a generative recommendation framework based on variable-length, LLM-aligned semantic identifiers. VaLiDRec constructs SIDs directly from informative native LLM vocabulary tokens via token importance estimation, semantic-quality-aware pruning, and collision-aware refinement, allowing identifier lengths to adapt to item semantic complexity. To model user preferences, VaLiDRec incorporates graph-aware soft prompts and reformulates recommendation as token-set prediction with token-level item scoring, eliminating autoregressive SID generation and beam search. Experiments on four real-world datasets show that VaLiDRec consistently outperforms strong sequential and generative recommendation baselines across all evaluation metrics. It further achieves superior zero-shot item cold-start performance and 87.49$\times$ faster inference than LC-Rec. These results demonstrate that LLM-native variable-length semantic identifiers provide a more expressive and efficient paradigm for generative recommendation.
Tags
Links
- Source: https://arxiv.org/abs/2607.25209v1
- Canonical: https://arxiv.org/abs/2607.25209v1
Trouble viewing inline? Open PDF directly →
Full Text
54,800 characters extracted from source content.
Expand or collapse full text
VaLiDRec: Variable-Length LLM-Aligned Semantic IDs for Generative Recommendation Shutong Qiao University of QueenslandBrisbaneAustralia shutong.qiao@uq.edu.au , Wei Yuan University of QueenslandBrisbaneAustralia w.yuan@uq.edu.au , Tong Chen University of QueenslandBrisbaneAustralia tong.chen@uq.edu.au , Hao Wang Computer Network Information Center, Chinese Academy of SciencesBeijingChina cashenry@126.com , Quoc Viet Hung Nguyen Griffith UniversityGold CoastAustralia henry.nguyen@griffith.edu.au and Hongzhi Yin University of QueenslandBrisbaneAustralia h.yin1@uq.edu.au Abstract. Generative recommendation commonly represents items using fixed-length semantic identifiers (SIDs) constructed through clustering and quantization. However, these artificial codes may overcompress item semantics, remain misaligned with pretrained LLM vocabularies, and require costly autoregressive decoding. In light of this, we propose VaLiDRec, a generative recommendation framework based on variable-length, LLM-aligned semantic identifiers. VaLiDRec constructs SIDs directly from informative native LLM vocabulary tokens via token importance estimation, semantic-quality-aware pruning, and collision-aware refinement, allowing identifier lengths to adapt to item semantic complexity. To model user preferences, VaLiDRec incorporates graph-aware soft prompts and reformulates recommendation as token-set prediction with token-level item scoring, eliminating autoregressive SID generation and beam search. Experiments on four real-world datasets show that VaLiDRec consistently outperforms strong sequential and generative recommendation baselines across all evaluation metrics. It further achieves superior zero-shot item cold-start performance and 87.49× faster inference than LC-Rec. These results demonstrate that LLM-native variable-length semantic identifiers provide a more expressive and efficient paradigm for generative recommendation. Recommender System; Generative Recommendation; Sequential Recommendation; Large Language Model †ccs: Information systems Recommender systems 1. Introduction Generative recommendation (GR) formulates recommendation as a conditional generation problem, where the target item identifier or textual representation is generated directly from user interaction histories, contextual information, and natural language prompts (Geng et al., 2022; Wang et al., 2023; Rajput et al., 2023; Wang et al., 2025). Unlike conventional discriminative recommenders that rank candidate items using matching functions, GR integrates user preference modeling, item semantic understanding, and candidate generation within a unified framework. Leveraging the strong language understanding and semantic modeling capabilities of large language models (LLMs) (Brown et al., 2020; Grattafiori et al., 2024; Bao et al., 2023), recent GR methods can directly exploit rich item metadata and pretrained semantic knowledge, making them particularly promising for sparse, long-tail, and cold-start recommendation scenarios. Generating appropriate item representations is fundamental to generative recommendation, as the output space must be both semantically expressive and precisely retrievable. Directly generating raw item IDs (Geng et al., 2022; Hua et al., 2023; Petrov and Macdonald, 2023) preserves one-to-one item mapping but lacks semantic structure, making it difficult to capture semantic relationships among items. In contrast, generating free-form textual descriptions provides richer semantic expressiveness but results in an open-ended output space, where generated content may be ambiguous, hallucinated, or difficult to align with items in the corpus. To balance semantic expressiveness, controllability, and inference efficiency, recent GR methods commonly adopt semantic identifiers (SIDs) (Rajput et al., 2023; Hou et al., 2023; Lin et al., 2025), which represent each item as a sequence of discrete semantic tokens and train generative models to predict the target item’s SID. These SIDs are typically constructed using clustering or quantization methods, such as RQ-KMeans (Deng et al., 2025), RQ-VAE (Lee et al., 2022), and FSQ (Mentzer et al., 2024), to encode item similarity into a structured output space. Consequently, SIDs have emerged as an effective interface between generative sequence modeling and large-scale item retrieval. Figure 1. Comparison of traditional fixed-length SID sequences and our variable-length SID sets. Our SIDs are stored as LLM vocabulary token IDs, denoted as Token_ID for illustration, while the decoded forms show their correspondence to item metadata. However, existing SID-based methods still exhibit three major limitations. First, most SIDs are constructed by clustering or quantizing continuous item representations into artificial discrete codes (Jia et al., 2025). Although these codes may preserve useful latent information, they are neither explicitly grounded in the original item metadata nor naturally aligned with the pretrained LLM vocabulary. Consequently, their semantic content is difficult to inspect or quantify, and their integration often requires vocabulary expansion, newly initialized code embeddings, or additional task-specific alignment. Second, most methods construct fixed-length SIDs (Rajput et al., 2023; Hou et al., 2025), assigning the same representational budget to all items regardless of their semantic content. Such a uniform design cannot adapt identifier capacity to item-specific needs: some items may be sufficiently represented by a few informative elements, whereas others may require richer identifiers to retain their distinguishing information. Third, existing methods typically generate SIDs autoregressively with beam search, resulting in decoding costs that increase with both identifier length and beam size. This overhead becomes particularly pronounced when longer identifiers are needed to provide greater representational capacity. To address these limitations, we propose VaLiDRec, a two-stage generative recommendation framework based on variable-length, LLM-aligned semantic identifiers. Rather than compressing item representations into artificial discrete codes, VaLiDRec constructs SIDs directly from the original item text using native LLM vocabulary tokens. In the first stage, it identifies semantically informative and discriminative tokens and employs a semantic-quality-aware greedy pruning strategy to select a compact token set that preserves the core meaning of each item. Consequently, each item is represented by a concise SID whose length naturally adapts to its semantic complexity. In the second stage, VaLiDRec incorporates collaborative signals through graph-aware behavioral prompts and fine-tunes the LLM with LoRA (Hu et al., 2022) to predict the target item’s SID. Training is jointly optimized with three complementary objectives: token-set prediction, semantic alignment, and recommendation ranking, which together promote accurate SID prediction, semantic consistency, and preference-aware inference. Finally, the predicted token scores are aggregated over all item SIDs to produce item-level relevance scores, eliminating autoregressive SID generation and beam search. In summary, our main contributions are as follows: • We propose a variable-length, LLM-aligned SID construction method that directly selects informative native LLM vocabulary tokens as item identifiers. Unlike quantization-based approaches, it avoids opaque latent codebooks, preserves explicit lexical semantics, and enables measurable semantic retention. • We develop a graph-prompted token-set recommendation framework that injects collaborative signals into LLMs through graph-aware soft prompts. By predicting SID token sets in parallel and aggregating token scores over item SIDs, VaLiDRec naturally supports variable-length identifiers while eliminating autoregressive decoding and beam-search overhead. • We conduct extensive experiments on multiple real-world recommendation datasets. The results demonstrate that VaLiDRec consistently outperforms both conventional and state-of-the-art sequential and SID-based generative recommendation baselines, while achieving superior inference efficiency, stronger zero-shot cold-start performance, and higher semantic retention. 2. Related Work 2.1. Sequential Recommendation Sequential recommendation predicts the next item from interaction histories. FPMC (Rendle et al., 2010) combines matrix factorization with first-order Markov chains for personalized transition modeling. Neural methods, including GRU4Rec (Hidasi, 2015), NARM (Li et al., 2017), and Caser (Tang and Wang, 2018), capture temporal dependencies, user intent, and local patterns, while SR-GNN (Wu et al., 2019) models sessions as item-transition graphs. Transformer-based methods further capture long-range dependencies, such as SASRec (Kang and McAuley, 2018) with causal self-attention and BERT4Rec (Sun et al., 2019) with masked-item prediction. More recent work enhances sequence representations through self-supervision and contrastive learning, including S3-Rec (Zhou et al., 2020), CL4SRec (Xie et al., 2022), and FEARec (Du et al., 2023). Despite their effectiveness, these methods primarily rely on item IDs and interaction signals within a discriminative ranking paradigm, limiting their use of item metadata and generalization to sparse or unseen items. 2.2. Generative Recommendation GR retrieves items by generating identifiers from user histories. TIGER (Rajput et al., 2023) uses residual-quantized SIDs with autoregressive decoding, while LC-Rec (Zheng et al., 2024) aligns quantized SIDs with LLM representations. Later work improves identifier learning through collaborative tokenization, embedding alignment, or end-to-end optimization, including TokenRec (Qu et al., 2025), LETTER (Wang et al., 2024a), ETEGRec (Liu et al., 2025a), and DIGER (Fu et al., 2026). HSTU (Zhai et al., 2024), EAGER (Wang et al., 2024b), and OneRec (Deng et al., 2025) further advance behavior modeling and unified retrieval-ranking generation. Limited SID capacity has been identified as a bottleneck in generative recommendation (Liu et al., 2025b). RPG (Hou et al., 2025) expands capacity with fixed-length OPQ codes, CapsID (Cheng et al., 2026) constructs variable-length latent SID sequences via soft capsule routing, and SA2CRQ (Wang et al., 2026) adaptively truncates RQ-VAE paths. Unlike these latent-code approaches, VaLiDRec constructs metadata-grounded SID sets directly from native LLM vocabulary tokens and predicts them in parallel. Figure 2. Overall framework of VaLiDRec. 3. Problem Formulation Let U and ℐI denote the user and item sets. For each user u∈u , let ℋu=(iu,1,…,iu,Tu)H_u=(i_u,1,…,i_u,T_u) denote the chronologically ordered interaction history. Given ℋuH_u, the sequential recommendation task is to predict the next item ju+∈ℐj_u^+ . Each item j∈ℐj is associated with metadata xjx_j. From xjx_j, we construct a variable-length semantic token set Sj⊆S_j , where V denotes the pretrained LLM vocabulary. We formulate next-item recommendation as predicting the semantic token set of the target item: (1) pθ(Sju+∣ℋu).p_θ (S_j_u^+ _u ). At inference time, the predicted token scores are aggregated over the SIDs of all candidate items to obtain item-level relevance scores and rank the full item catalog. 4. Methodology In this section, we present VaLiDRec, a two-stage GR framework based on variable-length, LLM-aligned SIDs. As illustrated in Figure 2, Stage 1 (Section 4.1) constructs semantic SIDs directly from item metadata, while Stage 2 (Section 4.2) incorporates collaborative signals through graph-aware soft prompts and performs parallel token-set prediction for item ranking. 4.1. Stage 1: LLM-Native SID Construction Existing SID methods use clustering or quantization with fixed code structures, assigning equal capacity to all items and potentially losing fine-grained semantics. Their latent codes are also misaligned with item metadata and pretrained LLM vocabularies. We instead construct variable-length SIDs from native LLM tokens, adapting their capacity to each item’s semantic complexity. 4.1.1. Token Importance Scoring Given the metadata text xjx_j of item j, the LLM tokenizer produces (2) Tj=(tj,1,…,tj,nj),T_j=(t_j,1,…,t_j,n_j), where njn_j is the sequence length. Let j⊆1,…,njP_j \1,…,n_j\ denote the positions of valid metadata tokens after filtering, and let j,i∈ℝdh_j,i ^d be the final-layer contextual representation at position i∈ji _j. To identify tokens that are both salient to the current item and discriminative across the corpus, we combine contextual activation with inverse document frequency: (3) IDF(t)=log|ℐ|+1df(t)+1,IDF(t)= |I|+1df(t)+1, where df(t)df(t) denotes the number of items whose metadata contains token type t. Unlike conventional TF-IDF (Salton and Buckley, 1988), which uses term frequency as the document-specific importance signal, we use the contextual hidden-state norm as a proxy for token salience. The occurrence-level importance score is (4) sj,i=‖j,i‖2(IDF(tj,i)+1),i∈j.s_j,i=\|h_j,i\|_2 (IDF(t_j,i)+1 ), i _j. This score favors token occurrences that are both contextually salient and corpus-discriminative. We construct a candidate position set j⊆jC_j _j by combining high-ranking candidates under sj,is_j,i, IDF(tj,i)IDF(t_j,i), and ‖j,i‖2\|h_j,i\|_2, together with a small number of prefix positions. If multiple positions correspond to the same vocabulary token, we retain only the occurrence with the highest importance score. 4.1.2. Greedy Pruning The candidate pool may contain redundant token occurrences, whereas retaining a fixed number of tokens assigns the same representational capacity to items with different semantic complexity. We therefore introduce a semantic-quality-aware greedy pruning strategy to construct compact, variable-length SIDs. We represent the metadata semantics of item j as (5) j=1|j|∑i∈j,i.e_j= 1|P_j| _i _jh_j,i. Let ℛj⊆jR_j _j denote the currently retained token positions. Their semantic representation is (6) (ℛj)=1|ℛj|∑i∈ℛj,i,e(R_j)= 1|R_j| _i _jh_j,i, and the corresponding semantic quality is (7) Q(ℛj)=cos((ℛj),j).Q(R_j)= (e(R_j),e_j ). A larger Q(ℛj)Q(R_j) indicates better preservation of the metadata semantics. We initialize ℛj←jR_j _j and iteratively remove the least essential token occurrence. Given a trade-off coefficient λ≥0λ≥ 0, the deletion score of position i∈ℛji _j is (8) Dj(i;ℛj)=Q(ℛj∖i)−λ[IDF(tj,i)]+∑i′∈ℛj[IDF(tj,i′)]++ϵ,D_j(i;R_j)=Q (R_j \i\ )-λ [IDF(t_j,i)]_+ _i _j[IDF(t_j,i )]_++ε, where [x]+=max(x,0)[x]_+= (x,0) and ϵ>0ε>0 is a small constant for numerical stability. The first term favors deletions that preserve item semantics, whereas the second penalizes the removal of corpus-discriminative tokens. At each iteration, we select (9) i⋆=argmaxi∈ℛjDj(i;ℛj).i = *arg\,max_i _jD_j(i;R_j). The pruning process is controlled by a minimum length LminL_ , a maximum length LmaxL_ , and a semantic-quality threshold τ. If |ℛj|>Lmax|R_j|>L_ , i⋆i is removed to satisfy the hard maximum-length constraint. Once |ℛj|≤Lmax|R_j|≤ L_ , removal continues only if |ℛj|>Lmin|R_j|>L_ and (10) Q(ℛj∖i⋆)≥τ.Q (R_j \i \ )≥τ. The process terminates otherwise. Thus, semantically simple items receive shorter identifiers, whereas information-rich items retain more tokens. Since the candidate positions correspond to distinct token IDs, the resulting semantic SID is (11) j=tj,i∣i∈ℛj.S_j= \t_j,i i _j \. After each update to ℛjR_j, the semantic SID SjS_j is updated accordingly. 4.1.3. Collision Handling Greedy pruning may assign identical semantic token sets to items with similar metadata. We therefore perform collision-aware refinement while preserving token occurrences that contribute most to semantic retention. For a retained position i∈ℛji _j, we define its functional contribution as (12) Δj(i)=[Q(ℛj)−Q(ℛj∖i)]+. _j(i)= [Q(R_j)-Q (R_j \i\ ) ]_+. A larger Δj(i) _j(i) indicates a greater loss of semantic quality after removing the corresponding token. Its normalized functional weight is (13) wj(i)=Δj(i)∑i′∈ℛjΔj(i′),if ∑i′∈ℛjΔj(i′)>0,sj,i∑i′∈ℛjsj,i′,otherwise.w_j(i)= cases _j(i) _i _j _j(i ),&if _i _j _j(i )>0,\\[8.0pt] s_j,i _i _js_j,i ,&otherwise. cases The second branch provides a fallback when removing any individual token does not reduce semantic quality. Two items j and j′j are considered collided if they share the same semantic SID: (14) Sj=Sj′.S_j=S_j . For each collided item, we select an unused candidate position inew∈j∖ℛji_new _j _j whose token tj,inewt_j,i_new is not already contained in jS_j, prioritizing larger IDF(tj,inew)IDF(t_j,i_new) and using sj,inews_j,i_new to break ties. If |ℛj|<Lmax|R_j|<L_ , the selected position is added to ℛjR_j; otherwise, it replaces the retained position with the smallest functional weight. Collision groups are recomputed after each round, and refinement continues until all collisions are resolved or the maximum number of rounds is reached. Although SjS_j is unordered, we deterministically serialize it as π(Sj)π(S_j) by sorting tokens by decreasing stored weight and occurrence-level importance. For each residual collision group, items are ranked by training interaction frequency, with ties broken by a fixed item index, yielding ranks rjr_j from zero. Using ⊕ to denote concatenation, the complete identifier is (15) S~j=π(Sj)⊕⟨SUFrj⟩. S_j=π(S_j) _r_j . Non-collided items use ⟨SUF0⟩ _0 . As a non-semantic disambiguation key, the suffix is excluded from graph construction, LLM input, token prediction, and semantic scoring. Hereafter, SjS_j and S~j S_j denote the semantic token set and complete stored identifier, respectively. 4.2. Stage 2: Graph-Prompted LLM for Token-Set Prediction The semantic SIDs from Section 4.1 capture item content but not behavioral transitions. Moreover, autoregressive decoding introduces artificial token ordering and costly beam search for variable-length token sets. We therefore formulate recommendation as graph-conditioned token-set prediction, where a graph-aware soft prompt models transition patterns and the LLM predicts SID tokens in parallel. Token scores are then aggregated across item SIDs to obtain item-level recommendation scores. 4.2.1. Graph-Aware Soft Prompt Let (t)∈ℝdE(t) ^d denote the LLM input embedding of token t. We initialize the representation of item j by averaging the embeddings of its semantic SID tokens: (16) j=1|Sj|∑t∈Sj(t).z_j= 1|S_j| _t∈ S_jE(t). For each mini-batch ℬB, we construct a directed item-transition graph from the user histories. For each user u, we add an edge iu,ℓ→iu,ℓ+1i_u, → i_u, +1 between consecutive interactions in ℋuH_u, together with self-loops for historical items. We initialize j(0)=jg_j^(0)=z_j. Let −(j)N^-(j) denote the multiset of incoming neighbors of item j. Each GraphSAGE (Hamilton et al., 2017) layer updates the node representation as (17) j(l+1)=ReLU((l)[j(l)∥1|−(j)|∑v∈−(j)v(l)]+(l)),g_j^(l+1)=ReLU (W^(l) [g_j^(l)\| 1|N^-(j)| _v ^-(j)g_v^(l) ]+b^(l) ), where l=0,…,L−1l=0,…,L-1, (l)∈ℝd×2dW^(l) ^d× 2d, (l)∈ℝdb^(l) ^d, and ∥\| denotes concatenation. We summarize the graph-enhanced historical item representations using recency-weighted pooling: (18) u=∑ℓ=1Tuρu,ℓiu,ℓ(L),ρu,ℓ=ℓ∑q=1Tuq.r_u= _ =1^T_u _u, g^(L)_i_u, , _u, = _q=1^T_uq. The pooled representation is projected into P continuous prompt embeddings: (19) u=reshape(pu+p)∈ℝP×d,P_u=reshape (W_pr_u+b_p ) ^P× d, where p∈ℝPd×dW_p ^Pd× d and p∈ℝPdb_p ^Pd. Each row of uP_u is a d-dimensional prompt embedding compatible with the LLM input space. Finally, we serialize and concatenate the historical semantic SIDs as π(Siu,1)⊕⋯⊕π(Siu,Tu)π(S_i_u,1) ·s π(S_i_u,T_u) and prepend uP_u to their token embeddings. Auxiliary suffix tokens are excluded from both graph construction and the LLM input. 4.2.2. LLM Fine-Tuning We fine-tune the LLM using LoRA together with the graph-prompt module. Let SIDV_SID denote the set of all semantic tokens appearing in the item SIDs, excluding auxiliary suffix tokens. During training, gradients of the input embedding matrix are restricted to tokens in SIDV_SID, while all other token embeddings remain frozen. The training objective combines token-set prediction, item-level ranking, and contrastive alignment. Let u∈ℝdh_u ^d be the final-layer hidden state at the designated prediction position following the serialized history after prepending the graph-aware soft prompt. To score SID tokens in the LLM vocabulary space, we reuse the corresponding input embeddings as output classifiers. For each t∈SIDt _SID, we compute (20) ou,t=u⊤(t),o_u,t=h_u E(t), where (t)E(t) is the corresponding LLM input embedding. Given a mini-batch ℬB, we define the candidate-token set as (21) ℬ=⋃u∈ℬSju+.T_B= _u S_j_u^+. For user u, tokens in Sju+S_j_u^+ are treated as positives and the remaining tokens in ℬT_B as in-batch negatives. Let yu,t=[t∈Sju+]y_u,t=I[t∈ S_j_u^+]. The token-set prediction loss is (22) ℒtoken= _token= −1|ℬ||ℬ|∑u∈ℬ∑t∈ℬ[ωyu,tlogσ(ou,t) - 1|B|\,|T_B| _u _t _B [ω y_u,t σ(o_u,t) +(1−yu,t)log(1−σ(ou,t))], +(1-y_u,t) (1-σ(o_u,t) ) ], where ω>0ω>0 is the positive-class weight. Token-level supervision captures target SID tokens but does not directly optimize item-level ranking. We therefore introduce an item-ranking objective that promotes the positive item over sampled negatives. For each user, we construct u=ju+∪u−A_u=\j_u^+\ _u^-, where u−A_u^- contains uniformly sampled negative items. The score of candidate item j is (23) au,j=1|Sj|∑t∈Sjσ(ou,t),a_u,j= 1|S_j| _t∈ S_jσ(o_u,t), and the item-ranking loss is (24) ℒrank=−1|ℬ|∑u∈ℬlogexp(au,ju+)∑j∈uexp(au,j).L_rank=- 1|B| _u (a_u,j_u^+) _j _u (a_u,j). Although the token-set and ranking objectives optimize token prediction and item ordering, they do not explicitly align the LLM-derived user representation with graph-enhanced item representations. We therefore introduce an item-level contrastive objective that aligns each user representation with its target-item representation relative to other target representations in the mini-batch. For contrastive alignment, let (25) ¯j=j(L),if j appears in the mini-batch graph,j,otherwise. g_j= casesg_j^(L),&if $j$ appears in the mini-batch graph,\\ z_j,&otherwise. cases We align the user representation with the graph-enhanced representation of its target item using (26) ℒitem=−1|ℬ|∑u∈ℬlogexp(sim(u,¯ju+)/τc)∑v∈ℬexp(sim(u,¯jv+)/τc), _item=- 1|B| _u (sim(h_u, g_j_u^+)/ _c ) _v (sim(h_u, g_j_v^+)/ _c ), where sim(⋅,⋅)sim(·,·) denotes cosine similarity and τc _c is the contrastive temperature. This objective aligns the LLM-derived user representation with the content- and graph-enhanced target-item space. Finally, the overall training objective is (27) ℒ=ℒtoken+αℒrank+βℒitem,L=L_token+ _rank+ _item, where α and β control the item-ranking and contrastive objectives, respectively. 4.2.3. Token-Level Item Scoring The fine-tuned LLM computes all semantic SID token scores in parallel, rather than autoregressively generating complete identifiers. For each token t∈SIDt _SID, we compute (28) pu,t=σ(ou,t)=σ(u⊤(t)).p_u,t=σ(o_u,t)=σ (h_u E(t) ). The relevance score of item j is obtained by averaging the probabilities of its semantic SID tokens: (29) qu,j=1|Sj|∑t∈Sjpu,t.q_u,j= 1|S_j| _t∈ S_jp_u,t. The final recommendation list is obtained by ranking all items j∈ℐj according to qu,jq_u,j. The length normalization prevents items with longer SIDs from systematically accumulating larger scores. Since all token probabilities are computed in a single LLM forward pass, this scoring process eliminates autoregressive SID generation and beam-search decoding. 4.2.4. Suffix Tie-Break Collision-aware expansion resolves most SID collisions, but some items may still share identical semantic token sets. Since suffix labels carry no semantic information, they are excluded from graph construction, LLM input, token prediction, and semantic score aggregation, and are used only for deterministic disambiguation. Consider two candidate items ja,jb∈ℐj_a,j_b such that Sja=SjbS_j_a=S_j_b. Their semantic scores are identical under token-level aggregation, so the item with the smaller suffix rank is preferred: (30) Sja=Sjb⟹ja≻jb⇔rja<rjb.S_j_a=S_j_b j_a j_b r_j_a<r_j_b. Thus, suffix ranks affect only items with identical semantic token sets and do not alter any strict semantic-score ordering. Table 1. Statistics of the standard and zero-shot item cold-start datasets. Dataset #Users #Items #Interactions Sparsity Standard Evaluation (5-core) Luxury 1,841 842 18,667 98.80% Scientific 2,843 1,549 19,099 99.57% Instruments 17,112 6,250 136,226 99.87% Arts 22,171 9,416 174,079 99.92% Zero-Shot Item Cold-Start Evaluation Luxury 19,748 8,308 47,913 99.97% 5. Experiments 5.1. Datasets and Evaluation Metrics We conduct standard experiments on four Amazon-2018 domains: Luxury Beauty, Industrial and Scientific, Musical Instruments, and Arts, Crafts and Sewing. We retain items with available metadata and apply iterative 5-core filtering, ensuring that each remaining user and item has at least five interactions. For item cold-start evaluation, following Zhang et al. (Zhang et al., 2026), we construct an item-cold split from the raw Luxury Beauty data without 5-core filtering. For each user sequence, the first 90% of interactions are used to construct training instances, while unseen items from the remaining interactions are selected as cold targets. The resulting cold-start instances are evenly divided into validation and test sets. We report Recall@K and Normalized Discounted Cumulative Gain (NDCG@K), which measure top-K target coverage and ranking quality, respectively. For standard evaluation, we use K∈5,10,20K∈\5,10,20\; for zero-shot item cold-start evaluation, we report results at K∈50,100K∈\50,100\ due to the substantially larger and sparser candidate space. 5.2. Implementation Details and Hyperparameter Settings All experiments are conducted on NVIDIA H100 GPUs. We use Llama-3.1-8B for SID construction and Llama-3.2-1B for recommendation training (Grattafiori et al., 2024); the two models can be replaced by any pair with compatible tokenizers and vocabulary mappings. For SID construction, we set the maximum metadata length, semantic quality threshold, and candidate pool size to 2,048, 0.95, and 64, respectively. SIDs contain 2–16 semantic tokens, with a distinctiveness coefficient of 0.05 and up to eight collision-aware expansion rounds. For recommendation, we use a two-layer GraphSAGE encoder with eight soft prompt embeddings and the most recent 20 historical items. We apply LoRA to the query and value projections with rank 16, scaling factor 32, and dropout 0.05. We optimize using AdamW with a learning rate of 1×10−41× 10^-4 and a batch size of 32. We set β=0.1β=0.1 and analyze α in Section 4. For efficiency evaluation, both VaLiDRec and LC-Rec use Llama-3.2-1B and are tested on the same NVIDIA H100 GPU with a batch size of 1; further details are provided in Section 5.7. All results are averaged over five independent runs with different random seeds. Statistical significance is assessed using a paired t-test at p<0.05p<0.05. 5.3. Baselines We compare VaLiDRec with two groups of representative baselines, including traditional SR methods and recent GR methods. • GRU4Rec (Hidasi, 2015) models sequential preferences with gated recurrent units. • Caser (Tang and Wang, 2018) captures sequential patterns using convolution over recent interactions. • SASRec (Kang and McAuley, 2018) models long-range dependencies with self-attention. • BERT4Rec (Sun et al., 2019) adopts a bidirectional Transformer architecture and learns user sequential preferences through a masked item prediction objective. • TIGER (Rajput et al., 2023) is a GR method that constructs residual-quantized SIDs and uses T5 (Raffel et al., 2020) to autoregressively generate target item identifiers. • LC-Rec (Zheng et al., 2024) is an LLM-based GR method that leverages language models to enhance item representation and recommendation generation. • RPG (Hou et al., 2025) is a recent GR method that improves recommendation by incorporating semantic and preference-aware generation signals. • SA2CRQ (Wang et al., 2026) is a GR method that improves long-tail recommendation by learning adaptive semantic codes and transferring residual knowledge across items.111As the original implementation has not been publicly released, we reproduce SA2CRQ based on the method described in the paper. 5.4. Performance Study Table 2. Overall recommendation performance on four datasets. The best results are highlighted in bold, and the second-best results are underlined. Dataset Metric GRU4Rec Caser SASRec BERT4Rec TIGER LC-Rec RPG SA2CRQ VaLiDRec Luxury Recall@5 0.2846 0.1879 0.2042 0.2330 0.2629 0.2622 0.2906 0.2542 0.3014 Recall@10 0.3128 0.2927 0.3014 0.3096 0.2826 0.2772 0.3167 0.2716 0.3405 Recall@20 0.3530 0.3324 0.3476 0.3531 0.3147 0.2955 0.3552 0.2944 0.3992 NDCG@5 0.2355 0.1127 0.1703 0.1465 0.2457 0.2421 0.2512 0.2408 0.2597 NDCG@10 0.2434 0.1465 0.1879 0.1719 0.2518 0.2470 0.2590 0.2462 0.2709 NDCG@20 0.2547 0.1565 0.1909 0.1828 0.2608 0.2516 0.2691 0.2519 0.2859 Scientific Recall@5 0.0661 0.0422 0.0292 0.0496 0.0555 0.0300 0.0531 0.0337 0.0685 Recall@10 0.0893 0.0647 0.0528 0.0735 0.0755 0.0489 0.0711 0.0502 0.0942 Recall@20 0.1259 0.1093 0.0837 0.1136 0.1095 0.0649 0.1006 0.0731 0.1287 NDCG@5 0.0466 0.0256 0.0166 0.0329 0.0370 0.0181 0.0341 0.0228 0.0475 NDCG@10 0.0541 0.0325 0.0240 0.0405 0.0434 0.0241 0.0386 0.0285 0.0552 NDCG@20 0.0617 0.0432 0.0317 0.0506 0.0520 0.0283 0.0465 0.0340 0.0637 Instruments Recall@5 0.0797 0.0570 0.0427 0.0694 0.0839 0.0559 0.0759 0.0771 0.0922 Recall@10 0.0906 0.0797 0.0637 0.0871 0.0946 0.0659 0.0806 0.0888 0.1042 Recall@20 0.1087 0.1074 0.0924 0.1107 0.1087 0.0874 0.0877 0.1055 0.1217 NDCG@5 0.0712 0.0348 0.0240 0.0603 0.0773 0.0446 0.0678 0.0687 0.0837 NDCG@10 0.0747 0.0421 0.0304 0.0660 0.0807 0.0478 0.0694 0.0726 0.0875 NDCG@20 0.0792 0.0490 0.0378 0.0721 0.0842 0.0533 0.0711 0.0768 0.0917 Arts Recall@5 0.0658 0.0330 0.0607 0.0576 0.0587 0.0194 0.0538 0.0476 0.0803 Recall@10 0.0770 0.0472 0.0852 0.0782 0.0678 0.0258 0.0583 0.0565 0.0934 Recall@20 0.0912 0.0672 0.1059 0.1044 0.0806 0.0321 0.0645 0.0650 0.1110 NDCG@5 0.0564 0.0199 0.0320 0.0398 0.0513 0.0143 0.0453 0.0408 0.0699 NDCG@10 0.0600 0.0244 0.0398 0.0464 0.0541 0.0164 0.0468 0.0437 0.0739 NDCG@20 0.0636 0.0294 0.0475 0.0530 0.0570 0.0179 0.0483 0.0458 0.0779 We compare VaLiDRec with eight representative baselines, including four sequential recommenders and four generative SID-based methods. Table 2 shows that VaLiDRec achieves the best performance across all datasets, metrics, and cutoff values. Conventional sequential models remain competitive because 5-core filtering retains relatively active users and items, allowing reliable behavioral patterns to be learned. On the relatively dense Luxury dataset, VaLiDRec improves Recall@10 and Recall@20 over RPG, the strongest baseline, by 7.5%7.5\% and 12.4%12.4\%, respectively. These results suggest that combining variable-length LLM-native SIDs with graph-enhanced preference modeling is more effective than the globally fixed code design used by RPG. On Scientific, VaLiDRec improves Recall@10 and NDCG@10 over GRU4Rec by 5.5%5.5\% and 2.0%2.0\%, respectively, demonstrating its benefit even when sequential signals are strong. The advantage becomes more pronounced on the sparser datasets: VaLiDRec improves all Recall metrics on Instruments by approximately 10%10\%, and all NDCG metrics on Arts by more than 22%22\%. These gains indicate improved candidate coverage as well as more accurate ranking of relevant items at top positions. TIGER and LC-Rec rely on quantized SIDs, whereas RPG uses globally fixed OPQ codes and SA2CRQ adaptively truncates RQ-VAE paths. Although these methods differ in their quantization strategies, they all operate on artificial code spaces. By contrast, VaLiDRec constructs variable-length SIDs directly from the native vocabulary of a pretrained LLM. Collectively, the results highlight the importance of jointly modeling SID semantics, vocabulary alignment, and user behavioral transitions. 5.4.1. Cold-Start Study Table 3. Zero-shot item cold-start performance on Luxury. The best and second-best results are highlighted in bold and underlined, respectively. Method Recall@50 NDCG@50 Recall@100 NDCG@100 GRU4Rec 0.0000 0.0000 0.0000 0.0000 BERT4Rec 0.0000 0.0000 0.0000 0.0000 TIGER 0.0042 0.0008 0.0065 0.0012 LC-Rec 0.1335 0.0562 0.1553 0.0619 RPG 0.1899 0.0555 0.2509 0.0640 VaLiDRec 0.1975 0.0575 0.2571 0.0672 Table 3 reports the zero-shot item cold-start results on Luxury, where target items are absent from the training interactions. GRU4Rec and BERT4Rec obtain zero performance because they cannot learn interaction-based representations for unseen target items. Generative SID methods leverage item content but differ in identifier construction. TIGER uses RQ-VAE to construct residual-quantized SIDs and trains T5 for autoregressive generation, whereas LC-Rec aligns quantized SID tokens with an extended LLM vocabulary through additional fine-tuning. RPG instead adopts OPQ to construct globally fixed long SIDs from independently quantized subvectors and predicts them in parallel, yielding strong recall. Nevertheless, all these methods rely on artificial quantization codes. VaLiDRec improves Recall@50, NDCG@50, Recall@100, and NDCG@100 over the corresponding strongest baselines by 4.0%4.0\%, 2.3%2.3\%, 2.5%2.5\%, and 5.0%5.0\%, respectively. By constructing variable-length SIDs directly from native LLM vocabulary tokens, VaLiDRec represents unseen items from metadata in the pretrained semantic space. The gains, particularly in NDCG, demonstrate its ability to rank relevant cold items more accurately. 5.5. Ablation Study Figure 3. Ablation results on four datasets. To assess each component, we consider four variants: w/o SID Refinement, which removes greedy pruning and collision-aware expansion; w/o Graph Prompt, which removes the graph-aware soft prompt; w/o Ranking Loss, which removes the item-level ranking loss; and w/o Contrastive Loss, which removes the item-level InfoNCE objective. Figure 3 reports Recall@20 and NDCG@20 on four datasets. Removing the graph-aware soft prompt causes the largest performance drop, especially on Arts, confirming its central role in preference modeling. While semantic SIDs capture item content, their unordered token structure lacks item-level cohesion and behavioral transition information. The graph prompt addresses this limitation by forming unified item representations, propagating transition signals, and summarizing recent interactions into a behavior-aware user prompt. Removing SID refinement also consistently degrades performance, consistent with the SID quality improvements in Table 5. Refinement removes redundant tokens, preserves semantics, and reduces collisions, yielding more compact and discriminative supervision. The ranking loss aligns aggregated token scores with the final recommendation objective, while the contrastive loss aligns user representations with graph-enhanced target items. Overall, the components provide complementary gains, with the graph prompt contributing the largest improvement. 5.6. Hyperparameter Study (a) Luxury (b) Scientific (c) Instruments (d) Arts Figure 4. Sensitivity to the ranking-loss weight α. We investigate the sensitivity of the item-level ranking loss weight α, which balances token-level SID prediction and direct item ranking. We vary α from 0.1 to 1.0 while fixing all other hyperparameters. As shown in Figure 4, the preferred ranking weight varies across datasets. Luxury achieves its best result at α=0.8α=0.8, indicating that relatively dense interactions support stronger item-level ranking supervision. Although Scientific exhibits larger fluctuations, its optimum also occurs at α=0.8α=0.8. Recall@20 on Instruments increases steadily and peaks at 0.80.8, which is consistent with the ranking objective helping distinguish items with similar predicted token sets. In contrast, Arts performs best at α=0.2α=0.2 and deteriorates at larger values, suggesting that excessive ranking supervision can overshadow token-level semantic learning in highly sparse and diverse item spaces. Overall, α=0.8α=0.8 provides the best trade-off on three datasets, while Arts benefits from a greater emphasis on token-level prediction. 5.7. Efficiency Analysis Table 4. Average online inference time per test instance on the Luxury item-cold dataset. L and B denote the SID length and beam size, respectively. The LLM computation column measures sequential decoding steps; offline SID construction is excluded. Method Inference Mechanism LLM Computation Beam Size Time (s) Speedup LC-Rec Autoregressive decoding (BL)O(BL) decoding steps 100 6.824 1.00× VaLiDRec Parallel token scoring One LLM forward pass – 0.078 87.49× We compare VaLiDRec with LC-Rec because both methods fine-tune the same LLM backbone for SID-based recommendation, while adopting different inference mechanisms. LC-Rec autoregressively generates quantized SID tokens and applies beam search to obtain recommendation candidates. Let L denote the SID length and B the beam size. Its inference requires (BL)O(BL) sequential LLM decoding steps, since each beam must be expanded over multiple generation steps. In contrast, VaLiDRec predicts the scores of all semantic SID tokens in parallel using a single LLM forward pass. The resulting token scores are then aggregated over item SIDs to obtain item-level relevance scores, without autoregressive generation or beam search. Therefore, the number of LLM forward passes is constant with respect to L and B. This does not imply constant end-to-end complexity: full-catalog item scoring requires (∑j∈ℐ|Sj|)O\! ( _j |S_j| ) lightweight token-to-item aggregation operations. SID construction is performed offline and is excluded from online inference. As reported in Table 4, under the same LLM backbone, hardware, and batch-size setting, LC-Rec requires an average of 6.824 seconds per test instance with a beam size of 100, whereas VaLiDRec requires 0.078 seconds. This corresponds to an 87.49×87.49× speedup, demonstrating that replacing sequential SID generation with one-pass token scoring substantially reduces the online LLM inference overhead. 5.8. SID Quality Analysis To evaluate SID quality, we compare the Initial SID used in the w/o SID Refinement variant with the Refined SID produced by the complete Stage 1 process. The Initial SID contains importance-selected candidates before pruning and collision handling. We assess semantic preservation, compactness, and item-level uniqueness. Table 5. Comparison of the semantic quality, compactness, and collision rates of the initial and refined SIDs. Dataset SID Quality ≥ 0.95 Length Compression Collision† Luxury Initial 0.9023 13.66% 14.81 0.1493 1.90% Refined 0.9461 83.02% 8.81 0.1034 1.78% Scientific Initial 0.9103 15.04% 15.14 0.1511 1.36% Refined 0.9495 84.12% 8.88 0.0982 0.77% Instruments Initial 0.9214 26.86% 14.75 0.1980 0.83% Refined 0.9526 90.51% 8.27 0.1356 0.56% Arts Initial 0.9245 26.00% 15.40 0.1890 0.97% Refined 0.9529 94.39% 7.56 0.1036 0.72% † Collision is measured before suffix-based disambiguation; the final collision ratio is 0 for all datasets. As shown in Table 5, SID refinement consistently improves semantic quality while producing more compact identifiers. Average semantic quality increases from 0.9023–0.9245 to 0.9461–0.9529, while the proportion of SIDs above 0.95 rises from 13.66%–26.86% to 83.02%–94.39%. Meanwhile, the average SID length is reduced from about 15 tokens to 7.56–8.88, indicating that semantic-quality-aware pruning effectively removes redundant tokens while preserving item semantics. Collision-aware expansion further reduces semantic collisions, and suffix-based disambiguation eliminates all remaining item-level collisions. Overall, the refined SIDs are more semantically faithful, compact, and uniquely identifiable. 6. Conclusion We presented VaLiDRec, a generative recommendation framework that constructs variable-length SIDs directly from the native vocabulary of pretrained LLMs. VaLiDRec selects informative metadata tokens through importance scoring and semantic-quality-aware pruning, resolves residual identifier collisions, and incorporates item-level structural relations and behavioral transitions through graph-aware soft prompts. By formulating recommendation as token-set prediction and token-level item scoring, it avoids autoregressive SID generation and beam search. Experiments on four datasets demonstrate consistent improvements over strong sequential and generative baselines, while the cold-start and efficiency results further show its effectiveness for unseen items and efficient online inference. In future work, we will extend VaLiDRec to multimodal item representations and investigate its transferability across recommendation domains. Acknowledgements.The Australian Research Council supports this work under the streams of Future Fellowship (Grant No. FT210100624), the Discovery Project (Grant No. DP240101108), and the Linkage Project (Grant No. LP230200892). References K. Bao, J. Zhang, Y. Zhang, W. Wenjie, F. Feng, and X. He (2023) Large language models for recommendation: progresses and future directions. In Proceedings of the Annual International ACM SIGIR Conference on Research and Development in Information Retrieval in the Asia Pacific Region, p. 306–309. Cited by: §1. T. Brown, B. Mann, N. Ryder, M. Subbiah, J. D. Kaplan, P. Dhariwal, A. Neelakantan, P. Shyam, G. Sastry, A. Askell, et al. (2020) Language models are few-shot learners. Advances in neural information processing systems 33, p. 1877–1901. Cited by: §1. W. Cheng, M. Gong, Q. Guo, H. Zheng, Z. Yang, J. Lou, and Z. Zheng (2026) CapsID: soft-routed variable-length semantic ids for generative recommendation. arXiv preprint arXiv:2605.05096. Cited by: §2.2. J. Deng, S. Wang, K. Cai, L. Ren, Q. Hu, W. Ding, Q. Luo, and G. Zhou (2025) Onerec: unifying retrieve and rank with generative recommender and iterative preference alignment. arXiv preprint arXiv:2502.18965. Cited by: §1, §2.2. X. Du, H. Yuan, P. Zhao, J. Qu, F. Zhuang, G. Liu, Y. Liu, and V. S. Sheng (2023) Frequency enhanced hybrid attention network for sequential recommendation. In Proceedings of the 46th international ACM SIGIR conference on research and development in information retrieval, p. 78–88. Cited by: §2.1. J. Fu, X. Ge, A. Karatzoglou, I. Arapakis, S. Verberne, J. M. Jose, and Z. Ren (2026) Differentiable semantic id for generative recommendation. arXiv preprint arXiv:2601.19711. Cited by: §2.2. S. Geng, S. Liu, Z. Fu, Y. Ge, and Y. Zhang (2022) Recommendation as language processing (rlp): a unified pretrain, personalized prompt & predict paradigm (p5). In Proceedings of the 16th ACM conference on recommender systems, p. 299–315. Cited by: §1, §1. A. Grattafiori, A. Dubey, A. Jauhri, A. Pandey, A. Kadian, A. Al-Dahle, A. Letman, A. Mathur, A. Schelten, A. Vaughan, et al. (2024) The llama 3 herd of models. arXiv preprint arXiv:2407.21783. Cited by: §1, §5.2. W. Hamilton, Z. Ying, and J. Leskovec (2017) Inductive representation learning on large graphs. Advances in neural information processing systems 30. Cited by: §4.2.1. B. Hidasi (2015) Session-based recommendations with recurrent neural networks. arXiv preprint arXiv:1511.06939. Cited by: §2.1, 1st item. Y. Hou, Z. He, J. McAuley, and W. X. Zhao (2023) Learning vector-quantized item representation for transferable sequential recommenders. In Proceedings of the ACM Web Conference 2023, p. 1162–1171. Cited by: §1. Y. Hou, J. Li, A. Shin, J. Jeon, A. Santhanam, W. Shao, K. Hassani, N. Yao, and J. McAuley (2025) Generating long semantic ids in parallel for recommendation. In Proceedings of the 31st ACM SIGKDD Conference on Knowledge Discovery and Data Mining V. 2, p. 956–966. Cited by: §1, §2.2, 7th item. E. J. Hu, Y. Shen, P. Wallis, Z. Allen-Zhu, Y. Li, S. Wang, L. Wang, W. Chen, et al. (2022) Lora: low-rank adaptation of large language models.. Iclr 1 (2), p. 3. Cited by: §1. W. Hua, S. Xu, Y. Ge, and Y. Zhang (2023) How to index item ids for recommendation foundation models. In Proceedings of the Annual International ACM SIGIR Conference on Research and Development in Information Retrieval in the Asia Pacific Region, p. 195–204. Cited by: §1. J. Jia, J. Gao, B. Xue, J. Wang, Q. Cai, Q. Chen, X. Zhao, P. Jiang, and K. Gai (2025) From principles to applications: a comprehensive survey of discrete tokenizers in generation, comprehension, recommendation, and information retrieval. arXiv preprint arXiv:2502.12448. Cited by: §1. W. Kang and J. McAuley (2018) Self-attentive sequential recommendation. In 2018 IEEE international conference on data mining (ICDM), p. 197–206. Cited by: §2.1, 3rd item. D. Lee, C. Kim, S. Kim, M. Cho, and W. Han (2022) Autoregressive image generation using residual quantization. In Proceedings of the IEEE/CVF conference on computer vision and pattern recognition, p. 11523–11532. Cited by: §1. J. Li, P. Ren, Z. Chen, Z. Ren, T. Lian, and J. Ma (2017) Neural attentive session-based recommendation. In Proceedings of the 2017 ACM on Conference on Information and Knowledge Management, p. 1419–1428. Cited by: §2.1. X. Lin, H. Shi, W. Wang, F. Feng, Q. Wang, S. Ng, and T. Chua (2025) Order-agnostic identifier for large language model-based generative recommendation. In Proceedings of the 48th international ACM SIGIR conference on research and development in information retrieval, p. 1923–1933. Cited by: §1. E. Liu, B. Zheng, C. Ling, L. Hu, H. Li, and W. X. Zhao (2025a) 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, p. 729–739. Cited by: §2.2. J. Liu, L. Collins, J. Tang, T. Zhao, N. Shah, and C. M. Ju (2025b) Understanding generative recommendation with semantic ids from a model-scaling view. arXiv preprint arXiv:2509.25522. Cited by: §2.2. F. Mentzer, D. Minnen, E. Agustsson, and M. Tschannen (2024) Finite scalar quantization: vq-vae made simple. In International Conference on Learning Representations, Vol. 2024, p. 51772–51783. Cited by: §1. A. V. Petrov and C. Macdonald (2023) Generative sequential recommendation with gptrec. arXiv preprint arXiv:2306.11114. Cited by: §1. H. Qu, W. Fan, Z. Zhao, and Q. Li (2025) Tokenrec: learning to tokenize id for llm-based generative recommendations. IEEE Transactions on Knowledge and Data Engineering. Cited by: §2.2. C. Raffel, N. Shazeer, A. Roberts, K. Lee, S. Narang, M. Matena, Y. Zhou, W. Li, and P. J. Liu (2020) Exploring the limits of transfer learning with a unified text-to-text transformer. Journal of machine learning research 21 (140), p. 1–67. Cited by: 5th item. S. Rajput, N. Mehta, A. Singh, R. Hulikal Keshavan, T. Vu, L. Heldt, L. Hong, Y. Tay, V. Tran, J. Samost, et al. (2023) Recommender systems with generative retrieval. Advances in Neural Information Processing Systems 36, p. 10299–10315. Cited by: §1, §1, §1, §2.2, 5th item. S. Rendle, C. Freudenthaler, and L. Schmidt-Thieme (2010) Factorizing personalized markov chains for next-basket recommendation. In Proceedings of the 19th international conference on World wide web, p. 811–820. Cited by: §2.1. G. Salton and C. Buckley (1988) Term-weighting approaches in automatic text retrieval. Information processing & management 24 (5), p. 513–523. Cited by: §4.1.1. F. Sun, J. Liu, J. Wu, C. Pei, X. Lin, W. Ou, and P. Jiang (2019) BERT4Rec: sequential recommendation with bidirectional encoder representations from transformer. In Proceedings of the 28th ACM international conference on information and knowledge management, p. 1441–1450. Cited by: §2.1, 4th item. J. Tang and K. Wang (2018) Personalized top-n sequential recommendation via convolutional sequence embedding. In Proceedings of the eleventh ACM international conference on web search and data mining, p. 565–573. Cited by: §2.1, 2nd item. H. Wang, W. Guo, L. Zhang, J. Y. Chin, Y. Ye, H. Guo, Y. Liu, D. Lian, R. Tang, and E. Chen (2025) Generative large recommendation models: emerging trends in llms for recommendation. In Companion Proceedings of the ACM on Web Conference 2025, p. 49–52. Cited by: §1. H. Wang, X. Yao, Y. Qiu, Q. Zhang, H. Wang, Y. Cui, S. Wang, S. Xu, and M. Li (2026) Towards efficient and generalizable retrieval: adaptive semantic quantization and residual knowledge transfer. arXiv preprint arXiv:2602.23978. Cited by: §2.2, 8th item. W. Wang, H. Bao, X. Lin, J. Zhang, Y. Li, F. Feng, S. Ng, and T. Chua (2024a) Learnable item tokenization for generative recommendation. In Proceedings of the 33rd ACM International Conference on Information and Knowledge Management, p. 2400–2409. Cited by: §2.2. W. Wang, X. Lin, F. Feng, X. He, and T. Chua (2023) Generative recommendation: towards next-generation recommender paradigm. arXiv preprint arXiv:2304.03516. Cited by: §1. Y. Wang, J. Xun, M. Hong, J. Zhu, T. Jin, W. Lin, H. Li, L. Li, Y. Xia, Z. Zhao, et al. (2024b) Eager: two-stream generative recommender with behavior-semantic collaboration. In Proceedings of the 30th ACM SIGKDD Conference on Knowledge Discovery and Data Mining, p. 3245–3254. Cited by: §2.2. S. Wu, Y. Tang, Y. Zhu, L. Wang, X. Xie, and T. Tan (2019) Session-based recommendation with graph neural networks. In Proceedings of the AAAI conference on artificial intelligence, Vol. 33, p. 346–353. Cited by: §2.1. X. Xie, F. Sun, Z. Liu, S. Wu, J. Gao, J. Zhang, B. Ding, and B. Cui (2022) Contrastive learning for sequential recommendation. In 2022 IEEE 38th international conference on data engineering (ICDE), p. 1259–1273. Cited by: §2.1. J. Zhai, L. Liao, X. Liu, Y. Wang, R. Li, X. Cao, L. Gao, Z. Gong, F. Gu, M. He, et al. (2024) Actions speak louder than words: trillion-parameter sequential transducers for generative recommendations. arXiv preprint arXiv:2402.17152. Cited by: §2.2. Z. Zhang, J. Zhao, X. Ma, X. Xin, M. de Rijke, and Z. Ren (2026) Cold-starts in generative recommendation: a reproducibility study. arXiv preprint arXiv:2603.29845. Cited by: §5.1. B. Zheng, Y. Hou, H. Lu, Y. Chen, W. X. Zhao, M. Chen, and J. Wen (2024) Adapting large language models by integrating collaborative semantics for recommendation. In 2024 IEEE 40th International Conference on Data Engineering (ICDE), p. 1435–1448. Cited by: §2.2, 6th item. K. Zhou, H. Wang, W. X. Zhao, Y. Zhu, S. Wang, F. Zhang, Z. Wang, and J. Wen (2020) S3-rec: self-supervised learning for sequential recommendation with mutual information maximization. In Proceedings of the 29th ACM international conference on information & knowledge management, p. 1893–1902. Cited by: §2.1.