acceptodds
Under review as a conference paper at ICLR 2027

CUBER: KEEP DEPENDENCY IN PARALLEL SID FOR GENERATIVE RECOMMENDATION

Abstract

Semantic IDs (SIDs) play a critical role in generative recommendation (GR), with early approaches capturing hierarchical item information through progressively refined code sequences. To improve efficiency, more recent approaches based on product quantization (PQ) decompose item representations into multiple subspaces and quantize them independently, enabling parallel SID construction and single-forward code prediction. However, such methods do not explicitly encode structured dependencies among SID codes. To address this limitation, we present Cuber, which captures structured dependencies among SID codes while retaining parallel code prediction. Specifically, Cuber integrates three key techniques: (1) RPQ-Tree, a unified SID construction framework that recursively composes residual and product quantization, introducing dependencies across quantization components while supporting single-forward prediction; (2) a geometry-aware embedding initialization scheme that transfers the structural relationships learned during quantization into the code-token embeddings; and (3) a progressive training mechanism that exploits partial-tree predictions to mine increasingly challenging hard negatives, strengthening both code-level discrimination and catalog-level ranking. Extensive experiments demonstrate that Cuber consistently outperforms competitive baselines across multiple recommendation metrics, achieving 25.2% improvement in Recall and 23.6% in NDCG.

Primary area:
generative models
Keywords:
Generative Recommendation, Large Language Models, Semantic ID

Reviews

Among:
Shape:
1234this paper, Top 15%
Figure 1. Mean review rating of the reviewed papers at ICLR 2027. This paper averages 3.00 over 3 reviews, above 85% of the others.
Reviewer_spULOpenReview ↗
Rating
3(+1)
Confidence
3
Informativeness
2
Presentation
2(−1)
Soundness
2
Read review
Paper summary

This paper proposes Cuber, a framework for parallel Semantic ID based recommendation. It introduces RPQ-Tree to combine residual and product quantization, uses geometry-aware initialization to transfer codeword information into token embeddings, and applies progressive hard-negative training to improve item discrimination.

Critical strengths

The paper addresses a relevant problem in parallel SID recommendation. Combining residual refinement with parallel code prediction is a reasonable direction, and the overall framework is technically coherent.

Critical weaknesses

W1: Combining product and residual quantization has been studied in earlier work such as Residual Vector Product Quantization. The proposed RPQ-Tree mainly extends this idea into a recursive framework for SID construction. The geometry-aware initialization relies on a standard orthogonal transformation, while the progressive training combines established hard-negative mining and ranking objectives. The paper does not clearly demonstrate a substantial technical advance beyond these existing components.

W2: Although RPQ-Tree introduces dependencies during quantization, the recommendation model still predicts SID codes through independent parallel heads and scores items using an additive combination of code probabilities. The proposed system does not explicitly model interactions between the predicted codes. The current experiments show that the overall method works better, but they do not establish that modeling code dependencies is the reason for these improvements.

W3: The current sequential ablation experiments do not adequately isolate the contributions of the method’s individual modules. The following comparisons are missing: comparing the quantization module with existing residual product quantization methods; comparing the initialization method with a simpler centroid-based initialization method; and comparing progressive training with standard hard negative mining and an item-level ranking objective that does not use the proposed hierarchy.

W4: Although the paper emphasizes single-forward prediction, it does not report comparisons of actual inference latency, throughput, or training costs. Moreover, its strongest performance claims are based on comparisons with only some baseline methods, and its cold-start results are less stable than those of MHL. The paper should also include more recent semantic-ID-based methods as baselines.

Questions for authors

see the weaknesses.

5 comments

W1: Technical Novelty

We would like to clarify that Cuber's novelty lies beyond simply combining existing techniques. Our contributions address three key challenges in parallel generative recommendation.

First, RPQ-Tree extends RQ–PQ quantization to parallel generative recommendation. RVPQ [1] was originally developed for approximate nearest neighbor (ANN) search, which relies on quantized representations for distance-based retrieval. In contrast, generative recommendation requires predicting SID codes from user histories, where lower reconstruction error does not necessarily imply better recommendation performance. Our work demonstrates the effectiveness of combining RQ and PQ for single-forward SID prediction. Furthermore, unlike the fixed PQ-then-RQ structure of RVPQ, RPQ-Tree enables flexible recursive compositions, including different subspace partitions across residual stages.

Second, geometry-aware initialization provides a lightweight bridge between SID construction and recommendation learning. Conventional GR methods typically separate these stages, preventing the generator from directly exploiting the codeword geometry learned during quantization. While methods such as ETEGRec and DIGER address this gap through joint optimization, our approach transfers the learned geometric relationships into token embeddings through a simple, geometry-preserving initialization, avoiding additional joint-training complexity.

Third, progressive training exploits the SID hierarchy rather than merely applying conventional hard-negative mining. It progressively uses deeper tree levels to identify increasingly fine-grained confusions and incorporates them into both code-level discrimination and catalog-level ranking.

Together, these contributions form a unified framework in which SID construction, geometric initialization, and hierarchy-guided training are jointly designed to improve recommendation quality while retaining efficient parallel prediction.

W2: Effectiveness of Code Dependencies

Cuber exploits the structural dependencies introduced during SID construction without explicitly conditioning one prediction head on another. Although SID codes are predicted in parallel, the prediction heads share the same user-history representation and are jointly optimized through a shared backbone. We hypothesize that this shared representation helps the model learn to predict hierarchically structured SIDs without requiring explicit interactions between the heads.

During the initial design of our method, we also explored explicit dependency modeling through an MTP-inspired layer-wise predictor (Cuber-LP) on the two-level Cuber-A and Cuber-B variants. It first predicts higher-level code distributions and then uses their probability-weighted embeddings to condition lower-level predictions through an additional structured attention layer. As shown below, Cuber-LP does not yield consistent improvements across the three datasets, while increasing trainable parameters by approximately 12.8%.

MethodSports R@10Sports N@10Beauty R@10Beauty N@10Toys R@10Toys N@10
Cuber-A0.05420.03090.09180.05180.09660.0557
Cuber-LP-A0.05360.03080.08850.05180.09650.0563
Cuber-B0.05380.03090.09080.05230.09580.0569
Cuber-LP-B0.05410.03110.09080.05250.09610.0560

Given these mixed results and the additional complexity, we retain RPG's parallel multi-head prediction architecture to preserve inference efficiency. Nevertheless, explicit dependency modeling remains a direction worth further investigation.

The ablation study in Table 3 already provides evidence for the contribution of hierarchical SID construction. Specifically, it compares OPQ-32 with RPQ-Tree before introducing geometry-aware initialization or progressive training, using the same co-occurrence-augmented item representations and parallel prediction architecture. RPQ-Tree consistently outperforms OPQ-32 across all three datasets, supporting the contribution of hierarchical dependencies introduced during SID construction to recommendation performance, independently of the other two proposed components.

References:

[1] Niu et al. Residual Vector Product Quantization for Approximate Nearest Neighbor Search. Expert Systems with Applications, 2023.

W3: Independent Contributions of Individual Modules

To better isolate the contributions of individual modules, we conduct three additional controlled experiments, each replacing one component of Cuber while keeping the remaining components and experimental settings unchanged. Specifically, (1) we replace RPQ-Tree with the RVPQ-style quantization structure adopted by MHQ in AsymRec [1], which applies residual quantization within each product-quantized subspace; (2) we replace geometry-aware initialization with the centroid-based initialization proposed in a recent study by Loveland et al. [2], which also explores the benefits of SID token initialization for recommendation performance; and (3) we replace progressive training with standard hard-negative mining based on full-SID item scores and an item-level ranking objective, without hierarchy-guided progressive mining. The results are presented below.

MethodSports R@10Sports N@10Beauty R@10Beauty N@10Toys R@10Toys N@10
Cuber-A0.05420.03090.09180.05180.09660.0557
w/ MHQ Quantization0.05280.03080.08580.04910.09210.0526
w/ Truncated Centroid Initialization0.04480.02470.08100.04750.08510.0499
w/ Standard Hard Negatives + Ranking0.05320.03030.08710.05080.09310.0549
MethodSports R@10Sports N@10Beauty R@10Beauty N@10Toys R@10Toys N@10
Cuber-B0.05380.03090.09080.05230.09580.0569
w/ MHQ Quantization0.05280.03080.08580.04910.09210.0526
w/ Truncated Centroid Initialization0.04940.02750.07880.04610.08600.0492
w/ Standard Hard Negatives + Ranking0.05260.03020.08920.05140.09710.0556

The results show that both Cuber variants outperform the MHQ-style quantization and truncated centroid initialization baselines across all datasets and metrics. Replacing progressive training with standard hard-negative mining and ranking also generally degrades performance, except for R@10 on Toys with Cuber-B. These findings provide further evidence of the individual contributions of all three components.

References:

[1] Huang et al. Asymmetric Generative Recommendation via Kronecker Residual Bridge and Multi-Faceted Hierarchical Quantization. arXiv:2605.14512, 2026.

[2] Loveland et al. Preserving Item Semantics for Free: Rethinking Token Initialization in LLM-Based Generative Recommendation. arXiv:2608.07816, 2026.

W4: Efficiency, Recent Baselines, and Cold-Start Performance

We provide additional comparisons of training costs, inference latency, and throughput against representative generative recommendation methods on Sports, as shown below. Per-epoch training times in brackets correspond to different training stages.

MethodEncoder Training TimeModel Parameter SizeModel Training Time per epochModel Training Peak MemoryInference TimeInference Throughput
TIGER59 min 40 s4.03 M27.1 s6.39 GiB7 min 48s76 req/s
RPG36.8 s13.58 M15.5 s4.02 GiB12.5 s2847 req/s
MHL37.2 s14.30 M[75.1s, 80.3s, 21.5s]5.60 GiB17.2 s2067 req/s
ACERec37.8 s29.56 M32.2 s6.69 GiB17.1 s2080 req/s
AsymRec30.8 s19.04 M25.4 s5.65 GiB14.6 s2439 req/s
Cuber-A66.2 s13.58 M[19.5s, 24.4s]4.02 GiB12.6 s2826 req/s
Cuber-B86.9 s13.58 M[19.3s, 24.3s]4.02 GiB12.3 s2880 req/s

Cuber incurs moderately higher SID construction and training costs than RPG but maintains the same parameter count and peak training memory. More importantly, its inference latency and throughput remain comparable to RPG and outperform the other methods, demonstrating that the proposed components preserve the efficiency of parallel prediction.

We also extend our recommendation performance comparisons to recent semantic-ID-based methods, including LETTER [1], ReSID [2], CapSID [3], ACERec [4], and AsymRec [5]. The results for LETTER, ReSID, and CapSID are taken from the CapSID paper [3], while those for ACERec and AsymRec are reproduced in our experiments.

MethodSports R@10Sports N@10Beauty R@10Beauty N@10Toys R@10Toys N@10
LETTER0.04350.02440.07080.04060.07410.0452
ReSID0.04750.02660.07700.04380.07860.0481
CapSID0.05270.02900.08390.04770.08550.0528
ACERec0.04160.02280.07610.04390.08620.0516
AsymRec0.04830.02910.07900.04760.09320.0549
Cuber-A0.05420.03090.09180.05180.09660.0557
Cuber-B0.05380.03090.09080.05230.09580.0569

Both Cuber variants consistently outperform these recent methods across all three datasets, further demonstrating their effectiveness alongside competitive inference efficiency.

Regarding cold-start performance, MHL's masked-history reconstruction introduces additional supervision by turning selected historical items into reconstruction targets. This provides further learning opportunities for infrequent items beyond next-item prediction, which may explain MHL's advantages in certain frequency groups. However, this approach also incurs substantial training overhead, including an additional forward pass for entropy-guided masking. Nevertheless, Cuber outperforms MHL in the sparsest frequency range ([0, 5]) on both Sports and Toys, demonstrating competitive cold-start performance with substantially lower training costs.

References:

[1] Wang et al. Learnable Item Tokenization for Generative Recommendation. CIKM, 2024.

[2] Liang et al. Rethinking Generative Recommender Tokenizer: RecSys-Native Encoding and Semantic Quantization Beyond LLMs. arXiv:2602.02338, 2026.

[3] Cheng et al. CapsID: Soft-Routed Variable-Length Semantic IDs for Generative Recommendation. arXiv:2605.05096, 2026.

[4] Xia et al. Unleash the Potential of Long Semantic IDs for Generative Recommendation. arXiv:2602.13573, 2026.

[5] Huang et al. Asymmetric Generative Recommendation via Kronecker Residual Bridge and Multi-Faceted Hierarchical Quantization. arXiv:2605.14512, 2026.

Thank you for your valuable feedback. We will revise the manuscript accordingly. We hope our responses have addressed your concerns and that you would consider revisiting your rating.

Reviewer_iWJVOpenReview ↗
Rating
3(+1)
Confidence
3
Informativeness
1
Presentation
2
Soundness
2
Read review
Paper summary

This paper proposes Cuber, a framework for parallel Semantic ID (SID) generation in generative recommendation. The authors aim to address the limitations of conventional product quantization, which enables parallel decoding but may lose structural dependencies among quantized codes. To this end, Cuber introduces an RPQ-Tree that recursively combines residual and product quantization, a geometry-aware embedding initialization strategy that transfers quantization information to the generative model, and a progressive training scheme incorporating hierarchy-guided hard-negative mining and ranking objectives.

Experiments on four Amazon recommendation datasets demonstrate improvements over several existing generative recommendation methods. Ablation studies and additional analyses investigate the contributions of the proposed components and the effects of different SID configurations.

Critical strengths

The paper addresses an important trade-off in generative recommendation between preserving structural information in Semantic IDs and enabling efficient parallel decoding. The proposed RPQ-Tree provides a flexible framework for combining residual and product quantization, allowing different configurations of hierarchical and parallel code structures. The overall approach is technically reasonable and potentially useful for improving the quality of parallel SID representations.

The paper provides relatively comprehensive experiments across four recommendation datasets, with comparisons against several representative generative recommendation baselines. The ablation studies suggest that the proposed quantization structure, geometry-aware initialization, and progressive training strategy each contribute to performance improvements. Additional analyses of SID length and decoding configurations provide useful insights into the behavior of the framework.

Critical weaknesses

Although the paper emphasizes preserving dependencies among Semantic ID codes, the proposed model still predicts different code positions independently during inference and aggregates their log-probabilities for item ranking. Therefore, the dependencies introduced by the RPQ-Tree are primarily reflected in the offline quantization structure and embedding initialization, rather than being explicitly modeled during generation. This raises questions about the extent to which the proposed framework actually addresses the dependency modeling problem highlighted in the motivation. Moreover, the individual components, including residual/product quantization, geometry-aware initialization, and hard-negative mining, are closely related to established techniques. Stronger evidence is needed to demonstrate that their combination provides a distinctive methodological contribution beyond improved SID construction and training.

The fairness of the experimental comparisons is not sufficiently established. In particular, Cuber constructs Semantic IDs using both textual and co-occurrence representations, followed by PCA-based dimensionality reduction. It is unclear whether competing SID-based methods use the same input features and preprocessing configurations. If the baselines rely on different representations, part of the observed improvement may be attributable to additional input information rather than the proposed RPQ-Tree or training strategy. A controlled comparison using identical input features and representation dimensions across methods is necessary to support the claimed improvements.

The experimental comparison with recent parallel SID generation approaches remains incomplete. Although the paper compares against representative methods such as RPG and MHL, additional comparisons with more recent alternatives, such as ACERec and VaLiDRec, would help clarify the advantages of the proposed framework. These approaches also investigate efficient or parallel recommendation generation using alternative Semantic ID representations. Without stronger comparisons, it is difficult to assess whether Cuber offers a meaningful improvement over the latest developments in this direction.

The paper emphasizes the efficiency benefits of single-forward parallel decoding, but the practical computational advantages are not sufficiently quantified. In particular, inference latency, throughput, and memory consumption under comparable hardware settings are not systematically reported against relevant parallel and autoregressive baselines. Since efficiency is a central motivation of the work, reporting only recommendation accuracy provides an incomplete picture of its practical value. Furthermore, the main results lack statistical variability estimates, making it difficult to assess the robustness of the reported improvements.

Questions for authors

Since the model still predicts Semantic ID positions independently during inference, how are the dependencies introduced by the RPQ-Tree actually exploited during generation? Could the authors provide additional experiments that isolate the contribution of residual dependencies from the effects of improved quantization and embedding initialization?

Were all SID-based baselines constructed using the same textual and co-occurrence features and PCA dimensionality as Cuber? If not, could the authors provide controlled comparisons under identical input representations to clarify how much of the improvement comes from the proposed method itself?

Could the authors provide comparisons with more recent parallel SID generation approaches, such as ACERec and VaLiDRec? In particular, how does Cuber compare with these methods in terms of recommendation accuracy, inference efficiency, and model complexity?

Could the authors report actual inference latency, throughput, and memory consumption under the same hardware settings as the baselines? How do the computational costs differ between full-catalog scoring and graph-based decoding?

How sensitive is the performance to the layer-specific scoring weights and the RPQ-Tree configurations, including codebook sizes and hierarchical structure? Would simpler configurations with uniform weights achieve comparable performance?

Could the authors provide results across multiple random seeds, together with standard deviations or statistical significance tests, to establish the robustness of the reported improvements?

9 comments

W1. Dependency modeling and methodological contribution

W1.1 & Q1.1. Dependencies during parallel prediction

In Cuber, although SID codes are predicted in parallel, the prediction heads share the same user-history representation and are jointly optimized through a shared backbone. We hypothesize that this shared representation and joint optimization help support effective parallel prediction through separate heads, even in the absence of explicit conditioning between the heads.

During the initial design of our method, we also experimented with explicitly exploiting the hierarchical dependencies among SID codes during inference. Specifically, we evaluated an MTP-inspired layer-wise predictor (Cuber-LP) on the two-level Cuber-A and Cuber-B variants. It first predicts higher-level code distributions and then uses their probability-weighted embeddings to condition lower-level code prediction through an additional structured attention layer. As shown in Table 1, this variant did not yield consistent improvements in Recall@10 or NDCG@10 across Sports, Beauty, and Toys, while increasing trainable parameters by approximately 12.8%. Given these mixed results and the additional complexity, we retained RPG’s parallel multi-head prediction architecture to maintain a simple and efficient prediction process. Nevertheless, explicit dependency modeling during prediction remains a promising direction that we are continuing to investigate.

Table 1. Parallel prediction and the Cuber-LP variant.

MethodSports R@10Sports N@10Beauty R@10Beauty N@10Toys R@10Toys N@10
Cuber-A0.05420.03090.09180.05180.09660.0557
Cuber_LP-A0.0536 ↓0.0308 ↓0.0885 ↓0.0518 —0.0965 ↓0.0563 ↑
Cuber-B0.05380.03090.09080.05230.09580.0569
Cuber_LP-B0.0541 ↑0.0311 ↑0.0908 —0.0525 ↑0.0961 ↑0.0560 ↓

W1.2. Distinctive methodological contribution beyond established components

We would like to clarify that Cuber's contribution goes beyond simply combining established techniques. Its three components are designed to address distinct but interconnected challenges in parallel generative recommendation.

First, RPQ-Tree extends RQ–PQ quantization to parallel SID prediction. RQ/PQ/RVPQ was originally developed for approximate nearest neighbor search, where quantized representations are used for distance-based retrieval. In contrast, generative recommendation requires predicting SID codes from user histories, and lower reconstruction error does not necessarily translate into better recommendation performance. Unlike the fixed PQ-then-RQ structure adopted by RVPQ-style methods, RPQ-Tree supports flexible recursive compositions of RQ and PQ, enabling different subspace partitions across residual stages while retaining single-forward SID prediction.

Second, geometry-aware initialization connects SID construction with recommendation learning. Conventional generative recommendation methods typically separate these stages, limiting the use of geometric relationships learned during quantization. While methods such as ETEGRec and DIGER address this gap through joint optimization, our method transfers codeword geometry into token embeddings through a lightweight, geometry-preserving initialization without requiring joint tokenizer-generator training.

Third, progressive training exploits hierarchical SID structure beyond conventional hard-negative mining. Instead of mining negatives solely based on full-SID scores, it progressively uses deeper tree levels to identify increasingly fine-grained confusable items and incorporates them into both code-level discrimination and catalog-level ranking.

To further validate these contributions, we conduct three controlled experiments, each replacing one component while keeping the others and all experimental settings unchanged. Specifically, (1) we replace RPQ-Tree with the RVPQ-style quantization structure adopted by MHQ, which applies residual quantization within each product-quantized subspace; (2) we replace geometry-aware initialization with the truncated centroid-based initialization adapted from the recent study by Loveland et al., which also investigates SID token initialization for recommendation; and (3) we replace progressive training with standard hard-negative mining based on full-SID item scores and an item-level ranking objective, without hierarchy-guided progressive mining.

Results for Cuber-A:

MethodSports R@10Sports N@10Beauty R@10Beauty N@10Toys R@10Toys N@10
Cuber-A0.05420.03090.09180.05180.09660.0557
w/ MHQ Quantization0.05280.03080.08580.04910.09210.0526
w/ Truncated Centroid Initialization0.04480.02470.08100.04750.08510.0499
w/ Standard Hard Negatives + Ranking0.05320.03030.08710.05080.09310.0549

Results for Cuber-B:

MethodSports R@10Sports N@10Beauty R@10Beauty N@10Toys R@10Toys N@10
Cuber-B0.05380.03090.09080.05230.09580.0569
w/ MHQ Quantization0.05280.03080.08580.04910.09210.0526
w/ Truncated Centroid Initialization0.04940.02750.07880.04610.08600.0492
w/ Standard Hard Negatives + Ranking0.05260.03020.08920.05140.09710.0556

Both Cuber variants outperform the MHQ-style quantization and truncated centroid initialization baselines across all datasets and metrics. Replacing progressive training with standard hard-negative mining and ranking also degrades performance in 11 of the 12 comparisons. These results support the effectiveness of each component within the complete framework.

W2 & Q2. Fairness

Increasing the PCA dimension from 128 to 144 does not consistently improve recommendation performance. We evaluated RPG, ACERec [1], MHL, and AsymRec [2] at both dimensions; the results in Table 2 show that the effect varies across methods and datasets. Cuber adopts 144 dimensions to accommodate equal-width partitions across its RPQ-Tree configurations.

We further evaluated all baselines with co-occurrence augmentation at PCA-144. Table 3 shows that Cuber achieves the highest mean Recall@10 and NDCG@10 across Sports, Beauty, and Toys. Adding co-occurrence information to other methods yields inconsistent gains: relative to PCA-144 alone, MHL declines in both metrics on three datasets, RPG declines on Toys, and AsymRec's NDCG@10 decreases on Toys. These comparisons support Cuber's integrated design, which maintains its advantage even when baselines use co-occurrence information at the same embedding dimensionality.

Table 2. PCA-128 versus PCA-144.

MethodPCA dim.Sports R@10Sports N@10Beauty R@10Beauty N@10Toys R@10Toys N@10CDs R@10CDs N@10
RPG1280.04190.02430.07340.04300.07870.04590.07080.0399
1440.04150.02380.07520.04370.07780.04540.07180.0405
ACERec1280.04160.02280.07610.04390.08620.05160.07760.0432
1440.04630.02590.08060.04650.08770.05240.07320.0404
MHL1280.05090.02920.07840.04860.08830.05470.06510.0380
1440.05140.03040.07900.04830.09220.05590.07170.0411
AsymRec1280.04830.02910.07900.04760.09320.05490.07760.0431
1440.05100.02850.08120.04830.09250.05500.07690.0432

Table 3. PCA-144 with co-occurrence augmentation for all methods.

MethodSports R@10Sports N@10Beauty R@10Beauty N@10Toys R@10Toys N@10
RPG0.04610.02650.08160.04710.07720.0425
ACERec0.04810.02750.08100.04540.08410.0491
MHL0.04960.02930.07640.04570.09190.0554
AsymRec0.05300.02900.08940.05170.09320.0524
Cuber-A0.05460.03130.09040.05160.09580.0559
Cuber-B0.05310.03060.08960.05180.09490.0558

W3 & Q3. Comparisons with recent parallel SID generation methods

We evaluated RPG, ACERec, MHL, and AsymRec against Cuber-A and Cuber-B using PCA-144 throughout. (resource constraints prevented us from reproducing VaLiDRec with the backbone used in its paper, and replacing it with Cuber's backbone did not yield a successful reproduction). The results in Table 4 show that Cuber maintains an overall performance advantage against these newer baselines.

Table 4. Recommendation accuracy of recent baselines and Cuber at PCA-144.

MethodPCA dim.Sports R@10Sports N@10Beauty R@10Beauty N@10Toys R@10Toys N@10CDs R@10CDs N@10
RPG1440.04150.02380.07520.04370.07780.04540.07180.0405
ACERec1440.04630.02590.08060.04650.08770.05240.07320.0404
MHL1440.05140.03040.07900.04830.09220.05590.07170.0411
AsymRec1440.05100.02850.08120.04830.09250.05500.07690.0432
Cuber-A1440.05460.03130.09040.05160.09580.05590.09700.0549
Cuber-B1440.05310.03060.08960.05180.09490.05580.09610.0546
For the efficiency and model-complexity aspects of Q3, see W4.1.

References:

[1] Xia et al. Unleash the Potential of Long Semantic IDs for Generative Recommendation. arXiv:2602.13573, 2026.

[2] Huang et al. Asymmetric Generative Recommendation via Kronecker Residual Bridge and Multi-Faceted Hierarchical Quantization. arXiv:2605.14512, 2026.

Reviewer_cYs8OpenReview ↗
Rating
3
Confidence
3
Informativeness
2
Presentation
3
Soundness
2
Read review
Paper summary

This paper considers generative recommendation (GR) and focuses on improving Semantic IDs (SIDs). The paper first points out that existing parallel SID methods do not explicitly encode structured dependencies among SID codes. To address this issue, the paper proposes Cuber, a framework for generative recommendation that aims to preserve dependencies among SID codes while retaining parallel decoding. Cuber consists of three parts: RPQ-Tree, which combines residual and product quantization to construct structured SIDs; a geometry-aware initialization scheme that maps codewords into the token embedding space; and a progressive training strategy that uses hierarchical information to identify hard negatives. Experiments on four Amazon recommendation datasets show improvements over several sequential and generative recommendation baselines.

Critical strengths

1.The motivation of Cuber is sound. The work aims to balance the efficiency of parallel SID prediction and the expressiveness of hierarchical item representations. Also, the combination of residual and product quantization is reasonable. The paper is well-written, and each method component is clearly introduced (Section 3.1 and 3.2). 2.SID construction is flexible. RPQ-Tree provides a unified formulation for combining different quantization structures. The recursive design is relatively general (Section 3.1). 3.The experimental results are good. Cuber achieves good performance across all four datasets, particularly on CDs and Vinyl. The comparison includes recent generative recommendation methods (e.g., RPG and MHL in Table 2). Furthermore, the paper provides clear ablation studies. The experiments separately evaluate RPQ-Tree, embedding initialization, and the training objective. The results show consistent improvements as these components are used.

Critical weaknesses

1.The technical contribution could be clarified. The main idea is to recursively combine residual quantization and product quantization. I find this straightforward and reasonable. However, a more detailed comparison with existing hierarchical quantization approaches would help clarify the technical contribution. 2.Please clarify the dependency modelling. As highlighted in the Abstract and Introduction, the central motivation is to preserve dependencies among SID codes. While RPQ-Tree introduces such dependencies during SID construction, the model still predicts SID codes in parallel using separate prediction heads. It is unclear how the dependencies introduced during construction are exploited during prediction 3.Please discuss the computational efficiency. The paper emphasizes efficient parallel decoding but mainly reports recommendation accuracy. It would be helpful to provide training costs and inference latency compared with existing methods (e.g., RPG and MHL).


After rebuttal: I have carefully read the rebuttal and lean to keep my score of 3

Questions for authors

1.Cuber is evaluated using two selected RPQ-Tree configurations, but it is unclear whether the improvements come from the hierarchical structure itself or simply from better reconstruction quality. 2.Could the authors compare different quantization methods with similar reconstruction errors? Since combining RQ and PQ can reduce reconstruction error

3 comments

W1: Comparison with Related Methods

Our original experiments already include TIGER, which employs hierarchical residual quantization. We further include comparisons with LETTER [1], ReSID [2], CapSID [3], and AsymRec [4]. The results for AsymRec are reproduced by us, while others are cited from [3]. Cuber consistently achieves the best performance among these methods.

MethodSports R@10Sports N@10Beauty R@10Beauty N@10Toys R@10Toys N@10
LETTER0.04350.02440.07080.04060.07410.0452
ReSID0.04750.02660.07700.04380.07860.0481
CapSID0.05270.02900.08390.04770.08550.0528
AsymRec0.04830.02910.07900.04760.09320.0549
Cuber-A0.05420.03090.09180.05180.09660.0557
Cuber-B0.05380.03090.09080.05230.09580.0569

W2: Effectiveness of Code Dependencies

In Cuber, although SID codes are predicted in parallel, the prediction heads share the same user-history representation and are jointly optimized through a shared backbone. We hypothesize that this shared representation and joint optimization help support effective parallel prediction through separate heads, even in the absence of explicit conditioning between the heads.

During the initial design of our method, we also experimented with explicitly exploiting the hierarchical dependencies among SID codes during inference. Specifically, we evaluated an MTP-inspired layer-wise predictor (Cuber-LP) on the two-level Cuber-A and Cuber-B variants. It first predicts higher-level code distributions and then uses their probability-weighted embeddings to condition lower-level code prediction through an additional structured attention layer. As shown in the table, this variant did not yield consistent improvements in Recall@10 or NDCG@10 across Sports, Beauty, and Toys, while increasing trainable parameters by approximately 12.8%. Given these mixed results and the additional complexity, we retained RPG’s parallel multi-head prediction architecture to maintain a simple and efficient prediction process. Nevertheless, explicit dependency modeling during prediction remains a promising direction that we are continuing to investigate.

MethodSports R@10Sports N@10Beauty R@10Beauty N@10Toys R@10Toys N@10
Cuber-A0.05420.03090.09180.05180.09660.0557
Cuber_LP-A0.0536 ↓0.0308 ↓0.0885 ↓0.0518 —0.0965 ↓0.0563 ↑
Cuber-B0.05380.03090.09080.05230.09580.0569
Cuber_LP-B0.0541 ↑0.0311 ↑0.0908 —0.0525 ↑0.0961 ↑0.0560 ↓

References:

[1] Wang et al. Learnable Item Tokenization for Generative Recommendation. CIKM, 2024.

[2] Liang et al. Rethinking Generative Recommender Tokenizer: RecSys-Native Encoding and Semantic Quantization Beyond LLMs. arXiv:2602.02338, 2026.

[3] Cheng et al. CapsID: Soft-Routed Variable-Length Semantic IDs for Generative Recommendation. arXiv:2605.05096, 2026.

[4] Huang et al. Asymmetric Generative Recommendation via Kronecker Residual Bridge and Multi-Faceted Hierarchical Quantization. arXiv:2605.14512, 2026.

W3: Computational Efficiency

We presented a comprehensive efficiency comparison on "Sports and Outdoors" against several representative methods below, including RPG and MHL. Per-epoch training times in brackets correspond to different training stages. All methods use the same embedding model and recommendation backbone for a fair comparison.

MethodEncoder Training TimeModel Parameter SizeModel Training Time per epochModel Training Peak MemoryInference TimeInference Throughput
TIGER59 min 40 s4.03 M27.1 s6.39 GiB7 min 48s76 req/s
RPG36.8 s13.58 M15.5 s4.02 GiB12.5 s2847 req/s
MHL37.2 s14.30 M[75.1s, 80.3s, 21.5s]5.60 GiB17.2 s2067 req/s
ACERec [1]37.8 s29.56 M32.2 s6.69 GiB17.1 s2080 req/s
AsymRec [2]30.8 s19.04 M25.4 s5.65 GiB14.6 s2439 req/s
Cuber-A66.2 s13.58 M[19.5s, 24.4s]4.02 GiB12.6 s2826 req/s
Cuber-B86.9 s13.58 M[19.3s, 24.3s]4.02 GiB12.3 s2880 req/s

TIGER incurs substantially higher tokenizer training and inference costs due to iterative RQ-VAE training and autoregressive beam-search decoding. Among RPG-based methods, Cuber requires more time for hierarchical SID construction, but this one-time cost remains acceptable. Cuber maintains the same number of trainable parameters and peak training memory as RPG, with competitive average per-epoch training times in both training stages. Importantly, Cuber achieves inference efficiency comparable to RPG and superior to the other methods, while delivering better recommendation performance.

Q1&Q2: Reconstruction Quality

The ablation study in Table 3 of the paper already compares OPQ-32, which has no residual connections, with RPQ-Tree before adding geometry-aware initialization or the progressive training objective. Both use the same co-occurrence-augmented item representations. Replacing OPQ with RPQ-Tree consistently improves recommendation performance across all three datasets, supporting the benefit of the residual hierarchical SID structure independently of these two additional components.

To examine whether these benefits can be explained solely by improved reconstruction, we compare different tree structures with the same 32-code budget and similar reconstruction quality. As shown in Table below, P4(R(P2(Q),P6(Q)))P_4(R(P_2(Q), P_6(Q))) and P2(R(P4(Q),P12(Q)))P_2(R(P_4(Q), P_{12}(Q))) have nearly identical MSE and cosine similarity, yet the former achieves higher R@10 and N@10. This comparison suggests that how residual and product quantization are organized matters for recommendation beyond reconstruction fidelity alone.

TopologyMSE ↓Cosine similarityR@10N@10
P4(R(P2(Q),P6(Q)))P_4(R(P_2(Q), P_6(Q)))0.0826820.9540930.05380.0313
P2(R(P4(Q),P12(Q)))P_2(R(P_4(Q), P_{12}(Q)))0.0822260.9544690.05150.0297

References:

[1] Xia et al. Unleash the Potential of Long Semantic IDs for Generative Recommendation. arXiv:2602.13573, 2026.

[2] Huang et al. Asymmetric Generative Recommendation via Kronecker Residual Bridge and Multi-Faceted Hierarchical Quantization. arXiv:2605.14512, 2026.

Thank you for your valuable feedback. We have revised the manuscript accordingly. We hope our responses have addressed your concerns and that you would consider revisiting your rating.

I appreciate the author adding new results, which address some of my concerns. I will maintain my initial score.

Comments on the paper

1 comment
AuthorsOpenReview ↗

Summary of Manuscript Revisions

We thank the reviewers for their valuable feedback. We have revised the manuscript in response to their comments and marked the changes in blue.

  1. Recent baselines. We added ACERec and AsymRec to the main performance comparison (Table 2). We also included both methods in the graph-decoding experiments (Section 4.3 and Appendix D) and the cold-start evaluation (Section 4.4).
  2. Component ablations. We replaced each of Cuber's three components in turn while keeping the other two fixed. Table 4 compares RPQ-Tree with the RVPQ-style MHQ structure used in AsymRec, geometry-aware initialization with truncated centroid initialization, and progressive training with standard hard-negative mining and an item-level ranking loss.
  3. Computational efficiency. Table 5 compares Cuber and the baselines on Sports in terms of SID encoder training time, trainable parameter count, per-epoch training time, peak memory usage, inference time, and throughput. Both Cuber variants match RPG in parameter count and peak memory usage and achieve comparable inference throughput.
  4. Distinction from RVPQ. We revised the Introduction and Section 3.1 to clarify how RPQ-Tree differs from RVPQ. While RVPQ adopts a fixed product-of-residual quantization structure, RPQ-Tree supports flexible recursive compositions of product and residual quantization. We also show how the RVPQ topology can be represented within RPQ-Tree and clarify the complementary roles of geometry-aware initialization and progressive training.
  5. Clarification of hierarchical modeling. We revised the descriptions throughout the manuscript to eliminate potential ambiguity regarding hierarchical modeling in Cuber. Specifically, Cuber incorporates hierarchical structure during SID construction and exploits the resulting information through embedding initialization and progressive training, while retaining parallel SID prediction without explicit inter-code conditioning.
  6. Datasets (Appendix B). We describe the four Amazon Reviews datasets and report the numbers of users, items, and interactions, along with the average input sequence length for each dataset (Table 6).
  7. Input representations (Appendix E). We evaluate how changing the PCA dimensionality from 128 to 144 affects four baselines (Table 8). We then compare all methods using the same co-occurrence features and 144-dimensional inputs on Sports, Beauty, and Toys (Table 9).
  8. Tree structures (Appendix F). We added reconstruction mean squared error (MSE) for each evaluated RPQ-Tree structure and remeasured encoder training time under a consistent protocol. Table 10 reports both measures alongside recommendation performance. We have also expanded the analysis of different RPQ-Tree structures, with additional discussion of quantizer allocation, reconstruction error, and encoder training time.
  9. Codebook size (Appendix G). We varied the number of entries per codebook across 64, 128, 256, and 512. Figure 9 shows how Recall@10 and NDCG@10 change on Sports, Beauty, and Toys.
  10. Decoding strategy (Appendix H). We compared parallel decoding with a layer-wise variant that conditions lower-level code predictions on higher-level code distributions (Table 11). This variant increased the trainable parameter count by approximately 12.8% without yielding consistent improvements in ranking performance. We therefore retained parallel decoding.
  11. Results across random seeds (Appendix I). We evaluated Cuber-A and Cuber-B with three random seeds on all four datasets. Table 12 reports each run, the mean, and the sample standard deviation for each metric. Table 2 reports these means for both Cuber variants.
  12. Corrections and presentation improvements. We corrected an erroneous MHL result on CDs in Table 2 and several minor issues, including incorrect table references. We also refined the wording throughout the manuscript to improve clarity and readability, and adjusted the formatting to improve the overall presentation.

We hope these revisions have addressed the reviewers' concerns and improved the clarity and completeness of the manuscript.

From OpenReview, CC BY 4.0. Authors as signed there; shown unedited.

Related papers

Loading the map…

Discussion (0)

Sign in to comment.