[SIGIR 2026] GRC: Breaking the One-Pass Curse in Generative Recommendation with Structured Reflection

TL;DR

Generative Recommendation (GR) is the "rising star" of retrieval, yet it is plagued by a fatal flaw: "one-pass" error accumulation. If the first token is wrong, the entire recommendation drifts. GRC (Generation-Reflection-Correction) solves this by teaching models to look back, localize their own errors in the semantic token space, and rewrite their trajectories. Optimized via GRPO and guided by Entropy Scheduling, GRC delivers a massive 15.74% boost in retrieval accuracy and significant revenue lifts in real-world production.

Problem & Motivation: The "Cascading Error" in Generative Retrieval

Generative Recommendation replaces traditional dual-tower ANN search by treating items as sequences of semantic tokens (e.g., [Cluster 5 -> Sub-cluster 2 -> Item 9]).

The Achilles' heel? Autoregressive Drift. In a one-pass decoding setup, if the model hallucinates the first "category" token, the subsequent "brand" and "product" tokens are essentially meaningless. Prior works like TIGER or COBRA utilize "teacher forcing" during training, but at inference, the model is "blind" to its own mistakes. GRC's insight is simple but powerful: Don't just generate; reflect and fix.

Methodology: The GRC Framework

GRC transforms the standard decoding trajectory into a structured three-act play:

1. The Structured Template

Unlike LLMs that use fuzzy natural language ("I think the category is wrong"), GRC uses Structured Reflection Labels:

• Token-level Localization: Exactly which token index (1 to L) did I get wrong?
• Semantic Consistency: Does my draft match the target's Category or Brand?

2. GRPO-Based Optimization

To explore the massive space of possible corrections, the authors use Group Relative Policy Optimization (GRPO). The reward function ($R$) is the hero here, combining:

• Task Reward ($R_{task}$): Reward for getting the final tokens right.
• Correction Reward ($R_{cor}$): Specifically rewarding the model if it correctly localized an error and if the post-correction sequence is better than the draft ($R_{\Delta }$).

3. Entropy-Guided Reflection Scheduling (EGRS)

Reflection adds latency. To remain industrial-grade, GRC uses Entropy. If a beam has high token-level uncertainty (entropy), the system allocates it a "correction budget." Low-entropy paths are assumed to be "confident" and skip the reflection phase, keeping the P99 latency low.

Experiments & Results: SOTA Performance

The authors tested GRC against giants like SASRec, TIGER, and COBRA across public Amazon datasets and a 1-billion-interaction industrial dataset.

• Accuracy: GRC achieved a 15.74% relative gain in Recall@5 on industrial data.
• Reflection Quality: RL-tuned models localized errors with ~61% accuracy, significantly higher than SFT-only models (~56%).
• Ablation Insight: Removing the "Quality Improvement Reward" ($R_{\Delta }$) caused a severe drop, proving that the model must be explicitly incentivized to improve rather than just change its answers.

Deep Insight & Conclusion

GRC represents a shift from "Passive Recommendation" to "Active Refinement." By constraining the reflection to a structured, discrete token space, the authors avoided the heavy compute of "Chain-of-Thought" while reaping the benefits of iterative reasoning.

Limitations: While EGRS mitigates latency, the framework still requires a larger GPU memory footprint during training to hold the expanded trajectories. Future work could likely distill this reflection capability back into a single-pass model using the GRC trajectories as superior "gold" data.

The Takeaway? If your generative model is hallucinating, don't just give it more data—give it a mirror.