TIGER vs. SASRec: Does Generative Recommendation Actually "Generalize" Better?

TL;DR

Generative Recommendation (GR) models, which represent items as sequences of semantic tokens, have recently outperformed traditional ID-based models. This study confirms the hypothesis that GR models are superior at generalization (predicting unseen transitions) but, surprisingly, inferior at memorization (replaying seen transitions). The secret sauce? GR models effectively turn "unseen" item jumps into "seen" token-prefix jumps.

The Paradigm Shift: Items as Sequences

In traditional sequential recommendation (like SASRec), every item is an atomic ID. In Generative Recommendation (like TIGER), an item is a sequence of semantic tokens (e.g., [102, 45, 12]).

While GR has shown SOTA results, the community hasn't known why. Is it just better at learning, or does it fundamentally handle specific types of data better?

Defining the Battlefield: Memorization vs. Generalization

The authors move beyond target-centric evaluation. They categorize user history transitions into:

1. Memorization: The specific pair of [Previous Item → Target Item] was seen in the training set.
2. Generalization: The pair is new, but can be inferred through:
   • Transitivity: A -> B and B -> C are known; can we predict A -> C?
   • Symmetry: A -> B is known; can we predict B -> A?
   • Substitutability: Multi-hop patterns that skip intermediate steps.

The Core Finding: A Double-Edged Sword

The experiments reveal a stark trade-off:

• SASRec (ID-based) is a memorization master. It anchors hard on specific item IDs, making it highly accurate when the user follows a previously seen path.
• TIGER (GR) is a generalization powerhouse. It effortlessly predicts items it has never seen in a specific context before.

Why? The Token-Level Lens. The authors discovered that over 99% of "generalization" instances at the item level actually contain token-level prefix memorization. Essentially, TIGER isn't "imagining" new rules; it's just reusing small token-level patterns it learned elsewhere.

The table above shows TIGER significantly leading in the "Generalization" columns while SASRec dominates the "Mem" column.

The Dilution Effect: Why GR Struggles to Memorize

If GR is so good at tokens, why does it fail at item memorization? The authors identify a "Dilution Effect." Because multiple items share the same semantic prefix, the probability mass is spread thin. When TIGER sees a familiar start to a sequence, it might suggest five different items that all "look" the same at the token level, reducing the chance of hitting the exact target ID compared to an ID-based model that treats every item as unique.

The Solution: Adaptive Ensembling

Since both models have complementary strengths, the authors propose an Adaptive Ensemble. Using Maximum Softmax Probability (MSP) as a confidence indicator:

• If the ID model is highly confident, it's likely a memorization case → Weight the ID model higher.
• If the ID model is uncertain, it's likely a generalization case → Lean on the GR model.

This simple, training-free strategy yielded improvements across all datasets, proving that the future of recommendation likely lies in balancing these two distinct capabilities.

Critical Analysis & Future Outlook

This paper provides a much-needed "sanity check" for the GR hype. It proves that GR's "intelligence" is grounded in hierarchical token patterns.

• Limitation: The study relies heavily on the quality of semantic ID quantization. If the tokenization is poor, the "token-level memorization" advantage vanishes.
• Takeaway: For product engineers, don't throw away your SASRec models yet. If your business depends on "repeat purchases" (heavy memorization), ID-based models are still king. If you are solving for "discovery" (generalization), GR is your best friend.

Senior Editor's Note: This work brilliantly bridges the gap between the "black box" of LLM-style recommendation and the classical logic of collaborative filtering. By decomposing performance into specific cognitive tasks (memory vs. logic), we can finally start designing architectures that don't just "predict," but "understand" the structure of the data.