PaperlayerView exact revision on arXiv

Source-linked AI summary

TGR: Advancing Industrial Recommendation from Generative-Paradigm Ranking toward Unified Generation and Reasoning

TGR Team, Lei Cheng, Haonan Hu, Beibei Kong, Yudong Li, Zang Li, Yunsheng Pang, Hongyang Su, Jianchao Tu, Yunlong Wang, Bing Wen, Junzhang Zhu, Shaojie Zhu, Chengxiang Zhuo

arXiv:2609.00986v1cs.IR

TL;DR

Industrial recommender systems are constrained by separately optimized cascades, fragmented list decisions, and limited semantic reasoning. TGR addresses these gaps with coupled ranking, end-to-end generation, and offline-amortized reasoning, and reports improvements across production deployments and evaluations.

  • Problem

    Separately optimized cascade stages fragment recommendation decisions, while conventional models have limited semantic knowledge and reasoning for nuanced intents.

  • Method

    TGR combines CCFormer generative-paradigm ranking, BARGE and HiGR end-to-end semantic-ID generation, and offline-generated reason-token injection.

  • Results

    TGR reports consistent gains across ranking, item generation, slate generation, and reasoning evaluations, including BARGE Hit@5 improvements of 10.2%–16.9% over OneRec.

  • Takeaways & Limitations

    The deployed stack advances recommendation toward generative ranking, unified generation, and reasoning without request-time reasoning rollout.

  • Takeaways & Limitations

    TGR remains a stack of coupled models rather than one model, and its amortized reasoning cannot directly reflect intra-session intent shifts.

Abstract

from arXiv · show

Industrial recommender systems typically rely on cascaded retrieval, pre-ranking, ranking, and reranking stages, whose separately optimized models limit scaling, fragment decision making, and lack semantic knowledge and reasoning. We present TGR (Tencent Generative Recommendation), an industrial framework that advances recommendation toward the generative paradigm along three coupled directions. TGR-GenRank upgrades ranking through CCFormer, which combines unified feature tokenization, a scalable Transformer backbone, feature-field separated cross attention, subspace token mixing, and hierarchical sequence compression while retaining per-item multi-task outputs. TGR-GenRec explores end-to-end generation under two paradigms: BARGE bridges item-boundary loss and semantic drift in hierarchical semantic-ID generation through item context-aware attention, hierarchical path reranking, and orthogonal dual-path decoding; HiGR performs whole-slate generation with prefix-structured semantic IDs, coarse-to-fine decoding, and listwise multi-objective alignment. TGR-Reason injects offline-generated semantic-ID reason tokens into online decoding, providing reasoning without request-time rollout. TGR is deployed across Tencent production surfaces serving hundreds of millions of users. CCFormer delivers significant gains in five A/B-tested scenarios and is fully launched in two, including +3.57% CTR and +1.71% advertising revenue. BARGE improves Hit@5 by 10.2-16.9% and yields +0.60% CTR and +1.70% reading time after full rollout. HiGR improves offline slate quality by 15.9-21.3% with a 5x inference speedup and achieves up to +1.22% watch time and +1.73% video views. TGR-Reason raises cold-start new-user Hit@1 by 477.8% and delivers +1.75% effective consumption and +13.09% new-user exposure-to-conversion online.

1. Introduction

Industrial recommendation is moving beyond separately optimized cascades toward generative-paradigm ranking, end-to-end generation, and reasoning-augmented recommendation. TGR develops these three directions for Tencent’s large-scale, heterogeneous production setting.

  • Cascaded retrieval, pre-ranking, ranking, and reranking stages fragment decisions because their models are separately optimized.The cascade also faces information loss and objective mismatch as candidates are progressively truncated.
  • Generative-paradigm rankers tokenize user, item, context, and sequence features into one stream, but long behavior sequences make fine-grained interaction computationally expensive.Quadratic sequence costs routinely force pre-compression or truncation.
  • Pointwise cascade scoring misses inter-item dependencies and positional effects in ordered slates, while direct autoregressive slate decoding is too slow for real-time recommendation.This creates a gap between stage-wise item decisions and list-level user experience.
  • Conventional ID-based models learn behavioral co-occurrence but have limited multimodal semantics, world knowledge, and deliberate reasoning for cold-start, long-tail, and ambiguous-intent cases.Existing LLM-derived reasoning approaches may execute reasoning for every request or refresh.
  • TGR addresses these challenges through CCFormer ranking, end-to-end BARGE and HiGR generation, and TGR-Reason’s reasoning-enriched semantic-ID tokens.The framework is designed for Tencent surfaces serving hundreds of millions of daily active users.

3. TGR-Reason — reasoning-augmented generative recommendation

TGR consolidates three deployed recommendation directions under shared production infrastructure and validates them with offline and online evidence. Its contributions cover generative-paradigm ranking, end-to-end generation, and offline-amortized reasoning.

  • TGR deploys TGR-GenRank, TGR-GenRec, and TGR-Reason across Tencent surfaces serving hundreds of millions of users.The report covers design decisions together with offline, scaling, ablation, and online A/B evidence.
  • CCFormer realizes TGR-GenRank with separated cross attention, subspace token mixing, hierarchical sequence compression, and single-pass candidate scoring.Its production recipe includes mixed-precision training, sparse-parameter compression, and Numerous-Torch serving.
  • BARGE adapts next-token semantic-ID generation with item context-aware attention, hierarchical path reranking, and dual-path decoding.HiGR instead performs whole-slate generation with PCRQ-VAE, coarse-to-fine decoding, and listwise multi-objective alignment.
  • TGR-Reason uses a LatentRec-trained offline Think model to export reasoning-enriched semantic-ID priors that enter the production generator without request-path reasoning rollout.The approach reports consistent offline gains and statistically significant online A/B lifts, strongest for cold-start new users.

2. The TGR Stack: Design Principles and Shared Foundations

The TGR Stack combines an in-place ranking upgrade with end-to-end generation and reasoning over shared semantic-ID, encoding, and infrastructure foundations. Its design principles emphasize deployability, structural sharing, and list-level optimization.

  • Architecture: TGR organizes recommendation into a ranking layer, a generation-and-reasoning layer, and shared foundation components.The foundation includes tokenizers, encoders, user modeling, multimodal understanding, and training infrastructure.
  • Design Principles: Each TGR model replaces a specific cascade stage while remaining behind existing safety, deduplication, and business-rule filters.Deployments must match or exceed incumbent offline metrics within the same online latency and GPU budgets.
  • Shared Foundations: TGR shares a semantic-ID tokenizer family, a common user/context encoding interface, and common post-training infrastructure across generative models.PCRQ-VAE serves slate generation, while OSQ-VAE serves NTP generation.
  • Design Principles: The stack optimizes for displayed lists rather than isolated items, using list- and session-level outcomes and listwise preference alignment where the paradigm permits.Slate generation integrates ranking fidelity, user interest, and diversity in a single listwise ORPO loss.
  • Shared Foundations: A common encoder maps user history and request features to contextual memory for decoder cross-attention, while CCFormer separately emits per-item scores in one pass.TGR-Reason reuses the generative encoder–decoder backbone so reasoning and memory signals enter generation without representation conversion.

3. TGR-GenRank: Generative-Paradigm Ranking

TGR-GenRank keeps the industrial cascade while replacing production rankers with CCFormer, a unified Transformer that models feature interactions and long behavior sequences efficiently. CCFormer improves offline ranking quality, scales with sequence length and model size, and delivers significant online gains across Tencent scenarios.

  • TGR-GenRank: CCFormer replaces production rankers within the cascade with unified tokenized inputs, an efficient Transformer backbone, and per-item multi-task outputs.It combines generative-paradigm modeling with the operational structure of cascaded recommendation.
  • CCFormer Architecture: CCFormer separates feature interaction from sequence modeling, using directed cross-field attention and subspace token mixing with hierarchical compression instead of global self-attention.The architecture partitions user, behavior-sequence, and target-item fields while preserving long-history access at subquadratic cost.
  • Offline Results: CCFormer achieves the best score on every dataset and metric, including 93.67% and 83.35% AUC on Taobao and KuaiRec.On the industrial dataset, it improves over HSTU by +0.28 AUC and +0.50 GAUC points.
  • Scaling Behavior: As behavior sequences grow from 0.5k to 2k, CCFormer rises from 77.72% to 78.17% AUC and from 70.95% to 71.57% GAUC, with widening margins over HSTU.With 0.5k behavior tokens, it matches HSTU’s AUC and surpasses its GAUC using 2k tokens.
  • Scaling Behavior: At matched capacity, CCFormer consumes roughly half HSTU’s GFLOPs while improving average relative gains by 1.02% AUC and 1.93% GAUC.At d = 128, it comes within 0.01 AUC points of HSTU at d = 256 using 4× fewer GFLOPs per sample.
  • Ablations: Ablations identify compression as the efficiency lever, subspace token mixing as the main quality contributor, and relative temporal-position encoding as an additional quality source.Removing compression reduces speedup from 2.21× to 1.29×; removing token mixing causes −0.21 AUC and −0.34 GAUC points.
  • Online Deployment: Online tests report CTR +3.57% in video recommendation and advertising-revenue lifts of +1.64% and +1.71%, with full launches in two scenarios.The gains remained stable after full deployment across the two launched scenarios.

4. TGR-GenRec: From Next-Token to Next-Slate Generation

TGR-GenRec develops two complementary end-to-end generation paradigms: BARGE generates items autoregressively with structural safeguards, while HiGR generates complete slates with list-level objectives and efficient decoding. Both are designed for production deployment and address distinct failures of item-wise or cascaded recommendation.

  • TGR-GenRec: TGR-GenRec ships BARGE for next-token item generation and HiGR for whole-slate generation, with each targeting a distinct generation paradigm.BARGE preserves autoregressive item generation, whereas HiGR emits the ordered result list as one structured object.
  • BARGE: BARGE addresses item-boundary loss and semantic drift through item context-aware attention, hierarchical path reranking, and dual-path decoding.These mechanisms preserve item structure, evaluate global path coherence, and provide a complementary recovery path without increasing the model, beam, or serving budgets.
  • BARGE: +0.60% click-through rate and +1.70% total reading time: BARGE improves both measures over the deployed multi-stage incumbent after online evaluation.The model was fully rolled out as a production retrieval channel with a long-term holdback group; longer observation showed larger and more stable improvements.
  • BARGE: At K = 10, BARGE’s decoding channels have Jaccard similarities of 0.183 on Beauty and 0.172 on Sports, with exclusive contributions of 15.6% and 24.3%.The complementarity supports OR fusion and is consistent with improved resistance to deeper-level path errors.
  • BARGE: 10.2%-16.9%: BARGE improves Hit@5 relative to OneRec across two industrial scenarios, while retaining a 12.6% gain at Hit@50.It achieves the best performance across all four reported Hit@K metrics in both scenarios.
  • HiGR: HiGR treats the ordered slate as one generation unit and combines prefix-contrastive tokenization, hierarchical decoding, and listwise preference alignment.This design targets relevance, ordering, compatibility, and diversity jointly, while achieving more than a 5× inference speedup over OneRec under matched decoding settings without KV caching.

5. TGR-Reason: Reasoning-Augmented Generative Recommendation

TGR-Reason connects offline latent reasoning to online generative recommendation through exported semantic-ID reason tokens. These tokens guide decoding and retrieve complementary group memory without request-time reasoning rollout.

  • Core design: Offline-generated reason tokens provide a shared interface connecting reasoning, memory retrieval, and online SID decoding.They are used both as semantic prompts and as queries for Group Memory Retrieval.
  • Results: +477.8% cold-start new-user Hit@1, rising from 0.0451 to 0.2606, is reported for direct reason-token injection on a commercial content platform.The reported deployment also shows consistent improvements across the evaluated settings.
  • Motivation: TGR-Reason targets cold-start, long-tail, and ambiguous-intent requests where behavioral co-occurrence provides insufficient evidence.These cases require intent inference beyond a user’s available history.
  • Offline reasoning: LatentRec trains reasoning supervision offline so the Think model emits complete top-Kr semantic IDs through ordinary SID decoding without inference-time reasoning rollout.The model exports reason tokens periodically rather than reasoning synchronously for each request.
  • Reasoning and memory injection: DRI conditions reason-token codewords on Personal Memory, while GMR retrieves population behavioral evidence from complete reason tokens for fusion with that memory.The two paths provide complementary conditioning to TGR-GenRec.

5.3. Training Recipe

The training recipe separates Think-model preparation, offline reason-token generation, and downstream generator conditioning. It also addresses large-scale constrained decoding by reproducing beam search with batched single-token rounds.

  • Think-model training: The Think model is trained through vocabulary expansion, content alignment, and LatentRec reasoning stages sharing one backbone.The stages make semantic IDs emit-able, ground the model on the target surface, and train latent reasoning.
  • Gen-model training: Precomputed top-Kr reason tokens are fixed conditioning features while TGR-GenRec learns the standard next-token SID objective.DRI inserts Personal-Memory-conditioned representations before corresponding target codewords under teacher forcing.
  • Gen-model training: When enabled, GMR context is jointly optimized through the same next-token loss, while GMR remains non-parametric and receives no gradient.No additional reasoning-specific objective is added on the generator side.
  • Refresh strategy: A two-pipeline refresh separates weekly Think-model retraining from daily user-level reason-token production within a fixed compute budget.Batched decoding allows predictions to be regenerated for users selected for refresh.
  • Offline generation at scale: 2.2× faster offline generation, from 174 to 80 minutes on eight A100 GPUs, is achieved by batched beam-search rounds that preserve reference enumeration and accuracy.The method expands live beams in batched single-token passes and prunes by cumulative log-probability.

5.4. Deployment

TGR-Reason moves expensive Think-model inference off the synchronous serving path by materializing versioned user-level Reason records. Online generation, memory retrieval, direct SID retrieval, and ranking consume valid records while preserving fallback behavior.

  • Asynchronous materialization: Reason records are asynchronously materialized in a distributed Reason Store so expensive Think-model inference stays outside the latency-critical request path.Nearline refreshes are request-triggered, while scheduled offline jobs backfill missing or stale records.
  • Online serving: At serving time, DRI injects a fixed-size soft prompt, GMR retrieves group memory, and TGR-GenRec autoregressively generates a SID list.Direct retrieval separately resolves stored top-k SIDs through the SID index to obtain exact item candidates.
  • Online serving: DRI, GMR, and SID-index lookup are bounded non-autoregressive operations that leave the decoding horizon, beam width, and beam-search space unchanged.Their request-time overhead is limited to store access, validation, projection, bounded retrieval, and aggregation.
  • Online serving: The same valid Reason record supplies rank-side features to CCFormer, allowing reasoning evidence to support both generation and downstream ranking.This reuse does not require synchronous Think-model inference.
  • Fallbacks and refresh: Invalid or missing records trigger baseline generation, retrieval, and ranking fallbacks, so service availability does not depend on successful Think-model execution.The current request also does not wait for a newly triggered nearline refresh.
  • Fallbacks and refresh: RTC admits asynchronous refreshes using record freshness, behavior change, expected marginal gain, and available inference capacity.Resident-GPU execution uses dynamic micro-batching, and refreshed records affect subsequent requests.
  • Storage: Versioned records include user or scene keys, reason artifacts, behavior cutoff, timestamps, model and codebook versions, and expiration metadata.The managed key–value service provides low-latency lookup, TTL expiration, and atomic conditional updates.

5.5. Evaluation Results

TGR-Reason improves offline Hit@K across traffic cohorts and cutoffs, with the largest gains for cold-start users near the head of the list. Online A/B testing also reports statistically significant improvements in effective consumption and new-user exposure-to-conversion.

  • Offline results: TGR-Reason improves every Hit@K cutoff across all recommendation, primary recommendation, and cold-start cohorts.The evaluation compares TGR-Reason with the deployed production generator across five cutoffs.
  • Offline results: Hit@1 rises from 0.3385 to 0.4339 (+28.2%) across all recommendation traffic, while Hit@5 and Hit@50 improve by 10.4% and 2.4%.The gain is larger in primary recommendation traffic, where Hit@1 improves by 58.6%.
  • Offline results: The improvement is strongest near the head of the list, while gains narrow at larger K because the production model already recovers many relevant items.Reasoning contributes most by moving a plausible target toward the first few positions.
  • Offline results: Cold-start users show a 477.8% relative Hit@1 gain, increasing from 0.0451 to 0.2606.At larger cutoffs, Hit@5, Hit@10, Hit@20, and Hit@50 improve by 39.2%, 24.9%, 20.1%, and 11.6%, respectively.
  • Online A/B: Online A/B testing improves Effective Consumption Rate by 1.75% and new-user Exposure-to-Conversion Rate by 13.09%, with both lifts statistically significant.The experiment uses the incumbent production generator as the control on a Tencent commercial content platform.

6. Conclusion, Limitations, and Future Directions

TGR consolidates generative-paradigm ranking, end-to-end generation, and reasoning-augmented recommendation in an industrial stack deployed across Tencent surfaces. The report also identifies current boundaries, including a multi-model architecture, tokenizer-dependent cold-start items, global alignment weights, and amortized reasoning.

  • Conclusion: TGR comprises TGR-GenRank, TGR-GenRec, and TGR-Reason, sharing semantic-ID tokenizers, user/context encoding, and Numerous-Torch infrastructure.The stack serves hundreds of millions of users across multiple Tencent surfaces.
  • Conclusion: CCFormer consistently outperforms strong industrial baselines offline and is fully deployed with +3.57% CTR and +1.71% advertising revenue.It uses feature-field separated cross attention, subspace token mixing, and hierarchical sequence compression.
  • Limitations: TGR remains a stack of coupled models rather than one model: GenRank still emits per-item scores, while GenRec uses separate production models and tokenizers.TGR-GenRank remains integrated with downstream cascade stages.
  • Limitations: Cold-start items remain constrained by hierarchical tokenizer quality because brand-new items enter the code space from semantic evidence before collaborative relations can be estimated.The demonstrated cold-start gains concern new users, not cold-start items.
  • Limitations: ORPO alignment applies one global weighting across ranking fidelity, genuine user interest, and diversity, leaving personalized weighting open.The current weighting is uniform across users and contexts.
  • Limitations: TGR-Reason amortizes reasoning offline through weekly Think-model retraining and daily reason-token regeneration, so intra-session shifts rely on input context.Explicit in-text reasoning remains too expensive for the request path.

A. Contributions

The contributor list is presented in alphabetical order by last name and spans the names listed across four lines.

  • Contributions: The contributors are listed in alphabetical order based on their last names.
  • Contributions: The listed contributors include Lei Cheng, Haonan Hu, Beibei Kong, Yudong Li, Zang Li, Yunsheng Pang, and Hongyang Su.
  • Contributions: The list continues with Jianchao Tu, Yunlong Wang, Bing Wen, Junzhang Zhu, Shaojie Zhu, and Chengxiang Zhuo.

B. Notation

Table 18 defines stack-level notation and principal model-specific symbols, with notation scoped to the relevant technical sections.

  • Notation: Table 18 scopes symbols to their listed technical sections because the production models are presented as independent parallel works.The same letter may denote different quantities in different chapters, including L and D for per-item SID depth.

C. Default Configurations and Hyperparameters

Table 19 consolidates the default configurations of CCFormer, BARGE, HiGR, and TGR-Reason in one reference. The entries retain each model’s source-specific setting context and omit unpublished values.

  • Table 19 consolidates the default configurations of CCFormer, BARGE, HiGR, and TGR-Reason.It serves as a single reference across the production models and TGR-Reason.
  • The configurations are drawn from the corresponding source papers and the paper’s §5.
  • Unpublished values, such as HiGR’s ILD regularization weight β, are omitted.

D. Complexity Analysis

The complexity analysis describes how CCFormer, BARGE, and HiGR reduce computational or memory costs through structured attention, fixed-width correction, and decomposed slate decoding. These designs support the reported serving and layer-allocation results.

  • CCFormer: CCFormer avoids global behavior-sequence attention’s O(Ls^2) cost using local temporal encoding, linear-cost subspace mixing, and hierarchical sequence compression.Strided convolutions geometrically shorten the sequence passed to deeper blocks while preserving access to the full history.
  • CCFormer: At matched capacity, CCFormer uses roughly half the per-sample GFLOPs of HSTU.
  • BARGE: BARGE corrects semantic drift at fixed beam width because hierarchical SID latency scales approximately with B and decoding memory with B × L.HPR uses lightweight per-layer dual-tower scoring, while DPD runs parallel decoder towers over a shared encoder.
  • HiGR: HiGR decomposes full-sequence beam decoding into greedy slate planning followed by local per-item beam search.The analysis uses slate size M, SID depth D, hidden size d, beam width B, and separate slate-planner and item-generator depths.
  • HiGR: HiGR’s decomposed decoding changes complexity from B · M^3D^3 · l_slate · d to M^3 · l_slate · d + B · M D^3 · l_item · d.This decomposition underlies the layer-allocation and serving results in §4.3.4.
Loading 2609.00986v1…