acceptodds
Under review as a conference paper at ICLR 2027

LoopGR: Parameter-Efficient Scaling for Generative Recommendation via Recurrent Depth

Abstract

Generative recommendation formulates item recommendation as autoregressive generation rather than a discriminative scoring problem. Although empirical studies exhibit favorable scaling behavior in recommendation, unleashing the benefits of scaling remains challenging under the strict model size and inference cost constraints of real-world systems. A central challenge is to combine expressive modeling of user-item interaction histories with flexible computational depth without proportionally increasing model size. We introduce **LoopGR**, a parameter-efficient scaling framework for generative recommendation via recurrent depth. LoopGR employs a tailored hierarchical recurrent depth mechanism that alternates between a shared generative decoder and a lightweight context updater. For efficient inference, we further develop recurrent trajectory self-distillation that distills a low-budget student from a high-budget teacher by aligning both trajectory states and evolution directions. Extensive Experiments show that LoopGR consistently outperforms strong generative recommendation baselines. Compared with a representative encoder–decoder baseline, LoopGR achieves superior performance while reducing model size by up to 52%. These results establish recurrent depth as a new scaling dimension, offering a flexible and resource-efficient scaling path for generative recommendation.

Primary area:
other topics in machine learning (i.e., none of the above)
Keywords:
Generative Recommendation, Scaling Laws, Looped Transformers

Reviews

Among:
Shape:
1234this paper, Top 32%
Figure 1. Mean review rating of the reviewed papers at ICLR 2027. This paper averages 2.40 over 5 reviews, above 68% of the others.
Reviewer_qsMQOpenReview ↗
Rating
2(+1)
Confidence
4
Informativeness
2
Presentation
2
Soundness
1
Read review
Paper summary

This paper proposes LoopGR, a SID-based generative recommender that alternates a shared decoder with a recurrent context updater. It also introduces recurrent trajectory self-distillation (RTSD) to transfer a high-budget teacher to a lower-budget student. Experiments on three Amazon Reviews 2014 categories report competitive recommendation accuracy with fewer parameters than an encoder–decoder baseline.

Critical strengths

The paper addresses a relevant trade-off between model size and inference cost. The latency measurements for compressed students and the ablations of different context updaters provide useful empirical insights.

Critical weaknesses

The novelty and scaling claims are not sufficiently established. LoopGR combines shared recurrent decoding with a lightweight context updater, while RTSD aligns intermediate predictions and their changes. The paper does not clearly establish a sufficiently distinct methodological contribution beyond these design choices. Moreover, the evaluation is limited to three Amazon Reviews 2014 categories with short average interaction histories. Parameter and FLOP scaling comparisons are presented only on CDs and Vinyl, which is insufficient to support the broader claim that recurrent depth is a general scaling dimension for generative recommendation.

The experimental protocol is also under-specified: the temporal train/validation/test split, candidate-ranking procedure, and variability across runs are not reported clearly. In addition, Table 2 compares RTSD at half the recurrent budget against alternative objectives at the full budget, making it difficult to isolate the benefit of the proposed distillation objective under matched inference costs.

Questions for authors

What exact temporal split and candidate-ranking protocol are used, and do the reported gains persist across multiple random seeds? Can RTSD be compared with alternative objectives at the same recurrent budget or latency?

5 comments
AuthorsOpenReview ↗

Response to Reviewer qsMQ (Part 1)

We thank the reviewer for the advice.

(W1) The methodological contributions of LoopGR and RTSD.

LoopGR introduces an encoder–updater–decoder architecture organized through hierarchical recurrent depth, together with a training strategy that separates trajectory formation from trajectory compression. We clarify these two contributions below.

First, the architectural contribution lies in separately organizing historical context refinement and target SID generation while coupling them through recurrent feedback. Existing backbones either keep historical context fixed during decoding or lack an explicit separation between context refinement and target prediction. LoopGR assigns these computations to distinct modules: the encoder initializes historical memory, the shared decoder refines target SID representations and the lightweight updater uses the intermediate decoder state to refine the memory for subsequent cycles. The conditioning memory itself evolves during recurrent decoding. The updater supports GRU, token mixing, or attention operators. This separation allows history refinement and target generation to use different operators and independently controlled recurrent budgets, so computation can be allocated to each according to its role while prediction feedback keeps the two processes coupled.

Second, the training contribution is to decouple exit readout from trajectory formation and transfer the learned refinement dynamics to a lower-budget model. Jointly optimizing intermediate exit readouts and recurrent trajectories requires the model to make accurate predictions at early cycles, which can cause representations to stabilize too early and limit the gains from additional recurrent steps. RTSD first trains a high-budget teacher with last step supervision, allowing intermediate states to compose a more effective trajectory. It then trains a lower-budget student by aligning predictive distributions and their evolution directions. This separates learning the refinement process from learning to approximate it with fewer recurrent steps. Our additional ablations show that RTSD preserves recommendation quality more effectively than teacher-initialized, task-only fine-tuning (W4/Q2).

(W2) Evaluation beyond Amazon and with longer interaction histories.

We have extended the evaluation to an industrial recommendation dataset with millions of training samples and an item sequence length of 100, corresponding to 400 SID tokens. We train on samples from the first seven days and evaluate predictions on the eighth day. Each historical item is represented by four SID tokens. We compare three baselines, including Lazy Decoder-only, TIGER and BARGE, with four LoopGR variants under this industrial setting. The complete results are reported below.

LoopGR with the Mixing updater achieves the highest Hit@K at all five cutoffs. Relative to TIGER, its improvements are 4.14%, 5.44%, 6.70%, 6.87% and 7.13% at K = 5, 10, 20, 50 and 100, respectively. These results provide additional evidence for LoopGR in industrial recommendation with longer input sequences and across different retrieval depths.

ModelHit@5Hit@10Hit@20Hit@50Hit@100
Lazy Decoder-only0.51800.57960.63830.69480.6990
TIGER0.54650.61250.66680.71370.7164
BARGE0.54770.62770.69140.74690.7496
LoopGR (w. Identity)0.55130.61880.67890.73340.7355
LoopGR (w. GRU)0.5626‾\underline{0.5626}0.6383‾\underline{0.6383}0.7007‾\underline{0.7007}0.7563‾\underline{0.7563}0.7585‾\underline{0.7585}
LoopGR (w. Linear Attn)0.55560.62450.68540.73950.7422
LoopGR (w. Mixing)0.56910.64580.71150.76270.7675
AuthorsOpenReview ↗

Response to Reviewer qsMQ (Part 2)

(W3, Q1) Data splitting, candidate ranking and robustness across random seeds.

All baselines use the same data split, and the additional five-seed experiments show that LoopGR's advantages persist in the mean results. We specify the public and industrial evaluation settings below.

  • Public datasets. We use the Beauty, Sports and CDs categories of Amazon Reviews 2014. Following the preprocessing operations in TIGER, we construct item sequences from users' review histories, sort interactions by timestamp, and filter out users with fewer than five reviews. We use a per-user chronological leave-one-out split: the last interaction is the test target, the penultimate interaction is the validation target, and the earlier interactions form the training sequence. LoopGR training examples are constructed with sliding windows over the training sequence, pairing each target with its preceding history. The validation history contains only interactions preceding the validation target. The test history additionally includes the validation interaction. The same split is used across baselines. For LoopGR's candidate generation and ranking on Amazon, we use autoregressive beam search with beam size 20 and Trie-based SID constraints. The Trie restricts generated prefixes to valid catalog SID prefixes. Completed SID sequences are ranked by cumulative token log-probability. Recall/Hit@5, Recall/Hit@10, NDCG@5, and NDCG@10 are computed by matching the held-out item's complete SID against the ranked generated sequences. With one target per example, Recall@K and Hit@K coincide. This evaluation uses generative retrieval over catalog SIDs without constructing a sampled-negative ranking pool.

  • Industrial dataset. We train on millions of samples from the first seven days and evaluate predictions on the eighth day. The historical item sequence length is 100, and each item has four SID tokens, giving an input SID sequence length of 400. The industrial evaluation reports Hit@5, Hit@10, Hit@20, Hit@50 and Hit@100, with results for Lazy Decoder-only, TIGER, BARGE and the four LoopGR variants shown in W2. This chronological setting evaluates recommendation on the subsequent day's interactions. Besides, we use autoregressive beam search with beam widths of 32, 32, 32 and 100 at the four SID decoding positions, respectively.

  • Random-seed evaluation. We conducted five runs with different random seeds for TIGER, ActionPiece and LoopGR on each of the three Amazon datasets. The full mean ± standard deviation results are provided below. LoopGR achieves higher mean performance than TIGER on all 12 metrics and than ActionPiece on 8 of 12 metrics. We will include these protocol details and repeated-run results in the revised manuscript.

DatasetsModelR@5N@5R@10N@10
BeautyTIGER0.0466±0.00110.0321±0.00020.0682±0.00140.0391±0.0007
ActionPiece0.0511±0.0014‾\underline{0.0511±0.0014}0.0340±0.0011‾\underline{0.0340±0.0011}0.0775±0.0017‾\underline{0.0775±0.0017}0.0424±0.0011‾\underline{0.0424±0.0011}
LoopGR0.0566±0.00020.0388±0.00080.0808±0.00060.0467±0.0007
Sports and OutdoorsTIGER0.0275±0.00110.0182±0.00050.0428±0.00280.0231±0.0006
ActionPiece0.0316±0.0005‾\underline{0.0316±0.0005}0.0205±0.0002‾\underline{0.0205±0.0002}0.0500±0.00070.0264±0.0003‾\underline{0.0264±0.0003}
LoopGR0.0334±0.00050.0225±0.00030.0495±0.0004‾\underline{0.0495±0.0004}0.0276±0.0003
CDs and VinylTIGER0.0496±0.00040.0327±0.00020.0760±0.00120.0412±0.0003
ActionPiece0.0544±0.00050.0359±0.0004‾\underline{0.0359±0.0004}0.0830±0.00080.0451±0.0005
LoopGR0.0537±0.0004‾\underline{0.0537±0.0004}0.0361±0.00040.0798±0.0007‾\underline{0.0798±0.0007}0.0445±0.0005‾\underline{0.0445±0.0005}
AuthorsOpenReview ↗

Response to Reviewer qsMQ (Part 3)

(W4, Q2) RTSD comparisons under the same recurrent inference budget.

The additional experiments compare RTSD with alternative student-training strategies and component ablations using the same 2-loop architecture, directly controlling the recurrent inference budget. We train a 4-loop teacher on each Amazon dataset and evaluate six alternatives to full RTSD: (1) training a 2-loop student from scratch; (2) reducing the frozen teacher's inference budget from four loops to two; (3) initializing the student from the teacher and fine-tuning with only the task loss; (4) output-only distillation; (5) removing the trajectory loss from RTSD; and (6) removing the direction loss from RTSD. The following table reports all four metrics on all three datasets.

The results support the contribution of trajectory supervision beyond teacher initialization, task-only adaptation and output-only distillation at the same student loop budget. Directly truncating the frozen teacher to two loops substantially degrades performance, whereas RTSD retains at least 97% of the teacher's score on every metric while halving the recurrent budget. On Sports, the student also exceeds the teacher on Recall@10 and NDCG@10. The ablation results show that trajectory-distribution alignment improves performance across most metrics. Removing this component reduces performance on 9 of 12 metrics. These results distinguish the roles of the two loss terms and substantiate RTSD's effectiveness under a fixed recurrent inference budget. We will add the full fixed-budget comparison to the revised ablation study.

AblationBeauty R@5N@5R@10N@10Sports R@5N@5R@10N@10CDs R@5N@5R@10N@10
LoopGR (Teacher, 4 loops)0.05460.03730.08060.04560.03300.02220.0488‾\underline{0.0488}0.0272‾\underline{0.0272}0.05370.03600.07910.0442
Train 2-loop student from scratch0.05170.03500.07540.04260.0327‾\underline{0.0327}0.02180.0488‾\underline{0.0488}0.02700.05070.03380.07670.0422
Reduce teacher inference budget (4 to 2 loops)0.02760.01830.04440.02370.01990.01270.03160.01650.02390.01560.03770.0201
Fine-tune 2-loop student from 4-loop teacher0.05150.03510.07790.04360.03110.02120.04670.02620.05120.03460.07780.0431
output-only distillation0.05300.03660.07770.04460.03160.02100.04740.02610.05140.03450.07620.0425
RTSD (Full, 2 loops)0.0541‾\underline{0.0541}0.0371‾\underline{0.0371}0.0790‾\underline{0.0790}0.04510.03240.0219‾\underline{0.0219}0.04950.02740.0521‾\underline{0.0521}0.0353‾\underline{0.0353}0.07810.0436
RTSD w/o trajectory loss0.05210.03600.0790‾\underline{0.0790}0.04470.03160.02150.04740.02660.05180.03500.0787‾\underline{0.0787}0.0436
RTSD w/o direction loss0.05330.03730.0790‾\underline{0.0790}0.0455‾\underline{0.0455}0.03230.0219‾\underline{0.0219}0.04850.0272‾\underline{0.0272}0.05180.03520.07850.0438‾\underline{0.0438}
Reviewer_h5vgOpenReview ↗
Rating
2
Confidence
3
Informativeness
2
Presentation
2
Soundness
2
Read review
Paper summary

LoopGR introduces hierarchical recurrent depth for generative recommendation by alternating a shared decoder with a lightweight context updater. Recurrent trajectory self-distillation compresses a high-budget teacher into a low-budget student, improving the trade-off between accuracy, parameter count, and computation.

Critical strengths
  1. The paper explores a practical alternative to parameter-based scaling for generative recommendation.
  2. The architecture enables prediction-conditioned history refinement through shared computation.
  3. Experiments examine accuracy, parameter efficiency, recurrent depth, and distillation latency.
Critical weaknesses
  1. The architectural contribution beyond existing looped Transformers is not sufficiently discussed or compared.
  2. RTSD lacks comparisons with directly trained low-budget models and output-only (without trajectories) distillation.
  3. Efficiency evidence lacks baseline latency and total training cost; evaluation is limited to three Amazon subsets without uncertainty estimates.
Questions for authors
  1. How does LoopGR compare with standard backbones at matched latency and training compute?
  2. Can the authors separately ablate trajectory-distribution alignment and directional alignment?
  3. How does RTSD compare with a directly trained student using the same loop budget and comparable training resources?
  4. Does the updater benefit from prediction feedback specifically, beyond simply adding history-processing computation?
4 comments
AuthorsOpenReview ↗

Response to Reviewer h5vg (Part 1)

(W1) The architectural contribution of LoopGR.

Thank you for the comment. Here, we provide further discussion of LoopGR in relation to existing looped Transformer methods. We believe LoopGR differs from these methods in two aspects.

  • LoopGR uses an encoder–updater–decoder architecture for autoregressive SID generation. Unlike some existing Looped Transformers (e.g., HRM [1], a sequence-to-sequence architecture whose high- and low-level recurrent modules both use encoder-only Transformer blocks), LoopGR couples a Transformer decoder operating on target representations with a sequence-modeling updater operating on historical representations. The decoder attends to the historical memory, and its intermediate representation feeds back into the updater to refine that memory. This hybrid architecture supports various updater operators, including GRU and token mixing, and separately controls the computation allocated to history refinement and target prediction.

  • LoopGR separates trajectory formation from trajectory compression. Learned halting objectives in some Looped Transformers couple exit selection with trajectory learning, potentially inducing suboptimal trajectories that constrain effective early exiting [2]. LoopGR first trains a high-budget teacher using last step supervision, allowing intermediate states to develop without requiring each to serve as an exit. Besides, LoopGR brings representation dynamics distillation to recurrent-depth models, transferring a high-budget teacher's prediction dynamics into a student with fewer recurrent steps. Our additional ablations show that RTSD outperforms teacher-initialized, task-only fine-tuning (see W2).

We will clarify these distinctions and include the additional references in the revision.

[1] Hierarchical Reasoning Model, 2025.

[2] Adaptive Depth in Looped Transformers: Diagnosing Learned Halting Gates and Trajectory Readouts, 2026.

(W2, Q2, Q3) The ablation study of RTSD

To comprehensively evaluate Recurrent Trajectory Self-Distillation (RTSD), we train a 4-loop teacher on each of the three Amazon datasets. We compare full RTSD with four ablation settings: 1) directly training a low-budget student from scratch, 2) output-only distillation, 3) removing the trajectory loss from RTSD, and 4) removing the direction loss from RTSD. All students use the same 2-loop architecture for a fair comparison.

As shown in the following table, RTSD achieves better recommendation performance than the alternative fine-tuning strategies in most cases. Under the same 2-loop inference budget, RTSD outperforms the student trained from scratch on 11 of 12 metrics and output-only distillation on all 12 metrics across the three datasets. These results support the benefit of aligning the recurrent trajectory beyond matching the teacher’s final predictive distribution alone. The RTSD student retains at least 97% of the teacher's performance across all 12 metrics while halving the loop budget. The component ablations indicate that trajectory loss provides the larger and more consistent contribution, while the direction loss further improves several metrics, particularly on Sports. Notably, the distilled student may surpass its teacher in some cases, consistent with the observations in Table 4.

AblationBeauty R@5N@5R@10N@10Sports R@5N@5R@10N@10CDs R@5N@5R@10N@10
LoopGR (Teacher)0.05460.03730.08060.04560.03300.02220.0488‾\underline{0.0488}0.0272‾\underline{0.0272}0.05370.03600.07910.0442
directly training a low-budget student0.05170.03500.07540.04260.0327‾\underline{0.0327}0.02180.0488‾\underline{0.0488}0.02700.05070.03380.07670.0422
output-only distillation0.05300.03660.07770.04460.03160.02100.04740.02610.05140.03450.07620.0425
RTSD (Full)0.0541‾\underline{0.0541}0.0371‾\underline{0.0371}0.0790‾\underline{0.0790}0.04510.03240.0219‾\underline{0.0219}0.04950.02740.0521‾\underline{0.0521}0.0353‾\underline{0.0353}0.07810.0436
RTSD w/o trajectory loss0.05210.03600.0790‾\underline{0.0790}0.04470.03160.02150.04740.02660.05180.03500.0787‾\underline{0.0787}0.0436
RTSD w/o direction loss0.05330.03730.0790‾\underline{0.0790}0.0455‾\underline{0.0455}0.03230.0219‾\underline{0.0219}0.04850.0272‾\underline{0.0272}0.05180.03520.07850.0438‾\underline{0.0438}
AuthorsOpenReview ↗

Response to Reviewer h5vg (Part 2)

(W3) The latency comparison.

We have conducted additional experiments on CDs comparing LoopGR with Encoder–Decoder, Naive Decoder-only and Lazy Decoder-only across five approximately matched GFLOPs groups. We measure inference latency and throughput over 30 batches, using a batch size of 256 and a beam size of 20. Due to the lack of official implementation details, our Lazy Decoder-only implementation uses a standard pre-norm Transformer with a tokenizer as the context processor. In the table, LoopGR configurations follow the format encoder_layers–decoder_layers–high_level_cycles. For example, 1-1-3 denotes a 1-layer encoder and a 1-layer decoder applied over 3 high-level cycles. We fix the number of low-level cycles to 1 for ease of comparison. Encoder-Decoder and Lazy Decoder-only configurations follow the formats encoder_layers-decoder_layers and context_processor_layers–decoder_layers, respectively.

As shown in the table, Lazy Decoder-only achieves better performance at low computational budgets, but in Group 1 it requires 4.50× as many parameters and 2.34× the inference latency of LoopGR. Comparing LoopGR with Encoder–Decoder at the same effective decoder depth in Group 1, LoopGR achieves better accuracy while reducing batch latency from 127.3 to 89.0 ms. At higher budgets, LoopGR achieves the best Recall@5 and NDCG@5 in Groups 4–5. Across all five groups, it provides 2.05–3.18× speedups over Naive Decoder-only and 1.65–2.34× speedups over Lazy Decoder-only, while using fewer parameters than both Encoder–Decoder and Lazy Decoder-only. Overall, these results demonstrate that LoopGR achieves better performance than Encoder–Decoder with fewer parameters across all five groups, while consistently delivering faster inference than both Decoder-only alternatives.

GroupModelsConfig.GFLOPsParams (M)Latency (ms)Throughput (samples/s)R@5N@5
Group 1LoopGR1-1-30.4271.3389.028780.03780.0259
Enc-Dec1-30.4482.69127.320120.03560.0230
Naive DecL=20.5281.18283.39040.01620.0102
Lazy Dec1-90.4325.99208.612280.04770.0317
Group 2LoopGR2-2-30.7592.19170.814990.04350.0292
Enc-Dec2-40.7643.81169.215130.04280.0274
Naive DecL=30.7921.75414.06180.02370.0153
Lazy Dec2-150.7719.80343.27460.04840.0331
Group 3LoopGR3-2-41.0902.65249.310270.04820.0324
Enc-Dec3-51.0794.92212.912020.04650.0303
Naive DecL=41.0562.10544.64700.02580.0165
Lazy Dec3-181.06611.94410.96230.04800.0329
Group 4LoopGR4-3-31.4213.04329.47770.05170.0349
Enc-Dec4-61.3956.03255.210030.04860.0317
Naive DecL=51.3192.56674.43800.02840.0182
Lazy Dec4-241.40515.75544.74700.04540.0314
Group 5LoopGR5-5-31.7534.76410.36240.05270.0353
Enc-Dec5-81.7767.81338.47560.04990.0326
Naive DecL=71.8473.48936.32730.03160.0204
Lazy Dec5-311.75920.12701.33650.04540.0317
AuthorsOpenReview ↗

Response to Reviewer h5vg (Part 3)

(W3) The additional dataset.

To extend our evaluation beyond Amazon, we conducted additional offline experiments on an in-house industrial recommendation dataset, training on millions of samples from the first seven days and evaluating predictions on the eighth day. The table below reports Hit@K for three baselines and four LoopGR variants. LoopGR with the Mixing updater achieves the best results at all five cutoffs. Compared to TIGER, the gains increase consistently from 4.14% at K=5 to 7.13% at K=100, indicating benefits across different retrieval depths. These results extend the empirical evidence beyond the three Amazon subsets and support the potential of LoopGR for industrial recommendation applications.

For uncertainty estimates, we additionally conducted five runs with different random seeds for LoopGR and two representative baselines, TIGER and ActionPiece, on Amazon datasets (see our response to Reviewer 9gYT, W3). We report the mean and standard deviation of each evaluation metric. We will incorporate both the industrial evaluation and new results into the revised manuscript.

ModelHit@5Hit@10Hit@20Hit@50Hit@100
Lazy Decoder-only0.51800.57960.63830.69480.6990
TIGER0.54650.61250.66680.71370.7164
BARGE0.54770.62770.69140.74690.7496
LoopGR (w. Identity)0.55130.61880.67890.73340.7355
LoopGR (w. GRU)0.5626‾\underline{0.5626}0.6383‾\underline{0.6383}0.7007‾\underline{0.7007}0.7563‾\underline{0.7563}0.7585‾\underline{0.7585}
LoopGR (w. Linear Attn)0.55560.62450.68540.73950.7422
LoopGR (w. Mixing)0.56910.64580.71150.76270.7675

(Q4) The role of prediction feedback.

Thank you for highlighting the role of prediction feedback. To isolate its contribution, we construct an ablation that retains the context updater but removes the injection of the hidden state of the BOS token. As shown below, removing this feedback slightly reduces performance on 11 of the 12 metrics across different datasets. These results suggest that context refinement benefits from intermediate prediction feedback beyond the context updating provided by the updater alone.

ModelBeauty R@5N@5R@10N@10Sports R@5N@5R@10N@10CDs R@5N@5R@10N@10
LoopGR0.05630.03890.07990.04650.03330.02230.04950.02750.05370.03630.07990.0447
LoopGR w/o query0.05490.03780.07960.04570.03280.02180.04950.02720.05320.03580.07940.0439

Thank you for the response and the additional experiments. I keep my original rating.

The rebuttal explains how LoopGR differs from general looped Transformers, but not why recommendation specifically needs hierarchical recurrent depth, a separate history updater, and prediction feedback. The motivation for these designs in the recommendation setting is still unclear.

The paper also does not discuss its differences from existing recurrent-depth work in recommendation. LARES [1] already applies depth-recurrent latent reasoning to sequential recommendation and aligns intermediate states with the final state, which is close to both the LoopGR architecture and RTSD. A discussion of this, and ideally a comparison, is needed.

[1] Liu et al. LARES: Latent Reasoning for Sequential Recommendation. arXiv:2505.16865, 2025.

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

Note: I have no knowledge of generative recommendation or loop transformer, and I can only review the manuscript to the best of my ability. My opinions can be ignored.

This paper introduces LoopGR, a method that integrates a recurrent-depth architecture into SID-based generative recommendation. It uses loops to enhance the model's reasoning depth without increasing the number of model parameters.

Critical strengths

The paper designs a novel parameter-efficient framework, LoopGR, for generative recommendation (GR) that enhances inference depth without increasing parameter scale, thereby improving model performance and reducing latency. The recurrent-depth architecture is tailored for SID-based generative recommendation, and experimental results demonstrate superior performance.

Critical weaknesses
  1. The loop design in the paper directly adopts the encoder-decoder architecture, which may be a popular choice in the field of generative recommendation (GR). However, it lacks an analysis of how the recurrent-depth architecture applies to decoder-only or lazy decoder-only architectures. This is particularly relevant because the paper's title states "FOR GENERATIVE RECOMMENDATION VIA RECURRENT-DEPTH."
  2. When clicking on the code link provided in the paper, it only directs to a README.md file labeled "LoopGR," rather than the actual code.
Questions for authors
  1. Figure 3(b) shows that as the number of cycles increases, performance may not necessarily improve and may even decline, which seems contrary to expectations. Why is this the case?
  2. Why was there no comparison with a non-loop model of equivalent depth in the experiments?
1 comment
AuthorsOpenReview ↗

Response to Reviewer E4gR

(W1) The architectural design of LoopGR.

Thank you for your comment. LoopGR is not intended to simply apply recurrent depth to existing Encoder–Decoder, Decoder-only or Lazy Decoder-only architectures. Instead, LoopGR introduces an encoder–updater–decoder architecture organized through hierarchical recurrent depth. It assigns initial context encoding, target prediction and context updating to different modules. Here, we will further clarify both this design rationale and its relationship to the other architectures.

In a conventional Encoder–Decoder architecture, the encoder constructs historical representations that serve as fixed conditioning memory during target generation. A standard decoder-only model simultaneously processes history and target tokens through a Transformer stack. Lazy Decoder-only architectures further reduce context-processing computation by preparing context representations separately and accessing them through lazy cross-attention.
Regarding applicability to the other architectures, recurrent depth can be introduced into a decoder-only model by repeatedly applying a shared stack to history and target representations. However, this alone does not provide the explicit separation between context refinement and target prediction. Similarly, repeatedly applying a lazy decoder block would only refine target representations while retaining its precomputed and static context memory.

Naturally, to organize context refinement and target prediction separately while allowing them to interact, we introduce a dedicated context updater. Instead of directly adopting recurrent depth in existing architectures, LoopGR investigates a distinct design choice: allowing the conditioning memory itself to evolve across recurrent decoding cycles. The encoder initializes the memory once, the shared decoder refines target representations, and the lightweight shared updater uses the intermediate decoder state to refine the memory for subsequent cycles. This design treats context as dynamic conditioning information and allows the computation devoted to target prediction and context refinement to be controlled through their respective recurrent budgets. Therefore, the encoder–updater–decoder design in LoopGR is motivated by the need to separately organize context refinement and target prediction while coupling them through recurrent feedback, rather than simply following a popular architectural choice. We will revise the Introduction and Section 4.1 to clarify this design rationale and its distinction from existing architectures.

(W2) Code availability.

We apologize for the oversight regarding code availability. Because the release of the source code is subject to internal approval, we will first provide implementation guidelines and pseudocode in the repository.

(Q1) Non-monotonic performance with increasing recurrent depth.

Increasing recurrent depth provides additional refinement steps, but does not guarantee monotonically improving recommendation accuracy. In Figure 3(b), Sports, which contains more interactions than Beauty, benefits more from deeper recurrence. It indicates that smaller datasets may provide insufficient training signal to fully exploit additional refinement steps. Moreover, an inherent drawback of recurrent neural networks is that gradient flow through more recurrent iterations may amplify training instability. These effects can offset the benefits of increased depth and potentially lead to performance declines.

(Q2) Comparison with a non-loop model at equivalent depth.

Thank you for the question. Our computation scaling study includes a comparison with a non-loop Encoder–Decoder at matched unrolled Transformer depth (see our response to Reviewer k64Y, W1). Specifically, Group 1 compares LoopGR (1 encoder layer, 1 decoder layer × 3 cycles) with a non-loop Encoder–Decoder (1 encoder layer, 3 decoder layers) at comparable computational depth. At comparable computation (0.427 vs. 0.448 GFLOPs), LoopGR uses fewer parameters (1.33M vs. 2.69M), achieves lower measured inference latency (89.0 vs. 127.3 ms), and improves R@5 (0.0378 vs. 0.0356) and N@5 (0.0259 vs. 0.0230). This comparison supports LoopGR as a promising accuracy–efficiency alternative to a non-loop architecture at matched Transformer depth. We will add the detailed computation scaling configurations to the appendix, explicitly reporting the unrolled Transformer depth and updater cycles to clarify this comparison.

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

This paper proposes LoopGR, a parameter-efficient framework for generative recommendation that introduces hierarchical recurrent depth to iteratively refine target predictions and historical context through shared modules. The authors further develop Recurrent Trajectory Self-Distillation (RTSD) to reduce inference computation while preserving recommendation quality. Experiments on three Amazon datasets demonstrate competitive recommendation performance and favorable parameter-efficiency trade-offs against existing baselines.

Critical strengths
  • LoopGR provides a meaningful adaptation of recurrent depth to generative recommendation by jointly refining target predictions and historical context through parameter sharing. The hierarchical recurrence analysis and updater ablations provide evidence supporting the effectiveness of this design.

  • The experiments demonstrate promising accuracy-parameter trade-offs compared with conventional generative backbones. The RTSD results further show that recurrent computation can be substantially reduced while largely preserving recommendation performance.

Critical weaknesses
  • Although parameter and FLOPs comparisons are provided, end-to-end latency comparisons against the main architectural baselines are missing. The latency analysis in Appendix A.2 only considers LoopGR variants, leaving its practical efficiency advantage over existing architectures insufficiently established.

  • The paper lacks separate ablations of trajectory alignment and directional alignment, as well as comparisons with simpler alternatives such as directly reducing recurrent steps or fine-tuning a shorter-budget student. Consequently, the specific contribution of RTSD remains insufficiently validated.

  • The evaluation is limited to three Amazon datasets, and no variance across random seeds is reported despite relatively modest improvements over strong baselines. Additionally, the claimed 10/12 wins over ActionPiece in Section 5.2 appear to be 8/12 according to Table 1, while the average interaction length for Sports in Table 3 appears inconsistent with the reported dataset statistics.

Questions for authors
  1. How does LoopGR compare with Encoder-Decoder, Decoder-only, and Lazy Decoder-only baselines in terms of end-to-end inference latency under comparable serving conditions?

  2. What are the individual contributions of the trajectory alignment and directional alignment losses in RTSD, and how does RTSD compare with simpler alternatives under the same inference budget?

  3. Could the authors report performance variance across random seeds and clarify the numerical inconsistencies in Table 1 and Table 3?

3 comments
AuthorsOpenReview ↗

Response to Reviewer 9gYT (Part 1)

(Q1, W1) The latency comparison between different architectures.

Thank you for your helpful suggestions. We have conducted additional experiments on CDs comparing LoopGR with Encoder–Decoder, Naive Decoder-only and Lazy Decoder-only across five approximately matched GFLOPs groups. We measure inference latency and throughput over 30 batches, using a batch size of 256 and a beam size of 20. Due to the lack of official implementation details, our Lazy Decoder-only implementation uses a standard pre-norm Transformer with a tokenizer as the context processor. In the table, LoopGR configurations follow the format encoder_layers–decoder_layers–high_level_cycles. For example, 1-1-3 denotes a 1-layer encoder and a 1-layer decoder applied over 3 high-level cycles. We fix the number of low-level cycles to 1 for ease of comparison. Encoder-Decoder and Lazy Decoder-only configurations follow the formats encoder_layers-decoder_layers and context_processor_layers–decoder_layers, respectively.

Notably, we excluded Lazy Decoder-only from the original computation scaling analysis in the main text because matching its GFLOPs to those of other architectures requires substantially different depth configurations. For example, in Group 5, Encoder–Decoder uses a 5-layer encoder and an 8-layer decoder, whereas Lazy Decoder-only uses a 5-layer context processor and a 31-layer decoder. Nevertheless, we agree that this difference warrants explicit evaluation and now include this baseline. Lazy Decoder-only achieves better performance at low computational budgets, but in Group 1 it requires 4.50× as many parameters and 2.34× the inference latency of LoopGR. Comparing LoopGR with Encoder–Decoder at the same effective decoder depth in Group 1, LoopGR achieves better accuracy while reducing batch latency from 127.3 to 89.0 ms. At higher budgets, LoopGR achieves the best Recall@5 and NDCG@5 in Groups 4–5. Across all five groups, it provides 2.05–3.18× speedups over Naive Decoder-only and 1.65–2.34× speedups over Lazy Decoder-only, while using fewer parameters than both Encoder–Decoder and Lazy Decoder-only. Overall, these results demonstrate that LoopGR achieves better performance than Encoder–Decoder with fewer parameters across all five groups, while consistently delivering faster inference than both Decoder-only alternatives. We will include these new comparisons and provide more analyses across different architectures in the revision.

GroupModelsConfig.GFLOPsParams (M)Latency (ms)Throughput (samples/s)R@5N@5
Group 1LoopGR1-1-30.4271.3389.028780.03780.0259
Enc-Dec1-30.4482.69127.320120.03560.0230
Naive DecL=20.5281.18283.39040.01620.0102
Lazy Dec1-90.4325.99208.612280.04770.0317
Group 2LoopGR2-2-30.7592.19170.814990.04350.0292
Enc-Dec2-40.7643.81169.215130.04280.0274
Naive DecL=30.7921.75414.06180.02370.0153
Lazy Dec2-150.7719.80343.27460.04840.0331
Group 3LoopGR3-2-41.0902.65249.310270.04820.0324
Enc-Dec3-51.0794.92212.912020.04650.0303
Naive DecL=41.0562.10544.64700.02580.0165
Lazy Dec3-181.06611.94410.96230.04800.0329
Group 4LoopGR4-3-31.4213.04329.47770.05170.0349
Enc-Dec4-61.3956.03255.210030.04860.0317
Naive DecL=51.3192.56674.43800.02840.0182
Lazy Dec4-241.40515.75544.74700.04540.0314
Group 5LoopGR5-5-31.7534.76410.36240.05270.0353
Enc-Dec5-81.7767.81338.47560.04990.0326
Naive DecL=71.8473.48936.32730.03160.0204
Lazy Dec5-311.75920.12701.33650.04540.0317
AuthorsOpenReview ↗

Response to Reviewer 9gYT (Part 2)

(Q2, W2) The contributions of RTSD

We thank the reviewer for these suggestions. To comprehensively evaluate Recurrent Trajectory Self-Distillation (RTSD), we train a 4-loop teacher on each of the three Amazon datasets. We compare full RTSD with five ablation settings: 1) training a student from scratch, 2) directly reducing the teacher's inference budget, 3) fine-tuning a student initialized from the teacher using only the task loss, 4) removing the trajectory loss from RTSD, and 5) removing the direction loss from RTSD. All students use the same 2-loop architecture for a fair comparison.

As shown in the following table, RTSD achieves better recommendation performance than the alternative fine-tuning strategies in most cases. Training a 2-loop student from scratch yields performance comparable to task-only fine-tuning from the teacher. RTSD outperforms task-only fine-tuning on all 12 metrics. These results support the benefit of trajectory distillation beyond teacher initialization and task supervision. Reducing the frozen 4-loop teacher to two loops at inference, without further training, substantially degrades recommendation performance. We attribute this degradation to the mismatch between training and inference loop budgets, particularly when inference uses fewer loops than training. The RTSD student retains at least 97% of the teacher's performance across all 12 metrics while halving the loop budget. The component ablations indicate that trajectory loss provides the larger and more consistent contribution, while the direction loss further improves several metrics, particularly on Sports. Notably, the distilled student may surpass its teacher in some cases, consistent with the observations in Table 4 of the main text. We will expand the ablation study in the revised manuscript to include these additional RTSD experiments.

AblationBeauty R@5N@5R@10N@10Sports R@5N@5R@10N@10CDs R@5N@5R@10N@10
LoopGR (Teacher)0.05460.03730.08060.04560.03300.02220.0488‾\underline{0.0488}0.0272‾\underline{0.0272}0.05370.03600.07910.0442
Train 2-loop student from scratch0.05170.03500.07540.04260.0327‾\underline{0.0327}0.02180.0488‾\underline{0.0488}0.02700.05070.03380.07670.0422
Reduce teacher inference budget (4 to 2 loops)0.02760.01830.04440.02370.01990.01270.03160.01650.02390.01560.03770.0201
Fine-tune 2-loop student from 4-loop teacher0.05150.03510.07790.04360.03110.02120.04670.02620.05120.03460.07780.0431
RTSD (Full)0.0541‾\underline{0.0541}0.0371‾\underline{0.0371}0.0790‾\underline{0.0790}0.04510.03240.0219‾\underline{0.0219}0.04950.02740.0521‾\underline{0.0521}0.0353‾\underline{0.0353}0.07810.0436
RTSD w/o trajectory loss0.05210.03600.0790‾\underline{0.0790}0.04470.03160.02150.04740.02660.05180.03500.0787‾\underline{0.0787}0.0436
RTSD w/o direction loss0.05330.03730.0790‾\underline{0.0790}0.0455‾\underline{0.0455}0.03230.0219‾\underline{0.0219}0.04850.0272‾\underline{0.0272}0.05180.03520.07850.0438‾\underline{0.0438}
AuthorsOpenReview ↗

Response to Reviewer 9gYT (Part 3)

(W3) The additional dataset.

Thank you for this constructive advice. To extend our evaluation beyond Amazon, we conducted additional offline experiments on an in-house industrial recommendation dataset, training on millions of samples from the first seven days and evaluating predictions on the eighth day. The table below reports Hit@K for three baselines (Lazy Decoder-only, TIGER and BARGE [1]) and four LoopGR variants. LoopGR with the Mixing updater achieves the best results at all five cutoffs. The gains increase consistently from 4.14% at K=5 to 7.13% at K=100, indicating benefits across different retrieval depths. LoopGR also consistently outperforms BARGE, the strongest baseline in this comparison. These results extend the empirical evidence beyond the three Amazon subsets and support the potential of LoopGR for industrial recommendation applications.

ModelHit@5Hit@10Hit@20Hit@50Hit@100
Lazy Decoder-only0.51800.57960.63830.69480.6990
TIGER0.54650.61250.66680.71370.7164
BARGE0.54770.62770.69140.74690.7496
LoopGR (w. Identity)0.55130.61880.67890.73340.7355
LoopGR (w. GRU)0.5626‾\underline{0.5626}0.6383‾\underline{0.6383}0.7007‾\underline{0.7007}0.7563‾\underline{0.7563}0.7585‾\underline{0.7585}
LoopGR (w. Linear Attn)0.55560.62450.68540.73950.7422
LoopGR (w. Mixing)0.56910.64580.71150.76270.7675

(W3, Q3) Results across random seeds and numerical corrections.

Thank you for these careful corrections. They help improve the rigor of our paper. For numerical corrections, we will correct the statement in Section 5.2 and update the dataset statistics in Appendix A.1 in the revision. In addition, we conducted five runs with different random seeds for two representative generative recommendation baselines (TIGER, ActionPiece) and LoopGR on three datasets. The table below reports the mean and standard deviation of each evaluation metric. We will incorporate these results into the revision.

DatasetsModelHit@5NDCG@5Hit@10NDCG@10
BeautyTIGER0.0466±0.00110.0321±0.00020.0682±0.00140.0391±0.0007
ActionPiece0.0511±0.0014‾\underline{0.0511±0.0014}0.0340±0.0011‾\underline{0.0340±0.0011}0.0775±0.0017‾\underline{0.0775±0.0017}0.0424±0.0011‾\underline{0.0424±0.0011}
LoopGR0.0566±0.00020.0388±0.00080.0808±0.00060.0467±0.0007
Sports and OutdoorsTIGER0.0275±0.00110.0182±0.00050.0428±0.00280.0231±0.0006
ActionPiece0.0316±0.0005‾\underline{0.0316±0.0005}0.0205±0.0002‾\underline{0.0205±0.0002}0.0500±0.00070.0264±0.0003‾\underline{0.0264±0.0003}
LoopGR0.0334±0.00050.0225±0.00030.0495±0.0004‾\underline{0.0495±0.0004}0.0276±0.0003
CDs and VinylTIGER0.0496±0.00040.0327±0.00020.0760±0.00120.0412±0.0003
ActionPiece0.0544±0.00050.0359±0.0004‾\underline{0.0359±0.0004}0.0830±0.00080.0451±0.0005
LoopGR0.0537±0.0004‾\underline{0.0537±0.0004}0.0361±0.00040.0798±0.0007‾\underline{0.0798±0.0007}0.0445±0.0005‾\underline{0.0445±0.0005}

[1] Bridging the Structural Gap: Adapting Autoregressive Generation for Recommendation, 2026.

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

The framework alternates a parameter-shared decoder with a lightweight context updater to iteratively refine target semantic ID predictions and user interaction representations. Additionally, the authors introduce Recurrent Trajectory Self-Distillation (RTSD), which transfers knowledge from a high-budget teacher to a low-budget student by aligning predictive distributions and their evolution directions. Experiments on three Amazon recommendation datasets demonstrate competitive performance against existing baselines, while achieving improved parameter efficiency and reducing inference costs through trajectory compression.

Critical strengths
  1. LoopGR introduces hierarchical recurrent computation that decouples computational depth from parameter count while dynamically refining user context during target generation. This design addresses an important challenge in generative recommendation and provides a promising alternative to conventional parameter-based scaling.
  2. The experiments include comparisons against established recommendation baselines, parameter and computation scaling analyses, and ablations of recurrent depth and context updater architectures. These evaluations provide useful evidence for the effectiveness of the proposed architecture and help characterize its performance-efficiency trade-offs.
Critical weaknesses
  1. Although the paper emphasizes inference efficiency and deployment constraints, the latency analysis in Appendix A.2 primarily compares LoopGR teachers and distilled students with different recurrent budgets. It does not provide direct wall-clock latency comparisons against competing architectures under matched recommendation quality or computational budgets. Furthermore, the Lazy Decoder-only baseline is excluded from the computation scaling analysis in Figure 3. These limitations make it difficult to establish whether LoopGR offers a consistently superior accuracy-latency trade-off over existing efficient architectures.
  2. RTSD combines predictive distribution alignment and evolution-direction alignment, but the paper does not isolate their individual contributions. Moreover, the experiments lack comparisons against low-budget students trained directly or fine-tuned from the teacher without trajectory distillation. Consequently, it remains unclear whether the improvements primarily arise from the proposed trajectory alignment mechanism, teacher initialization, or additional student training. This weakens the empirical justification for RTSD as a distinct methodological contribution.
Questions for authors
  1. Can the authors provide inference latency and throughput comparisons between LoopGR and the Encoder-Decoder, Decoder-only, and Lazy Decoder-only baselines under matched accuracy or computational budgets? This would help assess the practical efficiency advantages of recurrent depth.
  2. What are the individual contributions of predictive distribution alignment and evolution-direction alignment in RTSD? Can the authors provide an ablation comparing the full objective against variants using only one of these components?
  3. How does RTSD compare with a low-budget LoopGR trained from scratch or initialized from the teacher and fine-tuned using only the task loss? Such comparisons are important for determining whether trajectory distillation provides benefits beyond conventional training.
2 comments
AuthorsOpenReview ↗

Response to Reviewer k64Y (Part 1)

(W1, Q1) The latency comparisons between LoopGR, Encoder-Decoder, Decoder-only and Lazy Decoder-only.

Thank you for your helpful suggestions. We have conducted additional experiments on CDs comparing LoopGR with Encoder–Decoder, Naive Decoder-only and Lazy Decoder-only across five approximately matched GFLOPs groups. We measure inference latency and throughput over 30 batches, using a batch size of 256 and a beam size of 20. Due to the lack of official implementation details, our Lazy Decoder-only implementation uses a standard pre-norm Transformer with a tokenizer as the context processor. In the table, LoopGR configurations follow the format encoder_layers–decoder_layers–high_level_cycles. For example, 1-1-3 denotes a 1-layer encoder and a 1-layer decoder applied over 3 high-level cycles. We fix the number of low-level cycles to 1 for ease of comparison. Encoder-Decoder and Lazy Decoder-only configurations follow the formats encoder_layers-decoder_layers and context_processor_layers–decoder_layers, respectively.

Notably, we excluded Lazy Decoder-only from the original computation scaling analysis in the main text because matching its GFLOPs to those of other architectures requires substantially different depth configurations. For example, in Group 5, Encoder–Decoder uses a 5-layer encoder and an 8-layer decoder, whereas Lazy Decoder-only uses a 5-layer context processor and a 31-layer decoder. Nevertheless, we agree that this difference warrants explicit evaluation and now include this baseline. Lazy Decoder-only achieves better performance at low computational budgets, but in Group 1 it requires 4.50× as many parameters and 2.34× the inference latency of LoopGR. Comparing LoopGR with Encoder–Decoder at the same effective decoder depth in Group 1, LoopGR achieves better accuracy while reducing batch latency from 127.3 to 89.0 ms (30.1%). At higher budgets, LoopGR achieves the best Recall@5 and NDCG@5 in Groups 4–5. Across all five groups, it provides 2.05–3.18× speedups over Naive Decoder-only and 1.65–2.34× speedups over Lazy Decoder-only, while using fewer parameters than both Encoder–Decoder and Lazy Decoder-only. Overall, these results demonstrate that LoopGR achieves better performance than Encoder–Decoder with fewer parameters across all five groups, while consistently delivering faster inference than both Decoder-only alternatives.

GroupModelsConfig.GFLOPsParams (M)Latency (ms)Throughput (samples/s)R@5N@5
Group 1LoopGR1-1-30.4271.3389.028780.03780.0259
Enc-Dec1-30.4482.69127.320120.03560.0230
Naive DecL=20.5281.18283.39040.01620.0102
Lazy Dec1-90.4325.99208.612280.04770.0317
Group 2LoopGR2-2-30.7592.19170.814990.04350.0292
Enc-Dec2-40.7643.81169.215130.04280.0274
Naive DecL=30.7921.75414.06180.02370.0153
Lazy Dec2-150.7719.80343.27460.04840.0331
Group 3LoopGR3-2-41.0902.65249.310270.04820.0324
Enc-Dec3-51.0794.92212.912020.04650.0303
Naive DecL=41.0562.10544.64700.02580.0165
Lazy Dec3-181.06611.94410.96230.04800.0329
Group 4LoopGR4-3-31.4213.04329.47770.05170.0349
Enc-Dec4-61.3956.03255.210030.04860.0317
Naive DecL=51.3192.56674.43800.02840.0182
Lazy Dec4-241.40515.75544.74700.04540.0314
Group 5LoopGR5-5-31.7534.76410.36240.05270.0353
Enc-Dec5-81.7767.81338.47560.04990.0326
Naive DecL=71.8473.48936.32730.03160.0204
Lazy Dec5-311.75920.12701.33650.04540.0317
AuthorsOpenReview ↗

Response to Reviewer k64Y (Part 2)

(W2, Q2, Q3) The ablation of RTSD

We thank the reviewer for these suggestions. To comprehensively evaluate Recurrent Trajectory Self-Distillation (RTSD), we train a 4-loop teacher on each of the three Amazon datasets. We compare full RTSD with five ablation settings: 1) training a student from scratch, 2) directly reducing the teacher's inference budget, 3) fine-tuning a student initialized from the teacher using only the task loss, 4) removing the trajectory loss from RTSD, and 5) removing the direction loss from RTSD. All students use the same 2-loop architecture for a fair comparison.

As shown in the following table, RTSD achieves better recommendation performance than the alternative fine-tuning strategies in most cases. Training a 2-loop student from scratch yields performance comparable to task-only fine-tuning from the teacher. RTSD outperforms task-only fine-tuning on all 12 metrics. These results support the benefit of trajectory distillation beyond teacher initialization and task supervision. Reducing the frozen 4-loop teacher to two loops at inference, without further training, substantially degrades recommendation performance. We attribute this degradation to the mismatch between training and inference loop budgets, particularly when inference uses fewer loops than training. The RTSD student retains at least 97% of the teacher's performance across all 12 metrics while halving the loop budget. The component ablations indicate that trajectory loss provides the larger and more consistent contribution, while the direction loss further improves several metrics, particularly on Sports. Notably, the distilled student may surpass its teacher in some cases, consistent with the observations in Table 4 in Appendix A.2. We will expand the ablation study in the revised manuscript to include these additional RTSD experiments.

AblationBeauty R@5N@5R@10N@10Sports R@5N@5R@10N@10CDs R@5N@5R@10N@10
LoopGR (Teacher)0.05460.03730.08060.04560.03300.02220.0488‾\underline{0.0488}0.0272‾\underline{0.0272}0.05370.03600.07910.0442
Train 2-loop student from scratch0.05170.03500.07540.04260.0327‾\underline{0.0327}0.02180.0488‾\underline{0.0488}0.02700.05070.03380.07670.0422
Reduce teacher inference budget (4 to 2 loops)0.02760.01830.04440.02370.01990.01270.03160.01650.02390.01560.03770.0201
Fine-tune 2-loop student from 4-loop teacher0.05150.03510.07790.04360.03110.02120.04670.02620.05120.03460.07780.0431
RTSD (Full)0.0541‾\underline{0.0541}0.0371‾\underline{0.0371}0.0790‾\underline{0.0790}0.04510.03240.0219‾\underline{0.0219}0.04950.02740.0521‾\underline{0.0521}0.0353‾\underline{0.0353}0.07810.0436
RTSD w/o trajectory loss0.05210.03600.0790‾\underline{0.0790}0.04470.03160.02150.04740.02660.05180.03500.0787‾\underline{0.0787}0.0436
RTSD w/o direction loss0.05330.03730.0790‾\underline{0.0790}0.0455‾\underline{0.0455}0.03230.0219‾\underline{0.0219}0.04850.0272‾\underline{0.0272}0.05180.03520.07850.0438‾\underline{0.0438}

Comments on the paper

1 comment
AuthorsOpenReview ↗

A Friendly Reminder

Dear Reviewers,

Thank you for your thoughtful feedback and suggestions, which have helped us further strengthen our study. We have provided detailed responses and conducted additional experiments to address the concerns raised. We would appreciate your feedback on whether our responses and additional results have adequately addressed your concerns.

If any questions remain, we would be glad to provide further clarification. We would also be grateful if you could consider the additional evidence when finalizing your assessment. Thank you for your time and consideration.

Best regards,

The Authors

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

Related papers

Loading the map…

Discussion (0)

Sign in to comment.