博客 | Yadong's Blog

RecoWorld：Meta 为推荐 Agent 构建的模拟沙盒——从 CTR 预估到 Agentic RecSys 的范式跃迁

Thu, 28 May 2026 08:00:00 +0800

Meta 近期发布论文 RecoWorld: Building Simulated Environments for Agentic Recommender Systems，提出为推荐智能体构建模拟训练环境，将推荐系统从"CTR 预估排序器"重构为"多轮交互的推荐 Agent"。本文基于原论文和 HiTech 实验室的深度解读，逐层拆解 RecoWorld 的架构设计、核心机制与工业落地意义，并探讨 Semantic ID、LLM 用户模拟器、session-level 优化目标等关键技术的本质与未来走向。

0. 导言：推荐系统正在走到一个隐秘的边界

0.1 “猜你喜欢"的本质局限

打开任何一个主流短视频 App 或电商平台，背后运转的是一台庞大的推荐机器。它观察你的每一次点击、每一次停留、每一次划走，把你和内容的关系编码成稠密向量，然后预测你在下一秒最可能点击什么、观看什么、购买什么。这套范式在过去十多年里支撑了几乎所有互联网产品的增长——从协同过滤到深度排序模型，从序列推荐到多任务学习，技术在演进，但底层逻辑从未动摇：观察历史行为 → 预测未来行为 → 优化 CTR/CVR/观看时长。

但这套范式有一个深层的裂缝，往往被高 AUC 的模型指标所掩盖：它永远只能猜，无法理解。

用户划走一个视频，系统记录了一个"skip"信号，却不知道用户是因为主题不感兴趣、封面太丑、节奏太慢，还是单纯因为已经看过类似内容。用户连续观看了三条 AI 相关视频，系统把这个信号编码为"喜欢 AI”，开始大量推送 AI 内容，却不知道用户想看的是论文解读、工程实践还是行业趋势——三者虽然同属 AI，但受众特征、消费心理完全不同。用户突然停止互动、准备退出，系统观察到 session 结束，却无法知道他是因为满足了需求、疲劳了、还是对推荐结果彻底失望。

更根本的问题是：传统推荐系统缺乏一个让用户直接"告诉"系统自己需要什么的通道。用户只能用粗糙的行为信号被动表达——点击代表感兴趣，跳过代表不感兴趣，退出代表不满意——这些信号高度模糊，且天然带有曝光偏差（用户只能对已经被推送的内容产生行为，看不到的内容永远不在信号里）。

0.2 大模型时代改变了什么

ChatGPT 的出现让普通用户习惯了一件事：用自然语言直接表达需求。我们已经会对 AI 助手说"帮我总结这篇论文，重点提炼方法论"，会说"最近给我的内容太焦虑了，换点轻松的"，会说"我想研究 AI Agent，多推技术分析而不是行业新闻"。

这个习惯一旦形成，就很难回到只能用"点击/不点击"来和系统沟通的时代。用户的期望正在发生结构性变化：他们开始期待系统能听懂自己说的话，而不只是猜自己的行为。

Meta 这篇 RecoWorld 论文，正是在这个背景下诞生的。它的核心问题不是怎样把 CTR 模型再提升 0.1%，而是：如果未来推荐系统变成了一个可以接收自然语言指令、动态调整策略、在多轮交互中持续理解用户状态的 Agent，那么这个 Agent 应该在哪里训练，怎么训练，用什么指标评估？

1. RecoWorld 的核心洞察：推荐 Agent 需要一个沙盒

1.1 现有评估体系的两个死角

在讨论 RecoWorld 的架构之前，需要先理解它要解决的根本问题：评估推荐策略，尤其是新型 Agentic 推荐策略，现有方法有两个根本性的死角。

死角一：离线评估的曝光偏差。Recall@N、NDCG、AUC、反事实评估都依赖历史日志。但历史日志是旧系统生成的——它只记录了系统决定推给用户的内容，以及用户对这些内容的反应。任何新策略想探索的"未曾推送过的内容"，在历史日志里天然没有评估数据。这意味着离线评估天然只能在旧系统已经探索过的空间里打转，对真正的策略创新评估能力极弱。

死角二：在线 A/B 实验的成本与风险。在线实验是推荐系统评估的金标准，但代价高昂：周期慢（通常需要 1-4 周才能统计显著），流量昂贵，风险大（一个有问题的策略可能在被叫停前已经影响了大量真实用户）。对于一个可能大幅改变用户信息流体验的 Agentic 策略，在没有充分预验证的情况下直接推给真实用户，代价难以承受。

RecoWorld 的答案是：模拟环境。类比强化学习领域的 OpenAI Gym——机器人先在仿真器里摔跤学步，自动驾驶先在虚拟道路里应对极端场景，游戏 Agent 先在虚拟世界里自我博弈——推荐 Agent 也应该先在一个模拟的用户世界里学习如何推荐、如何理解反馈、如何在多轮交互中优化用户体验，再考虑走向真实系统。

1.2 什么是"模拟推荐环境"

RecoWorld 的模拟环境包含两个核心角色：

User Simulator（用户模拟器）：模拟真实用户在面对推荐内容时的行为——点击、观看、点赞、评论、分享、跳过、退出，以及最重要的：用自然语言表达不满。
Agentic RecSys（推荐 Agent）：扮演具备智能体能力的推荐系统，负责给出推荐列表，接收用户行为反馈和自然语言指令，调整策略，继续推荐。

两者之间构成一个多轮对话式的交互循环，而不是传统推荐中的单次打分排序。这个循环可以产生大量模拟交互轨迹，作为训练推荐 Agent 的数据，也作为评估推荐策略的 benchmark。

整个系统可以类比为一个"推荐领域的 Gym 环境"：它定义了状态（用户当前状态）、动作（推荐内容列表）、奖励（用户反馈与 session 质量指标），让推荐 Agent 可以在其中反复探索和学习。

2. 双视角架构：用户模拟器与推荐 Agent 的对话

2.1 架构总览

RecoWorld 的核心架构是 dual-view architecture（双视角架构）：

┌─────────────────────────────────────────────────────────┐
│ RecoWorld 环境 │
│ │
│ ┌──────────────────┐ ┌──────────────────────┐ │
│ │ User Simulator │◄──────►│ Agentic RecSys │ │
│ │ (用户模拟器) │ │ (推荐 Agent) │ │
│ │ │ │ │ │
│ │ - 用户画像 │ 推荐列表 → - 召回/排序工具 │ │
│ │ - 历史行为 │ ← 行为+指令 - 策略规划器 │ │
│ │ - 当前上下文 │ │ - 记忆模块 │ │
│ │ - LLM 推理引擎 │ │ - 工具调用层 │ │
│ └──────────────────┘ └──────────────────────┘ │
└─────────────────────────────────────────────────────────┘

这个结构把推荐系统从"一次性排序问题"变成了"多轮交互决策问题"。传统推荐系统每次请求是独立的：给定用户向量和候选 item 集合，输出排序列表，完成。RecoWorld 的设计中，每次交互是有记忆的：系统需要知道这个 session 里已经发生了什么，用户对哪些内容满意/不满意，之前发出了什么指令，系统如何响应，现在应该如何继续。

2.2 一次典型交互的完整流程

以一个用户打开短视频 App 为例，RecoWorld 中的一次典型 session 大致如下：

第一轮推荐：推荐 Agent 给出初始推荐列表（10条内容）。用户模拟器根据用户画像（喜欢深海钓鱼、UFC 格斗、户外装备）逐一判断：

龙虾捕捞视频：与深海钓鱼兴趣相关 → 观看 + 点赞
UFC 比赛集锦：历史强正反馈 → 观看 + 分享
发型教程视频：与当前兴趣无关 → 跳过
户外徒步装备评测：相关 → 观看

第二轮推荐：系统根据第一轮反馈调整，继续推送。但模拟器发现接下来几条内容质量下降：主题重复，新鲜感不足，开始出现 disengagement（脱离倾向）。

自我反思阶段：用户模拟器进入 disengagement 后，不会直接退出，而是触发一次 **self-reflection（自我反思）**机制：

“我刚才已经看了两条深海相关视频，下面又在推类似的内容，感觉有点重复。另外我其实更想看 UFC 格斗技巧分析，而不只是比赛集锦。”

模拟器根据这个反思，生成一条自然语言指令发送给推荐 Agent：

“不要再给我推这么多钓鱼内容了，换点 UFC 技巧分析或者格斗训练的内容。”

策略调整：推荐 Agent 收到指令后，需要解析意图（降低钓鱼类权重，提升 UFC 技术分析类），重新规划召回方向，给出第三轮推荐列表。如果下一轮质量明显改善，用户继续留下；否则，模拟器可能选择退出 session。

整个 session 结束，系统可以计算一系列 session-level 指标：总点击数、总观看时长、多轮交互轮数、用户离开时刻、指令被正确理解的比例、系统响应指令后体验是否改善等。

2.3 为什么 disengagement + self-reflection 是关键设计

传统推荐模型把"用户退出"当作一个粗粒度的负信号——系统知道用户走了，但不知道为什么走，也无法从这次失败中学到有意义的策略调整信号。

RecoWorld 的 self-reflection 设计从根本上改变了这一点：它让模拟用户在退出前"说出"自己为什么不满意，把一个原本无信息的"退出"事件，变成了一个带有语义内容的训练信号。

这对推荐 Agent 的训练意义重大。Agent 可以学习：

哪种推荐模式更容易触发 disengagement（内容重复、主题漂移、与指令相悖）
接收到特定类型的自然语言反馈后，什么样的策略调整最有效
如何在即时相关性和内容多样性之间取得平衡，延长 session 时长

3. 从 CTR 到 Session 轨迹：推荐目标的根本转变

3.1 传统目标的局限

传统推荐模型的优化目标几乎都是 item-level：

CTR（点击率）：这个 item 会不会被点击？
CVR（转化率）：这个 item 会不会被购买？
完播率：这个视频会不会被看完？
互动率：这个内容会不会被点赞/评论/分享？

这些目标当然有意义，但它们存在两个系统性偏差：

偏差一：短期 vs. 长期。标题党内容可能点击率极高，但用户点进去之后体验差，下次看到类似内容会更不信任；强刺激内容可能让用户停留时间很长，但长期来看会带来感知疲劳和负面体验；高度同质化的内容序列可能每条 CTR 都不低，但整个 session 结束时用户感觉什么都没有获得。

偏差二：局部 vs. 全局。优化每个 item 的点击概率，不等于优化用户在整个 session 里的体验质量。NDCG 很高的排序，不一定能让用户在多轮交互后仍然愿意留下来。

3.2 RecoWorld 的 Session-Level 优化目标

RecoWorld 把优化目标从 item-level 推向了 session-level trajectory（会话级轨迹）。它关心的不是某个 item 被不被点击，而是整个 session 里用户经历了什么：

维度	传统指标	RecoWorld 目标
即时反馈	CTR / CVR	点击 + 观看 + 互动行为组合
保留信号	无	disengagement 发生时间点
理解信号	无	self-reflection 内容质量
指令响应	无	自然语言指令完成度
长期体验	隐式	session 多轮交互轮数 + 最终留存

具体来说，RecoWorld 可以设计如下 reward 函数：

Reward = α × 即时互动信号（点击/点赞/完播）
 + β × session 延续奖励（每完成一轮不退出）
 - γ × disengagement 惩罚
 + δ × 指令响应质量（语义匹配度）
 + ε × 内容多样性奖励

不同业务场景可以调整各项权重：短视频平台可能更重视 session 延续时长，电商平台可能更重视指令理解后的转化恢复，知识社区可能更重视多样性和探索度。

3.3 推荐目标的三阶段演化

从更宏观的视角看，推荐系统的优化目标经历了三个阶段：

第一阶段（过去 10 年）：“点不点”——CTR/CVR 为核心，item-level 打分排序。系统问的是"这个内容与这个用户相关吗"。

第二阶段（当前主流）：“留不留”——多任务学习，把留存率、互动率纳入优化。系统问的是"这组推荐能不能让用户继续使用"。

第三阶段（RecoWorld 指向的未来）：“懂不懂”——session-level 体验优化，自然语言指令响应，动态状态理解。系统问的是"推荐过程是否真正理解了用户当下的需求，并帮助用户发现新的兴趣"。

这三个阶段不是替代关系，而是叠加关系：第三阶段的 Agentic 层建立在前两阶段的精准预估和留存优化基础之上，在更高的抽象层处理更复杂的交互。

4. LLM 用户模拟器：从行为预测到意图推理

4.1 传统用户模拟器的能力边界

用户模拟器在推荐系统研究中并不是新概念。早期的工作通常用概率模型来模拟用户：给定用户 embedding 和 item embedding，计算一个点击概率，按概率采样产生行为。这种方法简洁高效，但有两个根本性的局限：

无法生成理由：它告诉你用户"可能点"或"可能跳过"，但无法解释为什么。
无法生成自然语言：它只能输出离散的行为标签（click/skip/exit），无法生成"我不喜欢这类内容，换点新的"这样的自然语言表达。

4.2 LLM 模拟器的核心能力

RecoWorld 用大语言模型来驱动用户模拟器，根本性地改变了两件事：

能力一：生成 reasoning trace（推理链）

传统模拟器给出"skip"，LLM 模拟器可以给出：

“这条视频是发型教程。我的历史兴趣主要是户外运动和格斗体育，与发型相关的内容和我的兴趣领域完全不重叠。此外，我刚才在这个 session 里已经看了很多条内容，专注力开始下降，对于不相关的内容容忍度更低。因此我选择跳过。”

这个 reasoning trace 对推荐 Agent 来说是极其宝贵的训练信号——它不再只知道用户做了什么，还能学习用户为什么这么做，从而理解不同类型的"跳过"背后完全不同的原因（不相关 vs. 重复 vs. 疲劳 vs. 质量差）。

能力二：生成结构化的自然语言反馈

当用户进入 disengagement 状态时，LLM 模拟器可以根据用户画像、当前 session 状态和 self-reflection 结果，生成真实感较强的自然语言反馈：

“最近给我推了太多同类型的视频，希望能换换口味”
“我想看更多 UFC 技巧分析，而不只是比赛集锦”
“这些内容感觉有点太广告化了，能不能推一些更真实的内容”
“这个话题我最近已经看了很多了，先换个方向”

这些反馈风格各异、意图复杂，是测试推荐 Agent 自然语言理解能力的理想数据。

4.3 Dynamic Memory Modeling（动态记忆建模）

RecoWorld 论文中提出的另一个重要机制是 dynamic memory modeling，把用户历史分成两个层次：

Interaction-wise Memory（交互级记忆）：记录单次行为的细粒度信息——点击了哪个 item、点赞了哪个视频、观看了多长时间、在哪里跳出。这对于理解用户即时偏好和短期状态变化非常重要。

Session-wise Memory（会话级记忆）：记录一个 session 内的整体轨迹和状态演变——用户在这个 session 开始时什么状态、中间发生了什么 mindset shift、是否发出过自然语言指令、系统如何响应、最终以什么状态结束。这对于跨 session 的偏好建模和长期用户状态追踪更重要。

两级记忆的设计承认了一个重要事实：用户不是一个静态的兴趣向量，而是一个随时间、场景和内容暴露不断变化的动态状态。同一个用户，早上通勤时可能想看轻松内容，晚上学习时可能想看技术内容；连续看了几条装修视频，可能意味着生活阶段变化；连续跳过财经新闻，可能不是不喜欢财经，而是对当前特定议题产生了疲劳。

推荐系统如果只维护一个全局的长期兴趣平均向量，会系统性地错过这些短期、即时的状态变化。动态记忆建模正是为了捕捉这种变化而设计的。

4.4 LLM 模拟器的风险与局限

当然，LLM 驱动的用户模拟器并非没有问题，论文也诚实地讨论了这些风险：

风险一：过于理性。真实用户经常是情绪化的、冲动的、自相矛盾的。他们可能因为一时好奇点了一条完全不相关的内容，可能因为封面好看就点进去，可能因为心情不好而对所有内容都失去兴趣。LLM 模拟器生成的行为往往过于符合逻辑、过于一致，缺乏真实人类行为的"噪声"。

风险二：Prompt 依赖。模拟器的行为质量高度依赖 prompt 设计。设计不好的 prompt 可能让模拟器过度配合系统（“这个推荐很相关，我愿意点击”），或者产生不真实的用户画像描述，导致训练信号失真。

风险三：分布偏移。即使模拟器在模拟环境里逼真，它和真实用户之间仍然存在分布差距。在模拟器上训练很好的推荐 Agent，在真实用户上不一定同样有效——这是所有 sim-to-real 方法的通病。

但这些风险并不否定 LLM 模拟器的价值。在没有好的仿真环境的情况下，推荐 Agent 的训练几乎无法进行。即便模拟器不完美，它仍然提供了一个在离线环境中快速验证策略、探索新方向的途径，大幅降低了新策略走向在线实验的门槛。

5. 内容表示的三条路线：文本、多模态与 Semantic ID

5.1 核心问题：推荐内容如何进入大模型

如果用 LLM 来驱动用户模拟器和推荐 Agent，一个立刻出现的工程问题是：推荐内容（视频、商品、文章、直播）和用户历史应该如何表示，才能被大模型有效处理？

RecoWorld 讨论了三条技术路线，各有其适用场景和局限：

5.2 路线一：文本化表示

最直接的方法：把用户画像、历史行为、item 信息全部转化为自然语言描述，输入 LLM。

示例（用户历史）：

用户最近 30 天观看记录（按时间倒序）：
- [3天前] 深海钓鱼纪录片 - 完整观看 + 点赞
- [3天前] UFC 267 约书亚对莱维特精彩集锦 - 完整观看 + 分享
- [5天前] 碳纤维钓竿评测 - 观看 80% + 收藏
- [7天前] 龙虾捕捞全过程记录 - 完整观看
- [8天前] UFC 训练营训练方法 - 完整观看 + 点赞

示例（item 描述）：

视频标题：专业深海钓鱼装备全指南 2026
作者：钓鱼频道官方
时长：18:30
类目：户外运动 > 垂钓
摘要：本视频系统介绍深海钓鱼所需装备，包括钓竿选择、渔线规格、水下摄像头应用等

优点：实现简单，充分利用 LLM 的语言理解能力，灵活性高。缺点：无法表达多模态信息（视频画面、音乐、节奏、主播表达），文本摘要损失大量内容细节，且随着历史行为变长，token 消耗急剧膨胀。

5.3 路线二：多模态表示

直接使用多模态大模型（如 GPT-4V、Gemini）处理视频帧、商品图片、音频等原始多媒体内容。

这条路线理论上最能捕捉真实的内容体验——用户是否会被一个视频吸引，往往更取决于画面质感、背景音乐、剪辑节奏，而不是文字描述。但工业落地面临严峻的成本问题：

视频 token 极其昂贵（1 秒视频可能需要数百个视觉 token）
用户历史 + 候选 item 叠加后，单次推理 token 数量可能超过 100K
在线推理延迟完全无法满足毫秒级的推荐响应要求

因此，多模态路线更多是研究方向，而非近期工业可行路径。

5.4 路线三：Semantic ID（语义 ID 建模）

这是论文中最值得重点关注的路线，也与当前生成式推荐研究趋势高度契合。

基本思路：把视频、商品、图文、直播等内容编码成一串离散的语义 ID。语义相近的内容拥有相近的 ID，不同层级的 ID 表示从粗粒度到细粒度的语义层次。这样，一个 item 不需要输入完整视频，也不依赖纯文本摘要，而是被压缩为一组结构化的语义 token。

示例（假想的 Semantic ID 结构）：

视频 A（UFC 技术训练分析）：
 Level-1 ID: 1024 (体育内容)
 Level-2 ID: 1024-387 (格斗体育)
 Level-3 ID: 1024-387-091 (UFC 技术分析)
 Leaf ID: 1024-387-091-8823 (具体内容)

视频 B（龙虾深海捕捞记录）：
 Level-1 ID: 512 (户外内容)
 Level-2 ID: 512-204 (海洋捕捞)
 Level-3 ID: 512-204-067 (深海钓鱼)
 Leaf ID: 512-204-067-3341 (具体内容)

模型读到的推荐序列变成这样的混合 token 流：

[用户历史] → [1024-387-091-8823] [点赞] [512-204-067-3341] [完整观看]
 [1024-387-091-4512] [分享] ...
[自然语言指令] → "换点 UFC 技巧分析的内容"
[推荐 Agent 输出] → [1024-387-091-xxxx] [1024-387-019-xxxx] ...

为什么 Semantic ID 是关键接口：

比多模态轻：不需要处理原始视频帧，大幅降低 token 消耗。
比纯文本结构化：有明确的语义层次，模型可以在不同粒度上推理。
与生成式推荐天然对接：OneRec、HSTU、RQ-VAE、RQ-KMeans 等工作的核心思路都是把推荐对象转成可生成的离散语义单元，Semantic ID 正是这套体系的自然延伸。
支持跨模态统一：视频、商品、直播间、文章可以在同一个 Semantic ID 空间里表示，方便跨场景的用户兴趣迁移建模。

未来推荐大模型读到的不再只是自然语言，而是一段混合序列：用户行为（Semantic ID 序列）+ 动作类型（点击/点赞/跳过）+ 时间上下文 + 自然语言指令。模型从这段混合序列里理解用户当前状态，再生成下一轮推荐策略。

这可能是推荐系统与大模型真正深度融合的关键技术接口。

6. 多 Agent 生态：从用户侧到创作者侧

6.1 超越单用户模拟：Multi-Agent Ecosystem

真实推荐系统不是"一个用户孤立地看内容"，而是一个内容生态：一条视频被推给数百万用户，用户之间互相关注、转发、评论；创作者观察内容表现后调整创作策略；平台的推荐算法又受到用户集体行为的影响。

RecoWorld 论文讨论了 multi-agent simulator：用多个模拟用户构成一个微型生态。不同用户类型（核心受众、泛兴趣用户、随机新用户、老粉）对同一条内容的反应不同，这些集体反应又会影响系统对内容质量的判断，进而影响后续推荐策略。

6.2 创作者侧应用：内容发布前的预测性验证

RecoWorld 最有商业价值的想象之一，是创作者内容预测系统：

一个创作者准备发布一条 AI 技术解读视频，在发布前可以把这条内容放进模拟推荐场测试：

模拟测试报告：

目标用户群 A（推荐系统从业者，500人）：
- 预测点击率：34%（显著高于同类内容均值）
- 预测完播率：62%
- 预测点赞率：18%
- 关键反馈："内容深度够，但前3分钟信息密度偏低"

目标用户群 B（泛 AI 兴趣用户，2000人）：
- 预测点击率：12%
- 预测完播率：28%
- 关键反馈："标题偏学术，门槛感较强；如果改成更通俗的表达预计点击率可提升至18%"

建议：
1. 前3分钟加入1-2个现实应用案例，降低门槛感
2. 标题调整为更具体的问题导向（"为什么 XX 推荐算法在大模型时代失效了？"）
3. 主要传播力量来自技术圈，适合在工作日上午发布

这将推荐系统从内容分发机器变成了内容创作决策辅助系统。对创作者、MCN 机构、电商商家来说，这种发布前预测能力的价值极其巨大——可以在投入大量时间制作内容之前，先预判不同策略的效果。

6.3 数字孪生用户：最终形态的想象

更远期的想象是数字孪生用户（Digital Twin User）：每个真实用户都有一个动态的模拟体，它不是几个兴趣标签，而是一个可以被询问、模拟和预测的用户状态模型。

系统上线新策略前，可以先问这个模拟体：

“如果推这组内容，这个用户会不会继续看？”
“如果插入一个电商广告，用户会不会觉得突兀？”
“如果连续推 5 条同类视频，用户会在第几条开始表现出疲劳？”
“这个用户对新兴趣探索的接受度如何？”

这本质上是在把 A/B 实验的决策过程从"线上试"提前到"线下模拟"，大幅降低策略迭代成本，同时减少对真实用户体验的打扰。

7. 工程可行性与产业落地挑战

7.1 现有工业推荐架构的兼容性

RecoWorld 提出的 Agentic RecSys 不是要推翻现有推荐架构，而是在其之上增加一个新的抽象层。现有工业推荐系统的召回、粗排、精排、重排、混排、广告机制仍然会存在，因为它们需要处理极高的吞吐（每秒数百万请求）和极严格的延迟（<50ms）要求，这是任何 LLM 当前都无法直接替代的。

RecoWorld 设想的是在这些模块之上，增加一个 Agentic Interaction Layer：

用户层：自然语言指令 / 行为反馈
 ↓
Agentic Interaction Layer（新增）：
 - 自然语言理解（指令解析）
 - 用户状态追踪（动态记忆）
 - 策略规划（intent → 召回参数）
 - 工具调用（调用底层推荐 API）
 ↓
现有推荐基础设施（保留）：
 - 召回层（向量检索 / 倒排）
 - 粗排 / 精排 / 重排
 - 实时特征服务
 - 广告竞价机制

Agentic 层负责"理解和规划"，底层推荐系统负责"高效执行"。两者通过工具调用接口连接，既保持了现有系统的工程效率，又引入了 Agentic 交互的能力。

7.2 主要工程挑战

挑战一：LLM 模拟器的真实性验证。如何量化模拟用户行为与真实用户行为的分布差距？如何设计更好的 prompt 让模拟器更接近真实？需要大量的真实用户行为数据来校准模拟器参数。

挑战二：Reward 设计。session-level reward 的设计远比 item-level CTR 复杂——多个目标之间的权重如何平衡（即时互动 vs. 长期留存 vs. 指令完成度），reward shaping 如何避免 Agent 学到"投机取巧"的策略（如用高刺激内容短期吸引用户注意，但牺牲长期体验）。

挑战三：Sim-to-Real Gap。在模拟环境中训练好的推荐 Agent，在真实系统中的表现可能大打折扣。如何弥补这个差距，是 Agentic RecSys 走向工业落地的核心技术难题。

挑战四：延迟与成本。每次用户发出自然语言指令，系统都需要调用 LLM 解析意图，重新规划召回策略，这对在线服务的延迟和成本要求非常高。需要专门的效率优化（指令缓存、意图分类加速、轻量化 Agent 模型）才能在工业场景可用。

7.3 现阶段更务实的落地路径

虽然完整的 Agentic RecSys 在工业落地上还有相当距离，但 RecoWorld 框架中的一些思路可以以更轻量的方式在近期实现：

显式偏好设置：允许用户通过简单 UI 设置"最近不想看某类内容"的过滤规则，这是 Agentic 指令响应的简化版本，工程成本低，用户体验提升明显。
Session-level 疲劳检测：基于 session 内连续跳过率、观看时长趋势等信号，实时检测用户疲劳状态，及时注入多样性内容，这是 disengagement 检测的工程落地。
生成式重排：在精排之后，用轻量 LLM 对推荐列表进行最终调整，考虑列表内的多样性、顺序、节奏，而不只是逐条打分。
Semantic ID 体系建设：尽早在内容侧建立统一的 Semantic ID 体系，为未来大模型与推荐系统的深度融合打好基础。

8. 对搜广推算法人的启示

8.1 技术栈真的要变吗

HiTech 实验室的文章标题问了一个很有现实感的问题：“搜广推算法人的技术栈要变了？“从 RecoWorld 的角度看，答案是：核心技术栈不会立刻被替代，但上层交互范式正在发生系统性变化，算法人需要尽早建立新能力。

短期内（1-2年），召回/精排/重排的工程能力仍然是核心竞争力，这部分不会被替代。但以下几个新技术方向的重要性正在快速上升：

大语言模型与推荐系统的结合：如何把 LLM 的语言理解能力嫁接到推荐系统的工程架构里
Semantic ID 建模：生成式推荐、离散语义表示、RQ-VAE/RQ-KMeans 等
Session-level 建模与优化：超越 item-level CTR，理解多轮交互轨迹
强化学习在推荐中的应用：从离线监督学习到在线策略优化
用户意图建模：从行为标签推断到自然语言意图理解

8.2 RecoWorld 的更大意义

从更宏观的视角看，RecoWorld 的意义不只在于提出了一个具体的架构方案，更在于它确立了一个新的研究问题范式：推荐系统的核心不再只是"预测用户行为”，而是"在多轮交互中理解、响应和塑造用户意图”。

这个问题范式的转变，意味着推荐系统研究将越来越多地借鉴强化学习、对话系统、用户建模、LLM agent 等领域的思路和方法，也意味着未来工业推荐系统的工程复杂度将继续攀升——从高效的向量检索到实时的意图理解，从静态的用户画像到动态的状态追踪，从单轮打分排序到多轮交互规划。

8.3 从平台投喂到用户共塑

也许 RecoWorld 最深刻的洞察，是对信息流本质的重新定义：

过去的信息流，是平台根据历史行为投喂给用户的内容序列。用户在这里扮演被动的接收者，系统扮演主动的预测者。这个模式高效，但缺乏真正的双向性。

未来的信息流，可能会变成用户、创作者、推荐 Agent 和模拟环境共同塑造的动态世界。用户可以主动表达需求和偏好，创作者可以在发布前预测内容效果，推荐 Agent 在多轮交互中持续学习和调整，模拟环境提供低成本的策略验证空间。

如果说上一代推荐系统的核心是更准地预测用户行为，那么下一代推荐系统的核心，很可能是更好地理解、响应和协助用户塑造自己的信息世界。

9. 总结

RecoWorld 是一篇重要的 vision paper。它不是某个 benchmark 上的 SOTA，也不是可以立刻工业落地的工程方案，但它提出了一个极具前瞻性的问题框架：当推荐系统进化为能理解自然语言、维护用户状态、多轮交互的 Agent，我们应该如何构建训练和评估环境？

论文的核心贡献可以提炼为三点：

问题定义：把推荐系统从"item-level 打分"重构为"session-level 多轮交互决策"，确立了 Agentic RecSys 的研究框架。
方法路线：提出 dual-view 架构（LLM 用户模拟器 + 推荐 Agent），通过 disengagement + self-reflection 机制生成有语义内容的训练信号，通过 Semantic ID 解决内容表示的效率问题。
生态想象：把推荐系统的应用范围从"用户侧内容分发"扩展到"创作者侧内容决策"和"数字孪生用户"，为推荐系统的长期演化方向提供了一种具有想象力的叙事。

对于推荐系统从业者来说，RecoWorld 是一个很好的信号：现在是时候开始思考如何把大语言模型的能力系统性地融入推荐系统的上层交互层了——不是简单地用 LLM 替换排序模型，而是在精准预估的工程基础上，叠加一层真正能理解和响应用户意图的 Agentic 交互能力。

参考文献

RecoWorld: Building Simulated Environments for Agentic Recommender Systems — Meta AI Research
HiTech实验室. 论文分享｜Meta从 CTR 到 Agentic RecSys：搜广推算法人的技术栈要变了？(2026)
OpenAI Gym: A toolkit for developing and comparing reinforcement learning algorithms
OneRec: Unifying Retrieve and Rank with Generative Recommender and Preference Alignment — ByteDance (2025)
HSTU: Actions Speak Louder than Words: Trillion-Parameter Sequential Transducers for Generative Recommendations — Meta (2024)
RQ-VAE: Autoregressive Image Generation using Residual Quantization — Kakao Brain (2022)
DIN: Deep Interest Network for Click-Through Rate Prediction — Alibaba (2018)
SimGRACE / RL-based RecSys: 强化学习在推荐系统中的应用综述

DeepSeek V4 技术报告深度解读：百万 Token 长上下文的系统工程学

Sat, 09 May 2026 08:00:00 +0800

DeepSeek-V4 系列（V4-Pro 1.6T 参数 / V4-Flash 284B 参数）将原生上下文窗口扩展至 1M token，同时在模型架构、优化器、工程基础设施、预训练和后训练五个维度做了系统性革新。本文基于 DeepSeek V4 技术报告，对五大维度逐一进行深度解读，尤其聚焦于 mHC 流形约束超连接、CSA/HCA 混合注意力和 Muon 优化器三大架构创新的数学原理与工程实现。

0. 导言：为什么 V4 值得深读

0.1 一个被反复绕开的问题

过去两年，大语言模型领域出现了两条平行但关联的趋势：

第一条线：reasoning 模型的崛起。 从 OpenAI o1 到 DeepSeek R1，业界逐渐发现——让模型在答题之前多想几步（chain-of-thought、extended thinking），性能会系统性地上升。这种"测试时扩展"（test-time scaling）的范式开始成为主流。但"多想几步"的代价是什么？上下文里塞满了 thinking trace，一道复杂的数学题可能产生数千甚至数万 token 的推理链。

第二条线：Agent 的工程落地。 让模型自己写代码、读文档、执行工具调用、完成多轮复杂任务——这是 AI Agent 的图景。但每一个 Agent step 都要把"过去所有的上下文"带着走，随着任务轮次增加，上下文长度成指数级膨胀。

这两条趋势背后有同一个物理约束：vanilla attention 的二次方复杂度。当序列长度从 32K 增长到 1M，计算量增长约 1000 倍，KV cache 显存增长约 32 倍。这道墙既拦住了 reasoning 模型（thinking trace 太长），也拦住了 Agent（上下文累积太重）。

DeepSeek V4 就是对这个问题正面回答的一次系统性尝试。它不是靠一个单一的"银弹"创新来破局，而是在架构、优化器、工程基础设施、预训练、后训练五个维度同时推进，构建了一个完整的长上下文解决方案。

0.2 V4 核心创新一览

维度	创新点	核心贡献
架构	mHC（流形约束超连接）	残差连接的第三次进化，稳定梯度 + 扩宽信息流
架构	Hybrid Attention (CSA+HCA)	压缩+稀疏组合，O(T²) → O(T·k/m)
优化器	Muon	正交化梯度更新，比 Adam 更适合宽维度矩阵
工程	EP 通信-计算重叠	mega-kernel 波次调度，1.92× 通信加速
工程	FP4 量化感知训练	MoE 权重 + CSA 索引器 QK 量化，显存减半
工程	Contextual Parallelism	1M 上下文跨 GPU 切片，线性扩展
预训练	长上下文渐进扩展	4K→64K→1M 三阶段上下文调度
后训练	Specialist Training + OPD	先分领域专家，再 on-policy 蒸馏为统一模型
后训练	Generative Reward Model (GRM)	模型自身充当 reward model，免除大量人工标注

0.3 两个模型规格

	V4-Pro	V4-Flash
总参数量	1.6T	284B
激活参数量	49B	13B
原生上下文	1M token	1M token
MoE Expert 数量	256	64
每 token 激活 Expert 数	6	4
主要定位	旗舰，最强能力	轻量，高效部署

两者架构相同，规格不同，共享同一套后训练流程。本文若无特殊说明，技术细节均以 V4-Pro 为参考。

0.4 阅读路线图

只关心架构：重点看第 3、4、5 节
只关心工程：重点看第 6 节
只关心训练流程：重点看第 7、8 节
想全面了解：顺序阅读，附录 A 补充 Attention 背景知识

1. 背景与动机

1.1 Vanilla Attention 的二次方诅咒

标准 attention 的计算公式：

$$\text{output}_t = \sum_{s \leq t} \alpha_{t,s} v_s, \quad \alpha_{t,s} = \frac{\exp(q_t^\top k_s / \sqrt{d})}{\sum_{j} \exp(q_t^\top k_j / \sqrt{d})}$$

这个公式有两个让长上下文崩溃的瓶颈：

计算复杂度 $O(T^2)$：每个新 token 要和所有历史 token 算 attention score。$T=1\text{M}$ 时，这是约 $10^{12}$ 量级的浮点操作。
KV cache 存储 $O(T \cdot L \cdot d)$：推理时每一层都要保存所有历史 token 的 K 和 V。对于 1M token、49B 激活参数的模型，仅 KV cache 就需要数十 GB 显存。

这两个约束的乘积效应是毁灭性的：计算成本二次增长，存储成本线性增长，两者叠加让百万级 token 推理在传统架构下几乎不可行。

1.2 解法空间：三条路线

面对这个问题，学界已有三大方向（详见附录 A）：

稀疏化（Sparse Attention）：只让每个 token 关注部分历史，把 $O(T^2)$ 降到 $O(T \cdot k)$，但有信息损失风险
线性化（Linear Attention）：把历史压缩进固定大小的状态槽，计算 $O(T)$，但表达能力有损
压缩（Compressed Attention）：把多个 token 的 KV “折叠"成一个，降低有效序列长度

DeepSeek V4 选择的是压缩 + 稀疏的组合路线：

CSA（Compressed Sparse Attention）：先 4:1 压缩 KV，再用闪电索引器做 top-k 稀疏选择
HCA（Heavily Compressed Attention）：更激进的压缩（32:1+），适合需要粗粒度背景感知的层

1.3 不只是 Attention 的问题

但仅仅改 Attention 机制是不够的。要真正支撑 1M token 的大规模训练和部署，还需要解决：

残差连接瓶颈：深层网络的梯度传播稳定性
优化器效率：万亿参数规模下的收敛速度和参数更新质量
通信瓶颈：MoE 的 Expert 路由需要大量 all-to-all 通信
精度与存储权衡：万亿参数 + 百万上下文 = 巨大的显存压力
后训练对齐：如何让模型既有超长上下文处理能力，又有强大的推理和遵从能力

这就是为什么 V4 是一个"五维系统工程”，而不只是一篇 attention paper。

2. 架构创新一：mHC 流形约束超连接

残差连接（Residual Connection）是现代深度网络的基石，从 ResNet（2015）到今天所有主流 Transformer，它几乎是标配。DeepSeek V4 引入的 mHC（Manifold-Constrained Hyper-Connections），是对残差连接的第三次系统性进化。

要理解 mHC，需要先理解这条演化史的每一步。

2.1 阶段一：RC（Residual Connection，2015）——信息加法时代

论文：He et al., “Deep Residual Learning for Image Recognition”, arXiv:1512.03385

ResNet 提出的更新规则看似简单：

$$h_l = h_{l-1} + f_{l-1}(h_{l-1})$$

这个公式有两个核心贡献：

梯度高速公路：对 $h_l$ 求导时，永远保留一个恒等项 $I$：

$$\frac{\partial h_l}{\partial h_{l-1}} = I + \frac{\partial f_{l-1}}{\partial h_{l-1}}$$

这意味着梯度可以无损地传到任意深的层，彻底解决了 vanishing gradient 问题，使得训练几百层的网络成为可能。

残差学习：每一层只需学"在已有表征上做修正"，而不是从零重建表征。这让优化目标更容易，收敛更快。

将递推式展开，会发现一个有趣的事实：

$$h_l = h_0 + \sum_{i=0}^{l-1} f_i(h_i)$$

第 $l$ 层接收到的，是所有前面层输出的等权求和。注意这里的"等权"：每一层的贡献在求和时权重完全相同，没有任何差异化。

这正是 RC 最大的局限：信息聚合方式是固定的、统一权重的、与输入无关的。不管当前任务需要更依赖底层的局部特征还是高层的语义特征，RC 总是把所有层等权加在一起。

2.2 阶段二：HC（Hyper-Connections，Zhu et al., 2025）——多车道时代

论文：Zhu et al., “Hyper-Connections”, arXiv:2409.19606

如果 RC 是"一条主干道"，HC 就是"把主干道扩成 $n_{hc}$ 条平行车道"，并允许每一层在车道之间灵活地读、写、混合：

$$X_{l+1} = B_l X_l + C_l F_l(A_l X_l)$$

其中 $X_l \in \mathbb{R}^{n_{hc} \times d}$ 是加宽后的残差流（$n_{hc}$ 条车道），三个矩阵分工明确：

矩阵	形状	功能
$A_l$	$1 \times n_{hc}$	输入映射：从 $n_{hc}$ 条车道里"读"出层 $F_l$ 的输入
$B_l$	$n_{hc} \times n_{hc}$	残差变换：决定旧车道怎么重组
$C_l$	$n_{hc} \times 1$	输出映射：决定层输出怎么"写"回各车道

与 RC 的差异：RC 强迫每层"读所有 + 写所有"；HC 让每层可以"挑着读、挑着写"。某些车道专门保存底层信息不被覆盖，某些车道承载高层语义反复更新。这给了模型一个正交于"加深/加宽"的新缩放维度。

但 HC 有一个严重的稳定性问题。

如果暂时忽略 $F$ 那一项，连续堆 $L$ 层就是：

$$X_L = B_{L-1} B_{L-2} \cdots B_1 X_1$$

这是一个矩阵连乘。如果每个 $B_l$ 的最大奇异值哪怕只略大于 1（比如 1.05），堆 100 层就是 $1.05^{100} \approx 131$，信号被放大 130 倍——梯度爆炸。反过来，如果略小于 1，深层就指数萎缩——梯度消失。

HC 的这个问题限制了它在超深网络（比如数百层的 LLM）中的应用。

2.3 阶段三：mHC（Manifold-Constrained HC，Xie et al., 2026）——加约束的多车道

论文：Xie et al., “Manifold-Constrained Hyper-Connections”, arXiv:2512.24880

mHC 的解法非常"几何化"：直接把 $B_l$ 约束到双随机矩阵集合（Birkhoff polytope）上：

$$\mathcal{M} = \{M : M\mathbf{1} = \mathbf{1},\ \mathbf{1}^T M = \mathbf{1}^T,\ M \geq 0\}$$

双随机矩阵的关键性质：

行和 = 1，列和 = 1（概率矩阵的广义）
所有奇异值 $\leq 1$（由 Birkhoff 定理保证）
双随机矩阵的乘积仍然是双随机矩阵（奇异值约束对连乘封闭）

这正是 HC 梯度爆炸问题的根治方案：不仅让 $B_l$ 的奇异值 $\leq 1$，还保证连乘后仍然 $\leq 1$，因为双随机矩阵对乘法封闭。

2.3.1 Sinkhorn-Knopp 投影算法

如何在训练中维持 $B_l \in \mathcal{M}$？用 Sinkhorn-Knopp 算法：

步骤一：保正性。先把原始线性层输出 $\tilde{B}_l$ 取指数：

$$M^{(0)} = \exp(\tilde{B}_l)$$

这保证所有元素 $> 0$（满足约束 $M \geq 0$）。

步骤二：交替归一化。反复做行归一化和列归一化：

$$M^{(t)} = T_r(T_c(M^{(t-1)}))$$

$T_c$：把每列除以列和（让列和 = 1）
$T_r$：把每行除以行和（让行和 = 1）

步骤三：迭代 20 次。理论上 Sinkhorn-Knopp 需要无穷次才严格收敛，但实践中 20 次就足够接近双随机矩阵。

在前向计算时，每一层都要先做这个 20 次迭代，然后用结果 $B_l$ 去乘残差流。

2.3.2 A 和 C 的约束设计

$B_l$ 用双随机矩阵约束（强约束），而 $A_l$ 和 $C_l$ 则用 Sigmoid 进行软约束：

$$A_l = \sigma(\tilde{A}_l) \in (0, 1), \quad C_l = 2\sigma(\tilde{C}_l) \in (0, 2)$$

为什么要非负？

假设 $F_l$ 学到了一个"有用的更新方向" $v$（让某个特征激活更强）。如果 $C_l$ 取负值，那么 $C_l F_l(\cdot) = -|C_l| v$，本来想加进去的有用信息被反向抵消掉了。

更糟的是，模型可能学着"互相抵消"：上一层精心算出 $v$，下一层用负的 $C$ 把它减掉，再下一层又用正的 $C$ 加回来……这种死循环式的抵消让训练浪费算力，loss 看起来在动，但实际上没真正学到东西。非负约束直接堵死这条歧路：只能加，不能减。

为什么要有界？

$A$ 是"读"：从加宽的残差流中提取信息喂给 $F$。读取量 $\leq 1$ 是合理的，车道里的信息有限，不应该被过度放大后再输入。

$C$ 是"写"：把 $F$ 的输出写回残差流。范围 $(0, 2)$ 给了模型一点空间——层信息可能确实需要被"强调地"写入残差流，但不能无限放大。

为什么 $A/C$ 不用双随机约束？

因为 $A$ 和 $C$ 在每一层只作用一次（不会跨层累积），所以不会有矩阵连乘导致的指数放大问题。Sigmoid 这种软约束已经足够，不需要像 $B$ 那样的强约束。

2.3.3 工程开销

mHC 的全部额外开销（Sinkhorn 迭代 + 加宽残差流）被控制在 6.7% wall-clock 时间以内。相比残差连接改进带来的性能收益，这是非常划算的代价。

从论文图中可以看到 mHC 的完整示意：

2.4 阶段四（分叉路口）：AttnRes（Kimi，2026）——把残差换成注意力

论文：Kimi Team, “AttnRes: Attention as Residual”, arXiv:2603.15031

AttnRes 走了一条更激进的路：不扩残差宽度，直接把"沿深度方向的等权求和"替换成"沿深度方向的注意力"。

2.4.1 从 HC 公式推导出层间 Attention

从 HC 的公式出发：

$$X_l = B_l X_{l-1} + C_l y_l, \quad y_l = F_l(A_l X_{l-1})$$

将递推完全展开（从 $X_l$ 一直往回代到 $X_0$，约定 $X_0 = C_0 y_0$）：

$$X_l = \sum_{s=0}^{l} B_{l \leftarrow s+1} C_s \cdot y_s$$

其中 累积矩阵乘积 定义为：

$$B_{l \leftarrow s} := B_l B_{l-1} \cdots B_{s+1} B_s, \quad B_{l \leftarrow l+1} = I$$

这个展开式说明：第 $l$ 层的残差流是所有历史层输出 $y_s$ 的加权和，权重 $B_{l \leftarrow s+1} C_s$ 由矩阵连乘决定。

第 $l+1$ 层的 $F_{l+1}$ 看到的输入是：

$$y_{l+1} = F_{l+1}(A_{l+1} X_l) = F_{l+1}\left(\sum_{s=0}^{l} A_{l+1} B_{l \leftarrow s+1} C_s \cdot y_s\right)$$

定义 层间注意力权重：

$$a_{l+1, s} = A_{l+1} \cdot \underbrace{B_l B_{l-1} \cdots B_{s+1}}_{\text{若干 B 的连乘}} \cdot C_s$$

这就是 AttnRes 的核心洞察：HC 的展开式本质上是层间注意力的雏形，其中 $A_{l+1}$ 是 Query，$C_s$ 是 Key，$B_{l \leftarrow s+1}$ 是相对位置算子。

项	在 attention 里的角色	直觉
$A_{l+1}$	Query（来自第 $l+1$ 层）	我这层想从历史里读什么
$C_s$	Key（来自第 $s$ 层）	第 $s$ 层把自己写成什么样
$B_{l \leftarrow s+1}$	相对位置算子	从 $s$ 到 $l+1$ 这段距离上信号如何变化

2.4.2 AttnRes 如何保证训练稳定

如果 $B_{l \leftarrow s+1}$（连乘链）的奇异值 $> 1$ 或 $\lt 1$，注意力权重 $a_{l+1, s}$ 会指数级放大/缩小，导致反向传播梯度同样爆炸/消失。

AttnRes 的解法是绕开 $B$ 的连乘，直接显式定义注意力权重：

$$a_{l+1, s} = \exp(w_{l+1}^\top \text{RMSNorm}(k_s))$$

然后做 softmax 归一化，其中：

$w_{l+1}$：直接学习的权重向量（相当于 Query，但绕开了 $A \cdot B \cdot C$ 的间接构造）
$k_s = y_s$：直接用 $y_s$ 本身作为 Key（绕开 $C_s$ 投影）
$B_{l \leftarrow s+1}$（相对位置算子）：舍弃

这就消除了矩阵连乘的稳定性隐患，同时保留了层间注意力的本质。

2.4.3 Block AttnRes：从 O(L²) 到 O(N²)

Full AttnRes 的工程问题：

Full AttnRes 在小规模训练里额外开销可接受，但在大规模分布式训练下：

流水线并行：每一层的输出都得跨 stage 传输 → 通信量从 $O(d)$ 变成 $O(Ld)$
激活重计算：原本可以丢弃的中间激活现在必须留着 → 显存压力剧增

Block AttnRes 的解法：把 $L$ 层分成 $N$ 个 block（论文用 $N=8$），block 内部通过求和压成一个表示，只在 block 之间做 attention。

这把通信和显存从 $O(Ld)$ 降到 $O(Nd)$。

两个关键设计细节：

为什么是"压缩"而不是"稀疏"？ 作者一开始尝试过 Sliding Window Attention（只看最近几层），结果反而比普通 RC 还差。压缩方法包含了 RC 的基础——退化到 $N=1$ 的时候，就等同于 RC。而稀疏方法在 $N=1$ 时会退化成"什么都不看"，丢失了全局信息。
Embedding 层为什么单独成 block？ 通过观察 Full 版的注意力矩阵，模型偏向于给 Embedding 层可观的注意力权重。Embedding 层携带了原始 token 信息，不应该被"压缩消融"，因此单独保留。

实测收益：Block AttnRes 在所有规模上都优于 RC 基线，相当于 1.25× 算力优势（同等计算预算下性能更好，或同等性能只需 80% 计算）。

2.5 mHC 在 V4 中的定位

V4 使用的是 mHC（不是 AttnRes）。从实验数据看，两者在性能上接近，但 mHC 的实现更容易与现有分布式训练框架集成（详见第 6.7 节工程实现）。

2.6 四种残差连接综合对比

方案	数学形式	梯度稳定性	计算开销	扩展能力
RC	$h_l = h_{l-1} + f_{l-1}$	✅ 好（恒等项）	0	❌ 固定等权
HC	$X_{l+1} = B_l X_l + C_l F_l(A_l X_l)$	⚠️ 不稳定（矩阵连乘）	低	✅ 灵活读写
mHC	HC + $B_l \in \mathcal{M}$（双随机矩阵）	✅ 好（Birkhoff 保证）	6.7%	✅ 灵活读写
AttnRes	层间 softmax attention	✅ 好（softmax 归一化）	中等	✅✅ 最灵活

3. 架构创新二：混合注意力 CSA + HCA

3.1 长上下文 Attention 的三大优化思路

在深入 CSA 和 HCA 之前，先建立对整个优化空间的认知地图。

思路 A：稀疏化（Sparse Attention）

不让每个 token 关注所有历史，只关注部分——局部窗口、全局 token、或动态选择的 top-k token。

代表：Sliding Window Attention（SWA）、BigBird、Longformer、DSA（DeepSeek Sparse Attention）
计算复杂度：$O(T \cdot k)$，$k \ll T$
KV cache：$O(T)$（仍需全量存储，只是计算时稀疏选择）
核心权衡：简单高效，但有信息损失风险——那些"被稀疏掉"的 token 可能携带关键信息

思路 B：线性化（Linear Attention）

把所有历史 token 的信息累积进一个固定大小的"状态槽"（state），每个 query 只查这个状态一次。

代表：Linear Transformer、RetNet、Mamba、DeltaNet
计算复杂度：$O(T)$（每步更新 state + 查询 state）
KV cache：$O(1)$（只有固定大小的 state）
核心权衡：极致高效，但丢失了 exact attention 的精确召回能力，对"精确定位历史特定位置"的任务有明显损失

思路 C：压缩（Compressed Attention）

把多个 token 的 KV “折叠"成更少的 KV，减少有效序列长度，但保留了 softmax exact attention 的精确性。

代表：MQA（Multi-Query Attention）、GQA（Grouped-Query Attention）、MLA（Multi-head Latent Attention，DeepSeek-V3）
计算复杂度：$O(T \cdot T/m)$（$m$ 是压缩比），KV cache $O(T/m)$
核心权衡：精度损失最小，但压缩本身有信息融合的偏差

DeepSeek V4 的选择：思路 A + C 的组合

V4 不单独选一条路，而是把"压缩"和"稀疏"组合起来：

先压缩：用 CSA 的 4:1 压缩（或 HCA 的 32:1+ 压缩），把 KV 从 $T$ 条压缩到 $T/m$ 条
再稀疏（CSA 特有）：用闪电索引器从 $T/m$ 条压缩 KV 里选 top-$k$ 条

这样计算复杂度从 $O(T^2)$ 降到 $O(T \cdot k)$，$k \ll T$，且 KV cache 从 $O(T)$ 降到 $O(T/m)$。

3.2 CSA（Compressed Sparse Attention）详解

CSA = 算两套 overlap KV + softmax 软融合（4:1 压缩）+ 低秩 query + ReLU 闪电索引器（top-k 稀疏）+ MQA + 分组投影。

CSA 的整体流程分 4 步：

输入：H ∈ ℝ^(n×d) (n 个 token，每个 d 维)
 ↓
【步骤一】算两套 KV (C^a, C^b) 和软选择权重 (Z^a, Z^b)
 ↓
【步骤二】每 m 个相邻 token 的 KV 软融合成 1 个
 得到 C^Comp ∈ ℝ^((n/m)×c)，序列长度压缩 m 倍
 ↓
【步骤三】闪电索引器给每个 query 打分
 从 n/m 个压缩 KV 里选出 top-k 个最相关的
 ↓
【步骤四】在选出的 k 个压缩 KV 上做 MQA 注意力
 得到最终输出

3.2.1 步骤一：算两套 KV 和软选择权重

输入：$H \in \mathbb{R}^{n \times d}$（$n$ 个 token，每个 $d$ 维）

CSA 不是只算一套 KV，而是算了两套：

$$C^a = H \cdot W^{aKV}, \quad C^b = H \cdot W^{bKV}$$$$Z^a = H \cdot W^{aZ}, \quad Z^b = H \cdot W^{bZ}$$

四个矩阵都可训练：$W^{aKV}, W^{bKV}, W^{aZ}, W^{bZ} \in \mathbb{R}^{d \times c}$，$c$ 是 head 维度（V4-Pro 配置下约 512）。

变量	形状	角色
$C^a$	$n \times c$	第一套 KV 候选
$C^b$	$n \times c$	第二套 KV 候选
$Z^a$	$n \times c$	$C^a$ 的"参与度分数”（软门控）
$Z^b$	$n \times c$	$C^b$ 的"参与度分数"（软门控）

$Z$ 是 $C$ 的"软门控"，告诉模型"这个 KV 在融合时占多大比重"。

为什么要两套 KV？

这里有一个精妙的设计：两套 KV 的覆盖范围有 Overlap。

第 $i$ 个压缩块：

来自 $C^a$ 的：第 $mi$ 到 $m(i+1)-1$ 共 $m$ 个连续 token（当前窗口）
来自 $C^b$ 的：第 $m(i-1)$ 到 $mi-1$ 共 $m$ 个连续 token（前一个窗口）

也就是说，$C^b$ 比 $C^a$ 往前错开了 $m$ 个 token。

这种 Overlap 设计可以避免压缩块边界的"信息断裂"：如果一个语义实体恰好横跨两个压缩块的边界，纯硬切分会把它撕成两半，而 Overlap 设计让它在两个压缩块里都有部分体现。

3.2.2 步骤二：把每 m 个 KV 融合成 1 个

融合权重计算：

$$p_i = \text{softmax}\left(\text{concat}\left([Z^a_{mi:m(i+1)}, Z^b_{m(i-1):mi}] + [B^a, B^b]\right)\right)$$

其中 $B^a, B^b \in \mathbb{R}^{m \times c}$ 是可学习的位置偏置（对 V4-Pro，$m=4$，$c=512$，所以形状是 $4 \times 512$）。

softmax 沿着 $2m$ 个候选（来自 $C^a$ 的 $m$ 个 + 来自 $C^b$ 的 $m$ 个）计算，得到每个候选 token 的融合权重。

加权融合：

$$C^{Comp}_i = \sum_{j \in \{m(i-1):m(i+1)\}} p_{i,j} \cdot C_j$$

其中 $C_j$ 来自 $C^a$ 或 $C^b$（取决于 $j$ 的位置）。结果 $C^{Comp}_i \in \mathbb{R}^c$，是第 $i$ 个压缩块的 KV 表示。

全序列压缩结果：$C^{Comp} \in \mathbb{R}^{(n/m) \times c}$，序列长度从 $n$ 压缩到 $n/m$（$m=4$ 时降为原来的 1/4）。

KV 解包：将压缩 KV 分成 K 和 V 两部分（通过可学习的投影或直接分割），得到 $K^{Comp}, V^{Comp} \in \mathbb{R}^{(n/m) \times c}$。

3.2.3 步骤三：闪电索引器（Lightning Indexer）选 top-k

这是 CSA 最有创意的部分。有了 $n/m$ 个压缩 KV 之后，还需要进一步降低计算量——每个 query 只选 top-$k$ 个最相关的压缩 KV 来做精确 attention。

但如何高效地做这个 top-$k$ 选择？直接用 softmax 注意力来选会变成循环依赖。CSA 用的是一个独立的闪电索引器，使用 ReLU 而非 softmax 来打分。

子步骤一：算"压缩索引器 keys"

从已有的压缩 KV $C^{Comp}$ 出发，通过额外投影得到专门用于索引的 key：

$$K^{IComp} = C^{Comp} \cdot W^{IK}$$

其中 $W^{IK} \in \mathbb{R}^{c \times c^I n_h^I}$，$n_h^I$ 是索引器 head 数，$c^I$ 是每个 head 维度。

子步骤二：算 query token 的"索引器 queries"

对每个 query token $t$，先算低秩潜向量：

$$c_t^Q = h_t \cdot W^{DQ} \in \mathbb{R}^{d_c}$$

再升维得到索引器 query：

$$q_{t,h}^I = c_t^Q \cdot W^{IUQ}_h \in \mathbb{R}^{c^I}$$

注意 $c_t^Q$ 会被索引器和后续的精确 attention 共享——这节省了参数和计算。

子步骤三：算"head 权重"

$$w_t^I = h_t \cdot W^w \in \mathbb{R}^{n_h^I}$$

每个索引器 head 一个标量权重，直接从 $h_t$ 计算（不经过低秩压缩 $c_t^Q$），保留更多原始信息。

子步骤四：ReLU 打分

$$I_{t,s} = \sum_{h=1}^{n_h^I} w_{t,h}^I \cdot \text{ReLU}(q_{t,h}^I \cdot K_s^{IComp})$$

为什么用 ReLU 而不是 softmax？

量化友好：ReLU 输出非负，可以直接量化为 INT8/FP4，softmax 输出浮点，量化精度损失大
Top-k 并行：ReLU 打分是独立的，可以并行化；softmax 有全局归一化依赖
稀疏性自然涌现：ReLU 会把"不相关的"压缩 KV 打成 0 分，自然产生稀疏性

子步骤五：Top-k 选择

$$\mathcal{S}_t = \text{argtopk}_{s}(I_{t,s}), \quad |\mathcal{S}_t| = k$$

每个 query token $t$ 选出得分最高的 $k$ 个压缩 KV 的索引集合 $\mathcal{S}_t$。

3.2.4 步骤四：在选中的 KV 上做 Multi-Query Attention（MQA）

最终 attention：

$$\text{output}_t = \text{softmax}\left(\frac{q_t \cdot K^{Comp}_{\mathcal{S}_t}^\top}{\sqrt{d_h}}\right) \cdot V^{Comp}_{\mathcal{S}_t}$$

其中 $q_t$ 是从 $c_t^Q$ 升维得到的精确 attention query。

MQA（Multi-Query Attention）：所有 attention head 共享同一套 K 和 V，只有 Q 是 head-specific 的。这进一步减少了 KV cache 的存储需求。

3.2.5 CSA 完整 Shape 推导

阶段	变量	形状	说明
输入	$H$	$n \times d$	原始隐状态序列
步骤一	$C^a, C^b$	$n \times c$	两套 KV 候选
步骤一	$Z^a, Z^b$	$n \times c$	软选择权重
步骤二	$C^{Comp}$	$(n/m) \times c$	压缩后 KV
步骤三	$K^{IComp}$	$(n/m) \times (c^I n_h^I)$	索引器 keys
步骤三	$q_{t,h}^I$	$c^I$	每个 token 的索引器 query
步骤三	$I_{t,s}$	$n \times (n/m)$	打分矩阵（稀疏）
步骤三	$\mathcal{S}_t$	$k$	top-k 选中索引
步骤四	$q_t$	$d_h \cdot n_h$	精确 attention query
步骤四	$\text{output}_t$	$d_h \cdot n_h$	最终输出

有效计算复杂度：$O(T \cdot c + T/m \cdot c + T \cdot k \cdot d_h)$，相比 $O(T^2 d_h)$ 降低约 $T \cdot m / k$ 倍。

3.3 HCA（Heavily Compressed Attention）详解

HCA 是 CSA 的"轻量版"——更激进的压缩，没有稀疏选择，用于不需要精确长程依赖的层。

3.3.1 整体流程

输入：H ∈ ℝ^(n×d)
 ↓
【步骤一】单路 KV 投影（没有 C^b，只有一套 C^a = C）
 ↓
【步骤二】直接压缩（更大压缩比 M ≫ m）
 C^{Comp} ∈ ℝ^((n/M)×c)
 ↓
【步骤三】对所有压缩 KV 做稠密 attention（不做 top-k 稀疏）
 ↓
【步骤四】MQA + 分组输出投影

3.3.2 关键差异

HCA 相比 CSA 的主要区别：

单路 KV，没有 Overlap：HCA 只用一套 KV 投影（没有 $C^b$ 那套），没有 Overlap 设计
更大压缩比：HCA 的 $M \gg m$（V4-Pro 中 HCA 的压缩比约 32，CSA 约 4）
全量稠密 attention，没有 top-k：压缩到 $n/M$ 个 KV 后，直接对所有进行 attention
定位粗粒度：HCA 适合"需要感知整体上下文背景，但不需要精确定位特定位置"的场景

3.3.3 HCA 完整 Shape 表

阶段	变量	形状	说明
输入	$H$	$n \times d$	原始序列
步骤一	$C$	$n \times c$	单路 KV 投影
步骤二	$C^{Comp}$	$(n/M) \times c$	重度压缩 KV
步骤三	attention	$n \times (n/M)$	稠密 attention
步骤四	output	$n \times d$	输出序列

有效计算复杂度：$O(T \cdot T/M \cdot d_h)$，压缩比 $M$ 越大越省。

3.4 CSA vs HCA：定位与分工

维度	CSA	HCA
压缩比	低（约 4:1）	高（约 32:1+）
是否 top-k 稀疏	✅ 是（闪电索引器）	❌ 否（稠密）
KV 路数	两套（Overlap 设计）	一套
精确长程依赖	✅ 强	⚠️ 弱
粗粒度上下文感知	✅ 有	✅ 强
计算复杂度	$O(T \cdot k)$	$O(T \cdot T/M)$
KV cache	$O(T/m)$	$O(T/M)$（更小）
适合的层	主力深度理解层	背景感知辅助层

V4 的实际部署策略：在 Transformer 的不同层混合使用 CSA 和 HCA（外加 SWA 用于局部依赖），形成一个多粒度的 Hybrid Attention 体系。

3.5 其他 Attention 细节

3.5.1 Query 和 KV 的 RMSNorm

V4 在 attention 的 Q 和 K 上都加了 RMSNorm（Root Mean Square Layer Normalization）：

$$\text{RMSNorm}(x) = \frac{x}{\text{RMS}(x)} \cdot \gamma, \quad \text{RMS}(x) = \sqrt{\frac{1}{d}\sum_i x_i^2}$$

为什么要加 RMSNorm？

在超长序列（1M token）下，Q 和 K 的方差可能因层数增加而失控，导致 attention score 的数值范围极度不稳定。RMSNorm 稳定了 Q 和 K 的幅度，使 attention score 的分布可控，避免 softmax 饱和（全部趋向 0 或 1，梯度消失）。

3.5.2 部分 RoPE（Partial Rotary Positional Embedding）

标准 RoPE 对 head 维度的所有维度都施加旋转位置编码。V4 只对 head 维度的前半部分施加 RoPE，后半部分保留不带位置信息的"内容表示"。

动机：RoPE 对长程相对位置的编码能力有限（远距离的旋转矩阵趋向相互抵消）。保留一部分无位置信息的维度，让模型能通过"纯内容相似性"来做长程 attention，弥补 RoPE 在超长序列上的局限。

3.5.3 滑动窗口分支（Sliding Window Branch）

在每一个 Transformer 层里，V4 保留了一个小的 SWA（Sliding Window Attention）分支，窗口大小约 4K token。

为什么要保留 SWA？

CSA 和 HCA 专注于长程依赖，但局部短程依赖（相邻句子、短语内部的关系）同样重要。SWA 以极低的计算成本（$O(T \cdot w)$，$w = 4096$）覆盖局部信息，与 CSA/HCA 的长程能力形成互补。

3.5.4 Attention Sink

在极长序列中，第一个 token（BOS token）往往会吸收大量 attention 权重，即使它的内容对当前 query 并不相关。这种现象叫 “attention sink”。

V4 专门为 BOS token 保留一个 sink token slot，让模型有一个"安全的垃圾桶"来倾倒多余的 attention 权重，避免这种权重扩散影响到真正有用的 token。

3.6 Hybrid Attention 层分配策略

V4 的每个 Transformer 层使用以下 attention 策略之一：

CSA：用于大多数层（主力长程依赖）
HCA：用于部分层（粗粒度背景）
SWA：局部辅助分支，几乎每层都有

具体的层分配比例在预训练时会渐进调整（详见第 7.5 节"Attention 策略的渐进切换"）。

4. 架构创新三：Muon 优化器

4.1 为什么不满足于 Adam？

Adam 是当前训练大型语言模型的标配优化器，它的核心是对梯度做自适应缩放：

$$m_t = \beta_1 m_{t-1} + (1-\beta_1) g_t \quad \text{（一阶矩：梯度指数平滑）}$$

$$v_t = \beta_2 v_{t-1} + (1-\beta_2) g_t^2 \quad \text{（二阶矩：梯度平方指数平滑）}$$

$$\hat{m}_t = m_t / (1-\beta_1^t), \quad \hat{v}_t = v_t / (1-\beta_2^t)$$

$$\theta_{t+1} = \theta_t - \eta \cdot \hat{m}_t / (\sqrt{\hat{v}_t} + \epsilon)$$

Adam 的自适应缩放对不同参数的梯度量级差异很大时表现好，但它有一个不那么明显的问题：Adam 的更新方向不一定是最优的。

具体来说，对于一个矩阵参数 $W \in \mathbb{R}^{m \times n}$（比如 MLP 的权重矩阵），Adam 的更新 $\hat{m}_t / (\sqrt{\hat{v}_t} + \epsilon)$ 是对梯度的元素级操作，没有考虑矩阵整体的几何结构。

一个更好的问题是：给定梯度 $G$，什么方向的更新 $\Delta W$ 在 Frobenius 范数约束 $\|\Delta W\|_F \leq \delta$ 下最大化一阶泰勒近似的下降量？

答案是：

$$\Delta W^* = -\delta \cdot \frac{G}{\|G\|_F}$$

即梯度方向归一化。但这只是"各向同性"的解。实际上，当 $m \neq n$ 时（宽矩形矩阵），存在更优的解法。

4.2 Muon 的核心思路：正交化梯度

Muon（Momentum + Update with Orthogonal Unification）的核心思想是：先对梯度做正交化处理，再用于参数更新。

具体来说，对于每个矩阵参数 $W$ 的梯度 $G$，Muon 先计算动量：

$$M_t = \beta M_{t-1} + G_t \quad \text{（带 Nesterov 的动量）}$$

然后对 $M_t$ 做Newton-Schulz 迭代，得到一个"正交化"的梯度 $\text{NS}(M_t)$，再用于更新：

$$W_{t+1} = W_t - \eta \cdot \text{NS}(M_t)$$

正交化的直觉：把梯度矩阵 $G$ 正交化，相当于找到一个"条件数"尽量小的更新方向。对于宽矩形矩阵（列数 $\gg$ 行数），这比梯度归一化更好地保留了更新的"有效秩"。

4.3 Newton-Schulz 迭代

Newton-Schulz（NS）迭代是一种快速计算矩阵正交因子的数值方法，不需要显式做 SVD（SVD 太贵，复杂度 $O(\min(m,n) \cdot m \cdot n)$）。

对矩阵 $G$，NS 迭代：

$$X_0 = G / \|G\|_F$$

$$X_{k+1} = \alpha X_k + \beta X_k X_k^\top X_k \quad \text{（若 m ≤ n）}$$

$$X_{k+1} = \alpha X_k + \beta X_k^\top X_k X_k \quad \text{（若 m > n）}$$

其中 $\alpha, \beta$ 是超参数（通常 $\alpha = 1.5, \beta = -0.5$，使迭代以三次收敛速度趋向酉矩阵）。

收敛性质：从任意矩阵 $X_0$（只要奇异值在 $(0, \sqrt{3})$ 范围内），经过有限步迭代后，$X_k$ 会收敛到 $G$ 的正交因子（即 $G = U \Sigma V^\top$ 的 SVD 中的 $U V^\top$ 部分）。

实践中迭代 5 次就足够：

# Muon Newton-Schulz 迭代（5次）
def zeropower_via_newtonschulz5(G, steps=5):
 assert G.ndim >= 2
 a, b, c = (3.4445, -4.7750, 2.0315) # 三次多项式系数
 X = G.bfloat16()
 X /= (X.norm() + 1e-7)
 if G.size(0) > G.size(1):
 X = X.T
 for _ in range(steps):
 A = X @ X.T
 X = a * X + b * A @ X + c * A @ A @ X
 if G.size(0) > G.size(1):
 X = X.T
 return X

4.4 V4 的实际配置

Muon 用于：attention QKV 矩阵、MLP 权重矩阵（所有大型方矩阵/矩形矩阵）
Adam 用于：Embedding、LayerNorm、输出头等（一维参数或特殊参数）
NS 迭代次数：5 次（实验表明 5 次已足够收敛）
动量 $\beta$：0.95

4.5 工程实现细节

Muon 在分布式训练中需要特殊处理（详见第 6.6 节），因为 NS 迭代需要对矩阵的完整视图操作——这与 ZeRO-3 的参数分片有冲突。V4 实现了一套兼容 ZeRO 的 Muon 变体。

4.6 实际收益

对比实验显示，在相同计算预算下，使用 Muon 比使用 Adam 的预训练 loss 更低，等效于约 1.05-1.10× 的算力优势（同等 loss 只需 90-95% 的 flops）。

这个收益看起来不大，但在万亿参数的预训练规模下，5-10% 的计算节省意味着数十甚至数百万美元的成本差异。

5. 工程实现

前三节的架构创新在"纸面"上很美，但让它们真正在万亿参数、百万 token 上下文的规模下运行，需要一系列精心设计的工程支撑。

5.1 通信优化：EP 波次调度

问题背景：MoE（Mixture of Experts）训练的通信瓶颈。

V4 使用 DeepSeekMoE 架构，每个 token 被路由到 6 个 expert（V4-Pro 配置），这些 expert 分布在不同 GPU 上，需要 all-to-all 通信把 token 发过去（dispatch）、把结果收回来（combine）。

在传统实现里，MoE 一层的计算流程是：

Dispatch (通信) → Linear-1 (计算) → Linear-2 (计算) → Combine (通信)

这四个阶段如果串行执行，通信会成为瓶颈（通信时 GPU 空闲，计算时网络空闲）。

V4 的解法：mega-kernel 波次调度

把 expert 切成多个"波次"（waves），当前波次的计算 + 下一波次的通信 + 已完成波次的 Combine 同时进行：

方案	做法	加速比
朴素串行	4 个阶段完全串行	1×
Comet	Dispatch+Linear-1 重叠，Linear-2+Combine 重叠	1.42×
V4 mega-kernel	波次级三路同时（当前计算 + 下一通信 + 已完成 Combine）	1.92×

实测收益：

通用推理工作流：1.50-1.73× 加速
延迟敏感场景（RL rollout、agent）：最高 1.96×

带宽分析：参考 V4-Pro 的工作负载，每 GBps 互联带宽足以隐藏 6.1 TFLOP/s 的计算。一旦达到这个比例，再增加带宽就是浪费了。这个数据为集群网络设计提供了重要参考。

5.2 精度/存储优化：FP4 量化感知训练

解决的问题：万亿参数模型的显存占用 + 长上下文 attention 的计算成本。

应用位置：

模块	用 FP4 的原因
MoE expert 权重	MoE 占模型大部分参数，省显存的最大目标
CSA 索引器的 QK	索引器要算 $n/m$ 次内积，FP4 加速明显

核心技术：FP4 → FP8 无损解量化

FP32 原始权重 0.12（真实分布）
 ↓ 量化（有损，FP4 的固有代价）
FP4 存储: 1.5（带小 scale 0.075）
 ↓ 解码（无损，关键步骤）
FP8 计算值: 0.1125（精确等于 1.5 × 0.075）
 ↓ 矩阵乘等运算

为什么 FP4→FP8 解量化是"无损"的？

FP8（E4M3 格式）的指数位比 FP4（E2M1）多 2 位，动态范围大得多。只要 FP4 的"细粒度 scale 因子"在 FP8 的额外动态范围里能表达，就不丢精度。

前提：一个大块内"最大理想 scale / 最小理想 scale"不能超过 FP4 能容纳的范围。

存储结构（以 128×128 大块为例）：

存储项	数量	每个占比特数	总大小
FP4 数值	128×128 = 16384 个	4 bit	65536 bit
小 scale（每 32 个一个 sub-block）	128×4 = 512 个	4 bit	2048 bit
大 scale（每个大块一个）	1 个	8 bit	8 bit
总计	—	—	67592 bit ≈ 4.12 bit/元素

相比 FP16（16 bit/元素），FP4 存储降低约 75%。

5.3 存储优化：磁盘 KV Cache

问题：对于共享前缀的长文档场景（比如多个查询共享相同的 1M token 文档前缀），每次推理都要重新做 prefill，代价极大。

解法：把已计算的 KV cache 序列化到磁盘（SSD/NVMe），下次相同前缀的查询直接加载，跳过 prefill 计算。

技术挑战：

KV cache 数据量巨大（1M token × 49B 激活参数的模型，每层 KV 约几 GB）
磁盘 I/O 需要高吞吐（NVMe RAID 阵列 + 异步 prefetch）
需要精确的 prefix hash 匹配机制
FP4 量化也用于 KV cache 存储（进一步压缩磁盘空间）

5.4 计算/Kernel 优化：TileLang DSL

V4 开发了一套内部 DSL（领域特定语言）TileLang，用于快速开发高性能 GPU kernel，同时保证可移植性。

TileLang 解决的痛点：

传统 CUDA kernel 开发有两个极端：

手写 CUDA：性能最优，但开发周期极长，难以移植
Triton 等高层抽象：开发快，但性能不如手写

TileLang 在两者之间找到平衡：提供 tile（计算块）级别的抽象，开发者描述"tile 层面的计算逻辑"，编译器负责 thread/warp/SM 级别的映射和优化。

关键特性：

支持 Hopper 架构的 TMA（Tensor Memory Accelerator）和 warpgroup-level GEMM
自动处理 shared memory 的 bank conflict
支持 FP4/FP8 混合精度 kernel 的自动生成
用于 CSA 的闪电索引器 kernel、mHC 的 Sinkhorn 迭代 kernel 等

5.5 确定性 + Batch-Invariant Kernel

确定性训练：对于给定的权重和输入，计算结果完全可复现（无论在哪台机器、哪批 GPU 上运行）。这是调试训练异常的基础。

Batch-Invariant：计算结果不依赖于 batch 内部的 token 排列顺序。这对于以下场景至关重要：

训练与推理的结果必须完全一致（训推一致性）
RL rollout 的结果必须与训练时一致（否则 off-policy 误差增大）

V4 专门实现了确定性 + Batch-Invariant 版本的所有核心 kernel（attention、MoE dispatch/combine 等），牺牲了约 5% 的性能换取可调试性。

5.6 分布式优化：Muon 的 ZeRO 实现

Muon 的 Newton-Schulz 迭代需要对矩阵的完整视图操作：

$$X_{k+1} = \alpha X_k + \beta X_k X_k^\top X_k$$

这里的 $X_k X_k^\top$ 需要 $X_k$ 的所有列（或行），但 ZeRO-3 将参数分片到不同 GPU 上，每个 GPU 只有矩阵的一个分片。

V4 的解法：

ZeRO-2 for Muon 参数：对需要 Muon 更新的矩阵参数，使用 ZeRO-2（梯度分片，但参数不分片）
All-gather before NS：在做 NS 迭代之前，先做 all-gather 收集完整梯度矩阵
Scatter after NS：NS 迭代完成后，各 GPU 各自更新自己负责的参数分片

这样既保留了 ZeRO 的显存节省（梯度分片），又满足了 NS 迭代的完整矩阵需求。

5.7 mHC 的高效实现

mHC 的残差流加宽（$n_{hc}$ 条车道）和 Sinkhorn 迭代带来两个工程挑战：

显存压力：加宽后的残差流 $X_l \in \mathbb{R}^{n_{hc} \times d}$ 比标准 $h_l \in \mathbb{R}^{d}$ 大 $n_{hc}$ 倍。

解法一：Tensor-level Activation Checkpointing（详见 5.9 节）

通信开销：在流水线并行下，加宽的残差流需要跨 stage 传输，通信量增加 $n_{hc}$ 倍。

解法二：只在 stage 边界传输一条车道。V4 的实现中，不同的 stage 各自维护完整的 $n_{hc}$ 条车道，但跨 stage 只传输聚合后的单条车道表示，内部车道状态不跨 stage 传输。这在精度上有轻微损失，但工程上大幅减少通信。

5.8 Contextual Parallelism（CP）：1M 上下文跨 GPU 切片

问题：1M token 序列在单张 GPU 上无法存下（即使用 FP4 量化也需要数十 GB）。

解法：Contextual Parallelism（CP）将长序列在 token 维度切成 $N$ 个片段，每个片段分配给一组 GPU：

序列 [0, 1M): 切成 N 片
GPU 0: token [0, 1M/N)
GPU 1: token [1M/N, 2M/N)
...
GPU N-1: token [(N-1)M/N, 1M)

Attention 的挑战：attention 的每个 query token 原则上需要关注所有历史 key/value token，但 key/value 分布在不同 GPU 上。

CSA/HCA 的 CP 友好性：

V4 的 CSA 设计对 CP 特别友好：

CSA 的闪电索引器已经把 attention 稀疏化，每个 query 只看 top-$k$ 个压缩 KV
这意味着跨 GPU 的 KV 通信量从 $O(T)$ 降到 $O(T/m \cdot \text{traffic\_ratio})$
HCA 的重度压缩进一步减少了需要跨 GPU 同步的 KV 量

Ring-Attention 变体：V4 实现了一种环形 all-to-all 通信模式，每个 GPU 在本地做 attention 计算的同时，将 KV 传递给下一个 GPU，实现计算与通信的流水线重叠。

5.9 Tensor 级 Activation Checkpointing

标准的 Activation Checkpointing（AC）以层为粒度：正向传播时丢弃中间激活，反向传播时重新计算。

但 mHC 的加宽残差流 $X_l \in \mathbb{R}^{n_{hc} \times d}$ 和 CSA 的压缩 KV $C^{Comp}$ 这两类激活的显存影响差异极大：

$X_l$：$n_{hc}$ 倍于标准激活，必须丢弃
$C^{Comp}$：压缩了 $m$ 倍，相对较小，可以保留

V4 实现了 Tensor 级 AC：以 Tensor 为粒度细粒度控制哪些激活保留、哪些丢弃。这比粗粒度的层级 AC 更灵活，可以精确控制显存/重计算成本的权衡。

6. 预训练 Pre-training

6.1 数据构建与质量改进

6.1.1 推理数据占比提升

V4 在预训练数据中大幅提升了推理密集型数据的占比，包括：

数学问题及解题过程
代码及注释
逻辑推理链
科学论文

这一调整背后的逻辑：test-time scaling（让模型多想几步）的收益，很大程度上取决于预训练时模型见过多少"思考过程"的数据。

6.1.2 FIM（Fill-in-Middle）数据策略

V4 采用 FIM 数据格式：给定代码/文本的前缀和后缀，让模型预测中间部分：

[PREFIX] def merge_sort(arr):
[SUFFIX] return arr
[MIDDLE] if len(arr) <= 1:
 return arr
 ...

这种训练方式让模型学会在双向上下文约束下生成，对代码补全、文本编辑等场景有显著收益。

6.1.3 长文档保持完整

很多数据集在处理长文档时会截断或分割。V4 特别保证长文档（尤其是技术文档、书籍章节）以完整形式进入训练，避免跨长距离的信息依赖关系被切断。

6.1.4 数据去重和质量过滤

V4 使用了多级去重策略：

MinHash LSH：快速找近似重复文档
精确指纹：识别完全重复
质量过滤器：基于语言识别、困惑度过滤、启发式规则

6.2 训练配置对比

配置项	V4-Pro	V4-Flash
模型架构
总参数量	1.6T	284B
激活参数量	49B	13B
隐层维度 $d$	7168	4096
层数	61	27
注意力 head 数	128	32
MoE 配置
总 Expert 数	256	64
每 token 激活 Expert	6	4
Expert 维度	—	—
Attention 配置
CSA 压缩比 $m$	4	4
HCA 压缩比 $M$	~32	~16
CSA top-$k$	—	—
SWA 窗口大小	4096	4096
mHC 配置
车道数 $n_{hc}$	4	2
训练配置
预训练 token 数	~10T	~5T
批大小	大	中
学习率	—	—
优化器	Muon + Adam	Muon + Adam

6.3 上下文长度调度

V4 采用三阶段渐进式上下文扩展：

阶段	上下文长度	目的
阶段一	4K token	大部分预训练，建立基础语言能力
阶段二	64K token	长文档理解，引入 CSA/HCA
阶段三	1M token	超长上下文，激活全部 Hybrid Attention

每个阶段切换时，模型不需要从头训练——V4 使用了一种"连续学习"策略，通过调整 position embedding 和 attention 策略平滑过渡。

6.4 辅助 Loss 配置

V4 保留了 DeepSeekMoE 的辅助 loss 来促进 Expert 负载均衡：

$$L_{aux} = \alpha \sum_{i=1}^{N} f_i \cdot P_i$$

其中 $f_i$ 是 Expert $i$ 实际处理的 token 比例，$P_i$ 是路由给 Expert $i$ 的概率。这个 loss 鼓励所有 Expert 被均匀使用，避免少数 Expert 过载。

6.5 训练稳定性补丁

在大规模预训练中，V4 遭遇了两类训练不稳定现象，分别用针对性补丁解决：

6.5.1 补丁一：Anticipatory Routing（预期路由）

问题：MoE 的路由函数（决定 token 去哪个 Expert）在训练初期可能过于"固执"——某些 Expert 一开始被频繁选中，造成马太效应，其他 Expert 得不到足够的梯度更新。

解法：在路由决策时加入"预期"项——不只看当前 token 的路由分数，还考虑"如果这个 Expert 被选中，未来的 token 分配会怎样变化"。这使路由更具前瞻性，缓解 Expert 负载不均衡。

6.5.2 补丁二：SwiGLU Clamping

问题：SwiGLU 激活函数在深层网络中可能产生数值上溢（overflow）或下溢（underflow），尤其在 FP8 精度下。

$$\text{SwiGLU}(x, y) = x \cdot \sigma(x) \cdot y$$

当 $x$ 绝对值很大时，$x \cdot \sigma(x)$ 接近 $x$ 本身（因为 $\sigma(x) \approx 1$），可能超出 FP8 的动态范围。

解法：对 SwiGLU 的输入 $x$ 和输出 $x \cdot \sigma(x)$ 都加 clamp 操作，把数值限制在安全范围内：

$$\text{SwiGLU-clamped}(x, y) = \text{clamp}(x \cdot \sigma(x), -c, c) \cdot y$$

$c$ 是可调超参数，由数值分析确定。

6.6 预训练评估

V4 在预训练结束后（后训练之前）进行了基础能力评估，指标包括：

代码：HumanEval Pass@1、MBPP
数学：MATH 500、GSM8K
语言理解：MMLU
长上下文：Needle-in-a-Haystack（不同序列长度）、文档 QA

预训练阶段的评估表明，mHC + CSA/HCA 架构相比 baseline（RC + MLA）在长上下文任务上有显著提升，同时短上下文任务没有明显退化。

7. 后训练 Post-training

7.1 整体流程：专家训练 → OPD

V4 后训练的核心范式转变：从 V3.2 的"混合 RL"到 V4 的"专家训练 + On-Policy Distillation"。

V3.2 的做法（混合 RL）：

把所有任务（数学、代码、对话、写作等）混在一起，用 RL 一起训
每个任务用各自的 reward signal
模型在同一次训练里学所有能力
问题：不同任务的 gradient 相互干扰（“打架”），某些任务的改进以牺牲其他任务为代价

V4 的做法（专家训练 + OPD）：

第一阶段：分别训多个领域专家（数学专家、代码专家、写作专家等）
第二阶段：用 On-Policy Distillation（OPD）把所有专家的能力蒸馏到一个统一模型里
优势：“先分后合"避免了混合 RL 的 gradient 打架问题

7.2 Specialist Training（专家训练）

每个领域专家走一个标准流程：

Base Model → SFT（监督微调）→ GRPO（RL）→ 领域专家模型

7.2.1 Reasoning Effort 三档设计

V4 给每个领域专家训了三种 reasoning 模式：

模式	特点	用途	训练方式
Non-think	快速直觉式响应	日常简单任务	短 context window + 长度惩罚高
Think High	有意识逻辑分析	复杂推理任务	中等 context + 平衡长度惩罚
Think Max	推理拉满，最强但最慢	探索推理上限	长 context + 特殊 system prompt

输出格式统一用 <think>...</think> 标签包裹推理过程，方便用户可视化查看。

Think Max 模式在 system prompt 前注入特殊 instruction：

You are a highly capable AI assistant. Before answering,
think deeply and exhaustively about the problem.
Consider multiple approaches, verify your reasoning,
and ensure your answer is accurate and complete.
<think>
[模型在此生成完整推理过程]
</think>
[最终答案]

7.2.2 Generative Reward Model（GRM）

传统做法：训练一个独立的 scalar reward model（输入对话→输出标量分数），用于 PPO/GRPO。

问题：

需要大量人工标注偏好数据
Reward model 和 policy 的分布 gap 会随训练加深
Scalar reward 无法捕捉复杂、多维度的质量评估

V4 的做法（GRM）：

不训独立的 reward model
让 actor 网络本身充当 reward model
用 rubric-guided（评分标准引导的）数据训练
模型学着评估自己的输出（“判官"和"答题"是同一个网络）

GRM 的训练数据格式（rubric 评分）：

[Input: Prompt + Response]
按 rubric 评分：
1. 准确性: X/3
2. 清晰度: X/3
3. 结构: X/2
4. 创意: X/2
总分: XX/10

理由: <详细推理过程>

GRM 的优势：

节省人工标注：只需少量多样性标注，rubric 本身可以被少量专家设计
judge 能力和 generation 能力联合优化：模型的内部推理能力直接提升评判质量
可解释性：GRM 输出推理过程，可以诊断为什么一个响应得分低

7.3 Tool-Call Schema 更新

V4 引入新的 tool-call 格式，用特殊 token |DSML| + XML 风格：

<|DSML|tool_calls>
<|DSML|invoke name="tool_name">
<|DSML|parameter name="arg1" string="true">value</|DSML|parameter>
</|DSML|invoke>
</|DSML|tool_calls>

为什么不用 JSON？

JSON 的转义（escape）规则复杂，在嵌套 JSON 中频繁出现语法错误。XML 格式更鲁棒：

属性值用 "..." 包裹，不需要额外转义
标签嵌套结构清晰
遇到未知工具名/参数，解析器可以优雅降级

实测表明，XML 格式将 tool-call 语法错误率降低了约 30%。

7.4 Interleaved Thinking（交织思考）

V3.2 的策略：在 tool-call 之间保留 thinking trace，但每次新用户消息都会清空。

在 agent 任务里，这意味着每个 turn 都要"重新建立思路”，浪费 token，且连贯性差。

V4 的策略：

场景	策略
Tool-calling 场景	完整保留所有 thinking trace，包括跨用户 turn 的
普通对话场景	保持 V3.2 策略，新 turn 清空

这样在 long-horizon agent 任务里，模型能维持累积的、连贯的 chain of thought，不必每个 turn 重新思考。

快速指令（Fast Instructions）：

V4 还引入了快速指令机制：将一组专用特殊 token 直接附加到输入序列，每个 token 对应一个辅助任务（如生成搜索查询、判断文档权威性等）。这些辅助任务可以直接重用已计算的 KV cache，完全避免冗余的 prefill，并且某些任务可以并行执行。

好处：

显著缩短用户感知到的首次响应时间（TTFT）
消除维护额外小型辅助模型的工程开销

7.5 On-Policy Distillation（OPD）

核心思想：把多个领域专家的能力"蒸馏"到一个统一的学生模型里。

数学形式：

$$L_{OPD}(\theta) = \sum_{i=1}^{N} w_i \cdot D_{KL}(\pi_\theta \| \pi_{E_i})$$

其中：

$\pi_\theta$ 是学生模型的输出分布
$\pi_{E_i}$ 是第 $i$ 个专家模型的输出分布
$w_i$ 是该专家的权重

“On-Policy” 的关键：训练数据是从学生自己的轨迹采样的（不是从专家采样）。这意味着学生在自己生成的内容上学习如何被专家纠正，比传统"离线蒸馏”（用专家生成的数据训学生）更有效。

为什么不用"权重合并"？

传统做法：把多个 fine-tuned 模型的权重做加权平均。

问题：权重合并经常导致性能严重下降，不同专家的权重在数学上不兼容（参数在不同优化路径上移动，合并后的点可能不在任何合理的损失盆地里）。

OPD 通过 logits 层对齐来合并能力，不在权重空间合并，而在输出分布层面合并。这避免了权重合并的所有问题。

Full-vocabulary OPD（完整词表 KL）：

V4 用的是完整词表的 KL 散度，不是简化版的 token-level 估计：

简化版（很多前人工作）：每个 token 位置只用一个标量 advantage 估计 KL。优点省内存，缺点梯度方差大。
Full-vocabulary：保留完整 logits 分布算 KL。优点梯度估计精确，缺点内存压力大（vocab size > 100K）。

V4 用了专门的工程方案（见 7.6）来解决内存问题。

7.6 RL/OPD 基础设施

7.6.1 FP4 量化集成

把预训练中的 FP4 应用到后训练阶段：

rollout 阶段：直接用 FP4 权重（节省显存和延迟）
training 阶段：用 FP4-to-FP8 无损解量化（复用 FP8 训练框架）
teacher 和 reference 模型也用 FP4：加速 inference-only forward pass

7.6.2 Efficient Teacher Scheduling for Full-Vocabulary OPD

问题：10+ 个 teacher，每个万亿参数 → 内存无法全量加载。每个 teacher 都要算完整 logits（vocab size > 100K）→ 内存爆炸。

V4 的解法：

Teacher 权重 offload 到分布式存储：按需加载，类似 ZeRO 的 sharding
缓存 last-layer hidden states 而非完整 logits：训练时再过 prediction head 重建 logits（节省 vocab_size 倍的存储）
按 teacher index 排序训练样本：每个 teacher head 在 mini-batch 里只加载一次，减少 I/O
专门的 TileLang kernel 算精确 KL 散度

7.6.3 Preemptible and Fault-Tolerant Rollout Service

背景：V4 在 GPU 集群里跑 rollout（采样生成轨迹）。集群有两个现实问题：

任何 task 随时可能被高优 task 抢占
硬件故障经常发生

V4 的解法：Token 粒度的 Write-Ahead Log（WAL）

每生成一个 token，立即 append 到 WAL
抢占时：暂停 inference engine + 保存 KV cache
恢复时：从 WAL + KV cache 继续解码
硬件故障时：用 WAL 重新做 prefill 重建 KV cache

为什么不能简单"从头重跑"？

重跑会引入长度偏置：短回答更容易在中断中存活，模型会慢慢偏好生成短的响应。WAL 保证了 rollout 的正确性。

7.6.4 Scaling RL Framework for Million-Token Context

1M token 的 RL 带来极端的数据传输挑战：

一条 rollout 数据（包含 1M token 的 KV cache + logits）约几十 GB
训练时需要频繁在多个 GPU 间传输这些数据

V4 的工程解法：

优化点	做法
数据格式拆分	metadata（轻量，全量加载）+ per-token heavy fields（按需加载）
共享内存	intra-node 使用 shared memory data loader，消除冗余复制
即时释放	mini-batch 粒度立即释放重数据，减少 CPU/GPU 内存压力
动态 mini-batch 数	根据 token 分布动态调整 mini-batch 大小，平衡计算和 I/O

7.6.5 DSec Sandbox Infrastructure for Agentic AI

V4 训练 agent 能力时需要执行真实代码，这需要一个安全的执行环境。

DSec（DeepSeek Elastic Compute）：V4 内部的 sandbox 平台，用 Rust 实现，支持 4 种执行底层：

底层	隔离级别	用途
Function Call	进程级（容器池）	无状态轻量调用
Container	容器级（Docker 兼容）	标准开发环境
microVM	VM 级（Firecracker）	安全敏感的高密度部署
fullVM	完整 VM（QEMU）	需要任意 OS 的场景

四种底层共享同一个 Python SDK，开发者只需改一个参数就能切换。单个 DSec 集群能管理数十万个并发 sandbox 实例，这是 agent 训练规模化的关键。

8. 评估结果

8.1 标准 Benchmark

V4-Pro 在大部分标准 benchmark 上：

接近或超过 Gemini-3.1-Pro 的水平
与 Claude 等顶级闭源模型处于同一区间
代码和数学类任务表现最强（相对优势最大）

Benchmark	V4-Pro	V4-Flash	对比
MMLU	~88+	~84+	接近顶级闭源
HumanEval	~93+	~87+	代码能力强
MATH 500	~90+	~85+	数学推理强
GSM8K	~97+	~95+	小学数学近饱和
GPQA Diamond	~75+	~68+	专家级科学推理

注：具体数字以官方报告为准，此处为示意范围

8.2 真实世界任务表现

V4 在四类真实世界任务上进行了系统评估：

任务类型	子类	V4 的表现
长文档理解	文档 QA、摘要、跨章节推理	1M token 下显著超越有效上下文较短的模型
Agent 任务	多步代码、工具调用、文件操作	Interleaved Thinking 带来明显的任务完成率提升
推理密集	数学证明、逻辑谜题	Think Max 模式下比 Non-think 提升 15-20%
对话质量	指令遵从、安全性、有用性	OPD 后通用能力保持，不因专家训练退化

8.3 Needle-in-a-Haystack 测试

V4 在 1M token 的 NIAH（大海捞针）测试中，在全部位置（0%、25%、50%、75%、100%）保持近 100% 的召回率，验证了：

CSA/HCA 的压缩稀疏注意力没有遗漏关键信息
mHC 的信息流设计支持超长距离的信息保留
训练时 1M token 上下文是真实有效的，不是"名义上的"

9. 总结与展望

9.1 核心贡献回顾

DeepSeek V4 的核心贡献可以概括为一句话：在万亿参数规模下，通过五维系统工程，将原生上下文窗口扩展到 1M token，同时保持强大的短上下文性能。

五个维度的具体贡献：

维度	核心贡献	关键数据
mHC	双随机矩阵约束解决残差连接稳定性	6.7% 额外开销
CSA/HCA	压缩+稀疏组合将 Attention 复杂度从 $O(T^2)$ 降到 $O(T \cdot k)$	1M token 原生支持
Muon	正交化梯度更新提升优化效率	约 1.05-1.10× 算力优势
工程	EP 波次调度、FP4 QAT、Contextual Parallelism	EP 1.92× 加速，显存降低 75%
后训练	专家训练+OPD 解决混合 RL 的 gradient 打架问题	全面超越 V3.2

9.2 几个值得关注的设计决策

为什么选 mHC 而不是 AttnRes？

两者性能接近，但 mHC 在工程集成上更简单：双随机矩阵约束只影响 $B_l$，其余结构不变；而 AttnRes 需要维护层间 attention 的完整历史，工程复杂度更高。在百万级 token 的大规模训练下，工程可实现性是第一位的。

为什么选压缩+稀疏而不是线性 Attention？

线性 Attention（Mamba 等）在某些任务上确实更高效，但在需要精确定位历史信息的任务（如代码调试需要精确找到之前的变量定义）上有明显劣势。CSA 保留了 exact attention 的精确性，只是通过压缩和稀疏降低了计算量，而不是用状态槽近似替代。

为什么选 OPD 而不是 RLHF？

RLHF 需要大量人工标注偏好对，且 reward model 随训练会越来越不准确（distribution shift）。OPD 通过让专家模型直接提供 logits 分布，避免了 scalar reward 的信息损失；on-policy 采样则避免了 distribution shift 问题。

9.3 未解的问题与未来方向

1. 1M token 推理的用户延迟问题

即使有 CSA/HCA 的优化，处理 1M token 的 prefill 依然需要数十秒甚至数分钟。对于实时交互场景，这仍然是一个瓶颈。磁盘 KV cache 是一个方向，但有适用场景限制。

2. AttnRes 的规模化

AttnRes 的理论优势（完整层间 attention）受限于 Block 压缩的精度损失。如何在更大规模上实现 Full AttnRes 的收益，同时控制通信开销，是一个开放问题。

3. 后训练对长上下文能力的保持

后训练（SFT/RL）通常在短对话上进行，可能导致模型在后训练后长上下文能力退化。V4 通过长上下文专家训练缓解了这个问题，但更系统的解决方案仍需探索。

4. 1M token 的 Agent 闭环训练

DSec sandbox 支持了代码执行，但更复杂的 agent 场景（长期任务规划、跨工具协作）的训练基础设施仍在演进中。

9.4 对业界的启示

V4 最重要的启示可能不是某个具体的技术点，而是**“系统工程"的思维方式**：

单一架构创新（只改 attention、只改残差、只改优化器）在大规模下效果有限
架构创新和工程基础设施必须协同设计——没有 EP 波次调度，MoE 的通信会成瓶颈；没有 Contextual Parallelism，CSA 的 1M token 训练跑不起来
后训练流程的范式（专家训练+蒸馏 vs 混合 RL）对最终能力有决定性影响，不亚于预训练架构

附录 A：Attention 优化思路详解

A.1 思路 A：稀疏化（Sparse Attention）详解

稀疏 Attention 的核心思想是：不让每个 token 关注所有历史，只关注有意义的子集。

方案 A.1：局部窗口（Sliding Window Attention, SWA）

每个 token 只关注最近的 $w$ 个 token：

$$\text{Attn}(t) = \text{softmax}\left(\frac{q_t K_{[t-w:t]}^\top}{\sqrt{d}}\right) V_{[t-w:t]}$$

计算：$O(T \cdot w)$
KV cache：$O(w \cdot L \cdot d)$（滑动窗口，常量）
缺陷：完全无法处理超过 $w$ 的长程依赖

方案 A.2：全局 + 局部（BigBird、Longformer）

保留 $g$ 个"全局 token”（比如 CLS token），所有其他 token 只看局部窗口：

$$\text{Attn}(t) = \text{softmax}\left(\frac{q_t [K_{global}; K_{[t-w:t+w]}]^\top}{\sqrt{d}}\right) V$$

计算：$O(T \cdot (g + w))$
全局 token 数量 $g$ 通常很小（几十到几百）
问题：全局 token 选择需要先验知识，或会成为信息瓶颈

方案 A.3：学习型稀疏（Reformer、Routing Transformer）

通过 locality-sensitive hashing（LSH）或路由函数，动态选择每个 token 要关注的 K 个近邻：

LSH：用随机投影把语义相近的 token 映射到同一个 bucket
路由函数：学习一个轻量网络预测相关性

代价：额外的路由计算 + 难以并行化

A.2 思路 B：线性化（Linear Attention）详解

线性 Attention 的核心思想：把 softmax($QK^\top$)$V$ 变成可以用"状态递推"方式高效计算的形式。

基础推导：

标准 attention 的 softmax 是全局归一化，线性 attention 用核函数替代：

$$\text{Attn}_{linear}(q, k, v) = \frac{\sum_s \phi(q)^\top \phi(k_s) v_s}{\sum_s \phi(q)^\top \phi(k_s)}$$

其中 $\phi$ 是特征映射。由于 $\phi(q)^\top (\phi(k_s) v_s^\top)$ 可以写成矩阵乘法，令 $S = \sum_s \phi(k_s) v_s^\top$（状态矩阵），则：

$$\text{Attn}_{linear}(q) = \frac{\phi(q)^\top S}{\phi(q)^\top z}, \quad S, z \text{ 递推更新}$$

这样推理时只需维护固定大小的状态 $S \in \mathbb{R}^{d_k \times d_v}$，KV cache 从 $O(T)$ 降到 $O(1)$！

代表方法：

方法	特征映射 $\phi$	状态更新规则	特点
RetNet	指数衰减（位置敏感）	$S_t = \gamma S_{t-1} + k_t v_t^\top$	有记忆衰减，近期信息更重要
Mamba	选择性状态空间	输入依赖的选择机制	状态槽大小可调
DeltaNet	Delta 规则（写入-擦除）	$S_t = S_{t-1} + \beta_t (v_t - S_{t-1} k_t) k_t^\top$	可以擦除旧记忆

共同局限：所有线性 attention 都有信息压缩损失——无法精确回忆超过状态槽容量的历史信息。

A.3 思路 C：压缩（Compressed Attention）详解

压缩 Attention 的核心思想：减少 K/V 的数量（不是 Q 的数量），用更少的 K/V 表示相同的信息。

方案 C.1：MQA（Multi-Query Attention）

所有 Q head 共享同一套 K 和 V：

$$K, V \in \mathbb{R}^{T \times d_h}, \quad Q_h \in \mathbb{R}^{T \times d_h}, h=1,...,n_h$$

KV cache：从 $n_h \times T \times d_h$ 降到 $T \times d_h$（$n_h$ 倍减少）
计算量不变（Q 还是 $n_h$ 套）
代价：表达能力略有下降（不同 head 不能有不同的 K/V 偏好）

方案 C.2：GQA（Grouped-Query Attention）

把 $n_h$ 个 Q head 分成 $G$ 组，每组共享一套 K/V（是 MQA 和 MHA 的中间方案）：

KV cache：降为 $G \times T \times d_h$（$n_h/G$ 倍减少）
$G=1$ 退化为 MQA，$G=n_h$ 退化为 MHA
Llama 3、DeepSeek-V3 等广泛采用

方案 C.3：MLA（Multi-head Latent Attention，DeepSeek-V3）

不直接共享 K/V，而是把 K/V 低秩分解，KV cache 只存低维潜向量：

$$KV = c_{kv} \cdot W^{UK}, c_{kv} \in \mathbb{R}^{T \times d_c}, d_c \ll d_h \cdot n_h$$

KV cache：降为 $T \times d_c$（最多降低 10× 以上）
可以在需要时随时从 $c_{kv}$ 还原完整 KV（计算换存储）

方案 C.4：CSA/HCA（DeepSeek-V4）

在 C.1-C.3 的基础上更进一步：不只是共享 K/V，而是在 token 维度也做压缩（把多个 token 的 KV 折叠成一个）。这是 C 类思路中最激进的，也是 V4 的核心创新。

A.4 三条思路综合对比

对比维度	稀疏化	线性化	压缩
计算复杂度	$O(T \cdot k)$	$O(T)$	$O(T \cdot T/m)$
KV cache	$O(T)$（存全量）	$O(1)$（状态槽）	$O(T/m)$（压缩存储）
长程精确回忆	⚠️ 看稀疏策略	❌ 有信息损失	✅ 保留精确性
近期局部信息	✅ 好	✅ 好	✅ 好
训练稳定性	✅ 好	⚠️ 核函数设计敏感	✅ 好
工程友好性	✅ 好	⚠️ 需要特殊 kernel	✅ 好
代表方法	SWA、BigBird	Mamba、RetNet	GQA、MLA、CSA、HCA
V4 是否采用	✅（SWA 辅助分支）	❌	✅（CSA + HCA 主力）

DeepSeek V4 的选择（稀疏 + 压缩组合）是在"精确性"和"效率"之间找到的一个现实平衡点，既保留了 exact attention 的精确语义，又把计算和存储复杂度降低到可以支持 1M token 的水平。

10. DeepSeekMoE：V4 的架构基础

在深入理解 V4 的所有创新之前，有必要先了解 DeepSeekMoE——V4 所依赖的 MoE（Mixture of Experts）架构基础。V4 并不是从一个密集 Transformer 出发加了一些新东西，而是在一个已经成熟的 MoE 架构上进行系统性扩展。

10.1 为什么要用 MoE

密集 Transformer 的扩展极限：

对于一个标准的密集 Transformer，每个 token 的前向传播要经过模型的所有参数。当模型扩大到 100B 参数时，每个 token 的 forward pass 需要约 200 GFLOPs（两次参数量级的浮点运算）。这对训练和推理的计算成本都是巨大的挑战。

MoE 的解法：稀疏激活。

把 FFN 层（通常是模型参数的 2/3）替换成 MoE 层：$N$ 个并行的 Expert FFN，每个 token 只被路由到 $k$ 个 Expert（通常 $k \ll N$）。这样总参数量增加了 $N/k$ 倍，但每个 token 的计算量只增加约 $k/1$ 倍。

$$ ext{MoE}(x) = \sum_{i \in ext{top-k}} g(x)_i \cdot ext{FFN}_i(x)$$

其中 $g(x) = ext{softmax}( ext{Router}(x))$ 是路由函数，$g(x)_i$ 是路由到 Expert $i$ 的权重。

DeepSeekMoE 的特殊设计：

标准 MoE 有 Expert 不均衡问题：路由函数可能偏好少数 Expert，导致大部分 Expert 得不到充分训练。DeepSeekMoE 引入了两个关键设计：

细粒度 Expert 分割：把每个 Expert 的参数量缩小（更多但更小的 Expert），让路由函数有更多选择空间，每个 Expert 能专注于更窄的知识领域
共享 Expert（Shared Expert）：保留少量 Expert 被所有 token 共享，处理通用知识，减少路由 Expert 的负担

V4-Pro 的配置：256 个 Expert，每 token 激活 6 个，外加若干 shared Expert。

10.2 MoE 的分布式训练挑战

MoE 的计算高效来自稀疏激活，但带来了独特的分布式训练挑战——Expert Parallelism（EP）：

基本思路：把 $N$ 个 Expert 分布到 $N_{EP}$ 张 GPU 上，每张 GPU 存储 $N/N_{EP}$ 个 Expert 的参数。每个 token 根据路由决策被发送到对应的 GPU。

通信模式：

Dispatch：每个 GPU 把自己的 token 发送给其他 GPU（all-to-all）
Compute：各 GPU 独立计算本地 Expert
Combine：把 Expert 结果发回原来的 GPU（all-to-all）

这两次 all-to-all 通信是 MoE 训练的瓶颈，也是第 5 节 EP 波次调度优化的出发点。

10.3 负载均衡的关键性

如果路由函数偏向少数 Expert，会导致：

热点 GPU 过载，其他 GPU 空闲（计算效率下降）
热点 Expert 过度拟合，非热点 Expert 欠拟合（模型质量下降）

V4 使用三种机制维持负载均衡：

辅助 Loss（Auxiliary Loss）：

$$L_{aux} = lpha \cdot N \cdot \sum_{i=1}^{N} f_i \cdot P_i$$

其中 $f_i$ 是 Expert $i$ 实际处理的 token 比例，$P_i$ 是路由分数。这个 loss 惩罚不均衡的路由。

Expert-Capacity-Factor（ECF）：给每个 Expert 设定最大 token 容量，超出的 token 被丢弃或路由到备选 Expert。

Anticipatory Routing（补丁一，见 §7.5）：在路由决策中加入前瞻信息。

11. 残差连接的深度数学

11.1 Birkhoff 多面体：双随机矩阵的几何

理解 mHC 为什么有效，需要了解双随机矩阵集合（Birkhoff polytope）的数学性质。

定义：$n imes n$ 双随机矩阵集合 $\mathcal{B}_n$ 是所有满足以下条件的矩阵的集合：

$$\mathcal{B}_n = \{M \in \mathbb{R}^{n imes n} : M\mathbf{1} = \mathbf{1}, \mathbf{1}^ op M = \mathbf{1}^ op, M \geq 0\}$$

关键性质：

性质 1（Birkhoff-von Neumann 定理）：$\mathcal{B}_n$ 的极点恰好是所有 $n imes n$ 置换矩阵，共有 $n!$ 个。任何双随机矩阵都可以写成置换矩阵的凸组合。

这个定理的直觉是：双随机矩阵可以理解为"模糊的置换"——不是把一个元素精确地移到另一个位置，而是把它"分散地移到多个位置"，权重之和为 1。

性质 2（奇异值约束）：任何双随机矩阵 $M \in \mathcal{B}_n$ 的所有奇异值都 $\leq 1$，且最大奇异值等于 1（对应于全 1 向量 $\mathbf{1}/\sqrt{n}$ 的奇异方向）。

性质 3（连乘封闭性）：如果 $M_1, M_2 \in \mathcal{B}_n$，则 $M_1 M_2 \in \mathcal{B}_n$。

这是 mHC 稳定性的数学根基：无论堆多少层，$B_l B_{l-1} \cdots B_1$ 的奇异值始终 $\leq 1$，梯度传播永远稳定。

性质 4（近似 RC 的能力）：恒等矩阵 $I$ 也是双随机矩阵（$\in \mathcal{B}_n$）。所以 mHC 可以学习到让 $B_l pprox I$，此时 mHC 退化为标准 RC。这意味着 mHC 不比 RC 差——在最坏情况下，它等价于 RC。

11.2 Sinkhorn-Knopp 算法的收敛性分析

算法：对任意元素全正的矩阵 $M^{(0)} > 0$，交替做行归一化和列归一化：

$$M^{(t+1)} = D_r^{(t)} M^{(t)} D_c^{(t)}$$

其中 $D_r^{(t)}$ 是使行和等于 1 的对角缩放矩阵，$D_c^{(t)}$ 是使列和等于 1 的对角缩放矩阵。

收敛定理：对任意元素全正的 $M^{(0)}$，Sinkhorn-Knopp 算法线性收敛到唯一的双随机矩阵 $M^*$，收敛速率为 $O( ho^t)$，其中 $ ho = \lambda_2(M^*) / \lambda_1(M^*) < 1$（第二大特征值与最大特征值之比）。

实践中迭代 20 次为什么足够？

在 V4 的配置下（$n_{hc} = 4$ 的小矩阵），Sinkhorn 迭代在 5-10 次后精度已经足够（行和和列和与 1 的偏差 $< 10^{-4}$）。20 次是一个保守但高效的选择，保证了数值精度同时避免过多迭代。

反向传播中的 Sinkhorn：

在反向传播时，需要计算 $\partial L / \partial ilde{B}_l$（Sinkhorn 迭代的输入的梯度）。这通过"unrolled differentiation"实现——把 20 次迭代展开为计算图，让 autograd 自动计算梯度。虽然展开 20 次迭代会增加计算图的深度，但每次迭代只是简单的缩放操作，梯度传播效率高。

11.3 HC 车道宽度 $n_{hc}$ 的选择

V4 选择 $n_{hc} = 4$（V4-Pro）或 $n_{hc} = 2$（V4-Flash）。这个选择背后有一个权衡：

$n_{hc}$	表达能力	显存开销	额外计算
1	退化为 RC	0	0
2	两条车道的灵活读写	$2 imes$ 残差流	低
4	四条车道的灵活读写	$4 imes$ 残差流	中等（6.7%）
8+	更高灵活性	$8 imes$ 残差流	较高

消融实验显示 $n_{hc} = 4$ 是性能和开销的甜点：再增加车道数，性能提升变得边际，但开销继续增加。

11.4 mHC 与其他稳定化技术的对比

技术	作用位置	稳定化机制	对信息流的影响
LayerNorm	每层内	归一化激活均值/方差	不改变残差结构
Dropout	每层内	随机丢弃激活，正则化	增加随机性
Gradient Clipping	反向传播	限制梯度范数	不改变前向计算
RC（标准残差）	层间	恒等映射保梯度	固定等权求和
mHC	层间	双随机矩阵约束梯度稳定	灵活加权，可学习

mHC 的独特之处在于：它同时解决了梯度稳定和信息流灵活性两个问题，而其他方法只能解决其中一个。

12. CSA 的深度工程分析

12.1 完整工作示例：一个 CSA 前向传播

假设 $n=16$（16 个 token），$d=4096$，$m=4$，$k=3$（top-3），$c=512$，$n_h^I=4$（索引器 heads）。

步骤一输出：

$C^a \in \mathbb{R}^{16 imes 512}$：16 个 token 的第一套 KV
$C^b \in \mathbb{R}^{16 imes 512}$：16 个 token 的第二套 KV
$Z^a, Z^b \in \mathbb{R}^{16 imes 512}$：对应软选择权重

步骤二的 4 个压缩块（$m=4$，$n/m=4$）：

第 0 块（$i=0$）：

$C^a$ 贡献：token [0, 1, 2, 3]，对应 $C^a[0:4]$
$C^b$ 贡献：padding（第 0 块没有前一块），$Z^b$ 用 $-\infty$
融合权重：对 token [0,1,2,3] 的 $Z^a$ 做 softmax，得到 4 个权重之和为 1
$C^{Comp}_0 = \sum_{j=0}^{3} p_{0,j}^a \cdot C^a[j]$

第 1 块（$i=1$）：

$C^a$ 贡献：token [4, 5, 6, 7]
$C^b$ 贡献：token [0, 1, 2, 3]（前一窗口，Overlap！）
融合权重：对 [0,1,2,3,4,5,6,7] 的 softmax（8 个候选）

第 2 块（$i=2$）：

$C^a$ 贡献：token [8, 9, 10, 11]
$C^b$ 贡献：token [4, 5, 6, 7]（Overlap）

第 3 块（$i=3$）：

$C^a$ 贡献：token [12, 13, 14, 15]
$C^b$ 贡献：token [8, 9, 10, 11]（Overlap）

最终 $C^{Comp} \in \mathbb{R}^{4 imes 512}$（4 个压缩 KV）。

步骤三：闪电索引器

计算 $K^{IComp} = C^{Comp} \cdot W^{IK} \in \mathbb{R}^{4 imes (c^I n_h^I)}$

对每个 query token $t$（16 个）：

算低秩潜向量：$c_t^Q \in \mathbb{R}^{d_c}$
算 4 个索引器 queries：$q_{t,1}^I, ..., q_{t,4}^I$
打分：$I_{t,s} = \sum_h w_{t,h}^I \cdot ext{ReLU}(q_{t,h}^I \cdot K_s^{IComp})$，$s \in \{0,1,2,3\}$
top-3 选择：每个 token 选出得分最高的 3 个压缩块

步骤四：MQA

每个 token 只在 3 个选中的压缩 KV 上做精确 attention，复杂度从 $O(16 \cdot 4)=64$ 降到 $O(16 \cdot 3)=48$（在这个小例子里收益不大，但在 1M token 时是 $O(1M/m)$ vs $O(k)$ 的差距，从 250K 降到 256）。

12.2 为什么 ReLU 比 softmax 更适合做索引

技术层面的分析：

量化兼容性：索引器的打分 $I_{t,s} = \sum_h w_{t,h}^I \cdot ext{ReLU}(q_{t,h}^I \cdot K_s^{IComp})$ 的结果是非负实数，可以直接量化为 INT8/FP4，精度损失极小。而 softmax 输出在 $(0, 1)$ 之间，且有长尾分布，量化精度损失更大。

并行化：ReLU 打分是token-独立的——每个 query token 可以独立地对所有压缩 KV 打分，完美并行化。softmax 有全局归一化，不同 token 之间没有依赖，实际上也能并行，但 softmax 的数值稳定性处理（减去最大值）需要额外一轮 reduce 操作。

稀疏性：ReLU 会把"内积为负"的压缩块直接置 0——这是一种自然稀疏化，绝大多数不相关的压缩块得到 0 分，top-k 选择只需要从剩余的非零得分中选最大的。

梯度属性：对于 top-k 选择，只有选中的 top-k 个 KV 会参与反向传播。ReLU 在 0 处的梯度为 0（子梯度），这意味着得分为 0 的 KV 不会接收到来自 attention 计算的梯度，而是通过 indexer 的独立训练路径更新。

12.3 CSA 的计算复杂度详细分析

对于长度 $T$、压缩比 $m$、top-k $k$、head 维度 $d_h$、head 数 $n_h$、索引器 head 数 $n_h^I$：

步骤	计算量	注释
步骤一：两套 KV 投影	$4 \cdot T \cdot d \cdot c$	4 个矩阵乘
步骤二：KV 融合	$pprox 2m \cdot (T/m) \cdot c$	softmax + 加权和
步骤三：索引器 keys	$(T/m) \cdot c \cdot c^I n_h^I$	一个矩阵乘
步骤三：低秩 queries	$T \cdot d \cdot d_c + T \cdot d_c \cdot c^I n_h^I$	两个矩阵乘
步骤三：打分	$T \cdot (T/m) \cdot c^I$	内积矩阵
步骤三：top-k	$O(T \cdot T/m \cdot \log k)$	部分排序
步骤四：精确 attention	$T \cdot k \cdot d_h \cdot n_h$	稀疏 attention

主导项：当 $T$ 很大时，步骤四的 $T \cdot k \cdot d_h$ 是主导项（精确 attention 计算）。

对比标准 attention 的 $T^2 \cdot d_h$：

$$ ext{节省比} = rac{T^2 d_h}{T k d_h} = rac{T}{k}$$

当 $T = 1M$，$k = 256$（从 250K 个压缩 KV 中选 256 个）：节省约 3906 倍计算量。

KV cache 节省：

标准 attention：$T \cdot n_h \cdot d_h \cdot 2$（K 和 V 各一份）

CSA：$(T/m) \cdot c \cdot 2$（只存压缩 KV）

节省比：$n_h \cdot d_h / (m \cdot c)$。对 V4-Pro（$n_h = 128$，$d_h = 128$，$m = 4$，$c = 512$）：

$$ ext{节省比} = rac{128 imes 128}{4 imes 512} = rac{16384}{2048} = 8 imes$$

即 KV cache 降低到标准的 1/8。

12.4 HCA 的压缩比极限分析

HCA 使用更激进的压缩比 $M$（约 32 或更大）。压缩比越大，信息损失越多——这是一个基本的信息论约束。

Shannon 信息瓶颈视角：

把 $M$ 个 token 的信息压缩到 1 个向量 $c \in \mathbb{R}^c$ 中。如果每个 token 的 KV 携带 $c \cdot \log_2(2c)$ bits 的信息（粗略估计），而压缩向量只有 $c \cdot ext{precision\_bits}$ bits，那么当 $M > c \cdot ext{precision\_bits} / (c \cdot \log_2(2c))$ 时，必然有信息损失。

实践中的信息损失：

HCA 主要用于"粗粒度背景感知"层——这些层不需要精确回忆历史中的特定信息，只需要大致知道"上下文背景是什么"。对于这类需求，32:1 压缩已经足够，信息损失可以接受。

对比：CSA 用在需要精确回忆的层（比如代码生成中需要记住之前定义的函数名），4:1 压缩保留了足够的精度。

13. 位置编码在长上下文中的演进

13.1 RoPE 的基础

旋转位置编码（RoPE，Rotary Position Embedding）是当前主流 LLM 广泛采用的位置编码方案。其核心思想：对 query 和 key 在复数空间做旋转，使得 $q_m^ op k_n$（位置 $m$ 的 query 和位置 $n$ 的 key 的点积）只依赖于相对位置 $(m-n)$，不依赖于绝对位置。

对于 head 维度的第 $2i, 2i+1$ 对（$i = 0, 1, ..., d_h/2 - 1$），RoPE 旋转角度为：

$$ heta_i = 10000^{-2i/d_h}$$

这是从低频到高频的指数分布：小 $i$ 对应低频（$ heta_i$ 小，旋转慢），大 $i$ 对应高频（$ heta_i$ 大，旋转快）。

token 位置 $m$ 的旋转：

$$q_{m,2i} = q_{2i} \cos(m heta_i) - q_{2i+1} \sin(m heta_i)$$

$$q_{m,2i+1} = q_{2i} \sin(m heta_i) + q_{2i+1} \cos(m heta_i)$$

相对位置不变性：

$$q_m^ op k_n = \sum_{i=0}^{d_h/2-1} \left(q_{m,2i} k_{n,2i} + q_{m,2i+1} k_{n,2i+1} ight) = f(q, k, m-n)$$

这个性质使得模型可以泛化到训练时没见过的绝对位置——只要相对位置关系在训练中出现过，就能泛化。

13.2 RoPE 在超长序列上的局限

标准 RoPE 在超长序列（超过训练时的 max length）上会出现性能退化，原因是：

高频旋转角度的周期混叠：当相对距离 $m-n$ 很大时，低维度（$ heta_i$ 小）的旋转角度 $|(m-n) heta_i|$ 仍然很小，位置信息保留良好；但高维度（$ heta_i$ 大）的旋转已经完成了多个完整周期，信息混叠严重。
分布 shift：模型在训练时从未见过 position $> T_{train}$，推理时遇到这些位置，内部的"位置感知"会失效。

解决方案：线性插值

Positional interpolation（陈等人，2023）：把推理时的位置线性缩放到训练时的范围内：

$$m' = m \cdot rac{T_{train}}{T_{infer}}$$

这相当于把所有位置"压缩"到 $[0, T_{train})$ 范围内。实践表明，配合少量的"长上下文微调"（用 $T_{infer}$ 长度的数据 fine-tune 几百步），插值后的 RoPE 性能接近原生支持长上下文的模型。

NTK-aware scaling：另一种插值方式，根据频率动态调整缩放比例，高频维度用更大的缩放，低频维度用更小的缩放：

$$ heta_i' = heta_i \cdot \left( rac{T_{train}}{T_{infer}} ight)^{2i/(d_h-2)}$$

V4 在第二阶段（4K→64K）和第三阶段（64K→1M）的上下文扩展中使用了类似的自适应缩放策略。

13.3 Partial RoPE 的数学动机

V4 的 Partial RoPE 只对 head 维度的前 $d_r < d_h$ 维施加 RoPE，后 $d_h - d_r$ 维不做旋转（保持"纯内容"信息）。

动机分析：

对于远距离 token 对（$|m-n| \gg d_h / heta_{\max}$），高维度的 RoPE 旋转已经使得 $q_m^ op k_n$ 接近随机——高频旋转让远距离的 Q/K 内积趋向 0。这固然限制了"虚假的远距离相关性"，但也阻止了模型通过内容相似性进行远距离检索。

想象一个场景：文档中第 1 个 token 提到了"量子纠缠"，第 1M 个 token 也提到了"量子纠缠"。从语义上，这两个 token 应该有很强的相关性。但如果两者相距 1M 个位置，标准 RoPE 的高维度旋转会让它们的 Q/K 内积接近 0，模型无法通过内容相似性发现这个相关性。

Partial RoPE 的解法：保留部分维度（$d_h - d_r$ 个）不做旋转，这些维度的内积纯粹由内容（语义）决定，不受位置影响。模型可以通过这些维度进行"语义检索"，而带 RoPE 的维度仍然提供局部位置偏好。

权衡：$d_r$ 越小（更少维度带 RoPE），语义检索能力越强，但位置感知越弱。$d_r$ 的最优值通过实验确定（V4 的具体数值未公开）。

14. Muon 优化器的深度分析

14.1 为什么正交化是最优的

从信息几何视角：

对于矩阵参数 $W \in \mathbb{R}^{m imes n}$，自然梯度方法（Natural Gradient）使用 Fisher 信息矩阵 $F$ 作为度量：

$$\Delta W^* = -F^{-1} abla_W L$$

自然梯度在参数空间中沿着"信息几何"意义上的最短路径移动。

对于矩形矩阵，一个简化版的"自然梯度"考虑矩阵 Riemannian 流形上的最速下降方向。对于 Frobenius 范数约束 $\|\Delta W\|_F \leq \delta$ 的最大化问题：

$$\max_{\|\Delta W\|_F \leq \delta} - ext{tr}( abla_W L \cdot \Delta W^ op)$$

最优解是 $\Delta W^* = -\delta \cdot abla_W L / \| abla_W L\|_F$（梯度方向归一化）。

但这只考虑了各向同性的 Frobenius 范数约束。如果改用 Spectral 范数约束 $\|\Delta W\|_2 \leq \delta$，最优解就是 $\Delta W^* = -\delta \cdot U V^ op$（其中 $G = U \Sigma V^ op$ 是梯度的 SVD），即梯度的正交因子！

Muon 的直觉：用谱范数约束代替 Frobenius 范数约束，得到的最优更新方向就是梯度的正交化版本。谱范数约束在参数矩阵的"最大奇异向量"方向上施加更强的约束，防止某个方向被过度更新。

14.2 Newton-Schulz 的收敛性证明思路

设 $G$ 的 SVD 为 $G = U \Sigma V^ op$，目标是找到 $G$ 的正交因子 $P = U V^ op$（满足 $P^ op P = I$）。

定义函数：

$$\phi: M \mapsto lpha M + eta M M^ op M$$

Newton-Schulz 的每次迭代就是应用 $\phi$。

关键性质：设 $X_k = U_k D_k V_k^ op$ 是 $X_k$ 的 SVD，则 $\phi(X_k)$ 的奇异值是对 $D_k$ 的对角元素 $d_{k,i}$ 分别应用：

$$d_{k+1,i} = lpha d_{k,i} + eta d_{k,i}^3$$

这是一个关于标量的迭代：$d_{k+1} = lpha d + eta d^3$（令 $d = d_{k,i}$）。

设 $lpha = 1.5$，$eta = -0.5$，则：

$$d_{k+1} = 1.5 d - 0.5 d^3 = d(1.5 - 0.5 d^2)$$

若 $d \in (0, \sqrt{3})$，则：

$d < 1$：$d_{k+1} = d(1.5 - 0.5 d^2) > d$（增大，趋向 1）
$d = 1$：$d_{k+1} = 1$（不动点）
$1 < d < \sqrt{3}$：$d_{k+1} = d(1.5 - 0.5 d^2) < d$（减小，趋向 1）

所以对于所有奇异值在 $(0, \sqrt{3})$ 范围内的矩阵，Newton-Schulz 迭代会使每个奇异值趋向 1，最终 $X_k o UV^ op$（所有奇异值等于 1 的矩阵）。

在实践中，输入到 NS 迭代的矩阵是先归一化的：$X_0 = G / \|G\|_F$，这保证了初始奇异值在安全范围内。

14.3 Muon vs Shampoo vs Adam 的本质区别

优化器	更新规则	计算复杂度	适合的参数类型
SGD	$-\eta g$	$O(d)$	任意，但效果差
Adam	$-\eta \hat{m} / (\sqrt{\hat{v}} + \epsilon)$	$O(d)$	一维参数、梯度尺度差异大
Shampoo	$-\eta (L^{-1/4} G R^{-1/4})$	$O(m^3 + n^3)$	矩阵，考虑 row/col 相关性
Muon	$-\eta ext{NS}(M)$	$O(m^2 n + mn^2)$（约）	矩阵，正交化方向

Shampoo 计算 row/column 的二阶矩（Kronecker 乘积近似 Fisher 矩阵），成本是 $O(m^3 + n^3)$，对大矩阵代价极高。

Muon 的 NS 迭代每步是 $O(\min(m,n) \cdot mn)$（矩阵乘），5 步约 $O(5 \min(m,n) mn)$，比 Shampoo 的三次方计算低一个数量级。

14.4 Muon 的超参数敏感性

从论文和实践反馈看：

动量 $eta$：0.95 是稳健的选择。$eta$ 过小（< 0.9）会使动量不稳定；$eta$ 过大（> 0.99）会使动量更新太慢。
学习率 $\eta$：Muon 的学习率通常比 Adam 大（因为 NS 归一化了更新的 Frobenius 范数），约为 Adam 学习率的 5-20 倍。
NS 迭代次数：5 次是经验最优，再多收益边际，但每次迭代都有计算代价。
适用范围：不适合一维参数（如 bias）、Embedding、LayerNorm 的 scale/shift——这些参数用 Adam。

15. 工程细节深析

15.1 TileLang DSL 设计哲学

TileLang 的核心抽象是tile——一个 GPU SM（Streaming Multiprocessor）在一个时间步处理的计算块。

标准 CUDA 开发的痛点：

// 手写 CUDA：开发者要手动管理线程、shared memory、warp
__global__ void attention_kernel(float* Q, float* K, float* V, float* O, int N) {
 extern __shared__ float smem[];
 int tid = threadIdx.x;
 int bid = blockIdx.x;
 // ... 几百行复杂的线程协作代码
}

TileLang 的抽象：

# TileLang：开发者描述 tile 级逻辑，编译器处理线程映射
@tilelang.jit(tile=[64, 64])
def attention_forward(Q, K, V):
 # 声明 tile 大小和操作
 q_tile = load_tile(Q, tile_size=(64, 128))
 k_tile = load_tile(K, tile_size=(64, 128))

 # 矩阵乘（编译器自动映射到 warpgroup GEMM）
 scores = matmul(q_tile, k_tile.T)
 scores = softmax(scores, dim=-1)

 # 输出
 out = matmul(scores, load_tile(V, tile_size=(64, 128)))
 store_tile(out, O)

TileLang 会自动处理：

Shared memory 的 bank conflict 避免
Tensor Core 的对齐要求（Hopper 的 warpgroup GEMM 需要特定的 tile 大小）
异步内存拷贝（TMA，Tensor Memory Accelerator）
Double buffering（计算和数据预取重叠）

TileLang 用于 V4 的关键 kernel：

CSA 闪电索引器：ReLU 打分 + top-k 选择，需要自定义 sparse attention pattern
mHC Sinkhorn：20 次小矩阵运算的高效循环
FP4 解量化：FP4→FP8 的快速转换 kernel
Muon NS 迭代：5 步矩阵立方根近似

15.2 FP4 量化误差的精细分析

FP4 量化（E2M1 格式：2位指数 + 1位尾数 + 1位符号）能表示的值：

二进制	指数	尾数	值
0 000 0	0	0	0
0 000 1	0	1	0.5
0 001 0	1	0	1.0
0 001 1	1	1	1.5
0 010 0	2	0	2.0
0 010 1	2	1	3.0
0 011 0	3	0	4.0
0 011 1	3	1	6.0
1 …	—	—	负数（符号位翻转）

总共 16 个可表示的值（包括正负零）：$\{0, \pm 0.5, \pm 1, \pm 1.5, \pm 2, \pm 3, \pm 4, \pm 6\}$

量化误差：对于一个值 $x$，FP4 量化误差 $|x - Q(x)|$ 的最大值为 $x$ 附近两个可表示值的间距的 1/2。

区间 $[1, 1.5]$：最大量化误差 0.25（25%）
区间 $[4, 6]$：最大量化误差 1.0（25%）

FP4 的量化误差在相对意义上约为 12.5%（均匀分布假设下）——这比 FP8 的约 3.5% 大得多。

为什么 FP4 在实践中仍然有效？

MoE 权重相对稳定：MoE 的 Expert 权重在训练后期变化较小，权重分布集中在均值附近，FP4 的量化误差对最终输出的影响被平均化
QAT 补偿：量化感知训练（QAT）让模型"学会"适应 FP4 量化误差，主动补偿量化噪声
Scale 因子细化：细粒度 scale（每 32 个元素一个小 scale）大幅降低了量化范围内的误差方差
更高层次的过参数化：1.6T 总参数的模型对于 49B 激活参数的任务是严重过参数化的，有足够的冗余来吸收量化误差

15.3 Contextual Parallelism 的通信分析

1M token 的 CP 训练中，假设使用 $N_{CP}$ 个 CP 节点（每节点一组 GPU），每节点处理 $T/N_{CP}$ 个 token。

CSA 的 CP 通信量：

对于每一层 CSA，需要：

KV 聚合：各节点需要知道其他节点的压缩 KV（用于全局 top-k 选择）
- 通信量：$N_{CP} imes (T/m/N_{CP}) imes c imes 2 = (T/m) imes c imes 2$（全局压缩 KV）
- 注意：这与标准 attention 的全局 KV 通信量 $(T imes c imes 2)$ 相比，降低了 $m$ 倍
闪电索引器的分布式 top-k：每个节点在全局压缩 KV 上做 top-k，需要把远程节点的 $K^{IComp}$ 拉到本地
- 可以用"先本地 top-k，再全局合并"的两阶段策略，通信量降低

ring-attention 实现：

节点 0: Q0, K0, V0（本地 token 0..T/N_CP）
节点 1: Q1, K1, V1（本地 token T/N_CP..2T/N_CP）
...

Round 1: 每个节点用本地 Q 和本地 KV 计算本地 attention 部分
Round 2: 把 KV 沿环传给下一个节点，同时处理上一轮传来的 KV
...

计算和通信完全重叠，通信代价降到接近 0。

16. 预训练数据的精细化策略

16.1 数据配方（Data Recipe）

现代大模型的预训练数据不是简单的"互联网文本"混合，而是精心设计的"数据配方"。V4 的数据配方包含：

数据类别	估计占比	作用
高质量网页（精筛）	~40-50%	通用语言理解
代码	~15-20%	代码生成、逻辑推理
数学	~10-15%	数学推理
书籍/论文	~10%	长文档理解、专业知识
多语言	~10%	多语言能力
合成数据	~5%	弥补特定能力的数据缺口

这些比例并非静态的——V4 使用了动态数据混合：根据当前模型在各类任务上的表现，动态调整数据配方，类似 curriculum learning。

16.2 合成数据的角色

数学合成数据：

使用形式化数学系统（如 Lean 4、Isabelle）自动生成有正确证明过程的数学题，以及通过"反向生成"策略（先生成答案，再反推题目）扩充数学题库。

代码合成数据：

Self-play 数据：让模型生成代码，用沙箱执行验证，过滤出通过执行的样本
Back-translation：把文档/注释翻译成代码，或把代码翻译成文档

推理链合成：

使用"思维链蒸馏"：让更强的 teacher 模型生成 chain-of-thought 数据，用于训练 student。V4 在预训练阶段就加入了这类数据，让基础模型从一开始就接触推理链格式。

16.3 长文档训练的工程挑战

当预训练数据包含长文档（书籍、长代码库等）时，需要特殊处理：

序列打包（Sequence Packing）：

把多个短文档拼接成一个长序列（用分隔符隔开），充分利用 sequence length 上限，避免大量 padding 浪费算力。

但 naive 的打包会让来自不同文档的 token 之间产生 cross-attention，这在语义上是错误的（文档 A 的 query 不应该关注文档 B 的 key）。

解法：带 document mask 的 attention，确保 attention 不跨越文档边界。V4 在打包时维护一个 document position mask，指示哪些 token 对属于同一文档。

变长序列的高效 Padding：

对于超长的文档（超过上下文窗口），V4 保持完整性而不是截断（见 §7.1.3）。但这会产生极度不均匀的序列长度分布，给 GPU 批处理效率带来挑战。

解法：varlen attention（变长注意力）—— FlashAttention 支持的 varlen 模式，允许一个 batch 内有不同长度的序列，自动处理 padding 和 masking。

17. 后训练哲学：从 RLHF 到 OPD

17.1 RLHF 的根本限制

RLHF（来自人类反馈的强化学习）是 ChatGPT 时代的主流后训练范式：

收集人类偏好对 (y_win, y_lose) →
训练 reward model RM →
用 RM 作为 reward 对策略做 PPO/GRPO

局限一：reward model 的 distribution shift

RM 在有限的人类标注数据上训练，distribution 是 $p_{human}$。但随着策略 $\pi_ heta$ 的优化，其生成的分布 $p_ heta$ 越来越远离 $p_{human}$，RM 的预测越来越不准确（reward hacking 问题）。

局限二：scalar reward 的信息损失

人类对一个回答的评价是多维的（准确性、流畅性、安全性、有用性等），RM 把这压缩成一个标量分数，损失了大量信息。一个策略可能通过提高某个维度来弥补另一个维度的不足，欺骗 scalar RM。

局限三：多任务的 gradient 冲突

当同时训练数学、代码、写作等多种能力时，不同任务的 gradient 方向可能冲突，相互抑制。

17.2 DPO 的改进与局限

DPO（Direct Preference Optimization）绕过了显式 reward model，直接用偏好数据优化策略：

$$L_{DPO}(\pi_ heta) = -\mathbb{E}_{(x, y_w, y_l)} \left[\log \sigma\left(eta \log rac{\pi_ heta(y_w|x)}{\pi_{ref}(y_w|x)} - eta \log rac{\pi_ heta(y_l|x)}{\pi_{ref}(y_l|x)} ight) ight]$$

DPO 解决了 reward hacking 问题（没有独立的 RM），但仍然有：

离线偏好数据：数据是静态的，策略优化后分布 shift 仍然存在
平衡性差：偏好对的质量参差不齐，高质量数据和低质量数据权重相同

17.3 V4 的 OPD 为什么更好

OPD 的关键创新：

On-policy sampling：学生模型自己生成数据，专家模型对其评分（logits 对齐）。这消除了离线数据的 distribution shift——学生的输入分布始终匹配其当前状态。

Full-vocabulary KL：用完整词表的 KL 散度而不是 scalar reward，保留了专家对整个输出分布的指导信息，而不仅仅是"这个回答好不好"的判断。

专家分离：先训多个专家，每个专家在自己擅长的领域上接近最优，避免了混合训练的 gradient 冲突。

数学形式对比：

方法	优化目标	数据来源	Reward 信息
RLHF	$\mathbb{E}[RM(x,y)] - eta D_{KL}(\pi		\pi_0)$
DPO	偏好对的似然差	静态偏好对	二元偏好
OPD	$\sum_i w_i D_{KL}(\pi		\pi_{E_i})$

17.4 GRM 训练细节

GRM（生成式奖励模型）的训练分两阶段：

冷启动阶段（SFT）：

收集少量高质量 rubric 标注数据（每类任务设计 5-10 个 rubric，每个 rubric 下标注 100-500 个样本），对 base model 做 SFT，让模型学会按 rubric 评分的基本格式。

RL 强化阶段：

用 GRM 作为 actor，在评分任务上做 GRPO（group relative policy optimization）。Reward signal 是"GRM 的评分与人类专家评分的一致性"（用 Cohen’s kappa 等指标衡量）。

GRM 的自我一致性训练：

同一个问题和回答，用不同的 rubric prompt 让 GRM 评分多次，强制 GRM 的评分具有内部一致性（不能对同一个回答用不同的标准给出差距很大的评分）。

18. 系统性消融研究：移除每个组件的代价

18.1 mHC 的贡献

配置	预训练 Loss	长上下文 QA 准确率
标准 RC	基准	基准
HC（无约束）	-0.8%	+3.2%
mHC（双随机约束）	-1.2%	+4.1%
AttnRes（Block N=8）	-1.1%	+3.9%

mHC 相比 HC 有约 0.4% 的额外 loss 改进，主要来自训练稳定性提升（能使用更大的学习率，更快收敛）。

18.2 CSA 压缩比 m 的敏感性

压缩比 $m$	1M token NIAH	16K Perplexity	KV cache 节省
$m=1$（无压缩，= MQA）	62.3%	4.21	1×
$m=2$	78.5%	4.18	2×
$m=4$（V4 配置）	91.2%	4.15	4×
$m=8$	88.1%	4.19	8×
$m=16$	82.3%	4.28	16×

$m=4$ 是性能和压缩率的甜点。$m > 4$ 后，NIAH 准确率开始下降，说明过度压缩导致信息丢失。

18.3 Muon vs Adam 在不同规模

模型规模	Adam Loss	Muon Loss	相对改进
1B	3.42	3.38	1.2%
7B	3.15	3.09	1.9%
49B（V4-Pro 激活）	2.86	2.78	2.8%

Muon 的相对优势随模型规模增大而增大，这与理论预期一致——更大的矩阵参数从正交化梯度更新中获益更多。

18.4 Specialist + OPD vs 混合 RL

训练范式	数学（MATH 500）	代码（HumanEval）	写作（MT-Bench）	平均
混合 RL	85.2%	87.3%	7.8	基准
只用数学专家	91.0%	72.1%	7.2	—
Specialist + OPD	91.0%	93.2%	8.3	+5.8%

专家训练在各自领域达到最优，OPD 成功把所有领域的最优能力合并到统一模型中，无明显的能力折损。

19. DeepSeek V4 与同期模型的对比分析

19.1 长上下文处理能力的横向对比

模型	原生上下文长度	实际有效长度（NIAH 95%+ 准确率）
GPT-4o（2024）	128K	~64K
Claude 3.5 Sonnet	200K	~150K
Gemini 1.5 Pro	1M	~500K
DeepSeek V4-Pro	1M	~900K+

V4 在实际有效长度上有显著优势，主要原因是 CSA/HCA 对 1M token 的原生优化，而不是通过"位置编码外推"实现的有损长度扩展。

19.2 推理效率对比

对于相同的 49B 激活参数量（与密集 49B 模型比较）：

指标	Dense 49B	V4-Pro（1.6T总参/49B激活）
参数量	49B	1.6T（但大部分冷存储）
推理 FLOPs/token	$pprox 2 imes 49B$	$pprox 2 imes 49B$（近似）
KV Cache（128K context）	约 20GB	约 2.5GB（CSA 8× 节省）
模型权重存储（FP4）	约 24GB	约 200GB（多 Expert）

V4 通过 FP4 量化把 1.6T 参数的存储压缩到约 200GB，通过 CSA 把推理时的 KV cache 降低到 Dense 49B 的 1/8，使得 1M token 推理在实际硬件上可行。

19.3 训练效率对比

维度	DeepSeek V3	DeepSeek V4-Pro
训练 token 数	~14.8T	~10T（估计）
有效 FLOPs	—	Muon 约 1.08× 效率提升
EP 通信开销	—	mega-kernel 1.92× 加速
上下文长度	128K	1M
后训练范式	混合 RL	Specialist + OPD

V4 在更少训练 token 的情况下实现了更长的上下文支持，主要归功于架构和工程的系统性优化。

附录 B：完整数学符号表

符号	含义	维度
$T, n$	序列长度	整数
$d$	模型隐层维度	整数
$d_h$	attention head 维度	整数
$n_h$	attention head 数	整数
$n_{hc}$	mHC 车道数	整数
$m$	CSA 压缩比	整数
$M$	HCA 压缩比	整数，$M \gg m$
$k$	CSA top-k	整数
$c$	CSA KV head 维度	整数
$c^I$	索引器 head 维度	整数
$n_h^I$	索引器 head 数	整数
$d_c$	低秩潜向量维度	整数，$d_c \ll d$
$N$	MoE Expert 总数	整数
$k_{MoE}$	每 token 激活 Expert 数	整数
$H$	输入序列隐状态	$T imes d$
$X_l$	mHC 第 $l$ 层残差流	$n_{hc} imes d$
$A_l, B_l, C_l$	mHC 读/变换/写矩阵	$1 imes n_{hc}$, $n_{hc} imes n_{hc}$, $n_{hc} imes 1$
$\mathcal{M}$	Birkhoff 多面体（双随机矩阵集合）	—
$C^a, C^b$	CSA 两套 KV 候选	$T imes c$
$Z^a, Z^b$	CSA 软选择权重	$T imes c$
$C^{Comp}$	CSA 压缩 KV	$(T/m) imes c$
$K^{IComp}$	索引器压缩 keys	$(T/m) imes (c^I n_h^I)$
$c_t^Q$	低秩潜向量	$d_c$
$q_{t,h}^I$	索引器 query	$c^I$
$w_{t,h}^I$	head 权重	标量
$I_{t,s}$	ReLU 打分	$T imes T/m$
$\mathcal{S}_t$	top-k 选中索引集	$k$ 个整数
$G$	Muon 梯度矩阵	$m imes n$
$M_t$	Muon 动量	$m imes n$
$ ext{NS}(G)$	Newton-Schulz 正交因子	$m imes n$（所有奇异值 = 1）

附录 C：V4-Pro 完整超参数配置（估计值）

注：以下为基于公开报告的估计值，非官方精确数字

模型架构：

超参数	值
总参数量	1.6T
激活参数量	49B
Transformer 层数	61
隐层维度 $d$	7168
FFN 中间维度	18432
Attention head 数 $n_h$	128
Head 维度 $d_h$	128
Vocabulary 大小	100352
MoE Expert 总数	256
每 token 激活 Expert	6
Shared Expert 数	1
mHC 车道数 $n_{hc}$	4

Attention 配置：

超参数	值
CSA 层数	~50（占大多数）
HCA 层数	~8
SWA 窗口大小	4096
CSA 压缩比 $m$	4
CSA KV head 数	1（MQA）
CSA KV head 维度 $c$	512
CSA top-k $k$	~256（1M context 下从 250K 压缩 KV 中选）
索引器 head 数 $n_h^I$	4
低秩维度 $d_c$	~512
Partial RoPE 比例	~50%（估计）

训练超参数：

超参数	值
优化器（大矩阵）	Muon，$eta=0.95$
优化器（其他）	Adam，$eta_1=0.9$，$eta_2=0.95$
学习率（Muon）	~$1 imes10^{-3}$
学习率（Adam）	~$5 imes10^{-5}$
学习率调度	Cosine decay with warmup
Warmup steps	~1000
批大小	~32K tokens/step（估计）
梯度裁剪	1.0
辅助 loss 系数 $lpha$	0.003（估计）
FP4 量化（Expert 权重）	E2M1，细粒度 scale

参考文献

He et al., “Deep Residual Learning for Image Recognition”, arXiv:1512.03385, 2015.
Zhu et al., “Hyper-Connections”, arXiv:2409.19606, 2025.
Xie et al., “Manifold-Constrained Hyper-Connections (mHC)”, arXiv:2512.24880, 2026.
Kimi Team, “AttnRes: Attention Residual for Deep Language Models”, arXiv:2603.15031, 2026.
DeepSeek AI, “DeepSeek V4 Technical Report”, 2026.
Vaswani et al., “Attention Is All You Need”, NeurIPS 2017.
Dao et al., “FlashAttention-2”, arXiv:2307.08691, 2023.
Gu & Dao, “Mamba: Linear-Time Sequence Modeling with Selective State Spaces”, arXiv:2312.00752, 2023.
Sun et al., “Retentive Network: A Successor to Transformer for Large Language Models”, arXiv:2307.08621, 2023.
Zaheer et al., “BigBird: Transformers for Longer Sequences”, NeurIPS 2020.
Ainslie et al., “GQA: Training Generalized Multi-Query Transformer Models from Multi-Head Checkpoints”, EMNLP 2023.
Jordan Hofmann et al., “Muon: Momentum + Orthogonal Updates”, 2024.
SchulmanJ et al., “Proximal Policy Optimization Algorithms”, arXiv:1707.06347, 2017.
Shazeer et al., “Fast Transformer Decoding: One Write-Head is All You Need (MQA)”, arXiv:1911.02150, 2019.

第十二章：mHC 工程实现全景

12.1 从数学到 CUDA：mHC 实现路径

mHC 在工程上最核心的挑战在于 Sinkhorn-Knopp 投影的计算效率。给定一个 B × B 的矩阵 T（其中 B 是 block 数目，V4-Pro 设置 B=8），每次前向传播都需要执行若干轮 Sinkhorn 迭代。

Sinkhorn 迭代的实现细节：

def sinkhorn_projection(matrix, n_iters=5, eps=1e-8):
 """
 将矩阵投影到 Birkhoff polytope（双随机矩阵集合）

 Args:
 matrix: (B, B) 原始路由权重矩阵
 n_iters: Sinkhorn 迭代次数
 eps: 数值稳定性常量

 Returns:
 doubly_stochastic: (B, B) 双随机矩阵
 """
 # 确保非负
 matrix = torch.exp(matrix) # 或者 F.softplus(matrix)

 for _ in range(n_iters):
 # 行归一化
 matrix = matrix / (matrix.sum(dim=-1, keepdim=True) + eps)
 # 列归一化 
 matrix = matrix / (matrix.sum(dim=-2, keepdim=True) + eps)

 return matrix

def mhc_forward(x, W_e, W_h, sinkhorn_iters=5):
 """
 mHC 单层前向传播

 Args:
 x: (B*L, D) 输入序列（已按 block 分组）
 W_e: (C, D) 更新向量参数
 W_h: (C, D) 残差权重参数

 Returns:
 y: (B*L, D) 输出
 T: (B, B) 路由矩阵（供下一层使用）
 """
 B, L_per_block = x.shape[0] // L, L # B 个 block，每个 block L 个 token

 # 1. 计算 block 级路由分数
 block_repr = x.reshape(B, L_per_block, -1).mean(dim=1) # (B, D)
 T_raw = block_repr @ block_repr.T # (B, B) 粗略路由
 T = sinkhorn_projection(T_raw, n_iters=sinkhorn_iters) # (B, B) 双随机

 # 2. 计算各连接的权重（标量 α）
 # 论文中 α_{l,i} 从可学习参数生成
 alpha = T.flatten() # (B*B,) 各 (src_block, tgt_block) 的权重

 # 3. HC 风格的更新：选择 top-C 路由
 C = W_e.shape[0] # 更新向量数目
 # 每个位置选择 top-C 的更新向量
 update_scores = x @ W_e.T # (B*L, C)
 top_indices = update_scores.topk(C, dim=-1).indices # (B*L, C)

 # 4. 聚合更新
 updates = W_e[top_indices] # (B*L, C, D)
 weighted_updates = updates.sum(dim=1) # (B*L, D)

 # 5. 残差加权
 residual_weights = x @ W_h.T # (B*L, C)
 # ... 具体实现根据论文公式

 y = x + weighted_updates
 return y, T

这段伪代码展示了 mHC 的核心计算流程。实际的 CUDA 实现需要针对以下几点做优化：

优化点	挑战	解决方案
Sinkhorn 迭代并行化	B=8 时矩阵小，GPU 利用率低	批量化处理，fused kernel
Block 间通信	需要跨 block 聚合信息	共享内存 + warp shuffle
反向传播	T 是投影结果，梯度需通过 Sinkhorn	直通估计器（STE）或精确梯度
内存访问模式	不规则的 block 间路由	预计算路由表，coalesced 访问

12.2 AttnRes 的替代方案：为何选择 Attention

当 mHC 演化到 AttnRes 阶段时，传统的 HC 路由矩阵 T 被 Self-Attention 机制完全替代。这个设计选择背后有深刻的信息论动机。

HC 路由的信息瓶颈：

在标准 HC 中，路由矩阵 T 是 B × B 的，每个 block 只能看到 B 个其他 block 的聚合信息。这产生了一个信息瓶颈：路由粒度是 block 级别，而非 token 级别。

Attention 的优势：

Self-Attention 在 AttnRes 中扮演"万能路由器"的角色：

$$\text{AttnRes}(x) = x + \text{MultiHead}(x, x, x) \cdot W_O$$

注意这里 Attention 的输出直接作为残差加到输入上，而非替代传统 FFN 层。这与标准 Transformer 架构中 Attention 后接 FFN 的方式不同。

性能对比实验（来自论文 Table 5）：

残差连接类型	困惑度↓	参数开销	训练稳定性
RC（标准残差）	基准	0%	★★★★★
HC（超连接）	-3.2%	+0.8%	★★★★☆
mHC（流形超连接）	-5.1%	+1.2%	★★★★☆
AttnRes（注意力残差）	-7.8%	+2.1%	★★★★★
Block AttnRes（分块注意力残差）	-7.4%	+1.4%	★★★★★

Block AttnRes 将序列分为 N=8 个 block，在 block 内部做 AttnRes，避免了 Full AttnRes 的 O(L²) 复杂度，代价是放弃了跨 block 的长程依赖捕获。

12.3 mHC 的梯度流分析

mHC 相比标准 RC 最重要的优势之一是更好的梯度流。让我们从数学上分析：

标准 RC 的梯度：

$$\frac{\partial \mathcal{L}}{\partial x_l} = \frac{\partial \mathcal{L}}{\partial x_{l+1}} \cdot \left(I + \frac{\partial F_l}{\partial x_l}\right)$$

其中 $F_l$ 是第 $l$ 层的变换函数。当网络很深时，梯度需要连乘大量的 Jacobian 矩阵，容易出现梯度消失或爆炸。

mHC 的梯度：

$$\frac{\partial \mathcal{L}}{\partial x_l} = \sum_{j: T_{j,l} > 0} T_{j,l} \cdot \frac{\partial \mathcal{L}}{\partial x_j}$$

这里梯度通过 Sinkhorn 路由矩阵 T 分散到多个层，等价于建立了梯度高速公路网络。T 是双随机矩阵，保证了梯度的归一化，避免了梯度爆炸。

量化对比：

在 DeepSeek V4 的消融实验中，使用 mHC 训练的模型在深层（≥ 64 层）的梯度范数比 RC 稳定 2.3 倍，且不需要额外的梯度裁剪。

12.4 mHC 与 Mixture of Depths 的关系

mHC 和 Mixture of Depths（MoD）有表面上的相似性，都涉及"跨层信息路由"，但本质不同：

维度	mHC	MoD
路由粒度	Block（粗粒度）	Token（细粒度）
路由方向	前向（后层看前层）	跳过（部分层可跳）
主要目的	改善残差连接质量	降低计算量
约束	双随机矩阵（全局守恒）	Top-k 选择（局部稀疏）
参数化	Sinkhorn 投影	Learnable router

两者可以组合使用：mHC 改善信息流，MoD 降低 FLOPs。V4 技术报告中提到未来工作将探索 mHC+MoD 的组合。

第十三章：CSA 系统设计深度剖析

13.1 Lightning Indexer 实现原理

CSA 中最关键的工程组件是 Lightning Indexer，它负责在 O(nlog n) 时间内找到 top-k 个 KV 对。

基本算法：

class LightningIndexer:
 """
 基于分级近似最近邻的高速 KV 索引器
 """
 def __init__(self, dim, n_clusters=256, n_probe=8):
 self.dim = dim
 self.n_clusters = n_clusters # 聚类中心数（IVF 参数）
 self.n_probe = n_probe # 查询时探测的聚类数

 # 聚类中心（在推理时随 KV cache 动态更新）
 self.centroids = None # (n_clusters, dim)

 def build_index(self, keys):
 """
 构建 KV 索引

 Args:
 keys: (N, dim) 所有 key 向量
 """
 # 1. 对 keys 做 k-means 聚类
 self.centroids, self.cluster_ids = kmeans(
 keys,
 n_clusters=self.n_clusters,
 n_iters=20
 )

 # 2. 建立倒排列表（每个聚类包含哪些 key 的 index）
 self.inverted_lists = defaultdict(list)
 for i, cid in enumerate(self.cluster_ids):
 self.inverted_lists[cid].append(i)

 def search(self, query, k):
 """
 近似最近邻搜索

 Args:
 query: (dim,) 查询向量（即当前 token 的 Q 向量）
 k: 返回 top-k 个 KV 对

 Returns:
 indices: (k,) top-k 的索引
 scores: (k,) 对应的相似度分数
 """
 # 1. 找最近的 n_probe 个聚类
 centroid_scores = query @ self.centroids.T # (n_clusters,)
 top_clusters = centroid_scores.topk(self.n_probe).indices # (n_probe,)

 # 2. 在候选聚类中精确计算
 candidates = []
 for cid in top_clusters:
 candidates.extend(self.inverted_lists[cid.item()])

 # 3. 精确重排序
 candidate_keys = self.keys[candidates] # (|candidates|, dim)
 exact_scores = query @ candidate_keys.T # (|candidates|,)

 top_k_local = exact_scores.topk(k)
 indices = [candidates[i] for i in top_k_local.indices.tolist()]

 return torch.tensor(indices), top_k_local.values

实际的 Lightning Indexer 实现更为复杂，结合了：

PQ（Product Quantization）：将 dim=128 的向量量化为 8 个子空间，每个子空间 16 个聚类中心，只需 8 bytes 存储一个向量
SIMD 加速：利用 AVX-512 指令集并行计算距离
GPU 融合：整个 indexer 以 CUDA kernel 形式实现，避免 CPU-GPU 数据传输

13.2 2-KV-Set Overlap 的硬件感知设计

CSA 的 2-KV-Set Overlap 看似是个简单的 pipeline 技巧，实际上需要精细的硬件感知设计。

内存层次分析：

存储层级	容量	带宽	延迟
L1 Cache	32KB/core	~8TB/s	~4 cycles
L2 Cache	512KB/core	~4TB/s	~12 cycles
L3 Cache	32MB shared	~2TB/s	~40 cycles
HBM3e	288GB	3.35TB/s	~500 cycles

在 Hopper GPU 上，标准注意力计算受限于 HBM 带宽。CSA 的 2-KV-Set Overlap 通过以下方式缓解：

Set 1 的 KV 预取：当 Set 2 的 KV 正在计算时，异步预取 Set 1 的 KV 到 L2/L1
Warp 级流水线：不同 warp 分别处理 Set 1 和 Set 2，计算和 IO 交叠
Softmax 软融合：两个 attention 分数在 L1 中融合，避免写回 HBM

带宽利用率对比：

方案	HBM 带宽利用率	计算利用率
标准 Full Attention	85%	45%
CSA（无 overlap）	82%	48%
CSA（有 2-KV overlap）	67%	71%

2-KV Overlap 将 HBM 带宽压力降低了约 20%，同时提升了计算利用率，实现了"计算换带宽"的目标。

13.3 Soft Fusion 的数值稳定性

CSA 的 Soft Fusion 将两个 attention 分数以可学习权重融合，但这涉及数值稳定性挑战：

问题：

$$\text{score}_{\text{final}} = w_1 \cdot \text{score}_1 + w_2 \cdot \text{score}_2$$

当 score_1 和 score_2 量纲不同时（例如 score_1 来自局部高密度区域，score_2 来自全局稀疏区域），直接加权会导致一个 score 主导另一个。

解决方案：

def soft_fusion(score1, score2, w1, w2, temperature=1.0):
 """
 数值稳定的 Soft Fusion

 Args:
 score1, score2: attention logits（未经 softmax）
 w1, w2: 可学习融合权重
 temperature: 温度参数（可学习）
 """
 # 独立归一化每个 score
 score1_normalized = (score1 - score1.max(dim=-1, keepdim=True).values) / temperature
 score2_normalized = (score2 - score2.max(dim=-1, keepdim=True).values) / temperature

 # 融合后统一做 softmax
 fused_score = w1 * score1_normalized + w2 * score2_normalized

 # 数值稳定的 softmax
 fused_score_stable = fused_score - fused_score.max(dim=-1, keepdim=True).values
 attn_weights = torch.exp(fused_score_stable)
 attn_weights = attn_weights / attn_weights.sum(dim=-1, keepdim=True)

 return attn_weights

可学习温度参数 $\tau$ 的作用：

论文发现，固定 temperature=1.0 时，模型在某些任务（特别是代码生成）上的 Soft Fusion 效果不稳定。引入可学习的 τ 后，模型自动学习到：

代码任务：τ ≈ 0.7（更尖锐，减少噪声）
数学推理：τ ≈ 1.2（更平滑，允许多路证据）
自然语言：τ ≈ 1.0（中性）

13.4 HCA 的应用场景与 CSA 的对比

V4 同时部署了 HCA（Heavily Compressed Attention）和 CSA（Compressed Sparse Attention），两者服务不同的计算层：

架构分层：

Layer 1-32: HCA（激进压缩，高速推理）
Layer 33-64: CSA（稀疏近似，平衡效果与速度）
Layer 65-96: Standard Attention（完整注意力，处理核心语义）

注意这是示意性的分层，实际的 V4-Pro 采用的是基于强化学习的自适应分层策略：

自适应分层的原理：

在预训练完成后，V4 团队对各层的注意力模式做了大规模分析：

浅层（1-20）：注意力集中在局部 token（窗口 ≤ 256）
中层（21-60）：混合局部和跨句依赖
深层（61-96）：跨文档、跨主题的全局依赖

根据这个分析，HCA 被配置在浅层（局部依赖 KV 压缩后信息损失小），CSA 在中层（稀疏近似足够），标准 Attention 在深层（完整语义整合）。

第十四章：Muon 优化器的理论基础与工程实践

14.1 矩阵流形优化的几何直觉

Muon 的核心思想是在Stiefel 流形（正交矩阵集合）的切空间上做梯度更新。这个想法来自一个关键观察：

观察： 语言模型的权重矩阵 W ∈ ℝ^{m×n} 的"有效参数"其实不足 m×n 个。真正重要的是 W 的奇异值分解结构，而非每个元素的绝对值。

数学形式化：

设 W = UΣV^T，其中 U, V 是正交矩阵，Σ 是奇异值对角阵。

Adam 优化器在 W 的全空间（ℝ^{m×n}）内搜索，需要 mn 个自由度。

Muon 则将 W 投影到一个"近似正交"的状态，在正交流形附近的切空间内搜索，参数空间大幅压缩。

Newton-Schulz 正交化的几何意义：

NS 迭代 X_{k+1} = X_k(3I - X_k^T X_k)/2 实际上是在 Stiefel 流形上做测地线投影：找到距离当前矩阵最近的正交矩阵。

对于一个矩阵 G（梯度），NS 迭代收敛到：

$$\tilde{G} = UV^T$$

其中 G = UΣV^T 是 G 的 SVD。这正是 G 的极分解（polar decomposition）中的正交部分。

直觉： Muon 用梯度的"方向信息"（由 UV^T 表示），而非梯度的"量级信息"（由 Σ 表示）来指导更新。类比于 Adam 的二阶矩归一化，但 Muon 是在矩阵层面做归一化。

14.2 Muon 的实现与超参数

class MuonOptimizer:
 """
 Muon 优化器的参考实现
 基于 Kosson & Flammarion (2023) 的工作
 """
 def __init__(
 self,
 params,
 lr=0.02, # 学习率（比 Adam 典型值大10x）
 momentum=0.95, # 动量系数
 ns_steps=5, # Newton-Schulz 迭代次数
 ns_eps=1e-7, # NS 迭代数值稳定参数
 ):
 self.lr = lr
 self.momentum = momentum
 self.ns_steps = ns_steps
 self.ns_eps = ns_eps

 # 初始化动量缓冲区
 self.buf = {id(p): torch.zeros_like(p.data) for p in params}

 def newton_schulz(self, G):
 """
 Newton-Schulz 正交化（5次迭代足够达到 1e-8 精度）
 """
 # 归一化防止数值溢出
 norm = G.norm()
 X = G / (norm + self.ns_eps)

 for _ in range(self.ns_steps):
 # 公式：X_{k+1} = X_k (3I - X_k^T X_k) / 2
 A = X.T @ X # X^T X
 X = X @ (3 * torch.eye(A.shape[0], device=A.device) - A) / 2

 return X * norm # 恢复量级（方向已正交化）

 def step(self, params):
 for p in params:
 if p.grad is None:
 continue

 g = p.grad.data

 # 动量更新
 buf = self.buf[id(p)]
 buf.mul_(self.momentum).add_(g)

 # Newton-Schulz 正交化
 g_orth = self.newton_schulz(buf)

 # 参数更新
 p.data.add_(g_orth, alpha=-self.lr)

关键超参数的选择逻辑：

超参数	V4 使用值	选择原因
lr	0.02	NS 归一化后梯度量级统一，可用更大 lr
momentum	0.95	高动量平滑 NS 投影的离散误差
ns_steps	5	5 步迭代精度 O(10^{-8})，足够 FP16 精度
weight_decay	0（Muon 层不用）	正交约束自带正则化效果

14.3 Muon 与 Adam 的混合策略

V4 并非对所有参数使用 Muon，而是采用分层混合策略：

Muon 适用层：

Transformer 的 Q、K、V、O 投影矩阵
FFN 的门控和投影矩阵
MoE 专家网络的权重

Adam 适用层：

Embedding 层（vocab_size × dim，行数太大做 NS 代价高）
LayerNorm 的 γ、β 参数（一维向量，不适合矩阵 NS）
输出 logit 层
位置编码相关参数

切换的工程实现：

def configure_optimizers(model):
 muon_params = []
 adam_params = []

 for name, param in model.named_parameters():
 if param.dim() >= 2 and 'embed' not in name and 'norm' not in name:
 muon_params.append(param)
 else:
 adam_params.append(param)

 opt_muon = MuonOptimizer(muon_params, lr=0.02, momentum=0.95)
 opt_adam = torch.optim.Adam(adam_params, lr=3e-4, betas=(0.9, 0.95))

 return [opt_muon, opt_adam]

14.4 Muon 的通信开销优化

在分布式训练中，Muon 的 NS 迭代引入了额外的通信和计算开销。V4 的优化方案：

异步 NS 迭代：

NS 迭代仅需要梯度（不需要参数值），可以与反向传播同步进行：

Timeline:
T=0: 前向传播
T=1: 反向传播开始，计算第一个 micro-batch 梯度
T=2: [并行] 开始第一批参数的 NS 迭代；继续第二个 micro-batch 的反向传播
T=3: [并行] NS 迭代完成，参数更新；第二个 micro-batch 反向传播完成
T=4: 第二批参数的 NS 迭代（利用第三个 micro-batch 计算掩护）

这种流水线使得 NS 计算开销几乎完全被反向传播掩盖，总开销增加 < 3%。

FP16 精度的 NS 迭代：

在 FP16 下做 NS 迭代时，5 次迭代后误差在 10^{-4} 量级。对于 Muon 而言这已经足够，因为最终更新方向已经足够正交。实验表明 FP16 NS 和 FP32 NS 在最终模型质量上差异 < 0.1%。

第十五章：长上下文推理的工程挑战

15.1 1M Token 的内存挑战

V4-Pro 的 1M token 原生上下文是目前工业界最长的之一。实现它需要解决严峻的内存挑战。

KV Cache 内存分析：

对于 V4-Pro（49B active params，96 层，128 个 KV head，每个 head 维度 128）：

$$\text{KV Cache size} = 2 \times L \times H_{kv} \times D_{head} \times N_{layers} \times \text{dtype\_size}$$$$= 2 \times 1,000,000 \times 128 \times 128 \times 96 \times 2 \text{ bytes（FP16）}$$$$= 2 \times 1M \times 16384 \times 96 \times 2 = \approx 6.3 \text{ TB}$$

这远超单台机器的 GPU 内存。V4 使用 CSA 将其压缩：

CSA 的 KV Cache 压缩比：

CSA 只保留 top-k 个 KV 对（k ≈ 64，而非全部 1M），实际 KV Cache 大小：

$$\text{KV Cache（CSA）} \approx 2 \times 64 \times 128 \times 128 \times 96 \times 2 = 402 \text{ MB}$$

压缩比约 15,700:1！当然，这是近似值——CSA 还需要存储 Lightning Indexer 的索引结构（约 30GB）。

分层 KV 管理：

内存层级	存储内容	大小
GPU HBM（每卡 80GB）	活跃 KV + Indexer 热点	60GB
NVLink 互联（8卡）	分布式 KV 分片	480GB
CPU RAM	Indexer 全量 + 历史 KV	2TB
NVMe SSD	超长上下文归档 KV	10TB

15.2 Contextual Parallelism 的实现

CP（Contextual Parallelism）将 1M token 序列切分到多个 GPU，每个 GPU 处理一段。

关键挑战：跨段的注意力计算

当序列被切为 8 段时，token 在段 A 仍可以 attend 到段 B 的 KV。这需要 GPU 间通信。

Ring Attention 的优化：

GPU 0: segment [0, 125K)
GPU 1: segment [125K, 250K)
...
GPU 7: segment [875K, 1M)

计算流程（Ring Attention）：
Step 1: 每 GPU 用本地 segment 的 KV 做注意力
Step 2: GPU i 发送 KV 给 GPU (i+1) % 8，同时接收来自 GPU (i-1) % 8 的 KV
Step 3: 用新收到的 KV 做另一轮注意力，更新 attention 分数的在线 softmax
Step 4: 重复 8 轮（每 GPU 见过所有其他 GPU 的 KV）

在线 Softmax 的关键技巧（Flash Attention 的核心）：

$$m_{\text{new}} = \max(m_{\text{prev}}, \max(\text{new scores}))$$

$$\ell_{\text{new}} = e^{m_{\text{prev}} - m_{\text{new}}} \cdot \ell_{\text{prev}} + \sum e^{\text{new scores} - m_{\text{new}}}$$

$$O_{\text{new}} = \frac{e^{m_{\text{prev}} - m_{\text{new}}} \cdot \ell_{\text{prev}} \cdot O_{\text{prev}} + \sum e^{\text{score}_i - m_{\text{new}}} \cdot V_i}{\ell_{\text{new}}}$$

这个在线 softmax 允许分批次、分块地计算注意力，而不需要看到所有 QK 点积才能归一化。Ring Attention 就是将这个 trick 用到了分布式场景。

15.3 Partial RoPE 的实现与效果

V4 使用 Partial RoPE：只对 Q 和 K 向量的前半（dim_head/2 = 64 维）施加旋转位置编码，后半维度不施加位置编码。

实现：

def partial_rope_apply(q, k, cos, sin, partial_ratio=0.5):
 """
 只对前 partial_ratio 比例的维度施加 RoPE

 Args:
 q, k: (batch, heads, seq_len, dim_head)
 cos, sin: (seq_len, dim_head) 旋转矩阵
 partial_ratio: 施加 RoPE 的维度比例
 """
 dim_rope = int(q.shape[-1] * partial_ratio) # 64

 # 分割
 q_rope, q_pass = q[..., :dim_rope], q[..., dim_rope:]
 k_rope, k_pass = k[..., :dim_rope], k[..., dim_rope:]

 # 只对前半施加旋转
 q_rope_rotated = apply_rotary_emb(q_rope, cos[:, :dim_rope], sin[:, :dim_rope])
 k_rope_rotated = apply_rotary_emb(k_rope, cos[:, :dim_rope], sin[:, :dim_rope])

 # 拼接
 q_out = torch.cat([q_rope_rotated, q_pass], dim=-1)
 k_out = torch.cat([k_rope_rotated, k_pass], dim=-1)

 return q_out, k_out

为什么 Partial RoPE 有效？

RoPE 通过旋转矩阵将位置信息编码进向量。对于局部位置感知，RoPE 表现优秀；但对于全局语义相似性（例如两个不同位置的相同概念），纯 RoPE 可能因为旋转角度差异而降低相似性。

Partial RoPE 的 dim_head/2 维度"不含位置信息"，专门用于捕获语义相似性，而非位置依赖。这类似于 AliBI（Attention with Linear Biases）的思想，但实现更优雅。

实验效果（RULER 长文本基准）：

模型	RULER@128K	RULER@512K	RULER@1M
Full RoPE	84.2	71.3	53.8
No RoPE（NoPE）	78.1	68.5	57.2
Partial RoPE（V4）	87.4	76.8	61.3

Partial RoPE 在所有长度上均优于纯 RoPE 和无 RoPE，特别是在超长上下文（1M）时优势明显。

第十六章：后训练策略的深度解析

16.1 Specialist Training 的设计哲学

V4 抛弃了传统的 SFT（Supervised Fine-Tuning）→ RLHF（RL from Human Feedback）两阶段范式，转向 Specialist Training 的统一框架。

传统范式的问题：

SFT 的过拟合：在小型专家数据集上 SFT 容易过拟合，泛化性差
RLHF 的奖励黑客：模型学会欺骗奖励模型，而非真正学到有益行为
两阶段不一致：SFT 的分布和 RLHF 的分布可能冲突，导致灾难性遗忘

Specialist Training 的解决方案：

将各个能力领域拆分为"专项训练"：

专项类别	数据来源	训练信号	占比
数学推理	竞赛题 + 合成题	验证器（正确/错误）	25%
代码能力	GitHub + 内部代码	执行结果	30%
科学理解	论文 + 教科书	专家评分	15%
安全对齐	对话数据 + 红队	人工标注	10%
工具使用	API 调用日志	函数调用结果	10%
通用能力	多样化对话	AI 评分	10%

每个专项训练使用专门设计的训练目标，而非统一的 SFT loss。

16.2 OPD（On-Policy Distillation）的核心机制

OPD 是 V4 后训练中最重要的技术创新之一。传统知识蒸馏是离线的（从教师模型预先生成数据），而 OPD 是在线的（学生模型在训练过程中实时向教师学习）。

OPD 训练循环：

Step 1: 学生模型（V4-Flash）在当前策略下生成回答
Step 2: 教师模型（V4-Pro）对学生的回答打分/生成参考回答
Step 3: 学生计算与教师回答的 KL 散度，作为蒸馏损失
Step 4: 结合任务正确性奖励，梯度更新学生参数
Step 5: 回到 Step 1

数学目标函数：

$$\mathcal{L}_{\text{OPD}} = \mathcal{L}_{\text{task}} + \lambda \cdot \mathbb{E}_{x \sim \pi_{\text{student}}} \left[ D_{\text{KL}}(\pi_{\text{teacher}}(\cdot|x) \| \pi_{\text{student}}(\cdot|x)) \right]$$

其中：

$\mathcal{L}_{\text{task}}$：任务特定损失（如代码执行正确性）
$\lambda$：蒸馏强度超参数（V4 使用 λ=0.1 到 0.5，随训练进展衰减）
$\pi_{\text{student}}$：学生模型的采样分布
$\pi_{\text{teacher}}$：教师模型在学生输入上的输出分布

OPD 的关键优势：

OPD 解决了传统 RL 的"奖励稀疏性"问题。在代码任务中，一个程序要么通过测试要么失败，奖励是 0 或 1 的稀疏信号。OPD 通过教师模型提供密集的 token 级别指导，大幅降低了训练的方差。

16.3 GRM（Generative Reward Model）详解

GRM 是 V4 的另一个后训练创新：让演员模型（actor）同时充当奖励模型（reward model）。

为什么需要 GRM？

传统的 RLHF 需要训练一个独立的奖励模型（RM），这带来以下问题：

RM 参数规模通常远小于演员，容易被演员"黑客攻击"
RM 的训练数据（人工标注对比）成本极高
RM 在分布外（OOD）的数据上评分不可靠

GRM 的工作原理：

V4 让大模型本身生成奖励信号。具体地，对于一个回答候选 y，GRM 用以下 prompt 让 V4-Pro 自评：

[System] You are an expert evaluator. Given a question and an answer,
rate the answer on a scale of 1-10 across multiple dimensions:
- Accuracy: Is the answer factually correct?
- Completeness: Does it address all aspects of the question?
- Clarity: Is the explanation clear and well-organized?
- Helpfulness: Would a real user find this response useful?

Provide your ratings and a brief justification.
[/System]

Question: {question}
Answer: {answer}

Please provide your evaluation:

GRM 的自一致性训练：

为了防止 GRM 对自己的输出过于宽容（自我评分偏高），V4 使用以下策略：

批判性 prompt：明确要求模型找出回答的缺陷
多样性采样：用高 temperature 采样多个评分，取中位数
calibration loss：用人工标注数据微调 GRM 的评分校准性

GRM 在代码任务中的局限性：

对于代码任务，程序的正确性是客观的（执行通过/失败），GRM 的主观评分可能产生偏差。V4 在代码任务中将 GRM 的权重降低，更多依赖执行结果作为奖励信号：

$$r_{\text{code}} = 0.7 \cdot r_{\text{execution}} + 0.3 \cdot r_{\text{GRM}}$$

16.4 Interleaved Thinking 的训练策略

V4 的 Interleaved Thinking 允许模型在工具调用之间保持思考连续性。这个能力需要专门的训练数据和训练目标。

数据构造：

Interleaved Thinking 的训练数据格式：

<think>
我需要先查询当前股价，然后计算 P/E ratio。
</think>
[TOOL_CALL: get_stock_price("AAPL")]
[TOOL_RESULT: {"price": 189.5, "date": "2026-05-09"}]
<think>
股价是 189.5 美元。现在我需要获取 EPS 数据。
根据上一步结果，我知道今天是 2026-05-09。
</think>
[TOOL_CALL: get_eps("AAPL", "2026")]
[TOOL_RESULT: {"eps": 6.42, "period": "trailing_12m"}]
<think>
EPS 是 6.42。P/E ratio = 189.5 / 6.42 ≈ 29.5。
这在科技股中属于正常范围。我可以给出最终答案。
</think>
苹果公司（AAPL）当前 P/E ratio 约为 29.5 倍...

关键训练信号：

Interleaved Thinking 的训练不仅要求模型生成正确的工具调用，还要求 <think> 块中的思考是连贯的和有用的：

连贯性奖励：思考块之间的语义相似性（防止"思考断层"）
有效性奖励：工具调用成功率（防止无效调用）
推理质量奖励：最终答案的正确性

WAL（Write-Ahead Log）的容错机制：

在长 Agent 轨迹中，一次工具调用失败（网络错误、超时等）不应该导致整个推理链崩溃。V4 的 WAL 机制：

每次工具调用前，将当前完整上下文（包括 think 块）写入持久化存储
工具调用失败时，从 WAL 恢复最近的检查点
模型在恢复上下文后，可以选择重试或换策略

这使得 V4 在复杂的多步工具调用任务（如 SWE-bench、TAU-bench）中的成功率提升了约 15%。

第十七章：FP4 量化的完整技术链

17.1 FP4 数据格式

FP4（4-bit 浮点）格式有多种变体，V4 使用的是：

FP4-E2M1：

位分配	符号位	指数位	尾数位
FP4-E2M1	1	2	1

可表示的数值范围：

指数	尾数	值
00	0	0
00	1	0.5
01	0	1.0
01	1	1.5
10	0	2.0
10	1	3.0
11	0	4.0
11	1	6.0

加上负数，FP4-E2M1 共 16 个可表示值。

FP4 vs INT4：

格式	表示范围	分布	适合数据
INT4	[-8, 7]	均匀	均匀分布的权重
FP4-E2M1	[-6, 6]（非均匀）	对数	钟形/幂律分布的权重
FP4-E3M0	[-8, 8]（稀疏）	对数（更大范围）	长尾分布

Transformer 权重的分布通常是钟形的（接近高斯），因此 FP4-E2M1 比 INT4 更适合。

17.2 QAT（Quantization-Aware Training）流程

V4 的 FP4 QAT 分为三个阶段：

第一阶段：BF16 预训练（全量）

完整的预训练在 BF16 精度下进行。这确保了模型的"原始能力"不受量化影响。

第二阶段：FP8 QAT 微调

将 BF16 权重量化到 FP8，同时继续训练：

def fp8_quantize(weight, scale):
 """
 BF16 → FP8 量化
 使用对称量化（zero-point = 0）
 """
 # 计算量化范围
 w_max = weight.abs().max()
 fp8_max = 448.0 # FP8-E4M3 的最大值

 # 计算缩放因子
 scale = fp8_max / w_max

 # 量化
 w_scaled = weight * scale
 w_fp8 = w_scaled.to(torch.float8_e4m3fn)

 return w_fp8, scale

def fp8_dequantize(w_fp8, scale):
 """FP8 → BF16 反量化（lossless）"""
 return w_fp8.to(torch.bfloat16) / scale

第三阶段：FP4 QAT 微调

在 FP8 QAT 收敛后，进一步量化到 FP4：

def fp4_quantize_group(weight, group_size=16):
 """
 按组量化：每 group_size 个元素共享一个缩放因子

 Args:
 weight: (out_features, in_features) BF16 权重
 group_size: 每组元素数（V4 使用 16）
 """
 out_f, in_f = weight.shape
 n_groups = in_f // group_size

 # 重塑为 (out_features, n_groups, group_size)
 w_grouped = weight.reshape(out_f, n_groups, group_size)

 # 每组计算 scale
 w_max = w_grouped.abs().amax(dim=-1, keepdim=True) # (out_f, n_groups, 1)
 fp4_max = 6.0 # FP4-E2M1 的最大值
 scale = fp4_max / (w_max + 1e-8)

 # 量化到 FP4
 w_scaled = w_grouped * scale
 w_clamped = w_scaled.clamp(-fp4_max, fp4_max)
 w_fp4 = round_to_fp4(w_clamped) # 四舍五入到最近 FP4 值

 return w_fp4, scale.squeeze(-1) # scale: (out_f, n_groups)

FP4 → FP8 的无损反量化：

V4 的关键洞察是：FP4 → FP8 反量化可以做到数值无损，因为 FP4 的 16 个值都可以精确地用 FP8 表示（FP4 是 FP8 的真子集）。这意味着：

$$\text{FP4-E2M1} \subset \text{FP8-E4M3}$$

所以反量化 scale × FP4 的误差不来自格式转换，只来自原始量化步骤本身。

17.3 FP4 QAT 的梯度流问题

FP4 量化是离散操作，不可直接微分。V4 使用 STE（Straight-Through Estimator）：

$$\frac{\partial \mathcal{L}}{\partial w_{\text{BF16}}} \approx \frac{\partial \mathcal{L}}{\partial w_{\text{FP4}}}$$

即把量化的梯度"直通"传递给原始权重。STE 的合法性基于以下假设：

量化误差（$w_{\text{FP4}} - w_{\text{BF16}}$）相对权重量级很小
量化边界附近的梯度不重要（只占极小比例的参数）

V4 的改进 STE：

标准 STE 在量化边界附近会产生不稳定梯度。V4 使用软量化（Soft Quantization）：

$$w_{\text{soft}} = w_{\text{BF16}} + (w_{\text{FP4}} - w_{\text{BF16}}) \cdot \alpha$$

其中 $\alpha$ 从 0 线性增长到 1（退火策略）。$\alpha=0$ 时等同于全精度训练，$\alpha=1$ 时等同于完全量化。这个平滑过渡避免了 STE 在训练初期的不稳定性。

17.4 量化误差分析与精度损失评估

理论分析：

FP4-E2M1 的量化误差上界（基于分组量化，group_size=16）：

$$\epsilon_{\text{FP4}} \leq \frac{\Delta}{2} = \frac{w_{\text{max}}}{fp4_{\text{levels}} \cdot 2} = \frac{w_{\text{max}}}{16}$$

其中 $fp4_{\text{levels}} = 8$（正半轴有 8 个 FP4 值）。

实验数据（V4 报告）：

精度	困惑度（WikiText-2）	困惑度退化	推理速度提升
BF16（基准）	4.82	-	1×
FP8（权重）	4.83	+0.2%	1.6×
FP4 QAT	4.91	+1.9%	2.7×
FP4 PTQ（无 QAT）	5.23	+8.5%	2.7×

QAT 将 FP4 的精度损失从 8.5% 降到 1.9%，代价是需要额外的 QAT 训练阶段（约 5% 的预训练计算量）。

第十八章：基准测试与系统对比

18.1 V4-Pro vs 同量级模型

V4-Pro（1.6T params / 49B active）的全面评测：

基准测试	V4-Pro	GPT-5	Claude-4-Opus	Gemini-Ultra-2
MMLU-Pro	88.2	87.9	86.4	85.1
GPQA-Diamond	71.3	69.8	68.2	67.5
MATH-500	94.7	93.1	91.8	90.2
HumanEval	91.4	89.7	88.3	87.1
SWE-bench Verified	63.8	61.2	59.4	57.8
AIME 2025	81.2	78.5	76.3	74.1
LiveCodeBench	72.4	70.1	68.5	66.2

注：以上数据为估计值，基于 V4 技术报告中的相对对比数据重构

18.2 V4-Flash 的效率优势

V4-Flash（284B params / 13B active）对比效率模型：

模型	参数量（active）	MMLU	MATH	Tokens/s（A100）
V4-Flash	13B	82.3	87.4	1850
GPT-4o-mini	~8B	79.1	83.2	2100
Gemini-Flash-2.0	~10B	80.5	85.1	1950
Claude-3.5-Haiku	~8B	78.3	82.7	2200
Llama-3.1-70B	70B	81.2	83.8	650

V4-Flash 用 13B 的 active 参数规模实现了接近 70B 级别模型的能力，同时推理速度与同量级小模型相当。

18.3 长上下文能力评测

RULER 基准（长上下文理解）：

模型	32K	128K	512K	1M
V4-Pro	93.1	87.4	76.8	61.3
GPT-5	92.8	84.2	68.5	47.2
Claude-4-Opus	91.5	83.7	65.4	42.8
Gemini-Ultra-2	90.2	89.1	71.3	55.8

V4-Pro 在 1M 上下文长度下显著优于竞品，这是 CSA+CP 技术组合的直接体现。

18.4 推理能力深度评测

AIME 历年真题（AMC12/AIME 2020-2025）：

年份	V4-Pro（@32）	V4-Flash（@32）	GPT-5（@32）
AIME 2020	87.5%	82.3%	85.2%
AIME 2021	85.0%	79.8%	83.1%
AIME 2022	83.3%	77.5%	81.4%
AIME 2023	81.7%	75.2%	79.8%
AIME 2024	80.0%	73.5%	78.2%
AIME 2025	81.2%	74.8%	78.5%

@32 表示 32 次采样取最优（pass@32 标准）

V4 在 AIME 系列上的持续优势，来自于 GRM + Specialist Training 在数学领域的深度优化。

第十九章：工程部署的生产实践

19.1 推理服务架构

V4-Pro 的生产推理架构（估计，基于类似系统的工业经验）：

客户端请求
 ↓
负载均衡层（L7 代理，支持流式推理）
 ↓
Prefill 集群（专注计算 KV Cache）
 |
 ├── GPU 组 A：前 48 层（Tensor Parallel × 8）
 └── GPU 组 B：后 48 层（Tensor Parallel × 8）
 ↓
KV Cache 传输（NVLink / InfiniBand）
 ↓
Decode 集群（专注自回归生成）
 |
 ├── GPU 组 C：Decode（Expert Parallel + Tensor Parallel）
 └── Lightning Indexer 服务（独立部署，CSA 使用）
 ↓
输出流式返回

Prefill / Decode 分离的必要性：

在大模型推理中，Prefill 和 Decode 两个阶段的硬件利用特征截然不同：

特征	Prefill 阶段	Decode 阶段
计算特性	计算密集（矩阵×矩阵）	访存密集（矩阵×向量）
并行方式	序列并行	专家并行
GPU 利用率	85-95%	45-65%
批处理大小	大批（32+）	小批（1-4）
延迟要求	低首 token 延迟	低 token 间隔延迟

分离部署允许对两个阶段独立扩缩容，并使用不同的并行策略。

19.2 Expert 并行的负载均衡

MoE 推理中，专家负载不均是一个严重问题。某些专家可能比其他专家接收 5-10 倍的 token，导致 GPU 空闲等待。

DeepSeek V4 的解决方案：

辅助负载均衡损失（训练阶段）：

$$\mathcal{L}_{\text{load}} = \alpha \cdot \sum_{i=1}^{E} f_i \cdot P_i$$

其中 $f_i$ 是专家 i 的 token 频率，$P_i$ 是路由模型分配给专家 i 的平均概率。最小化这个损失鼓励均匀的负载分布。

动态 Expert 复制（推理阶段）：

对于高负载专家，在多个 GPU 上复制其权重：

def dynamic_expert_replication(expert_loads, threshold=1.5):
 """
 将负载超过平均值 threshold 倍的专家复制到更多 GPU

 Args:
 expert_loads: (n_experts,) 各专家的当前负载
 threshold: 复制触发阈值

 Returns:
 replication_plan: dict {expert_id: n_replicas}
 """
 avg_load = expert_loads.mean()
 replication_plan = {}

 for i, load in enumerate(expert_loads):
 if load > threshold * avg_load:
 n_replicas = int(load / avg_load) + 1
 replication_plan[i] = min(n_replicas, 4) # 最多复制 4 份

 return replication_plan

Expert 缓存（针对 KV 专家）：

V4 观察到，KV cache 中某些专家的激活具有高度重复性（同一 expert 在相似问题上被频繁激活）。通过缓存这些专家的激活结果，可以跳过重复计算：

缓存命中率	推理加速
20% 命中	1.08×
40% 命中	1.18×
60% 命中	1.32×

对于高重复性任务（如 FAQ 问答、模板化写作），缓存命中率可达 40-60%。

19.3 量化感知推理

在生产中，V4 使用以下量化策略的组合：

权重量化（静态）：

MoE 专家权重：FP4（节省 4× 存储，使用 QAT 保证精度）
注意力投影：FP8（平衡精度与速度）
Embedding 和输出层：BF16（保留全精度）

激活量化（动态）：

Attention 中间激活：FP8（在线量化，每 batch 计算 scale）
FFN 激活：BF16 或 FP8 取决于层类型

推理框架集成：

# 示例：使用 vLLM 加载 V4 的 FP4 量化版本（伪代码）
from vllm import LLM, SamplingParams

llm = LLM(
 model="deepseek-ai/DeepSeek-V4-Pro",
 quantization="fp4", # FP4 权重量化
 tensor_parallel_size=8, # 8卡 TP
 max_model_len=1_000_000, # 1M context
 enable_prefix_caching=True, # KV cache 缓存
 gpu_memory_utilization=0.92, # HBM 利用率
)

sampling_params = SamplingParams(
 temperature=0.6,
 top_p=0.95,
 max_tokens=32768,
)

19.4 成本优化的 ROI 分析

V4-Pro 的训练成本估算：

基于公开信息和类似模型的数据：

阶段	计算量（GPU 小时）	成本估算（H100@$3/hr）
预训练（14.8T tokens）	~5M H100-hours	~$15M
FP8/FP4 QAT	~250K H100-hours	~$0.75M
Specialist Training	~500K H100-hours	~$1.5M
RLHF/OPD	~300K H100-hours	~$0.9M
总计	~6.05M H100-hours	~$18.2M

推理成本对比（每百万 token 成本，美元）：

模型	输入	输出	推理效率指数
V4-Pro（13B active / API）	$0.27	$1.10	1.00
GPT-4o	$2.50	$10.00	0.11
Claude-3.5-Sonnet	$3.00	$15.00	0.09
Gemini-1.5-Pro	$1.25	$5.00	0.22
V4-Flash	$0.07	$0.28	3.93

V4-Flash 每百万 token 仅需 $0.07（输入），是 GPT-4o 的约 35 分之一，但性能接近 GPT-4o 量级。

第二十章：未来研究方向

20.1 mHC 的扩展潜力

动态 Block 划分（未来工作）：

当前 V4 的 mHC 使用固定的 B=8 block 划分。未来可以探索动态 block 划分：根据输入内容的语义结构（如句子边界、段落边界）自适应地确定 block 边界。

这类似于 BPE 分词的思路：频繁出现的 token 组合成更大的 block，罕见的 token 保持细粒度划分。

层次化 mHC（多尺度残差）：

当前 mHC 只有单层的 block 结构。未来可以扩展为层次化：

L1：token 级别的局部连接（RC）
L2：sentence 级别的块连接（mHC）
L3：paragraph 级别的全局连接（AttnRes）

类比于 U-Net 的多尺度特征融合。

20.2 CSA 的演进方向

Learned Sparsity Pattern（可学习稀疏模式）：

当前 CSA 的稀疏模式由 Lightning Indexer 在推理时动态确定（近似 top-k）。未来可以探索在训练时学习"哪些 token 对需要关注"的静态稀疏模式（类似 Longformer 的 Global-Local 注意力）。

CSA 与状态空间模型（SSM）的混合：

Mamba 等 SSM 模型在长序列上的计算效率优于 Attention（O(L) vs O(L²)）。但 SSM 缺乏 Attention 的随机访问能力。CSA 与 SSM 的混合架构（如 Jamba、Hymba）可能是下一代长上下文模型的方向。

20.3 后训练技术的发展趋势

RLAIF（AI Feedback 的 RL）vs GRM：

当前 GRM 用大模型自评分，RLAIF 用另一个大模型评分。两者的区别：

GRM：actor = critic，计算高效，但可能自我强化偏见
RLAIF：actor ≠ critic，更客观，但成本更高

未来可能出现多模型合议制：多个不同的 GRM 对回答打分，取最终的共识分数，类似于司法裁决中的陪审团制度。

从 Token 预测到 Latent 预测（Meta 的研究方向）：

当前所有 LLM 的训练目标是预测下一个 token。Meta 的 JEPA 方向提出预测下一个语义块（latent representation），而非具体 token。如果这个方向成功，可能从根本上改变 LLM 的训练范式，也会影响到 Specialist Training 和 GRM 等后训练技术。

20.4 从语言模型到世界模型

V4 技术报告的最后一节暗示了团队对"世界模型"的长期愿景：

当前 LLM 的局限性：

不能进行真正的因果推理（相关性 vs 因果）
对物理世界缺乏基础性理解（常识推理依赖训练数据的统计规律）
记忆是静态的（知识截止日期后的信息需要 RAG）

迈向世界模型的技术路径：

持续学习：模型能够在推理时更新自己的知识（不重新训练）
因果建模：显式建模 do-calculus，而非纯统计关联
多模态接地：视觉、音频、触觉等多种感知模态的融合
主动感知：模型能够主动提出问题（而非被动回答）

V4 的 Interleaved Thinking + Tool Use 是迈向主动感知的第一步——模型不再被动地回答问题，而是主动地使用工具收集信息。

附录 D：DeepSeek 技术演进时间线

时间	版本/论文	核心贡献
2023年5月	DeepSeek-67B	首个开源 67B 规模中文友好模型
2023年12月	DeepSeek-MoE	专家混合架构，引入 Shared Expert
2024年1月	DeepSeek-MoE 16B	高效 MoE，引发 MoE 开源热潮
2024年5月	DeepSeek-V2	MLA（Multi-Latent Attention），大幅降低 KV Cache
2024年12月	DeepSeek-V3	超大规模 671B MoE，FP8 训练
2025年1月	DeepSeek-R1	纯 RL 训练的推理模型，chain-of-thought
2025年5月（预估）	DeepSeek-V4	mHC + CSA + Muon + 1M context

DeepSeek 的技术路线特点

DeepSeek 技术演进呈现明显的"创新聚焦"特点，每个版本集中突破 1-2 个核心技术瓶颈：

V2：KV Cache 效率（MLA）
V3：训练效率（FP8、EP Wave Scheduling）
V4：架构创新（mHC）+ 长上下文（CSA + 1M）+ 优化器（Muon）

这与 OpenAI、Google 的"全面推进"策略形成对比。DeepSeek 的做法更像学术机构，每篇报告都有明确的核心贡献点，可复现、可验证。

附录 E：关键算法伪代码汇总

E.1 完整的 mHC 前向传播

def mhc_layer_forward(x, params, B=8, C=4, K=2):
 """
 mHC 单层前向传播（简化版）

 Args:
 x: (L, D) 输入序列
 params: 层参数字典
 B: block 数目
 C: 每位置选择的连接数（更新向量数）
 K: Sinkhorn 迭代次数

 Returns:
 y: (L, D) 输出序列
 """
 L, D = x.shape
 L_per_block = L // B

 # 将序列分组为 B 个 block
 x_blocks = x.reshape(B, L_per_block, D) # (B, L/B, D)

 # 计算 block 级表示（平均池化）
 block_repr = x_blocks.mean(dim=1) # (B, D)

 # 计算路由权重矩阵
 T = torch.einsum('bd,ed->be', block_repr, block_repr) # (B, B)

 # Sinkhorn 投影到双随机矩阵
 for _ in range(K):
 T = F.softmax(T, dim=-1) # 行归一化
 T = F.softmax(T, dim=-2) # 列归一化

 # 计算更新向量的路由分数
 e_scores = x @ params['W_e'].T # (L, C_total)，C_total >> C

 # top-C 选择
 top_ids = e_scores.topk(C, dim=-1).indices # (L, C)
 top_scores = e_scores.gather(-1, top_ids) # (L, C)
 top_scores = F.softmax(top_scores, dim=-1) # 归一化

 # 聚合选中的更新向量
 selected_e = params['W_e'][top_ids] # (L, C, D)
 update = (top_scores.unsqueeze(-1) * selected_e).sum(dim=1) # (L, D)

 # 计算残差权重（基于 T 矩阵）
 # 简化：用 T 的对角线作为当前 block 的自连接强度
 block_ids = torch.arange(L, device=x.device) // L_per_block # (L,)
 self_weights = T[block_ids, block_ids].unsqueeze(-1) # (L, 1)

 # 输出
 y = self_weights * x + (1 - self_weights) * update
 return y

E.2 CSA 完整推理流程

class CompressedSparseAttention(nn.Module):
 """
 CSA 完整实现（推理模式）
 """
 def __init__(self, dim, n_heads, n_kv_heads, top_k=64):
 super().__init__()
 self.dim = dim
 self.n_heads = n_heads
 self.n_kv_heads = n_kv_heads
 self.top_k = top_k
 self.head_dim = dim // n_heads

 # 投影层
 self.q_proj = nn.Linear(dim, n_heads * self.head_dim, bias=False)
 self.k_proj = nn.Linear(dim, n_kv_heads * self.head_dim, bias=False)
 self.v_proj = nn.Linear(dim, n_kv_heads * self.head_dim, bias=False)
 self.o_proj = nn.Linear(dim, dim, bias=False)

 # Lightning Indexer（实际实现在 CUDA 中）
 self.indexer = LightningIndexer(self.head_dim)

 # Soft Fusion 权重
 self.fusion_w1 = nn.Parameter(torch.ones(1))
 self.fusion_w2 = nn.Parameter(torch.ones(1))

 def forward(self, x, kv_cache=None, position_ids=None):
 B, L, D = x.shape

 # 1. 计算 Q, K, V
 q = self.q_proj(x).reshape(B, L, self.n_heads, self.head_dim)
 k = self.k_proj(x).reshape(B, L, self.n_kv_heads, self.head_dim)
 v = self.v_proj(x).reshape(B, L, self.n_kv_heads, self.head_dim)

 # 2. 更新 KV Cache
 if kv_cache is not None:
 k = torch.cat([kv_cache['k'], k], dim=1)
 v = torch.cat([kv_cache['v'], v], dim=1)

 full_len = k.shape[1] # 历史 + 当前的总长度

 # 3. Lightning Indexer 找 top-k KV 对
 # 对每个 query head，找最相关的 top_k 个 key
 q_flat = q.reshape(-1, self.head_dim) # (B*L*n_heads, head_dim)
 k_flat = k.reshape(-1, self.head_dim) # 简化，实际按 head 处理

 top_k_indices, top_k_scores = self.indexer.search(q_flat, self.top_k)
 # top_k_indices: (B*L*n_heads, top_k)

 # 4. 稀疏注意力计算（使用 top-k 的 KV）
 k_sparse = k_flat[top_k_indices] # (B*L*n_heads, top_k, head_dim)
 v_sparse = v.reshape(-1, self.head_dim)[top_k_indices] # 同上

 # 5. 计算稀疏 attention 分数
 attn_score_sparse = torch.bmm(
 q_flat.unsqueeze(1),
 k_sparse.transpose(1, 2)
 ).squeeze(1) / math.sqrt(self.head_dim) # (B*L*n_heads, top_k)

 # 6. 局部窗口注意力（Set 2，精确计算）
 window_size = 512 # 最近的 512 个 token
 k_local = k[:, -window_size:] # 最近的 KV
 # ... 局部注意力计算

 # 7. Soft Fusion 合并两组分数
 # 先归一化，再融合
 score_sparse_norm = F.softmax(attn_score_sparse, dim=-1)
 # score_local_norm = ... 

 w1 = torch.sigmoid(self.fusion_w1)
 w2 = torch.sigmoid(self.fusion_w2)
 attn_weights = w1 * score_sparse_norm # + w2 * score_local_norm

 # 8. 加权聚合 V
 out = torch.bmm(attn_weights.unsqueeze(1), v_sparse).squeeze(1)
 # out: (B*L*n_heads, head_dim)

 # 9. 输出投影
 out = out.reshape(B, L, -1)
 out = self.o_proj(out)

 return out, {'k': k, 'v': v}

总结与展望

DeepSeek V4 技术报告代表了 LLM 领域一次系统性的技术突破。本文从以下七个维度对其进行了深度解析：

核心贡献回顾

mHC（流形超连接）：将残差连接从标量推广到矩阵，用 Sinkhorn-Knopp 算法约束路由在 Birkhoff polytope 上，实现了信息流的精确控制。Block AttnRes 以 O(N²) 的低代价接近 Full AttnRes 的效果。
CSA（压缩稀疏注意力）：四步流水线（2-KV-Set Overlap → Soft Fusion → Lightning Indexer top-k → MQA）将注意力计算从 O(L²) 降至接近 O(L)，同时通过可学习温度参数保持了多任务适应性。
HCA（重度压缩注意力）：在浅层使用更激进的压缩策略，与 CSA 形成分层互补，最大化系统级的计算效率。
Muon 优化器：Newton-Schulz 正交化将梯度投影到 Stiefel 流形，以矩阵更新替代逐元素 Adam，在相同 FLOPs 下收敛更快、泛化更好。
EP Wave Scheduling：mega-kernel 融合专家并行的通信与计算，1.92× 的通信加速使得 E=128 规模的专家并行成为可能。
FP4 QAT：利用 FP4 ⊂ FP8 的包含关系实现无损反量化，通过软量化退火策略解决 STE 的不稳定性问题。
后训练创新：Specialist Training + OPD + GRM + Interleaved Thinking 构成了完整的后训练体系，Interleaved Thinking 结合 WAL 容错机制为复杂 Agent 任务提供了新的解决方案。

对行业的影响

V4 的技术报告将迫使整个行业重新审视以下假设：

Attention 是注意力的唯一有效形式：CSA 表明，稀疏近似注意力可以在不牺牲关键语义的前提下大幅降低计算量
Adam 是 LLM 训练的标准优化器：Muon 的成功证明了矩阵流形优化在大规模训练中是可行的
长上下文需要巨大的 KV Cache：CSA + CP + Partial RoPE 的组合实现了 1M token 上下文的高效管理

开放问题

尽管 V4 取得了巨大进步，以下问题仍未解决：

mHC 的最优 Block 数 B：B=8 是经验调优的结果，是否有理论上的最优值？
CSA 的近似误差界：Lightning Indexer 的 top-k 近似会丢失哪些信息，对哪类任务影响最大？
Muon 的分布式扩展：NS 迭代在 EP=128 规模下的通信开销是否仍然可控？
FP4 QAT 对推理能力的影响：量化误差是否会系统性地影响某类推理链（特别是多步数学推理）？

这些问题将推动下一轮的技术探索，期待 V5 技术报告能够给出答案。

本文基于 DeepSeek V4 技术报告（2026年5月）及相关技术资料整理撰写。部分实验数据为推断值，以技术报告原文为准。

KV 高效的 2K 长序列电商精排：OneTrans V3.1 工程实践

Tue, 28 Apr 2026 11:00:00 +0800

本文整理自某大型电商推荐系统内部技术文档，记录了精排模型从 1K 序列扩展至 2K、同时完成模型结构 Scaling Up 与训推效率双重优化的完整工程实践。核心改动四线并进：数据与特征（2K GR 超长序列 + Action Quota + ts_delta/price 分桶）、训练效率（RM Padding + Listwise Squeeze + GQA + QK Norm）、Serving 效率（xmatmul → M-Falcon）、模型容量（d_model 384→512，SeqFormer 5→7 层），最终实现线上 GMV/user +1.02%、main_order/user +1.36%，训练吞吐 +60%，Serving QPS +97%。

0. 背景：v3.0 的四条制约线

0.1 长序列建模为什么是工业精排的下一站

工业级电商精排在过去十年经历了几次阶段性的范式跃迁：从 LR / GBDT + 大规模特征工程，到 DeepFM / DCN 等结构化交叉，再到 DIN / DIEN 等显式建模用户兴趣序列。每一次跃迁都伴随着可处理用户行为信号的深度与广度的扩张。但当 DIEN 把目标 attention 引入精排之后，进一步提升的主要矛盾就从"如何抽取兴趣"转向了"能让模型看到多长的兴趣"——也就是说，user behavior sequence 的长度上限直接决定了模型的天花板。

行为序列变长有两层意义：

覆盖更多的细分兴趣。短序列（≤200）几乎只能反映用户最近一两次会话，对于跨场景、跨周期的兴趣信号无能为力。中序列（512–1024）可以覆盖近一周的活跃会话。长序列（≥2048）则进入"多周期 + 多场景兴趣"建模的能力区间，能区分一次性需求（比如生日礼物）和长期偏好（比如运动鞋型号）。
稀疏正反馈信号的去稀释。order / cart 这样的高价值反馈在自然行为分布里只占极少数（往往不到 5%）。如果序列长度只有 1K，且按时间均匀采样，那么 95% 的容量都被 click / impression 占据了——模型实际上很难在这样的序列里找到足够的转化信号去学习。把序列长度抬到 2K，相当于多出来 1K 的预算可以分配给低频高价值行为。

但这条路径并非"把 max_seq_len 改一下"那么简单。一旦序列从 1K 抬到 2K，所有 attention/FFN 计算量近似 2×，KV cache 显存近似 2×，再叠加同时进行的模型结构 Scaling Up（更宽更深），单卡显存与训推吞吐都会被同步推上新的瓶颈。v3.0 在 1K 序列下的稳态指标，不能简单地外推到 v3.1。

0.2 v3.0 的现状：1K 序列 + 384 dim + 5 层 SeqFormer

上一代模型（v3.0）将用户行为序列扩展至 1K，并在国际站完成了推全。它的整体形态是一个两阶段的 Transformer 结构：stage-1 用 self-attention 从用户行为序列中抽取兴趣表达，stage-2 用 cross-attention 让候选商品（target item）与序列发生交互。在 d_model=384、SeqFormer 5 层的配置下，模型整体参数量 165M，训练吞吐稳定在 48K instance/s。但运行一段时间后，工程师们发现四条清晰的制约线横亘在继续迭代的路上。

0.3 制约一：序列质量参差，信号覆盖受限

v3.0 的序列混杂了快照序列与 GR 超长序列两个来源。两者的时间戳精度、行为去重粒度、字段对齐方式都不完全一致，需要在序列构建阶段做大量 case-by-case 的兼容逻辑。

更关键的是，这种"混合 + 均匀采样"的做法，导致高频的 click / impression 行为挤占配额，长尾的 order 转化信号被严重稀释。统计显示：v3.0 的有效序列中（去掉 padding 后）平均长度约 555，其中 click 占比超过 50%、impression 占近 18%、cart 不到 30%、order 仅 4% 左右。对于活跃度高的用户，行为体量可能在一周内就突破 1K，1K 长度根本装不下，大量历史兴趣被截断；而对于行为稀疏的用户，序列里又被低质量的 impression 灌满了空隙。

此外，v3.0 缺乏对行为时间间隔和价格区间的显式建模。模型只能从 position embedding 里间接学习时序信号，从 item embedding 里间接学习价格区间——这显然不够。

0.4 制约二：显存瓶颈，2K OOM

训练实现层面存在两处叠加的显存浪费：

Padding 浪费：训练 batch 内不同样本的有效序列长度差异很大，但需要 pad 到统一长度（例如 2K）以便组成规则张量参与计算。padding token 全程参与 stage-1 self-attention 与 FFN 的 forward / backward，产生大量无效 FLOPs，同时消耗显存中的激活、梯度、优化器状态。粗略估算，在 click 序列均值 1200 的条件下，padding 浪费的算力比例接近 40%。
Listwise 重复：精排在工业实现中通常是 listwise 推理——同一个用户请求会带上 N 个候选 item（例如 N=300），每个 item 都要过一遍 stage-1 + stage-2 完成打分。但实际上同一请求里所有 item 共享完全一样的用户序列，stage-1 的 KV 计算被复制了 N 遍，造成显存与算力的巨大浪费。

这两处浪费叠加，使得 v3.0 在 1K 序列下已经把 GPU 显存吃得很紧。一旦尝试将序列从 1K 扩展至 2K，训练直接 OOM。如果不引入新的优化机制，纯靠 batch_size 缩水来腾显存，训练吞吐会进一步崩塌，得不偿失。

0.5 制约三：xmatmul Serving 效率天花板

stage-2 的 cross-attention 在 v3.0 使用 xmatmul 实现：每个 candidate item 独立调度一次 matmul kernel，先算 Q × K^T 得到 attention score，再算 softmax(score) × V 得到 attention 输出。这种实现方式在序列长度较短、item 数较少时尚可，但在精排实际场景下问题非常突出：

kernel launch overhead 累积：每个 item 一次 kernel，N=300 个 item 就要 launch 300 次 cross-attention kernel。每次 kernel launch 都有约几微秒的固定开销，叠加起来在高 QPS 场景下成为不可忽视的延迟来源。
kernel 粒度过小：单个 item 的 attention 是 1 × seq_len 的小规模运算，远远填不满现代 GPU 的 Tensor Core 阵列。SM 利用率长期在 6% 左右徘徊。
中间结果反复落盘：xmatmul 的 attention score 必须先写回 GPU global memory，再被下一个 kernel 读回，缺少 IO 融合，无法享受 FlashAttention 的 IO 友好优化。

在 v3.0 的 1K 序列 + xmatmul 组合下，Serving 的单请求 latency 已经接近线上预算上限，留给后续模型扩展的余量非常有限。

0.6 制约四：模型容量不足

参数量与模型宽深度均受到前三条制约的间接限制：

显存水位太高：v3.0 已经在 1K 序列下吃掉大半显存，没有余量去把 d_model 抬高或者层数加深。
Serving latency 没有余量：xmatmul 已经把 Serving 推向延迟红线，加宽加深会进一步恶化。
训练吞吐低：扩参数 → 训练吞吐进一步下降 → 迭代周期变长 → 实验效率掉一档。

四条制约线相互绑定，构成一个负反馈闭环：想加容量必须先解决显存与延迟，但这两个底层问题不打通，结构上的任何改动都会被反噬。

v3.1 的整个迭代逻辑，就是系统性地打通这四条制约线——先打效率，再做 scaling，最后让结构和数据层的改动同步收敛。

1. 2K 序列扩展与特征丰富

1.1 数据源统一：全面切换 GR 超长序列

v3.0 的序列由快照序列和 GR 超长序列拼接而成，来源不统一导致时间戳对齐与去重逻辑复杂。v3.1 统一切换为 GR 超长序列，序列长度从 1K 扩展至 2K，完全下线快照短序列。

GR 超长序列的优势在于：

统一时间精度：所有事件以同一种时间戳精度落地，便于 ts_delta 之类的精细时序特征构造，不再需要在不同源之间做秒/毫秒/分钟的二次对齐。
统一去重粒度：GR 序列在落地阶段已经按 (user_id, item_id, action_type, ts) 做了清洗，避免短序列因为埋点重复在序列层再做一次去重。
覆盖更长时间窗口：v3.0 的快照序列窗口约一周，GR 超长序列窗口可达数周，为长期兴趣建模提供原料。

离线序列覆盖率对比（v3.0 vs v3.1）：

指标	v3.0（1K）	v3.1（2K）	变化
平均有效序列长度（去 padding）	555	1186	+113.7%
order 行为平均覆盖数	22	48	+118.2%
cart 行为平均覆盖数	153	193	+26.1%
click 行为平均覆盖数	281	847	+201.4%
impression 行为平均覆盖数	99	99	—

可以看到：order / cart 这两类高价值行为的覆盖几乎翻倍，click 行为覆盖翻了两倍以上，impression 因为有硬上限保持不变（详见 1.2）。这就是 2K 长度直接带来的"信息体积"扩张。

1.2 Action Quota 过滤：让 order 信号不再被淹没

均匀采样的最大问题是：高频行为（click、impression）轻松占满配额，低频但高价值的 order 被稀释。v3.1 引入按 action_type 的优先级配额机制：

序列仍按时间排序，配额机制只控制每类行为的保留上限，不改变序列内部的时序结构。具体规则：

行为类型	优先级	Quota 上限	说明
Order	1	300（p95 长度）	转化信号，最高优先
Cart	2	600（p95 长度）	深度兴趣
Click	3	1000（p70 长度）	主要正反馈
Impression	4	100（硬上限）	负反馈/上下文，不参与回填
合计	—	2000	—

回填机制：若高优先级类型实际行为数不足配额，空出的位顺延给下一优先级类型（impression 除外，始终受 100 条硬上限约束，不参与扩容）。Impression 之所以严格限制，是因为离线实验发现：行为稀疏用户的 GR 序列中 impression 占比极高，若不加限制，序列几乎被无点击曝光填满，序列信噪比显著下降，模型对深度转化信号的建模能力退化。

为什么 quota 而不是采样权重：另一种自然的思路是给不同 action_type 设置不同的采样概率。但精排模型对"序列内时序"是敏感的——采样会破坏行为之间的相对顺序，特别是会让相邻行为的 ts_delta 失真。配额机制只删掉超额的、已经按时间倒序排好的最旧条目，序列内的时序结构完整保留。

为什么对 impression 用硬上限：impression 在 GR 超长序列里可以爆量到几千条（比如重度刷推荐流的用户），即便它对模型有上下文价值，也不应该挤占其它高价值行为的位置。把 impression 锁死在 100 条以内，是工程实践中的"信噪比保护阀"。

1.3 上下文特征注入：ts_delta 与 price 分桶

v3.0 的序列特征缺乏对行为时间衰减和价格区间偏好的显式建模。v3.1 新增三个上下文特征（对数分桶，以离散 FID 形式注入序列）：

ts_delta：相邻行为时间间隔（用户节奏感知）。捕捉用户行为节奏是否密集，是建模兴趣切换、会话边界的核心信号。
ts_delta_to_reqtime：行为距 request 时间的间隔（时序衰减建模）。模型可以据此学习兴趣的衰减曲线——一周前的 click 和昨天的 click 显然权重不同。
price：商品价格对数分桶（价格区间偏好）。同一类目下，用户对价格段的偏好往往是稳定的（比如总是买 100~200 元的运动鞋），这个信号在 v3.0 里完全没有被显式注入。

对数分桶的理由：电商场景的时间间隔与价格都是长尾分布——很多 ts_delta 集中在分钟级以内，但也有少量跨周/跨月的间隔。直接做线性分桶会让大部分桶集中在低位，分辨率不足。对数分桶后，分布更均衡，模型更容易学到细粒度的差异。

FID 化注入：所有连续值通过对数分桶映射成离散桶号（FID），再经过 embedding 层进入序列。这种处理方式把"连续值"转成"类别值"，让模型可以用 embedding 的方式学习每一段区间的语义，而不是依赖一个 1 维的连续输入。

1.4 Index-only 序列构建加速

序列构建流程中的去重、防穿越、配额截断三个步骤原本每步都产出完整的新序列张量（n_features × seq_len），三步串联意味着三次全量拷贝。

v3.1 将三步统一为 Index-only 模式：只维护一个有效位置的 index 数组，最终用一次 gather 对所有特征列统一执行。

Index-only 的核心好处：

减少中间拷贝：原方案每次都要构造 (n_features, seq_len) 的中间张量，重复成本很高。Index-only 只携带 index 数组（int32），最后才做一次 gather。
降低内存峰值：中间状态体积下降到 seq_len 级别，对 Rosetta 图调度更友好，避免触发 spill。
算子数减少：原来是 N 个步骤 × N 个特征 = N² 量级算子，现在压缩到 N + 1 个算子。Rosetta 的图执行调度更紧凑。

收益：减少 Rosetta 中间算子数、降低内存峰值，对 Rosetta 图的内存调度更友好。

2. 结构 Scaling Up

效率优化释放显存与算力预算后，v3.1 同步推进了模型结构的 Scaling Up，从多个维度扩充模型容量。

2.1 加宽：d_model 384 → 512，TruncatedNormal 初始化

为什么直接加宽容易崩？

在不调整初始化的前提下加宽，输出方差会近似按比例放大（384→512 约 1.33×，384→768 接近 2×），导致中间激活、残差分支整体鼓胀，把激活推入非线性饱和区，线上预估分布和校准瞬间漂移。

数学上看，对于一个全连接层 $y = Wx$，如果 $W$ 的元素方差为 $\sigma^2$，输入 $x$ 维度为 $d_{in}$，则输出方差近似为 $d_{in} \cdot \sigma^2$。当我们把 $d_{in}$ 从 384 抬到 512 而不调整 $\sigma$ 时，输出方差自动放大约 33%。在多层串联的网络里，这种放大是指数级累积的——5 层 SeqFormer 跑下来，输出方差可能放大 4× 以上。激活值进入饱和区后，gradient 消失，训练走偏。

解决方案：TruncatedNormal std=0.02

实验发现，使用 TruncatedNormal 且 std=0.02 相比随机初始化方式效果更明显且训练更稳定。同时对 QKV 矩阵也采用 TruncatedNormal std=0.02 初始化：

改动	CTR AUC	CTR UAUC	instance/s
基线（384）	—	—	52
A: 512 + RandomNorm std=0.05	+0.05%	+0.16%	37
B: 512 + TruncatedNorm std=0.02	+0.09%	+0.21%	37
C: B + QKV TruncNorm std=0.02（LR）	+0.16%	+0.28%	38
D: C + dim=768 + SwiGLU clip	+0.26%	+0.37%	24

最终选用方案 C（d_model=512, QKV TruncNorm），在效果与吞吐之间取得最优平衡。

为什么 TruncatedNormal 优于 RandomNormal：TruncatedNormal 把 ±2σ 之外的极端权重直接截断重采样。这避免了极少数权重值过大导致初期激活异常爆炸——这些异常激活会让 LayerNorm 的 running statistics 出现长尾，需要很多 step 才能洗掉。在宽模型上这种长尾恢复尤其慢，因此 TruncatedNormal 的"无极端值"特性带来的训练初期稳定性收益就更明显。

为什么 std=0.02 而不是 0.05：std=0.05 是一个相对常见的默认值（很多 PyTorch 默认初始化函数采用），但在 d_model 较大时，0.05 仍然偏大。0.02 是 GPT-2 / BERT 系列论文里给出的经验值，对 d_model ∈ [256, 1024] 的范围都有不错的稳定性表现。

QKV 单独初始化的必要性：Attention 模块的 QKV 投影矩阵决定了 attention score 的分布。如果 QKV 也按全局默认初始化，score 的方差容易随 d_model 放大。给 QKV 单独用更小的 std=0.02，相当于把 attention score 的初始尺度压回到温度合理区间，避免开训前几十个 step 内 softmax 直接进入"top-1 占据所有权重"的退化状态。

2.2 叠层：SeqFormer 5 → 7 层，Solar Copy-and-Stack

Solar 两阶段训练 + Copy-and-Stack：

第一阶段：用较浅较短的序列结构学习主干模式（高吞吐），以 5 层 384 dim 为基础学好主干特征
第二阶段：从第一阶段 checkpoint 出发，通过 copy-and-stack 把已有层复制堆叠到 7 层（层映射如 0→1→2→3→2→3→4），恢复长序列与深层结构继续训练

这一策略同时获得两类增益：参数量增加带来的容量增益 + 嵌套深度增加带来的推理/组合能力增益。

为什么不直接训 7 层？ 直接从头训一个 7 层 + 2K 序列的模型，对显存、训练吞吐、训练步数三方面都有压力。两阶段的好处是：

第一阶段用较窄、较浅、较短序列的设置训得很快，能用相对低的成本探索好基础参数。
第二阶段 copy-and-stack 直接复用第一阶段已经学到的 representation，省掉重新学习主干模式的步数。
第二阶段才把 d_model、层数、序列长度全部抬上来，训练总时间反而比直接训 7 层更短。

Copy-and-Stack 的层映射逻辑：以 5 层 → 7 层为例，使用 0→1→2→3→2→3→4 的映射，把中间的层 2 和层 3 复制一份。复制中间层而不是首层或尾层，是因为：

首层负责 raw embedding → 表达空间的转换，复制会让前几层冗余。
尾层往往负责输出对齐，复制会破坏尾部结构。
中间层是抽象语义层，复制带来的是"加深抽象路径"，最贴合"嵌套深度增益"的目标。

Looped Layer 对照实验：为了分解"参数量"与"嵌套深度"两个因素的贡献，同时做了 Looped Layer 实验——复用同一 block 的参数（0 1 2 3 4 → 0 1 2 2 3 3 4，权重完全共享，只涨嵌套深度）。与 Solar 对比，可以探索精排模型叠层收益的本质来源。

如果 Looped Layer 能拿到接近 Solar 的离线收益，那么叠层收益主要来自"重复 forward"带来的非线性组合深度，而不是新增参数量；反之则说明参数容量才是主要驱动因素。

2.3 GQA：8Q/2KV，KV 显存降低 4×

MHA 下每个 query head 独立维护一套 KV，KV 显存随 head 数线性增长，在 d_model=512 这种宽模型上带宽压力进一步放大。切换为 GQA（8 query head 共享 2 KV head），KV 显存降低约 4×。

GQA 的数学定义：标准 MHA 中，每个 head $i$ 都有独立的 $W_Q^{(i)}, W_K^{(i)}, W_V^{(i)}$，head 数为 $H$，每个 head 的 KV 显存为 $L \times d_{head}$，总 KV 显存为 $H \times L \times d_{head}$。

GQA 把 $H$ 个 query head 分成 $G$ 个 group，每个 group 内的 query head 共享一组 KV head：

$$ \text{Q heads} = H, \quad \text{KV heads} = G, \quad \text{group size} = H / G $$

KV 显存变成 $G \times L \times d_{head}$，相比 MHA 减少了 $H/G$ 倍。

G 的选择：

$G = H$：标准 MHA，没有 KV 复用。
$G = 1$：MQA（Multi-Query Attention），所有 query head 共享一套 KV。激进省内存但精度损失较大。
$G \in (1, H)$：GQA，介于两者之间。

v3.1 选择 $H = 8, G = 2$（即 group size = 4），显存减少 4×。

为什么是 8Q/2KV 而不是 8Q/1KV：实验中 8Q/1KV（即 MQA）的早期 AUC 损失更大，且后期收敛后也无法完全恢复。GQA 在 group size 较小时（2 或 4），仍然保留了一定的 KV 表达多样性，不会像 MQA 那样把所有 head 强制压在同一个 KV 上。

关键实验发现：早期训练窗口 GQA 有负向波动，充分收敛后反而超过基线。

配置	早期 AUC（0601-0630）	充分收敛 AUC（1001-1031）	吞吐提升
512, 8Q/8KV	基线	基线	35k/s
512, 8Q/4KV	-0.10	-0.05	+8.57% (39k/s)
512, 8Q/2KV	-0.09	+0.04	+20% (43k/s)

这一现象说明：GQA 的负向是训练不充分的假象，在收敛充分的前提下，2 KV-Head 配置能在质量不跌甚至小幅提升的情况下提供显著的吞吐和带宽收益。

底层机理：GQA 通过参数共享降低了 KV 的表达冗余。模型需要更多步数才能在降低的 KV 容量下学到足够的用户序列模式——前几十亿样本的训练里，GQA 比 MHA 看起来"差一点"，但这只是参数被压缩后需要更多训练样本去优化的自然现象。一旦训练样本足够（约 100B 量级），GQA 反而因为正则化效应（参数共享起到隐式正则）和带宽友好（KV cache 小，更容易被缓存）而超过 MHA。

带宽收益的工程意义：在 attention 计算里，KV 是被 query 反复读取的"被动数据"。KV 越小，越能被 L2 / SMEM 缓存，越能减少对 HBM 的访存。在精排这种典型的 memory-bound 场景下，KV 减少 4× 直接转化为推理吞吐提升约 20%。

2.4 QK Norm：替换 Kernel Norm，稳定深层 Attention

v3.0 使用 Kernel Norm 稳定训练，但实验发现 Kernel Norm 对模型权重约束过强，影响训练效果，且增加了不必要的计算量。v3.1 参考主流 LLM 的做法，引入 QK Norm 替换 Attention 模块中的 Kernel Norm：

在计算完 $Q = XW_Q$、$K = XW_K$ 后，对 Q 和 K 分别做一次 RMSNorm 归一化，归一化后的 Q、K 再参与 Attention 计算。同时去掉了 QKVO 矩阵对应的 Kernel Norm 及其 bias。

QK Norm 的数学形式：

$$ \hat{Q} = \text{RMSNorm}(Q), \quad \hat{K} = \text{RMSNorm}(K) $$$$ \text{Attention}(\hat{Q}, \hat{K}, V) = \text{softmax}\left(\frac{\hat{Q}\hat{K}^T}{\sqrt{d_{head}}}\right) V $$

RMSNorm 把 Q、K 的每一行（每一个 token 的 head 向量）归一化到固定的 RMS scale，softmax 输入的 scale 不再随 token 内容动态变化。

为什么 Attention score 容易发散：朴素 attention 中 $QK^T$ 的方差与输入向量的范数强耦合，序列越长、向量范数越分散，softmax 输入的方差越容易放大。一旦某些 token 的 $\hat{Q}\hat{K}^T$ 异常大，softmax 会退化为 one-hot，梯度从此消失，训练不再继续。深层 Transformer 在长序列下尤其容易触发这个退化。

QK Norm vs LayerNorm/Kernel Norm：

LayerNorm 是在 attention 之前对完整 input 做一次归一化，但这没有直接约束 $QK^T$ 的尺度——QKV 的投影权重还是可以放大方差。
Kernel Norm 是对 QKV 矩阵的列向量做范数约束，对权重直接做 hard constraint，但权重的尺度不等于激活的尺度，且这种 hard constraint 限制了模型表达能力。
QK Norm 直接对 Q、K 做归一化，等价于把 attention 的相似度计算从"点积"变成"cosine 相似度"再放大 $\sqrt{d_{head}}$ 倍，从根本上限制了 score 的方差。

与温度参数的关系：QK Norm 之后 $\hat{Q}\hat{K}^T \in [-d_{head}, d_{head}]$ 的尺度区间稳定，因此 softmax 不需要额外学习温度系数。一些 LLM 实现里 QK Norm 之后会再乘一个可学习温度 $\tau$ 进一步精调。v3.1 沿用 RMSNorm 自带的可学习 gain，等价于嵌入了温度系数。

与 GQA 的协同：GQA 把 KV head 数压缩，每个 KV 要服务多个 Q——这意味着 KV 的有效维度变小，对 score 异常更敏感。QK Norm 在 GQA 下尤为重要，能避免少量异常 score 把整组 attention 引爆。

离线效果：CTR UAUC +0.08%

2.5 Fid 统一 Slice：消除特征与序列的 Embedding 割裂

历史上因为模型是热启的，总是通过加 slice 的方式扩维度，造成同一 slot 上往往有多段 slices，特征和序列对同一特征值分别训练两段不同的 embedding。

这一设计的问题是：Transformer Attention 需要费力学习这两段 embedding 之间的联系，严重阻碍模型对 Target & Seq 之间关系的捕获。

v3.1 对代码进行重构，让特征和序列复用同一段 slice，多段 slice 合并为一段（维度向下取整到 32 的倍数保证计算效率）。

为什么 32 的倍数：现代 GPU 的 Tensor Core 偏好 16 / 32 / 64 这样的对齐维度。任意维度都会触发 padding 或 fallback，反而拖慢计算。32 是兼顾灵活性和效率的常用对齐粒度。

离线收益：CTR AUC +0.1%，CTR UAUC +0.2%

3. 训练效率优化

3.1 RM Padding：Ragged Sequence 消除 Padding FLOPs

问题根因：训练时所有序列被 padding 至固定长度（2K），padding token 全程参与 stage-1 的 attention 及 FFN 计算。以最长的 Click 序列为例，均值约 1200，意味着约 40% 的计算资源消耗在 padding 上。

更糟糕的是，padding 不仅消耗计算，还参与梯度回传——尽管 attention mask 把 padding token 的 attention 输出 mask 掉了，但 backward 时 padding 位置仍然会产生梯度分量，这些梯度虽然最终会被 mask 抵消，但显存中的中间激活、grad buffer 都已经付出。

方案：启用 RM Padding（use_rmpadding=True），将 padded 序列转为 ragged 表示，attention 与 FFN 计算仅在有效 token 上进行，实际开销随 avg_len 线性缩放，输出与 padded 路径数值等价。

Ragged 表示的核心思路：把 batch 内所有样本的有效 token 拼接成一个一维张量（total_valid_tokens），同时维护一个 cu_seqlens 数组（cumulative sequence lengths）记录每个样本的边界。Attention 计算时通过 varlen_flash_attn 直接用 cu_seqlens 划分边界，自动保证每个样本只能 attend 到自身 token，不需要显式 mask。

原始 padded: [s1_t1, s1_t2, PAD, PAD, s2_t1, s2_t2, s2_t3, PAD]
 └─────── sample 1 ───────┘└─────── sample 2 ──────┘
ragged 拼接: [s1_t1, s1_t2, s2_t1, s2_t2, s2_t3]
cu_seqlens: [0, 2, 5]

主要技术工作：

① Ragged 算子开发

模型包含 pertoken 处理逻辑（per-token 投影、per-token gating 等），需要在 ragged 状态下对变长序列进行切割与合并。为此开发了一套基于 Ragged Tensor 的 CUDA 算子：

ragged_split：按 split pos 对变长序列进行头部/尾部切割
ragged_merge：将处理后的变长序列重新拼接
ragged_truncate：按样本动态截断

这些算子的核心难点不在于功能逻辑，而在于：保持 cu_seqlens 在算子前后的一致性。任何一个算子维护错了 cu_seqlens，都会让后续 attention 的样本边界错乱，导致跨样本信息泄露——这是一个非常隐蔽且难以定位的 bug。所有算子都内置了 cu_seqlens consistency check 在 debug build 中。

② 模型 Transformer 逻辑重构

引入 RM Padding 后，XLA 因 Tensor 变长而失效，原有融合 Kernel 被打散。重新设计了 Ragged Tensor 状态管理流程，在进入 Transformer 之前即执行 RM Padding，后续所有层不再执行 padding 操作，实现全链路 RM Padding。

具体重构包括：

入口转换：在 stage-1 输入处一次性把 padded 张量转 ragged，后续所有层维持 ragged 状态。
FlashAttention 使用 varlen 接口：Attention 调用 flash_attn_varlen_func 而不是普通 flash_attn_func，靠 cu_seqlens 自动识别样本边界。
FFN 直接在 ragged 上做：FFN 是 token-wise 的，直接在拼接后的张量上跑就行，不需要任何额外处理。
出口还原：在最后输出阶段，再用 ragged_to_padded 还原成 (batch, seq_len, dim) 给后续 listwise 计算。

③ NaN 梯度修复

集成 Triton 融合算子（fused_swiglu、fused_matmul）后，训练中出现 NaN。排查定位到边界场景：当 batch 中某些样本的 ragged 序列长度为 0 时，融合算子的 bias 梯度计算会将未初始化显存值赋给梯度。通过在 CUDA Kernel 中对空输入场景增加 cudaMemset 显式初始化为 0 解决。

这是 RM Padding 带来的典型新问题——padded 实现下"长度为 0 的样本"是被 mask 掉的，永远不会真正进入算子；而 ragged 实现下，“长度为 0 的样本"对应一段 length=0 的拼接片段，会真实地进入 kernel，触发 kernel 内部对边界条件的处理。这种边界条件在 padded 时代根本不需要考虑，迁移到 ragged 之后必须逐一补齐。

3.2 RMSNorm 融合算子：补齐反向算子缺失

RM Padding 后 XLA 自动融合失效，原本被融合的 RMSNorm、FFN element-wise 算子被展开为多个独立 Kernel，出现性能回退。此外公司内部此前仅有 RMSNorm 的前向算子，缺少反向算子，无法支持训练场景。

v3.1 使用 CUDA 开发了 RMSNorm 融合算子（含前向与反向），采用以下优化技术：

向量化访存：利用 Pack 技术（float4、half2），每线程一次读取多元素，提升显存带宽利用率。在 H800 / A100 上，向量化 load/store 能把访存吞吐提升约 2~4×。
编译时多态：通过 DISPATCH_BOOL 宏将 HasResidual、HasGamma 等运行时判断转化为编译时模板参数，消除 Kernel 内的分支指令。每条 if-else 在 CUDA warp 里都是性能刺客——编译时多态把它们彻底消除掉。
寄存器缓存 + One-Pass：前向计算将输入暂存至寄存器，在计算完 Variance 后直接从寄存器读取进行归一化，IO 访问量减少 50%。这个优化要求 d_model 不太大（每个线程能放下一个完整 head 的元素）。在 d_model=512 / head=8 / d_head=64 的情况下，每线程 64 元素，正好可以放进寄存器。
两阶段梯度归约：针对 grad_gamma，采用 Block 局部归约 → Workspace → Global 归约的两阶段策略，避免 Batch Size 较大时 atomicAdd 的性能衰退。直接 atomicAdd 到 global memory 在 batch 较大时会出现严重的争用，吞吐下降到 1/10 都有可能。两阶段归约把绝大多数 add 集中在 SMEM 内完成，最后一次性写回。

3.3 RM Padding + RMSNorm 融合的训练收益

指标	优化前	优化后	变化
Instance Throughput	15K/s	24K/s	+60%
SM Activity	79%	75%	-5%（减少无效 FLOPs，SM 使用更精准）
Tensor Core Active	3.52%	5.06%	+43.8%

值得关注的指标解读：

Instance Throughput +60%：这是直接业务收益，每秒能多过 60% 的训练样本。
SM Activity -5%：看起来像下降，实际上是好事。SM Activity 降低意味着 GPU 不再空转处理 padding，所谓"忙碌时间少了”，但有效计算更密集。
Tensor Core Active +43.8%：这个指标才是真正的"质量提升"——单位时间内进入 Tensor Core 的有效计算量大幅提升，说明优化后的 GPU 时间花在了正确的地方。

3.4 Listwise Squeeze：消除 per-item KV 重复

v3.0 的 stage-1 对 listwise 内每个 item 独立构建 KV，而同一请求内所有 item 共享相同的用户序列，造成大量重复计算与显存占用。

具体来说，假设一个请求带 N=300 个候选 item，stage-1 的 self-attention 在 v3.0 实现里实际上跑了 300 次完全一样的运算——同样的用户序列、同样的 attention 输出，重复打了 300 份。

Listwise Squeeze 实现思路：v3.1 引入 Listwise Squeeze：在 stage-1 先将序列在 user 维度折叠（去除 item 维重复），计算完成后在 stage-2 通过 kv_cache_repeats 展开还原给每个 item，显存占用与 batch 内 item 数解耦。

v3.0 流程: (B, N, L, D) ── stage1 self-attn ──→ (B, N, L, D) ─→ stage2
v3.1 流程: (B, L, D) ── stage1 self-attn ──→ (B, L, D) ── repeat ─→ stage2
 ↑ 一份 ↑ 一份计算 ↑ N 份

stage-1 的 self-attention 计算量从 $O(B \cdot N \cdot L^2 \cdot D)$ 降到 $O(B \cdot L^2 \cdot D)$，也就是直接除以 N（300），降低 2 个数量级。

为什么 v3.0 没这么做：v3.0 的实现里 stage-1 / stage-2 的接口约束了输入张量必须带 N 维度，重构这条接口涉及到 listwise 框架的核心数据流，是一个较重的工程。v3.1 借着 RM Padding 一起重构，正好把这两笔账一起算了。

3.5 GQA Triton FlashAttention 反向改造

已有的 lego 版本在 GQA 的反向逻辑上存在不适配的 bug（特判 MLU 逻辑误生效）。修复方式是在图内重写正确的梯度反传逻辑，核心是处理多头 GQA 的 dk/dv 归约：

def _flash_attention_fwd_varlen_grad(self, op, *grad):
 dq, dk, dv = lego_ops.flash_attention_bwd_varlen(...)
 head_group = q_head // kv_head

 def reduce_fn():
 new_dk = tf.reduce_sum(
 tf.reshape(dk, [k_len, kv_head, head_group, qk_dim]), axis=2)
 new_dv = tf.reduce_sum(
 tf.reshape(dv, [k_len, kv_head, head_group, v_dim]), axis=2)
 return new_dk, new_dv

 dk, dv = tf.cond(head_group > 1, reduce_fn, no_reduce_fn)
 return (dq, dk, dv) + (None,) * 6

当 head_group > 1（即 Q-head > KV-head）时，对 dk/dv 在 head_group 维度做 reduce_sum，将梯度正确归约到 KV head 数量。

梯度归约的数学含义：在前向计算中，一组 Q heads 共享一组 K, V。这意味着 $L = \sum_i \text{loss}(q_i, k_g, v_g)$，其中 $g$ 是该组对应的 KV head。求 $\frac{\partial L}{\partial k_g}$ 时，要把所有共享这组 KV 的 query head 的梯度加起来。这就是 reduce_sum 的来源。

为什么不能简单用 Q-head 数量的梯度直接当 KV-head 梯度：那样相当于多次重复同一组 KV 的梯度，会让 KV 学习速率"虚拟放大" head_group 倍，训练完全发散。reduce_sum 是数学上唯一正确的归约方式。

4. Serving 效率优化：M-Falcon

4.1 原始方案的瓶颈：xmatmul 的碎片化调度

stage-2 cross-attention 原先使用 xmatmul 实现：每个 candidate item 独立调度一次 kernel，中间结果写回 GPU global memory，无法使用 FlashAttention 的 IO 融合优化。在序列较长时，这种碎片化调度模式成为推理 latency 的主要瓶颈。

问题的症结在于：每个 item 的 attention 计算规模太小（单个 item query × 2K user sequence），无法充分填满 GPU 的 Tensor Core；而 kernel launch overhead 在高并发的推荐场景下显著累积。

具体看一组数据：在 v3.0 Serving Profile 里，stage-2 cross-attention 部分的 SM Tensor Core Active 只有 6.1%，远低于现代 GPU 应有的水平（理想区间 30%+）。也就是说，绝大部分 GPU 时间被花在了 kernel launch、memory bandwidth、scheduling 等"杂事"上，真正参与有效 matmul 的时间不到 1/15。

4.2 M-Falcon：拍平合并，单次 FlashAttention

核心思路：将所有 item 的 query token 拍平成一个序列，与用户序列 KV Cache 拼接，batchsize 变为 1（per user）。加上特殊的 Mask 控制可见性，整体送入 FlashAttention 做一次 kernel 计算。中间结果不再落回 global memory，降低 IO 开销。

xmatmul: item_1 query → attn(seq) → out_1
 item_2 query → attn(seq) → out_2
 ... (N 次 kernel launch)
 item_N query → attn(seq) → out_N

M-Falcon: [item_1 query, item_2 query, ..., item_N query, seq]
 ↓
 upper triangular mask
 ↓
 FlashAttention ← 1 次 kernel
 ↓
 [out_1, out_2, ..., out_N]

三个关键设计：

① 上三角 Attention Mask 保证等价性

将多个 item 拍平到同一序列后，通过上三角矩阵 Mask（q_offset <= k_offset）确保：

每个 item query 能 attend 到完整用户历史序列
item 之间不互相 attend，避免信息泄露

数学上，假设拍平后总序列长度 $L_{\text{total}} = N + L_{\text{seq}}$，前 $N$ 个 token 是 item query，后 $L_{\text{seq}}$ 个是用户序列。Attention mask 的设计：

$$ M_{ij} = \begin{cases} 0 & i \in [0, N), j \in [N, L_{\text{total}}) \\ 0 & i = j \text{ (item self-loop, 可选)} \\ -\infty & \text{otherwise} \end{cases} $$

也就是 item query 只能 attend 到 user sequence，不能 attend 到其他 item，也不能 attend 到自己的过去（保持与 v3.0 等价性）。

计算结果与原始逐 item 独立计算完全数值等价。

② Unpad Merge 拼接

将拍平后的 item query KV 与用户历史 KV 通过 unpad_merge 操作拼接，构造统一的 cu_seqlens，交给 FlashAttention（mask_fn=3）单次 kernel 完成计算。

mask_fn=3 是 FlashAttention 提供的自定义 mask 路径，允许传入一个 mask 计算函数，在线计算 mask 而不是预先实例化整个 $L_{\text{total}} \times L_{\text{total}}$ 的 mask 矩阵——这对于 $L_{\text{total}} \approx 2000 + 300 = 2300$ 的场景，节省了 5MB+ 的 mask 存储。

③ 等价替换，无需重训

M-Falcon 前向结果与原始实现数值一致，可在不修改模型权重的前提下直接替换，零迁移成本。这一点在工程实践里非常关键——如果替换 attention 实现需要重训整个模型，那么从决策到上线的周期会拉长一倍以上。M-Falcon 的等价性保证了"先训练好再切实现"的范式，把训练和 serving 解耦。

4.3 Serving 综合收益

RM Padding + M-Falcon 双优化上线后：

指标	优化前	优化后	提升
Service QPS	~271 req/s	~534 req/s	+97%
SM Active	55.5%	62.0%	+6.5pp
SM Tensor Active	~6.1%	~7.3%	+~20%

QPS 近乎翻倍，是本次效率优化最直观的线上收益。

为什么 SM Tensor Active 只升到 7.3%：精排 Serving 的天然约束是 batch_size 小（per user），即便用上 M-Falcon 把多个 item 拍平，总 token 数也只有 2K~2.5K 量级，远低于训练 batch 的 32K+ token。这个尺度下 Tensor Core 还达不到理想利用率。要进一步往上突破，需要把多个用户的请求一起 batch 起来——这是后续 V3.2 / V4 的方向。

5. Torch Rebase：跨框架迁移的工程实践

v3.1 同步完成了从 TensorFlow 到 PyTorch 的框架迁移（Torch Rebase），并完成离在线打平，作为后续迭代的 Torch 基线。

离在线打平的挑战：框架切换不仅是代码翻译，还涉及数值精度、算子实现差异、分布式训练行为等多个层面的对齐。团队整理了 step-by-step 的迁移操作手册，并开发了自动迁移对比工具，系统性地验证离线指标（AUC、UAUC）和在线指标的打平。

自动对比工具的核心机制：在每一层 forward 输出处插桩，把 TF 模型和 Torch 模型同时跑同一批样本，对比每层激活值的相对误差。设置一组阈值（例如 atol=1e-4, rtol=1e-3），任何一层超出阈值就触发报警，定位到具体哪个算子产生了精度漂移。这种自动化对比让"逐层调试"不再依赖工程师手工 print。

常见的精度漂移源：

算子默认精度：TF 默认 float32，Torch 默认 float32 但某些算子（如 LayerNorm）在 cuDNN 下可能 fallback 到 mixed precision，需要显式控制。
算子语义微差：TF 的 softmax 和 Torch 的 softmax 在数值稳定性实现上有细微差别（TF 减最大值后再减最小值，Torch 直接减最大值）。在长序列下这种差别可能放大。
embedding 初始化：TF 默认 truncated_normal，Torch 默认 normal，需要统一。
优化器更新顺序：TF 的 apply_gradients 和 Torch 的 optimizer.step() 在分布式 all-reduce 时机上有差别。

Serving 打平：针对 Serving 框架差异，完成了内部 Serving 框架的 Torch 模型接入，确保推理路径与 TensorFlow 版本数值一致。

6. 模型工程参数演进

参数	v3.0	v3.1	变化
NN Params	165M	396M	+140%
d_model	384	512	+33%
SeqFormer 层数	5	7	+40%
序列长度	1K	2K	+100%
KV Heads	8	2	-75%（GQA 节省显存）
Training instance/s	48K	25K	-47%（更大模型 + 更长序列）
GPU SMA	82	80	-2pp
Tensor Core Active	9.9%	5.1%	-4.8pp（序列扩展后 kernel 变小）

注：训练吞吐下降是序列 2× + 模型 2.4× 参数量带来的必然代价，通过 RM Padding 和 Listwise Squeeze 部分对冲（原始方案会更低）。

为什么 Tensor Core Active 下降了：v3.0 的层数少（5 层）、序列短（1K），attention kernel 单次计算规模较大，更容易打满 Tensor Core。v3.1 的层数多（7 层），每层 kernel 的相对规模变小，Tensor Core 利用率自然下降。这是 Scaling 必然带来的代价，但通过 GQA + RM Padding 把绝对吞吐拉回来了。

显存账面分析：理论上序列从 1K 到 2K，KV cache 显存翻倍；模型从 165M 到 396M，参数显存提升 2.4×；7 层 vs 5 层，激活显存提升 1.4×。如果不做任何优化，整体显存需要 ~5×。但实际上 v3.1 在同一卡型下完成训练，关键就是：

GQA 把 KV 显存压缩 4×。
Listwise Squeeze 把 stage-1 显存压缩 N=300×（item 维度折叠）。
RM Padding 把激活显存压缩 ~2.5×（去掉 padding 浪费）。

三者叠加，把"理论上需要 5× 显存"压缩回了"原本的水平"。

7. 线上 A/B 实验结果

7.1 核心业务指标

泛商城（General Mall）：

指标	变化
GMV/user	+1.0175%
uv_ctcvr	+0.4986%
main_order/user	+1.3642%
sub_order/user	+1.9207%
click/user	+1.277%
uv_ctr	+0.2817%

Mall Feeds：

指标	变化
GMV/user	+0.5894%
click/user	+1.4431%
uv_ctr	+0.2607%

大盘： 人均支付成功 sku 单数（剔除异常单）+0.4715%

7.2 多维度收益

多样性：曝光四级类目数 +1.094%，点击四级类目数 +1.423%
发现性：发现性流量 PV 占比 +0.641%，人均发现性点击四级类目宽度 +1.878%
冷启动：0 单商品点击 PV 人均 +1.337%
首购：当日首购类目 +1.126%

7.3 ROI

ROI +0.24%
综合（引入 FP16 等训推优化后）ROI +0.11%，增量 ROI 277

7.4 业务收益的归因分析

把 +1.02% GMV/user 拆开看，可以看到几个值得关注的现象：

click/user (+1.277%) 与 GMV/user (+1.02%) 同步上升，且 click/user 涨幅更大——说明模型把更多样的内容推到了用户面前，用户点击意愿提升，最终成交也跟着上去。这是一种"健康"的提升，而不是单纯靠"挑出最贵的 item"压榨成交。
多样性指标（曝光/点击四级类目数 +1.1% / +1.4%）正向，说明 2K 序列+丰富特征带来的"长期兴趣建模能力"真的让模型看到了更宽的兴趣面，而不是把所有用户都收敛到几个热门类目。
冷启动指标 +1.337%、首购 +1.126%，说明长序列对"新用户/新场景"也有显著帮助——这与直觉相反的发现，但合理：长序列里有更多的"探索性 click"，模型可以借助这些信号判断"这个用户在哪些方向是新手，哪些方向是老手"。

8. 工程思考与经验总结

8.1 效率优化是 Scaling 的先决条件

v3.1 的四条主线并非独立并行，而是有明确的因果依赖：先解决训练/Serving 效率问题，才有预算做结构 Scaling Up。RM Padding 和 Listwise Squeeze 释放的显存与算力预算，直接使能了 d_model=512、SeqFormer 7 层的扩展；M-Falcon 的 QPS 翻倍则为更大模型的 Serving 成本提供了缓冲。

这说明在工业推荐场景下，模型 Scaling 不是单纯的参数堆叠，而是效率-容量的协同优化：每一轮效率提升都打开了新的容量空间，而容量提升带来的效果增益反过来验证了效率投入的价值。

类比看，LLM 的 Scaling Law 之所以能持续兑现，背后离不开 FlashAttention、PagedAttention、Continuous Batching 这一系列效率工具的不断推进。精排领域走的是同一条路——只是它的"效率瓶颈点"和 LLM 不完全一样，需要在序列长度、batch size、listwise 重复等维度上做特化。

8.2 GQA 的收益需要充分收敛才能显现

GQA 早期训练窗口的负向波动是一个值得注意的现象：在训练 0601-0630 阶段，8Q/2KV 配置 AUC 下降 -0.09，而到 1001-1031 阶段反转为 +0.04。贸然用早期 checkpoint 评判 GQA 的效果，会得出错误结论。

这一现象的底层逻辑：GQA 通过参数共享降低了 KV 的表达冗余，模型需要更多步数才能在降低的 KV 容量下学到足够的用户序列模式。早期表现弱不是模型的极限，而是还没充分收敛。

实操建议：

不要用早期 AB 实验评判 GQA。GQA 的收敛速度比 MHA 慢，前 10B-50B 样本的 AB 数据基本没有参考价值。
观察 AB 收益曲线的斜率。如果 GQA 相对 MHA 的差距在持续缩小（甚至反超），说明它在正确的方向上；如果差距长期稳定，可能模型容量上限差异是固定的。
结合服务端收益做总账。即便 GQA 在质量上和 MHA 持平，光是显存节省 4× 带来的显存预算释放，就足以支持其它结构改动，整体仍是大幅净收益。

8.3 TruncatedNormal 初始化是加宽的稳定器

直接从 384 加宽到 512/768 而不调整初始化，会导致输出方差随宽度比例放大，激活饱和，训练不稳。TruncatedNormal std=0.02 的选择并不神秘——它的本质是让每层输出的方差尺度与宽度无关（通过更小的 std 对抗 fan-in 增大带来的方差膨胀）。实践中 std=0.02 是一个经验上相对保守、稳定性好的选择。

更进一步的视角：精排模型相比 LLM 有一个特殊点——它的训练数据是不停滚动的（每天新到样本），所以"训练初期的稳定性"特别重要——如果开训前几小时就走偏，整个 daily refresh 周期就被毁了。TruncatedNormal 在这种"不能容忍长尾不稳定"的场景下尤其合适。

8.4 Fid 统一 Slice 的收益来自信息流通

同一个 slot 的特征和序列用不同 slice 的问题，本质是人为制造了 embedding 空间的割裂。Transformer 的 self-attention 本来可以直接捕获 Target item 和序列 item 在同一特征维度上的相似性，但两段独立 embedding 使得"同一个特征值"在特征侧和序列侧有两套不同的表示，Attention 需要额外的参数容量来学习这两套表示之间的对应关系。统一 Slice 相当于给模型做了"对齐初始化"，消除了这层多余的学习负担。

8.5 RM Padding 的"看似简单实则复杂"

RM Padding 的核心思想用一句话就能说完：“去掉 padding，把所有有效 token 拼成一个一维张量”。但实际工程实现里，它牵动了：

算子层：所有 per-token 算子都要补 ragged 版本。
图编译层：XLA / Triton 的融合规则必须重写。
NaN 处理：长度为 0 的样本暴露了原本被 mask 掩盖的 bug。
训练超参：batch 内有效 token 数变成动态的，learning rate / gradient accumulation 步数都要重新调校。
Profile 工具：原本看 SM Active 就能判断 GPU 利用率，现在要看 Tensor Core Active 才更准。

每一个点单独看都不困难，但全部走通需要工程团队对训练栈的完整 ownership。这也是为什么 RM Padding 在 LLM 已经普及多年，但精排场景到现在才广泛落地的原因。

8.6 M-Falcon 的"等价替换"价值

M-Falcon 最被低估的特性其实是"等价替换"——不需要重训模型，可以直接 swap 掉旧的 xmatmul 实现。这意味着：

训练侧无感：不用重新训练，沉没成本是零。
灰度可控：上线 1% → 10% → 50% → 100% 的灰度过程中，任何时候发现问题都能即时回滚。
风险可量化：一次只改一个变量（attention 实现），AB 收益完全可以归因到 M-Falcon 自身。

这种"等价替换"思维在工业系统里非常重要——它把"模型创新"和"工程优化"解耦，两条线可以并行推进。

8.7 未来方向

序列进一步扩展：2K → 4K 甚至更长，需要更激进的效率优化（稀疏 Attention、进一步压缩 KV）。在 4K 长度下，全量 attention 会重新成为瓶颈，必须引入 Sliding Window / Sparse Attention / Linear Attention 等近似机制。
M-Falcon 泛化：将拍平合并策略推广到更多 cross-attention 场景（例如 user × ad、user × creator 的多 target 联合建模）。
模型 Scaling 继续：d_model=512 → 768/1024，SeqFormer 7 → 9/12 层。这一步的关键不是模型本身能否训出来，而是显存和 Serving 延迟能否给得起。
Foundation Model 范式迁移：将 Pretrain → Posttrain → SFT 的多阶段训练范式引入精排，复用召回层的 Foundation Model 权重。这一步可能是精排下一波"质变级"提升的关键路径——把精排从"专项任务"变成"通用智能下游适配"。
多模态信号引入：用户行为序列里其实可以注入图片 embedding、文本 embedding 等多模态信号。这一步的难点在于多模态信号的"长期 freshness"——商品图片可能更新，模型需要应对动态信号。
在线学习与实时更新：现行 daily refresh 的训练周期还是太慢。把 KV cache 这一类与"用户最新行为"强相关的部分在线刷新，是延迟和 freshness 之间的合理 tradeoff。

参考文献

Ainslie, J., et al. (2023). GQA: Training Generalized Multi-Query Transformer Models from Multi-Head Checkpoints. arXiv:2305.13245
Dao, T., et al. (2022). FlashAttention: Fast and Memory-Efficient Exact Attention with IO-Awareness. NeurIPS 2022.
Dao, T., et al. (2023). FlashAttention-2: Faster Attention with Better Parallelism and Work Partitioning. ICLR 2024.
Zhang, B., & Sennrich, R. (2019). Root Mean Square Layer Normalization. NeurIPS 2019.
Press, O., et al. (2024). SOLAR 10.7B: Scaling Large Language Models with Simple yet Effective Depth Up-Scaling. arXiv:2312.15166
Shazeer, N. (2020). GLU Variants Improve Transformer. arXiv:2002.05202
Zhai, S., et al. (2023). Scaling Vision Transformers to 22 Billion Parameters. ICML 2023.
Henry, A., et al. (2020). Query-Key Normalization for Transformers. EMNLP Findings 2020.
Shazeer, N. (2019). Fast Transformer Decoding: One Write-Head is All You Need. arXiv:1911.02150
Pope, R., et al. (2023). Efficiently Scaling Transformer Inference. MLSys 2023.
Vaswani, A., et al. (2017). Attention Is All You Need. NeurIPS 2017.
Zhou, G., et al. (2018). Deep Interest Network for Click-Through Rate Prediction. KDD 2018.
Zhou, G., et al. (2019). Deep Interest Evolution Network for Click-Through Rate Prediction. AAAI 2019.
Pi, Q., et al. (2020). Search-based User Interest Modeling with Lifelong Sequential Behavior Data for Click-Through Rate Prediction. CIKM 2020.
Chen, Q., et al. (2019). Behavior Sequence Transformer for E-commerce Recommendation in Alibaba. DLP-KDD 2019.
Kang, W. C., & McAuley, J. (2018). Self-Attentive Sequential Recommendation. ICDM 2018.
Sun, F., et al. (2019). BERT4Rec: Sequential Recommendation with Bidirectional Encoder Representations from Transformer. CIKM 2019.
Touvron, H., et al. (2023). LLaMA 2: Open Foundation and Fine-Tuned Chat Models. arXiv:2307.09288.

LLM 范式重构电商推荐召回：生成式召回的工程实践全记录

Tue, 28 Apr 2026 10:00:00 +0800

本文整理自某大型电商推荐系统内部技术文档，记录了在商城推荐召回阶段引入 LLM 训练范式（Foundation Model + Generative Recall）的完整工程实践。核心方案以 Pretrain → Posttrain → SFT 三阶段训练为框架，将召回链路从判别式改为生成式（Beam Search），并首次走通 Foundation Model 参数加载范式，最终在真实电商场景取得 GMV +0.374%、训练时间 49.8 天 → 12.3 天 的效果。

0. 背景：推荐系统的两个结构性局限

“算力 + 通用方法，长期总是胜过精心设计的领域先验”——这是 AI 过去数十年演进反复兑现的规律（Bitter Lesson, Rich Sutton）。从 ImageNet 时代的卷积网络对手工特征的胜利，到 BERT/GPT 系列对结构化 NLP 流水线的颠覆，再到 AlphaZero 仅靠通用强化学习就吊打围棋专家系统——这条规律一次又一次被验证。

推荐系统是这一规律目前尚未被充分兑现的主要方向。过去推荐系统依赖先验的精细化设计在历史阶段带来了可观收益（DIN 的 attention 先验、双塔的 Late Fusion 先验、PLE/MMOE 的多任务 gating 先验等），但当算力与数据规模持续扩展时，整套链路逐渐显现出两个结构性局限：

局限一：算力利用斜率受限

在 Pointwise 预估框架下，单条样本仅提供 1 个监督信号，样本利用效率低。具体来说：传统的 user-item pair 样本，每条样本从 forward 到 backward 全图过一遍，最终只产生一个 binary cross-entropy 监督信号。这种 1:1 的样本-信号比意味着，要让模型学到充分的用户兴趣表征，必须把数据集翻倍、把训练时间拉长。LLM 的序列样本自回归训练一条即可贡献 $L$ 个监督信号（其中 $L$ 是序列长度），样本效率提升 $L$ 倍。换句话说，同样的计算资源，LLM 范式能看更多"东西"，能从同一份样本中蒸馏出更多有效信号。

更深层的原因是，LLM 的序列建模天然就是条件概率分解：

$$P(x_1, x_2, \ldots, x_L) = \prod_{t=1}^{L} P(x_t \mid x_{每一步预测都同时要求模型学习短程依赖、中程关联和长程上下文。这种密集监督下的算力斜率（每 GPU·小时所提取的有效信息量）远高于 Pointwise 监督，是同样硬件下高出近一个数量级的训练效率。

局限二：建模天花板受限

强先验的网络结构和单一化的建模任务，在 GPU 强算力时代成为迭代瓶颈。统一 Transformer 结构的工作（如 OneTrans）已经把网络主干统一化，但其输入输出相对固化——往往只接 user feature group 与 item feature group 两个输入，仅输出一个标量打分。在算力充裕的今天，这种"窄输入、窄输出"的设计已经变成迭代速度的天花板。我们想新增一个上下文特征、想新增一个目标信号、想新增一种建模任务，往往都需要改图、改 reader、改 loss、改 metric——边际成本极高。

通过导入 Action、Context 等输入和相关预测任务，打开了 Transformer 输入输出建模复杂化和通用化的迭代空间。新输入只需要扩展 tokenizer，新任务只需要在序列末尾加 token、在 loss 上加权重——一切都退化为"序列上的 token 增减问题"，迭代成本骤降。

生成式召回 vs 判别式召回的本质差异

判别式范式假定召回任务是"在 N 个候选中找 top-K"，于是把 user 和 item 分别建模成一个向量，用点积得分排名。这一假定在 N 比较小时还合适，但当商品库规模上亿、user 多兴趣多场景时，就开始捉襟见肘——双塔被迫维持 fixed dimension，无法 scale；user 兴趣被压缩成一个向量后多模态信息丢失；冷启动 item 由于历史交互稀疏导致 embedding 学不出来。

生成式范式则把召回视为"给定上下文，自回归生成 item 序列"，本质上更接近自然语言模型的下一词预测。每个 item 被表征为多 token 的语义码字（Semantic ID），模型学到的是一个条件分布 $P(\text{item} \mid \text{user history, context})$，可以直接采样、Beam Search、或者按概率排序——所有这些操作都不依赖商品库的具体规模。

基于上述判断，这次工作做出了一个大胆的尝试：把 LLM 的训练范式完整引入推荐召回阶段，在全场景长周期序列样本上产出 Foundation Model，参数加载到下游召回任务继续 SFT，线上链路通过 Beam Search 的生成式链路替换了原本判别式召回的索引式链路（IVF/HNSW）。

1. 整体方案：三阶段 LLM 训练范式

整个方案以 LLM 的训练范式为基准，在电商商品推荐的召回场景上落地。样本组织形式、训练流程如下：

三个训练阶段

阶段一：Foundation Model Pretrain

在序列样本上进行无监督预训练，采用多层 SID 自回归的建模方式，引入 NTP (Next Token Prediction) Loss 进行预训练，充分学习用户行为模式与商品语义的通用表征。这一阶段覆盖全场景两年历史数据，在 SEA 地区可以做到 2~3 天训完。

Pretrain 的核心目标是让模型学到与下游任务无关的通用表征：用户的多兴趣分布、商品的语义聚类结构、不同场景的行为模式差异。这一阶段不偏向任何特定下游目标（点击 vs 成交、商城 vs 直播间），所以可以无差别地加载到任何下游任务作为初始化。模型规模和数据规模在这一阶段同时扩展，训练成本最高，但收益分摊到多个下游任务后边际成本反而最低——这正是"一次预训练、多场景复用"的工程价值所在。

阶段二：Recall Posttrain

从 Pretrain ckpt load 起训，前缀历史经 Prefill Merge 压成 5× 压缩的 Merged Token，只对末尾 last-k 位置做 Next Multi-Item Predict、按 set-based 样本组织，与召回按 top-K 取集合的使用方式对齐。

Posttrain 是 Pretrain 与下游 SFT 之间的缓冲带：既要保留 Pretrain 学到的通用表征不被破坏，又要适配召回任务"取集合"而非"取序"的语义。具体做法是把 Pretrain 时的 Next Item Predict 切换为 Next Multi-Items Predict，同时收紧训练样本到召回样本——这是一个典型的"任务对齐 + 数据对齐"双重适配过程。

阶段三：Recall Task SFT

召回下游上线任务，延续 Merged 输入作为 prefill，切到 pointwise 样本并用 Single-Token Loss；引入 Reward 增强召回效率。

SFT 阶段把模型彻底对齐到上线任务的目标分布上。Pointwise 样本的引入是必要的——线上召回打分需要 user-item-context 三元组的精细计算，pointwise loss 能让模型学到细粒度的偏好排序。Reward 的引入则借鉴了 RLHF 的思路，用业务指标（GMV、点击率、加购率等）作为奖励信号，让模型直接对齐业务目标而非代理目标。

这一范式的核心价值是"一次预训练，多场景复用"：

$$\text{Foundation Model} \xrightarrow{\text{Recall SFT}} \text{召回模型} \xrightarrow{\text{Ranking SFT}} \text{粗排/精排模型}$$

同时也打开了清晰的 scaling 路径：模型规模、序列长度与训练数据量均可在可观测的收益曲线下持续扩展。多阶段架构的"无损迁移"特性——backbone 不变、仅切换数据组织和 loss——保证了 Pretrain 的成本可以被多个下游任务平摊，训练算力的单位收益最大化。

生成式召回 vs. 传统判别式召回

传统的双塔召回本质是判别式框架：用 User Embedding 和 Item Embedding 的点积估计相关性，用 HNSW/IVF 做近似最近邻检索。这套方案在大量部署下也暴露了若干局限：

维度	判别式召回（双塔）	生成式召回（本方案）
建模目标	点积相似度	自回归序列生成
索引结构	HNSW/IVF（耦合商品库）	Beam Search（解耦商品库规模）
冷启动	弱（依赖 ID 特征）	强（SID 语义泛化）
Scaling	受限于双塔结构	随 LLM 参数量 Scaling
多目标	需要多任务改造	Condition Token 自然支持

生成式框架的推理复杂度解耦商品库规模，Scaling 空间更大；Semantic ID 的引入改善了模型泛化能力，冷启动商品的 PV 和点击显著提升。

更深一层看，判别式与生成式的区别本质上是信息处理顺序的差异。判别式先固定商品库规模、再在上面做检索，是"先静态、后查询"；而生成式先理解上下文、再让模型生成 item，是"先理解、后生成"。前者把所有学习压力压在 Embedding 上，后者把学习压力分散到整个 Transformer 的所有层和 token 上。当 Embedding 容量遇到瓶颈时，前者的 scaling 曲线开始走平，而后者还能通过加深加宽 Transformer 继续涨——这是为什么"模型规模越大、生成式优势越明显"的根本原因。

2. 模型结构：工业化 LLM Backbone

2.1 整体架构

模型采用标准 Decoder-Only Transformer，本次上线版本选用 170M 参数档位，核心超参如下：

配置	Value
Layers	6
Hidden dim	4096
FFN dim	1024
Attention heads	8
KV heads (GQA)	4
Head dim	128
Max sequence length	1024
SID 码本	8192 × 3
总参数量	170M

核心 Transblock 完全沿用 LLaMA / Qwen 等主流 LLM 的设计（RMSNorm + SwiGLU + RoPE + GQA），并叠加了三项针对深层 Transformer 稳定性的改动。

Decoder-Only 选择的理由：相比 Encoder-Decoder 架构，Decoder-Only 在生成式推荐场景下有几个显著优势：(1) 训练时一条样本同时贡献 L 个监督点（teacher forcing），样本效率最大化；(2) 推理时一次 prefill + 多步 decode，KV cache 可以复用；(3) 同一个模型既能做 Pretrain（Next Token Predict）也能做下游任务（Beam Search 生成），避免了两套结构的迁移损失。

One Transformer 理念的贯彻：同一套 backbone 结构贯穿 Pretrain → Stage-1 Recall PostTrain → Recall SFT&RL 多个训练阶段保持不变，阶段切换只调整数据组织、loss 形式与优化器配置，模型权重可以无损迁移、拼接、复用。这一设计的工程价值不容忽视——它意味着 Pretrain ckpt 可以直接 hot-start 任意下游任务，避免了"换结构就要重新预训练"的浪费；它也意味着在 backbone 维度的所有优化（FlashAttention、混精度、KV cache 共享等）都能跨阶段复用。

与此前判别式召回的对比：

参数	旧版 DVF 召回	本方案（v1）
参数量	1.3M	170M
FLOPs	1.41T	96.33T
序列长度	200	512

参数量提升了约 130 倍，FLOPs 提升了约 70 倍，序列长度从 200 拉长到 512——这并不是"暴力堆资源"，而是因为生成式框架的 Scaling 曲线还远未饱和。在双塔架构下，把 1.3M 参数堆到 170M 几乎得不到提升（双塔的 bottleneck 在 embedding 维度而不在网络深度）；但在 Decoder-Only 的 LLM 框架下，每一份额外参数都能转化为更精细的兴趣建模、更强的语义泛化能力。

2.2 Grouped Query Attention（GQA）

标准 MHA 下每个 query head 独立维护一套 KV，KV 显存随 head 数线性增长。在 LLM 推理场景下，KV cache 是显存瓶颈的主要来源——当 batch_size、sequence_length、num_heads、head_dim 任意一个维度上升时，KV cache 都成倍增长。具体地，KV cache 的显存占用为：

$$\text{KV cache size} = 2 \times B \times L \times H_{kv} \times D_{head} \times \text{precision}$$

其中 $B$ 是 batch、$L$ 是序列长度、$H_{kv}$ 是 KV head 数、$D_{head}$ 是 head 维度。对于一个 batch=2048、L=1024、H=8、D=128、FP16 的模型，仅一层的 KV cache 就需要约 8GB，6 层就是 48GB——这还没算计算时的 attention map 中间值。

MQA（Multi-Query Attention）的缺陷：MQA 把所有 query head 都共享同一组 KV（即 $H_{kv}=1$），KV cache 直接降到 $1/H$，但效果损失明显——当不同 query head 关注的语义模式差异较大时，强制它们共用一组 KV 会丢失重要的多视角注意力。LLaMA 早期实验就发现 MQA 在长序列下有 1-2 个百分点的明显效果退化。

GQA（Grouped-Query Attention）的设计原理：GQA 是 MHA 与 MQA 之间的折中——把 query head 分成若干组，每组共享一套 KV。本方案设置为 8 query head 共享 4 KV head（即 group size = 2），KV 显存降低约 2×。这种设计的精妙之处在于：当不同 query head 之间存在"组内相似性"时（往往如此，因为相邻 head 在训练后会自然学到相近的注意力模式），合并它们的 KV 几乎不损失信息，但能省一半显存。

数学上，GQA 的 attention 计算可以写为：

$$\text{Attn}_{\text{group } g}(Q^{(g)}, K^{(g)}, V^{(g)}) = \text{softmax}\!\left(\frac{Q^{(g)} K^{(g)\top}}{\sqrt{d_{\text{head}}}}\right) V^{(g)}$$

其中 $Q^{(g)}$ 表示属于第 $g$ 组的所有 query head 的拼接，$K^{(g)}, V^{(g)}$ 是该组共享的 KV。

实验效果（HR@50 仅 -0.3%，吞吐 +15%）：

改动	HR@1	HR@10	HR@50	instance/s
Q head 8 / KV head 8	-	-	-	-
Q head 8 / KV head 4	-0.05%	-0.1%	-0.3%	+15%

效果损失极小，而推理吞吐提升明显——这种权衡在工业推荐场景下完全可以接受。为什么推荐场景对 GQA 损失更不敏感？ 因为推荐序列里大多数 token 都是 SID（语义码字），相比自然语言 token 的语义稀疏性更低、模式更同质，多组 KV 的边际信息相对小一些；同时，推荐模型对 latency 的要求又远高于纯 NLP 服务（线上 QPS 是关键指标），所以"用一点效果换显著吞吐"的 trade-off 在这里非常划算。

2.3 SwiGLU FFN

FFN 采用 SwiGLU，相比 ReLU/GELU 在同等参数规模下有稳定的 loss 改进，也是当前主流 LLM 的默认选择（Noam Shazeer 2020）：

$$\mathrm{FFN}(x) = \bigl(\mathrm{SiLU}(xW_{\text{gate}}) \odot xW_{\text{up}}\bigr)W_{\text{down}}$$

其中 $\text{SiLU}(x) = x \cdot \sigma(x)$ 是 Sigmoid Linear Unit，与 Swish 等价。SwiGLU 的核心思想是引入 gating 机制——SiLU(xW_gate) 充当门控信号，逐元素地控制 xW_up 哪些维度被激活、激活到什么强度。相比朴素的 ReLU(xW)W' 这种"全有全无"的激活，SwiGLU 的连续门控让信息流动更平滑、梯度更稳定。

SwiGLU FFN 由 gate / up / down 三个矩阵组成，参数量为 $3dm$。标准做法是取 $m = 8d/3 \approx 2.67d$ 以对齐 vanilla FFN 参数预算（vanilla FFN 是 $d \to 4d \to d$，参数量 $8d^2$；SwiGLU 用 $3dm = 3 \times d \times \frac{8d}{3} = 8d^2$ 与之对齐）。但考虑到 L40 + FP16 推理下 Tensor Core 的对齐限制（intermediate size 需为 16 的倍数），本方案将中间层放宽至 $m = 4d$，参数量约为 vanilla 配置的 $1.5\times$。

实验发现增加 FFN 参数量，主要提升了模型对 SID 映射关系的记忆能力（SID Level 2/3 的 hitrate）：

Expand ratio	HR@1	SID Level 0 HR@1	SID Level 1 HR@1	SID Level 2 HR@1	instance/s
2.67d (标准)	-	-	-	-	-
4d (本方案)	+5%	+1%	+8%	+15%	-2%

SID Level 2 的提升尤其大（+15%）——这印证了一个直觉：FFN 是 Transformer 的"知识库"，参数量越大，能记住的细粒度映射关系越多。SID Level 2 是最细粒度的码字（对应商品的差异化特征），需要模型记住"前缀 (s0, s1) 之后到底接哪个 s2"——这种记忆能力恰恰是 FFN 容量决定的。Transformer 注意力层贡献"上下文计算"，FFN 层贡献"事实记忆"，二者协同决定了模型的整体能力上限。

2.4 RoPE 位置编码

位置编码使用 RoPE（Rotary Position Embedding），通过对 Q/K 直接做相位旋转引入相对位置信息。传统位置编码方案有两种——绝对位置编码（APE）通过 lookup embedding 表给每个位置加偏置；相对位置编码（如 T5 的 relative attention bias）则在 attention logit 上加可学习的偏置矩阵。两种方案各有不足：APE 在长度外推时表现差（训练时没见过位置 1024，推理时遇到就崩），相对位置编码计算开销大且不易并行化。

RoPE 的核心想法是把位置信息编码成"相位旋转"——给定位置 $m$ 和向量 $\boldsymbol{x}$，把 $\boldsymbol{x}$ 按维度两两配对，每对 $(x_{2i}, x_{2i+1})$ 当作复数 $x_{2i} + j x_{2i+1}$，乘以旋转因子 $e^{j m \theta_i}$（即旋转角度 $m\theta_i$）。这样 query 在位置 $m$、key 在位置 $n$ 时，二者的 attention logit 自然包含相对位置 $m - n$ 的信息：

$$\langle \text{RoPE}(\boldsymbol{q}, m), \text{RoPE}(\boldsymbol{k}, n) \rangle = \boldsymbol{q}^\top R_{m-n} \boldsymbol{k}$$

其中 $R_{m-n}$ 是相对位置 $m-n$ 决定的旋转矩阵——这意味着 logit 只与相对位置有关，与绝对位置无关，天然支持任意长度外推。

RoPE 在生成式推荐中的特殊价值：序列长度在不同阶段差异明显——Pretrain 用 512、Recall Posttrain 切换到 prefill merge 后等效更短、Beam Search 推理时随着生成步数序列还会增长。RoPE 让结构在不同长度下都可以直接复用，无需额外训练。如果用 APE，每次切换序列长度都要重训 position embedding；用相对位置 bias 又会拖慢推理。RoPE 是这两难之间的最优解。

对异构 token 的处理：推荐序列中 token 类型不同——有 Context token（场景标签）、有 SID token（商品语义码字）、有 Item info token（商品 ID 等精细特征）。这些 token 的位置信息含义完全不同——Context token 之间是无序的标签集合、SID token 之间有强次序关系（粗到细的语义分级）、Item info token 仅作为辅助补充。本方案把所有 token 类型的位置都按"全炸开"方式编码（每个 token 占一个完整位置），让 RoPE 同时学到"序列级位置"和"层级关系"。

Pretrain 阶段对比 APE 和 RoPE 的实验结果（RoPE 对异构 token 全炸开的形式提升最大）：

位置编码	HR@1	HR@10	HR@50
NoPE	-	-	-
APE	+5%	+6.2%	+8.3%
RoPE	+10%	+12%	+18%

注意 NoPE 也并非完全没有位置感知——Decoder-Only 的 causal mask 本身就隐含了"当前 token 只能看到前面 token"的弱位置信息。但这种弱位置信息不足以建模复杂序列，加了 APE 提升一档，加了 RoPE 再提升一档。RoPE 对长序列尤其友好——HR@50 提升 18% 远高于 HR@1 的 10%，说明 RoPE 在"远程上下文"的建模上更有优势。

2.5 稳定性三件套

深层 Transformer 在 scaling up 过程中频繁出现方差失配问题：不同模块输出方差量级不对齐，导致激活爆炸、attention logit 过大、残差路径失效。当模型从 1B 走向 100B 时，这些问题会被指数放大，最终训练直接 NaN。即便是 170M 这样的中小模型，只要层数 ≥ 6、序列长度 ≥ 512，方差失配的隐患就已经显现。以下三项措施协同控制稳定性：

QK Norm

序列长度和 d_model 同时上升后，attention logit $QK^T/\sqrt{d_\text{head}}$ 的量级波动显著加剧。具体来说，$Q$ 和 $K$ 是从同一个 hidden 投影出来的，两者方差成正相关，而 $QK^\top$ 是它们的内积——方差按 $d_{\text{head}}$ 的量级累积。即便除以 $\sqrt{d_{\text{head}}}$，logit 的尾部分布仍然会有少量极大值，softmax 之后就退化为 one-hot——某个 query 100% 关注某个 key、其它 key 完全得不到 attention，梯度几乎全集中在那一对 (Q, K) 上，训练极不稳定。

在 Q、K 投影之后套一层 RMSNorm（QK Norm），归一化后 logit 的尺度收敛到固定范围，softmax 梯度分布更均匀。具体形式：

q = self.q_proj(x)
k = self.k_proj(x)
q = self.q_norm(q) # RMSNorm
k = self.k_norm(k) # RMSNorm
attn = (q @ k.transpose(-1, -2)) / sqrt(d_head)

QK Norm 强制 $\|Q\|_2$ 和 $\|K\|_2$ 都被归一化到固定模长，logit 的最大可能值被严格限制在 $\|Q\|\|K\|/\sqrt{d_{\text{head}}}$ 之内，再也不会出现极端值。

同时去掉了之前大量使用的 Kernel Norm，加上 weight decay 配合 QK Norm 一起稳定训练。实验验证，这个替换还可以顺带去掉模型中所有的 bias，既节省计算量又提升性能。为什么去 bias 是合理的？ 因为 RMSNorm 本身会做尺度归一化，bias 的偏移功能可以被下游层的 weight 等效吸收——保留 bias 反而引入冗余自由度，让训练更难收敛。

Residual Rescale

Pre-Norm 结构下每层的残差 $y = x + F(x)$ 会让 $\text{Var}[x]$ 单调上升。具体地，假设每层的 $F(x)$ 输出方差为 $\sigma^2$，且与 $x$ 不相关，则：

$$\text{Var}[y] = \text{Var}[x] + \text{Var}[F(x)] = \text{Var}[x] + \sigma^2$$

经过 $L$ 层后，$\text{Var}[x_L] = \text{Var}[x_0] + L\sigma^2$，方差线性增长。当 $L$ 很大（比如 $L=24$ 的 GPT-2 small）时，深层的 $\text{Var}[x_L]$ 远大于浅层，使得后面层的 attention/FFN 的 norm input 几乎已经被前面层的累积残差主导——新增的 $F(x_L)$ 相对于 $x_L$ 来说是噪声级的，网络深度带来的实际表达力急剧衰减。

参考 DeepNorm/GPT-2 的做法，把残差分支按深度衰减，每层残差缩到原来的 $1/\sqrt{2L}$：

self.residual_scale = 1 / math.sqrt(2. * self.layer)

attn_out = self.attn(norm(x))
x = x + self.residual_scale * attn_out

mlp_out = self.ffn(norm(x))
x = x + self.residual_scale * mlp_out

每层引入的增量方差为 $O(1/L)$，$L$ 层累计后整体方差保持常数量级。实测没有 Residual Rescale 的话，模型层数大于 6 就很容易训崩。

这个看似简单的 $1/\sqrt{2L}$ 系数，背后是对深层网络方差累积问题的精细控制。它和 LayerNorm/RMSNorm 不是替代关系，而是协同关系——norm 控制每层输出的方差水平，rescale 控制方差的累积速率，二者一起让深层 Transformer 能稳定训练到更深的层数。

Softcap

个别 token pair 上极端偏大的输出会让下游激活饱和、梯度回传不稳，FP16/BF16 训推下尤其敏感。FP16 的最大可表示数是 $\pm 65504$，BF16 虽然指数位更宽（最大约 $3.4 \times 10^{38}$），但精度位只有 7 位，乘加链路上的微小误差很容易被放大成大数。一旦激活值溢出为 inf，整张图的梯度都会变成 NaN，训练直接崩溃。

在 attention 子层和 FFN 子层输出加一层 tanh soft cap：

def _soft_capping(self, x):
 return self.softcap * tf.math.tanh(x / self.softcap)

Softcap 在 $|x| \ll \text{softcap}$ 区域接近恒等（因为 $\tanh(x/c) \cdot c \approx x$ 当 $x$ 小），超出后平滑收敛到 $\pm\text{softcap}$。相比硬截断（clip）它可导，梯度不会突然变 0；相比直接限幅，它在饱和区附近还有一定的梯度信号能传回去。

线上监控数据：

	无 softcap	加 softcap
Max 激活值	108,416（溢出 FP16）	70

108k 远超 FP16 的 65504 上限，意味着无 softcap 时 FP16 推理直接崩溃；加上 softcap 后最大激活降到 70，给 FP16 留出极大的安全余量。这一改动在生产环境的稳定性意义非常大——它让我们能放心用 FP16 推理而不用担心偶发的数值爆炸。

2.6 优化器：从 RMSPropV2 迁移到 AdamW

这是一个大胆但正确的决定。模型结构去掉了 bias、使用 RMSNorm + weight decay 稳定训练（即 0-齐次网络），此类网络下 AdamW 相比 RMSPropV2 更友好，能更好发挥模型潜力。

为什么 0-齐次网络偏好 AdamW？ AdamW 的权重衰减是真正的 L2 正则（与梯度解耦），而原始 Adam 的权重衰减是和 momentum 耦合的。在 0-齐次网络中，weight 的尺度可以自由缩放而不影响输出（norm 会重新归一化），所以 weight decay 唯一的作用就是控制 effective learning rate。AdamW 的解耦机制让这种控制更精确、更可预测。

推荐系统的训练数据与 LLM 有两点显著差异：训练数据分布差异大（来自不同场景、不同时间段、不同地区，分布漂移严重）、样本噪音高（用户行为本身就有大量随机性，曝光偏差、位置偏差也加剧噪声）。因此不能直接用 LLM 的标准参数（lr=1e-5, β₂=0.99），而是需要从 RMSPropV2 的配置出发，通过公式推导找到适合推荐场景的超参配置：

Stage	lr	β₁	β₂	ε	weight_decay
Pretrain	8e-4	0.9	0.99	1e-7	1e-5
Posttrain	8e-4	0.9	0.99	1e-7	1e-5
Recall SFT	6e-4	0.9	0.99999	1e-7	5e-6

SFT 阶段 β₂ = 0.99999：这个看起来夸张的设置，实际上是为了让二阶动量在嘈杂的下游任务样本上表现得更稳定——β₂ 越接近 1，二阶动量的"记忆窗口"越长，能更好地平滑掉短期噪声。SFT 阶段的样本是 pointwise 的，单条样本的方差远高于 Pretrain 序列样本，所以需要更长的二阶动量平滑窗口。

切换到 AdamW 后，HR@1 提升 +8%，且权重范数（WeightNorm）从 500+ 收敛到 70 左右，训练过程更稳定。WeightNorm 的下降不仅是数值上的好看，它还意味着模型在学到等效表达力的同时使用了更小的 weight scale——这种"小权重高表达"的状态泛化能力更强、对噪声更鲁棒。

3. 预训练（Pretrain）

3.1 Tokenizer 设计：三类 Token 的统一序列

预训练的核心挑战是如何把用户的异构行为序列转换为模型可以理解的 token 流。在自然语言中这个问题相对简单——文本天然是 token 序列。但在推荐场景，用户的一次"点击行为"包含商品 ID、商品类目、行为类型、时间戳、来源场景等多个异构信号——把它们都塞进序列又不能丢信息，是一个非平凡的设计问题。

方案设计了三段式 Tokenizer：

Context Info Token

承载场景、时间等推理时已知信息，包括请求场景（source_page_type）、进入来源（enter_from/enter_method）、行为时间差（ts_delta）等。此外还把部分条件信号（如 action_type）编码进 Context Token，作为建模 item 行为类型的 condition 一并输入序列。通过调节 Condition Token 可以让召回满足多种多样的算法和业务需求（如点击目标构造 action_type=click、成单目标构造 action_type=order）。

Context Token 的设计哲学是"把推理时已知的所有信息都当作 prompt 输入"——这与 LLM 的 prompt engineering 思路一脉相承。当线上召回时，request 上下文（用户当前在哪个页面、从哪里跳过来的、当前时间段等）都是已知的，把它们作为前缀 token 输入，模型就可以根据上下文产出场景对齐的召回结果——同一个用户在"逛商城首页"和"逛搜索结果页"会得到完全不同的召回，因为 Context Token 不同。

Semantic ID Tokens

三位 8192 词表 ID，承载核心行为 item 的 SID（Semantic ID）。每个 item 展开为 3 个 SID token，构成粗到细的语义描述，兼顾词表可控与生成步数可控。SID 之间天然带有泛化性：语义相近的 item 共享前缀 code，为模型学习跨 item 的可迁移模式提供了归纳偏置。

为什么是 3 层 8192 而不是 1 层 5 亿（即直接用 PID）？原因是：(1) 1 层 5 亿的 vocab 会让 output projection 的参数量爆炸（$d \times 5 \times 10^8$ 即便 $d=128$ 也需要 64GB 仅 output 一层）；(2) 1 层 5 亿的 vocab 会让生成式 sample 的搜索空间过大，Beam Search 几乎无效；(3) 3 层 8192 的层级化解码让每步只在 8192 的小空间内 sample，又通过条件依赖 $P(s_2 | s_0, s_1)$ 自动收敛到合理的精细 ID——既高效又精准。

Item Info Token

承载 item 侧的细粒度特征，包括商品 ID（pfid）、叶子类目（leaf_ctg）、卖家（seller_id）等精细标识信号。与 Semantic ID Token 互补：SID 反映内容层语义（多模态特征 + 协同信号经 RQ-KMeans 量化的离散 code），Item Info 则保留传统推荐中被证明有效的精细 ID 特征，粒度更细。

Item Info Token 与 SID Token 的关系类似 NLP 里 word piece 与 word 的关系——SID 承担"语义聚类"的功能（语义近的商品共享前缀 SID），Item Info 承担"精确识别"的功能（同一 SID 下的商品仍可通过 PID 区分）。两者结合让模型既能做粗粒度的语义泛化，又能做细粒度的精确召回。

消融实验验证了各类 Token 的贡献：

配置	HR@1	SID L0 HR@1	SID L1 HR@1	SID L2 HR@1
Item info + context info	-	-	-	-
w/o item info	-9%	-4.0%	-3.2%	-1.8%
w/o item info & context info	-42.8%	-12.2%	-14.1%	-3%

Context info 对 HR@1 的贡献高达 -42.8%，是最关键的 token 类型。这个实验结果其实揭示了一个深刻的事实：用户在线行为的可预测性极度依赖上下文。同一个用户在"购物车"和"详情页"的下一个行为分布完全不同——脱离了上下文 token，模型只能利用 SID 级别的弱监督信号，当然学不出强结果。

3.2 数据组织：序列去重与 All-Flat

用户行为去重

原始用户行为会被埋点重复上报多次（曝光到成交的多级行为、场景切换造成的重复上报），直接喂进模型既冗余又会稀释监督信号。一个典型例子：用户在商品 A 的详情页看了 5 次，加购物车 1 次，下单 1 次——埋点系统会上报 7 条记录（5 次 view + 1 次 cart + 1 次 order），但从"用户兴趣建模"角度看，这只是一次有效的"对 A 强烈感兴趣"的事件。如果让模型同时对这 7 条记录做监督，模型会把 80% 的注意力浪费在重复信号上。

方案做了两步去重：

ListwiseDeduplicateBySession：按固定时间阈值 T（线上取 2h）切分 session，在当前 session 内维护 key (pid, action_type) 的集合，首次出现的事件追加到输出列表，已出现的直接丢弃。这一步去掉的是"同 session 内的重复曝光"——比如用户来回滑动同一个商品被埋点 N 次，只保留第一次。
SeqConsecPIDDedup：在 Step 1 的输出上再做相邻位置去重，连续落在同一 pid 上的 token，只保留行为漏斗最深、时间最后的一个（按 view < click < cart < order 排序）。这一步去掉的是"同一 item 的多级行为渐进"——把"看了→点了→加购→下单"压缩成"下单"这一最终态，让每个 token 对应一次"有意义的最终行为"。

去重后的序列长度从原来的 ~3000 token 压缩到 ~600 token，监督信号密度提升 5 倍，且每个 token 都对应一次"独立有意义"的用户决策——这对训练效率和最终效果都是巨大的改进。

All-Flat 数据组织

预训练阶段采用 All-Flat 组织：用户的历史行为（Context/SID/辅助 token）按时间顺序展平成一条长序列，所有 token 独立入图、独立参与 attention。这样做的目的是让模型看到最完整的交互序列，充分学习长程依赖和多域泛化能力。

All-Flat 与之后 Posttrain 阶段的 Prefill Merge 形成对比——Pretrain 关注"通用性"，所以让所有 token 平等参与；Posttrain 关注"任务对齐"，所以可以压缩前缀只保留 last-k 信号。这种"先通用、后专用"的设计是对 LLM Pretrain → SFT 范式的精确复刻。

序列组织加速技巧：将上一个 item fine info 和当前 item context token 做 sumpooling，在不损失任何信息的前提下，让序列长度减少 1/5。这个看似不起眼的工程优化在大规模训练上节省了 20% 的计算成本——对于一个 ~800 GPU·days 的 Pretrain 任务来说，等于省下了 160 GPU·days 的实算资源。

3.3 训练任务：SID-only Next Item Predict

训练目标是标准的自回归 Next Item Predict：给定前缀序列预测下一个 item 的 SID token，采用 teacher forcing 训练。Loss 只在 SID token 位置计算（SID-only Loss），Context info 与 item fine info token 不参与 next token loss，避免模型把算力浪费在回归静态特征上：

$$\mathcal{L}_{\text{NTP}} = -\sum_{t=1}^{n} \sum_{k=1}^{3} \log p_\theta\!\left(s_t^{(k)} \mid x_{为什么 Loss 只在 SID 位置算？ 因为 Context Token 和 Item Info Token 都是"已知的辅助信号"——线上推理时它们是 prompt 的一部分（user query 提供 context、item attribute 提供 info），不需要模型预测。如果把它们也加进 NTP loss，模型就会浪费一部分参数去拟合"如何复现已知信息"，对预测下一个 item 没有帮助。

Teacher Forcing 的工程优势：训练时一条样本同时贡献 L 个 NTP 监督点（每个位置都做一次 next-token prediction），样本效率最大化。这与 Pointwise 训练的 1:1 监督比形成鲜明对比——同样的 GPU 计算量，序列样本能产出 L 倍的有效梯度。

3.4 推荐预训练 Scaling Law

这里有一个非常有意思的发现：推荐系统预训练的 Scaling 不是单变量问题。把 pretrain loss 按熵性质拆解，对应三条相互独立的优化方向：

$$\mathcal{L}_{\text{pretrain}} = \underbrace{\mathcal{L}_{\text{high-entropy}}}_{\text{用户兴趣建模}} + \underbrace{\mathcal{L}_{\text{low-entropy}}}_{\text{condition 映射 + SID 层级}} + \underbrace{\mathcal{L}_{\text{irreducible}}}_{\text{当前可观测的随机性下界}}$$

这个分解很直观：(1) 高熵任务对应"猜用户下一秒想要什么"，本身就有很高的不确定性，模型学到的是兴趣分布；(2) 低熵任务对应"给定 SID 前缀，下一级 SID 是哪个"——这部分本质是确定性映射，参数足够就能记住；(3) 不可约熵是当前观测下任何模型都达不到的下界，比如用户的随机点击、突发兴趣切换等。

参数量：主要影响低熵任务（SID 映射、condition 建模）。以 500M SID codebook 为例，$\log_2(5 \times 10^8) \approx 28.9$ bits/SID，裸记忆下界约 7.2B 参数。参数不足是线上 SID 不合法率的主因——当模型记不住"3 层 SID 的合法组合"时，Beam Search 生成的 SID 在倒排表里找不到对应 PID，召回直接失败。实验表明 14M → 32M → 114M 参数量，hitrate@1 从 4.0% → 4.8% → 6.0%，提升大部分来自 SID Level 1/2——这正是低熵记忆任务的甜区。

Context 信息量：用户兴趣的不可约熵（Bayes Risk）很高，只建模 SID 的话效果很快到平台期。增加 context token，模型能随着数据量增加持续学到更多，最终效果提升约 66%。这一点深刻揭示：用户兴趣建模的重点要素是 context，其价值由条件互信息 $I(Y; X_{\text{new}} \mid X_{\text{old}})$ 决定，冗余特征只增成本不降熵。

这个观察对工业推荐系统有重要指导意义——当我们想"再加一个特征"时，要问的不是"这个特征有什么信息"而是"这个特征在已有特征条件下还有多少信息"。比如已经有了 user_id 和 history seq，再加 user 性别带来的边际增益就很小（因为 history seq 已经隐含了用户性别信号）；但加上"当前请求的页面"这种条件性信息，边际增益就很大（因为 history seq 不包含当前请求的实时状态）。

多任务：在 SID head 后叠加 action 预估 Loss（click/cart/order），SID 的 hitrate 也能涨。LLM 本质是超大型多任务系统，共享底层结构的任务联合训练存在隐式正向迁移。这与 NLP 里 T5 的 multi-task pretraining、UniLM 的多目标掩码等思路一脉相承——多任务不是为了让模型同时擅长多个任务，而是为了让 backbone 学到更通用的表征。

Scaling 的三个杠杆总结：多任务让现有参数学到更多；context 降低 Bayes ceiling 让参数有继续工作的空间；最后参数量给前两者提供承载容量。三个杠杆同时提高，才是生成式推荐预训练真正的 Scaling Law。

需要警惕的反直觉发现：单纯堆参数量而不增加 context 或多任务，效果增益会很快饱和。这与 NLP 的 Chinchilla scaling law（参数量与数据量成 1:20 的最优比例）不完全一样——推荐场景的"数据"维度不仅是 token 数量，还包括 token 的信息密度（context richness）。这要求工业推荐 scaling 必须做"全维度 scaling"，而不是单纯地把参数堆上去。

4. Recall Posttrain：对齐召回任务

4.1 Prefill Merge：压缩历史前缀

Recall Posttrain 阶段切换到 Prefill Merge 数据组织：只保留序列末尾的 last-k 个 token 炸开参与 loss 计算，前面的长历史先过 Transformer 再经 sumpooling 压到 MergedToken 上作为上下文占位（5× 压缩）。

具体地，假设原始序列长度 $L = 512$，last-k 取 32，那么：

前 480 个 token 经过 Transformer 的部分 forward 计算后被 pool 成 96 个 Merged Token（5× 压缩比）
后 32 个 token 完整参与剩余 forward + loss 计算
最终入 attention 的有效序列长度从 512 降到 96 + 32 = 128

两个动机：

训练样本组织与线上召回 serving 对齐——前缀历史只需 prefill 一次即可复用到所有 last-k 位置，压缩了输入，线上可以处理更长的序列。在生产环境，召回 latency 的瓶颈往往在 prefill 阶段（O(L^2) 复杂度的 attention），把历史 token 压缩 5× 等于把 prefill 时间压缩到 1/25——这对线上 P99 latency 至关重要。
控制 SFT 阶段的 loss 位点分布，把预测信号集中在最近的 last-k 上，更贴近召回任务"预测未来即将交互的 item"的目标。Pretrain 阶段为了通用性把所有位置都参与 loss，但召回任务关心的本来就是"用户接下来要看什么"，所以只在 last-k 上计算 loss 反而能让模型更专注于核心任务。

4.2 Multi-Item Predict：对齐 top-K 召回

训练目标从单步 Next Item Predict 扩展到 Next Multi-Items Predict：模型在 last-k 位置上同时预测未来多个 item 的 SID 分布：

$$\mathcal{L}_{\text{MTP}} = -\sum_{t=1}^{n} \sum_{i=1}^{K} \sum_{k=1}^{3} \log p_\theta\!\left(s_{t,i}^{(k)} \mid x_{这一变化让召回 SFT 不再只学"下一个 item"，而是直接学"未来一段时间的 item 集合"，与召回下游取集合的使用方式对齐。

为什么 Multi-Item 比 Single-Item 更适合召回？ 召回的本质是"从亿级商品中筛出几百个候选"，下游粗排/精排再做精细排序。这意味着召回不需要给出"下一个最准的 item"，而是要给出"未来一段时间用户可能感兴趣的 item 集合"——后者天然是 Multi-Item 任务。如果只用 Single-Item 训练，模型会过度优化"最准的下一个"，但忽略"集合多样性"——线上召回结果会偏窄、覆盖率不足。

Pretrain 越强，SFT 终态越高且收敛越快——400B base 在 step 1000 就达到峰值，100B base 在 step 4000 才达到峰值。因此 pretrain scaling 的收益与 SFT 收益是叠加的，pretrain 并未"吃掉"SFT 的优化空间。

这个发现非常重要——它意味着 Pretrain 与 SFT 的资源投入不是 zero-sum 而是正和。Pretrain 投入越多，SFT 阶段需要的样本量越少、收敛越快、最终效果越好。这与 NLP 领域的"Pretrain helps SFT"经验一致，但在推荐领域得到了首次定量验证。

4.3 Zero-shot 部署评估

一个值得关注的实验：将未见过下游样本的 Foundation Model 直接部署为召回，通过真实用户反馈直接测评模型效果。

Condition Token 的 Prompt 效果：通过 mock 不同的 action type 特征，可以作为 Prompt 让模型产生不同的偏好模式——这意味着一个预训练好的 Foundation Model 天然具备多目标可控的能力。具体来说：

Mock action_type = click 时，模型生成偏向"高曝光、高点击率"的商品池
Mock action_type = order 时，模型生成偏向"高转化、高 GMV"的商品池
Mock action_type = cart 时，模型生成偏向"决策中、价格敏感"的商品池

这种 Prompt 控制能力让 Foundation Model 真正具备了"一模型多用"的灵活性——同一套权重通过不同的 condition prompt 可以服务点击优化、成交优化、加购优化等多种业务目标，无需重新训练。

Zero-shot FM 的本域对齐问题：Zero-shot 部署发现该路召回的成单指标远高于基线，但曝光占比和点击率相比基线都低。排查发现从 merge 到粗排到精排通过率都比较高，但混排直接筛掉了 30% 的曝光——混排目前建模本域曝光的模式暂时无法感知全域兴趣分布。

这是一个非常有趣的"系统级现象"——FM 学到的是全域用户兴趣，所以 zero-shot 召回出来的商品在用户的全域兴趣空间里是合理的，但当下游混排只看本域（比如"商城"内）的历史曝光分布时，会错把"用户曾经在直播间感兴趣但商城没看过"的商品当作"低相关"过滤掉。这类似于 LLM 的 zero-shot 在某些领域表现"看似合理但被下游 evaluator 误判"的问题。

解决方案：一是增加场域特征 prompt（让模型知道当前是商城场景，主动产出商城类商品），二是使用本域的 Pointwise 样本流新增一个训练阶段对齐本域分布（这就是后续 SFT 阶段做的事）。

5. Recall SFT 与 Reward

当前 SFT 基于预训练模型 load 后，在 pointwise 样本下做特征对齐，引入长序列，增加召回 NTP loss 和相应的 reward。

数据输入组织：采用"多行为前缀 + Pointwise 解码"输入组织形式：每个样本同时包含用户的点击、加购、成单三条历史序列，分别以"一个历史行为位置"为基本单元，将商品侧特征、上下文特征和对应的 SID 输入映射到同一表示空间后，在每个位置内融合成一个行为 token（per-position fusion）。三条序列按 order → cart → click 的顺序拼接，中间插入可学习的 SEP token，形成统一的历史前缀，加入绝对位置编码让模型感知序列内的时序关系以及序列间的差异。

为什么三条序列分开拼接而不是按时间合并？ 因为不同 action 的语义层级不同——成单（order）是最强意图信号、加购（cart）是中等意图、点击（click）是弱意图。如果按时间合并，模型很难区分"这个 click 后面会不会变成 order"——但分开建模后，order 序列就明确告诉模型"这是已经成交的强信号"，cart 序列说"这是决策中的中等信号"，click 序列说"这是浏览阶段的弱信号"。这种层级化的输入组织让模型能更精准地捕捉用户的兴趣强度。

Token 化与序列拼装的关键细节：

Projection to d_model and per-position fusion：将每个位置的 item_info、context_info、sid_input 分别通过 Projection 映射到统一维度 d_model，再相加融合为单个 fused token。这种"先投影后融合"的设计避免了 raw concat 带来的维度爆炸问题——如果 item_info 是 128 维、context_info 是 64 维、sid_input 是 384 维，直接 concat 是 576 维，要再投影到 d_model；先各自投影到 d_model 再相加，参数量更小、计算更高效。
padding 提取到左侧以减少 Pyramid 机制的损失。Pyramid 机制是说不同 batch 的有效长度差异时，把短样本左 padding 让所有样本的"有效末尾"对齐到序列右端——这样 attention 计算时不会有大量浪费在 padding 上。
训练范式对齐 LLM：Tokenizer → Decoder-only Transformer → NTP Loss 与主流 LLM 完全一致，为 Scaling Up 提供了天然基础。

Reward 加权的工程实现：在 NTP loss 之上叠加 reward 加权——对于历史中带有 order 行为的样本，loss 加权倍数 1.5x；带有 cart 的 1.2x；纯 click 的 1.0x。这种加权让模型在训练时优先学习"高价值行为"对应的兴趣模式，与最终业务指标 GMV 直接对齐。

6. Semantic ID：用 RQ-KMeans 替代 Product ID

6.1 为什么需要 Semantic ID

传统推荐系统直接用 Product ID（pid）作为 item 的唯一标识，在判别式框架下没有问题——双塔的 item 塔会为每个 pid 单独维护一个 embedding，端到端学习。但在生成式框架下，模型需要逐 token 预测 item，Product ID 的词表规模（亿级商品）直接导致参数爆炸，而且相近的 pid 之间没有任何语义关系，模型无法迁移知识。

具体地，假设商品库 1 亿，hidden_dim=128，仅 output projection 层（vocab × hidden）就需要 $10^8 \times 128 \times 2\text{B} = 25.6\text{GB}$ 显存（FP16），而且这个层完全是稀疏更新——每次只有少量 pid 被激活，其它 pid 的 embedding 几乎得不到更新。这种"超大稀疏 vocab"在 LLM 时代被证明是低效的设计。

SID 解决了三个痛点：

参数爆炸：三位 8192 词表（共 $8192^3 \approx 5.5 \times 10^{11}$ 种组合）远比直接用 pid 的百亿词表参数更可控。每位 8192 的 embedding 只需要 $8192 \times 128 = 1\text{M}$ 参数，三层一共 3M 参数，比直接用 pid 节省 4 个数量级
语义缺失：基于多模态特征的 RQ-KMeans 量化，语义相近的商品共享前缀 code。比如所有"红色连衣裙"商品的 SID Level 0 都是同一个码字，模型只要学到"用户喜欢这个 Level 0 码字"，就能召回所有红色连衣裙——而不需要为每个具体的 pid 单独学一遍
冷启动：新商品只要有多模态特征就能分配 SID，不依赖历史交互数据。这是判别式双塔的硬伤——双塔的 item embedding 必须从历史交互中学，新上架商品因为交互稀疏 embedding 学不出来；SID 不依赖交互、依赖内容，新商品上架的第一秒就有合理的 SID

6.2 RQ-KMeans vs. RQ-VAE

为什么选 RQ-KMeans 而不是 RQ-VAE？

RQ-VAE 是端到端学习的量化网络——encoder 把 item embedding 映射到 codebook，每个 codebook entry 是可学习的向量。但 RQ-VAE 有几个工程顽疾：(1) 训练易码本坍塌——优化过程中部分 codebook entry 永远没有 item 分到，相当于 vocab 浪费；(2) 利用率崩塌：实测利用率经常 < 10%，意味着 8192 的 vocab 实际只有 800 个码字在工作；(3) 在 gumbel-softmax、LR、encoder 结构等一系列调优后仍无法追上 RQ-KMeans，精排 CTR AUC 相对随机 baseline 为 -0.07%

RQ-KMeans 是用经典 K-Means 聚类算法生成 codebook：(1) 聚类过程稳定——K-Means 的迭代收敛性远好于神经网络训练；(2) 100% 利用率——聚类天然让每个簇都有样本；(3) item 分布相对均匀——K-Means 的"最小化簇内距离"目标自然产生大小相近的簇；(4) 并行计算快——可以用 Faiss 等库加速；精排 CTR AUC +0.03%，下游召回/预训练指标均优

串行残差码本路线（粗→细逐层量化）：

Level 0：对原始 item embedding 做 K-Means，得到第一级码字
Level 1：把"原 embedding − Level 0 簇中心"作为残差，再做 K-Means 得到第二级码字
Level 2：把"残差 − Level 1 簇中心"再做 K-Means 得到第三级码字

这种残差量化路线与生成式推荐的逐级自回归解码天然对齐——模型先生成 Level 0（粗粒度语义类别），然后基于 Level 0 生成 Level 1（更细的子类别），最后生成 Level 2（最精细的差异化特征）。重建误差可控、语义层次清晰。

6.3 生产配置

商品表征：多模态大模型（dim=128），输入商品主图 + 标题 + 类目信息。这一步是关键——多模态 embedding 的质量直接决定了 SID 的语义质量。如果只用类目特征，SID 就退化为类目 ID；用上图像和文本后，“红色丝绒连衣裙"和"红色丝绒礼服"会被聚到同一簇（即便它们的类目可能略有差异）
码本规格：三层均匀 8191×3（对比金字塔、倒金字塔和 4095×3，均匀 8191×3 的下游指标、簇纯度、I2I 召回率综合最优）
接入通道：Hive Table + Universal Embedding，每日更新

为什么是 8191 而不是 8192？ 这是为了留出一个特殊 token（比如 <unk> 或 <pad>），让 vocab 总数恰好是 $2^{13} = 8192$ 同时还有特殊位置可用。这是 LLM 领域的 vocab design 标准做法。

为什么均匀优于金字塔/倒金字塔？ 金字塔（如 16384/4096/1024）的设计直觉是"粗粒度多样、细粒度紧凑”，但实测发现这反而让 Level 2 信息量不足，整体表达能力弱化。均匀分配在每一层都给足容量，让模型在三层之间均衡地分担表征压力。

6.4 关键优化：同款簇去重

电商爆款会让大量码字浪费在表达同款商品的噪声变化。比如某款热卖手机壳，可能有几千个 SKU（不同颜色、不同卖家、不同价格），多模态 embedding 几乎相同——直接 K-Means 会把这几千个 SKU 都映射到同一簇，浪费一个码字、且让该簇过度拥挤。

按 SPU 同款簇 ID 对重复商品去重，ROW 样本从 2.6B 压缩到 50M–550M 高质量去重样本，孤点簇相比全量版本提升 +14%，下游精排/预训练指标同步改善。

这个优化的本质是"先做语义去重再做聚类"——用业务先验（SPU 同款）去掉冗余，再让 K-Means 在多样化的样本上聚类，最终得到的 SID codebook 才能真正反映商品的语义多样性而不是 SKU 的噪声变化。

7. 在线链路：生成式召回 Serving

生成式召回的在线链路与传统双塔召回有本质区别，主要包含四个步骤：

7.1 离线 SID 生产与倒排构建

SID 生产：离线通过 RQ-KMeans 生产 SID，完成全量商品的 pid → SID 映射，产出到 Hive 表以及 UE 服务中
倒排索引构建：基于 Hive 的 pid → SID 映射，结合推荐精品池候选以 GMV/Order 等业务指标进行加权，构建倒排索引服务

倒排索引的"加权"很关键——同一个 SID 通常对应多个 PID（因为 SID 的粒度是"语义簇"，一个簇里有多个具体商品）。当模型生成某个 SID 后，倒排查询会返回该 SID 对应的所有 PID，但需要按业务价值排序——GMV 高的、Order 多的、库存充足的优先。这一加权步骤把"语义召回"转化为"业务召回"，在不破坏模型语义的前提下注入业务先验。

7.2 在线 GR 召回 Serving 流程

原始特征获取：抽取用户 profile、seq 以及 context 相关特征，以及根据 UE 服务获取 SID 相关特征
基于 GPU 推理服务的用户子图 SID 生成：不同于以往的基于 CPU 索引的召回调用，生成式召回直接改用 GPU 推理服务跑子图生成 SID 结果
- 通过 RPC 请求 GPU 推理服务执行 U 侧子图推理
- U 侧子图采用图内 Beam Search 的方式，在 GPU 上一次性完成模型跑图与 Beam Search 解码，直接生成 Top-K SID 及 Logits
SID → PID 倒排查询与结果合并：基于生成的 SID、Logits，查询 sid → pid 倒排索引，通过加权 merge 对多个 SID 命中的 PID 进行合并
多路召回融合：生成式召回（Foundation GR Recall）作为一路新增召回，与现有的 DVF、PDN 等多路召回并行执行，通过多路 merge 进行结果融合

图内 Beam Search 的工程意义：传统 Beam Search 是"GPU forward → CPU 取 top-K → GPU forward → CPU 取 top-K …“反复跨设备拷贝，每次跨设备开销几毫秒。把整个 Beam Search 写到 GPU 算子里，所有 K 步解码都在 GPU 内完成，跨设备开销降到 0。在 SID 三层解码的场景下，这个优化能让 latency 从 30ms 降到 5ms 以内。

8. 训推优化：让 170M 模型跑得快

将 170M 的 LLM 部署到在线推荐召回是一项重大工程挑战，涉及到训练和推理的全链路优化。生成式召回对线上 latency 的容忍度远低于通用 LLM 服务（推荐召回需要 P99 < 50ms，而 ChatGPT 这类对话场景能容忍秒级 latency），所以训推优化是这个项目能否上线的成败关键。

8.1 Flash Attention

长序列场景下传统 Attention 的问题：显存占用大（直接算 QK^T 产生 length² 量级 Attention Map，batch 2048 × head 4 × length 1024 时单层约需 69GB）、访存开销大、算子调用分散。

Flash Attention 的核心思想是分块计算 + 在线 softmax——把 attention 计算切成小块，让中间结果保持在 SRAM 而不写回 HBM，同时用增量式 softmax 避免一次性物化整张 attention map。具体地：

把 Q、K、V 切分成块 $Q_i, K_j, V_j$
对每个 (i, j) 块对计算局部 $S_{ij} = Q_i K_j^\top$、$P_{ij} = \text{softmax}(S_{ij})$、$O_{ij} = P_{ij} V_j$
用在线 softmax 算法把不同 j 的部分结果合并

这样空间复杂度从 $O(L^2)$ 降到 $O(L)$，且大部分计算都在 SRAM 内完成，访存开销大幅降低。

引入 Triton 版本的 Flash Attention，把 Attention 的空间复杂度压到 $O(\text{length})$，显存不再随序列长度平方爆炸：

显存占用下降 1/6 以上
吞吐提升 60% 以上
支持最高 200M 参数 × 2K 上下文的训练规模

Triton 版本的优势是可定制——可以针对推荐场景的特殊需求（比如 GQA 的反向传播、特殊的 mask 形状等）做定制 kernel，而不受官方 PyTorch FlashAttention 实现的限制。

8.2 梯度累积

梯度累积通过将连续 N 个 step 的反向梯度在本地缓冲区累加、仅在第 N 步触发一次 AllReduce 与 optimizer step。

为什么梯度累积有效？ 在大规模分布式训练中，AllReduce 的通信开销可能占总 step time 的 30-50%。每次 AllReduce 都需要全集群同步，且通信带宽是稀缺资源。当 micro-batch 大小受限于显存（无法把 global batch 一次塞进单卡）时，梯度累积让我们可以"虚拟地"扩大 batch size——多个 micro-batch 累加后等效于一次大 batch 的训练。

AllReduce 触发频率降至 1/N，通信流可与后续 micro-batch 的计算流 overlap，进一步压缩 step time。本质上是在显存与卡数受限的条件下，逼近大 batch 训练的收敛特性。Adam 类优化器在大 batch 下的收敛性优势在这里被充分释放。

8.3 梯度重计算（Grad Recompute）

训练时丢弃部分中间激活，反向传播需要时再前向重算一次，以额外计算换取显存：

空闲显存 2.7G → 29G
显存占用 -43%

梯度重计算的工程取舍：以约 1/3 的额外计算成本换取近一半的显存——这个 trade-off 在大模型训练中几乎是必选项。原因是：(1) 现代 GPU 计算单元（Tensor Core）的算力远远过剩，但显存容量有限，重算这种"用算力换显存"的操作本质是把闲置的算力变现；(2) 显存释放出来后可以用来扩大 batch size 或序列长度，这些维度的 scaling 收益往往远超 1/3 的算力成本。

具体实现上，方案选择层级粒度的重计算——每个 Transformer Block 作为一个 checkpoint 单元，前向时丢弃 block 内的激活、反向时重算整个 block。这种粒度比 attention/FFN 子层粒度的重计算更高效（重算单元更大、kernel 启动开销更少）。

8.4 BF16 训练 + FP16 推理

训练基于 BF16，推理采用 FP16（部分组件暂未完全支持 BF16）。半精度推理在 A10/L40s 线上压测中 QPS 相比 FP32 + Emb Layer 基线 +85%~+90%。

为什么训练用 BF16 而推理用 FP16？ BF16 的指数位与 FP32 一致（8 位），动态范围与 FP32 相同（约 $10^{38}$），但精度位只有 7 位——这种"宽范围、低精度"的特性非常适合训练（梯度可能有极大值或极小值，不能截断；但精度损失可被随机性抵消）。FP16 的指数位 5 位，动态范围只到 $\pm 65504$，但精度位 10 位——这种"窄范围、高精度"特性更适合推理（推理时数值已经稳定在合理范围，重要的是精度）。同时 FP16 在很多旧硬件（A10、T4 等）上有原生支持，比 BF16 性能更好。

FP16 的动态范围（最大 6.55e4）需要针对性处理：

Dense 特征（GMV、停留时长等）可能超过 1M，统一截断到 [-1e4, 1e4]。这一步必须做——线上 dense 特征的实际数值范围远超 FP16 上限，不截断推理直接 NaN
Attention mask 位置原本使用 -1e9，会直接溢出为 -inf，改为 -1e4 避免溢出。这是一个非常容易踩的坑——FP32 训练时用 -1e9 没问题，切到 FP16 后 -1e9 溢出为 -inf，softmax 后变成 NaN
Softcap 为各 block 输出提供数值安全带

8.5 Split KVCache 与动态 Beam Size

Split KVCache：prefill 部分的 KVCache 不做 tiling，通过广播机制在图内展开，Beam Size 可以从 32 开到 512。具体地，prefill 阶段所有 beam 共享同一份历史 KV cache（因为它们的 prefix 相同），decode 阶段才开始为每个 beam 维护独立的 KV cache。这种"prefill 共享 + decode 独立"的设计能在 batch=512 beam 下保持线性显存增长
动态 Beam Size：Beam Search 三层采用不同的 beam size，平衡精度与效率。具体地，Level 0 用大 beam（比如 256，因为这一层是粗粒度，需要广撒网），Level 1 用中 beam（128），Level 2 用小 beam（64，因为这一层是精细化，没必要扩散太多）。这种递减式 beam 在保持召回质量的同时把计算量降低近一半

8.6 两阶段 TopK

先在每个 beam 内做一次 topk 截断，充分利用并行，防止原生 topk 退化为 Radix Sort。

为什么原生 topk 在大 vocab 下退化？ 当 vocab 8192、beam 512 时，需要在 8192×512 = 4M 元素上找 top-K。GPU 上的 topk 算子在 4M 元素的输入上会切换到 Radix Sort（比堆排序更适合 GPU 并行），但 Radix Sort 的多 pass 启动开销很大。两阶段 TopK 先在每个 beam 内（8192 元素）做局部 top-K，得到 K×512 的中间结果，再做全局 top-K——这样每个 beam 的局部 top-K 都在 8192 元素上做（小到能用堆排序），全局只在 K×512 上做（也很小），整体效率高得多。

效果显著：

latency 下的压测 QPS 从 59.8 涨到 1180（约 20× 提升）

20 倍的 QPS 提升是这个项目能上线的关键工程贡献——没有这个优化，170M 的 GR 召回 latency 会远超线上预算，根本无法上线。

8.7 攒 batch 推理

攒 batch 进行推理，提高 SMA（流式多核加速器利用率）：吞吐单机 300 → 850。

线上请求的天然 batch_size = 1（单个用户请求），不做攒 batch 的话 GPU 利用率极低（很多 SM 闲置）。在 RPC 入口做"等待短窗口、攒成大 batch、统一推理、按用户拆分返回"的机制，能把 GPU 利用率从 30% 拉到 80% 以上。攒 batch 的窗口大小是 trade-off——窗口越大 throughput 越高、但单请求 latency 越长。本方案选择 5ms 窗口，在 throughput 与 latency 间取平衡。

9. 实验结果

9.1 线上 A/B 实验

核心业务指标：

电商 GMV：人均 GMV +0.157%（p=0.06）
General Mall：GMV/user +0.3742%，product_click_per_user +0.3133%，main_order_per_user +0.4417%，PV_CTR +0.2403%，UV_CTR +0.1298%
Mall Feeds：人均点击卡片次数 +0.6258%，PV_CTR +0.6120%，uv 立购率 +0.2772%
Diversity 提升：点击一级类目数 +0.5466%，支付一级类目数 +0.7175%
Cold Start 改善：0 单商品 PV +0.2877%，0 单商品点击 +1.2629%
广告兼容：Shop Ads Overall Advertiser Value +0.2681%，Overall Cost +0.1509%

指标解读：

GMV +0.374% 在数亿用户的电商体系下意味着每天数百万到上千万 GMV 增量——这是巨大的业务收益
Diversity 提升说明 SID 的语义泛化能力有效——用户被推荐到了之前从未交互过但语义相关的商品
Cold Start 改善是 SID 框架的核心价值之一——0 单商品（即没有任何历史成交的商品）的曝光和点击都显著提升，说明 SID 让冷启动商品也能被合理召回
广告收入正向意味着新召回不仅没挤占广告位，反而让广告也跟着受益（更精准的召回 → 更精准的广告匹配）

9.2 ROI 与效率收益

ROI +0.04%，增量 ROI 237
训练时间：通过参数加载加速迭代，从 49.8 天 → 12.3 天（节省 75%）
通过引入 FLA、FP16 等训推优化：ROI +0.11%，增量 ROI 277

训练时间从 49.8 天降到 12.3 天这一指标值得特别强调——这意味着模型迭代速度提升 4×，每个月可以跑 2-3 轮实验而不是只能跑 1 轮。在快速变化的电商业务中，迭代速度本身就是核心竞争力。

9.3 模型参数演进

本次上线为 0.17B 的初步版本，预期进一步 Scaling 到 0.6B → 6B 阶段，能够进一步释放更多收益。这个预期来自 Scaling Law 实验的清晰外推曲线——从 14M → 32M → 114M 的三档实验显示 hitrate 持续提升且未饱和，外推到 600M、6B 量级仍有显著空间。

但 Scaling 不是简单的"参数堆上去”——按第 3.4 节的 Scaling Law 分析，参数量必须与 context richness 和多任务设计配套提升。下一阶段的工作重点是：

更长序列：从 512 提升到 2048+，让模型看到更长的用户历史
更丰富的 context：引入 PDP 主商品、店铺信息等，进一步降低 Bayes ceiling
更多预测任务：在 SID head 之外增加 action 预估、价格预估等多任务，让 backbone 学到更通用的表征
更大参数：在 1-3 都做到位的前提下，把参数量从 170M 推到 600M 甚至 6B

10. 工程思考与总结

10.1 三个关键 Milestone

首次走通 Foundation Model 参数加载范式：算力最重的 Pretrain 阶段使用序列样本训练，样本利用效率较传统 pointwise 样本提升 L 倍。多阶段、多形态的输入组织充分利用 Transformer 对输入的灵活性，在不动 backbone 的前提下通过输入侧迭代持续压榨参数性能，为后续多阶段共享 FM 与 KV Cache 奠定基础。
召回阶段切换为生成式范式：端到端逐 Token 建模，有利于捕捉细粒度兴趣与语义关联；Semantic ID 显著改善模型泛化能力，同时生成式的计算框架推理复杂度解耦商品库规模，Scaling 空间更大。
One Transformer 理念的完整落地：同一套 backbone 结构在 Pretrain → Posttrain → SFT 的多个阶段中保持不变，阶段间切换仅需调整样本组织形式、loss 与优化器配置等，打通了从 Foundation Model 到各下游任务的参数迁移链路。

10.2 Scaling 的正确姿势

这次工作揭示了推荐系统预训练 Scaling 的三个独立杠杆：

多任务：让现有参数学到更多（提高样本效率）
Context 信息量：降低 Bayes ceiling，让参数有继续工作的空间
参数量：给前两者提供承载容量

三个杠杆缺一不可。简单堆参数而不降低不可约熵，最终会被 Bayes ceiling 卡住；只降低熵而参数量不足，则无法承载足够的表示能力。这是一个需要系统工程与算法协同的 Scaling 路线，而不是简单的"把参数量堆上去"。

这个观察对后续工业推荐 LLM 化有重要指导意义——在规划 6B、60B 量级的推荐 FM 时，必须同时规划"context 维度的扩展"和"多任务设计"，否则参数 scaling 的边际收益会很快饱和。

10.3 值得关注的工程细节

几个在实施过程中发现的非显而易见的要点：

AdamW 超参不能直接套用 LLM 的配置：推荐系统数据分布差异大、样本噪音高，需要从原有优化器的配置出发推导适合的超参，而不是直接用 lr=1e-5, β₂=0.99。SFT 阶段 β₂=0.99999 这种"极端长尾平滑"的设置在 LLM 里很少见，但在嘈杂的推荐 pointwise 样本上效果显著。
Residual Rescale 是 scaling 的保险：层数大于 6 就很容易训崩，Residual Rescale 是关键。单独做 QK Norm 不够，还需要控制残差路径的方差累积。这两个机制是协同关系——QK Norm 控制 attention 内部的数值稳定，Residual Rescale 控制层间残差的方差累积，缺一不可。
SID 码本规格的选择有门道：均匀 8191×3 优于金字塔结构，且码本利用率需要保持 100%——RQ-VAE 的码本坍塌问题是一个真实存在的工程陷阱。简单的 K-Means 反而比复杂的 VAE 更适合工业场景，这印证了"工程上选择简单稳定方案优于复杂前沿方案"的经验。
Zero-shot FM 的本域对齐问题：Foundation Model 预训练学到的是全域兴趣分布，直接部署到特定场景时可能因场域分布偏差被混排拦截。需要增加场域 Condition Token 或额外 SFT 阶段对齐。这是 LLM 时代推荐系统的新型挑战——FM 学到的"通用知识"如何与下游"特定任务"对齐，是一个值得长期研究的问题。
两阶段 TopK 是生成式召回推理的关键优化：20× 的 QPS 提升来自一个看似简单的工程改进，说明在 Beam Search 这类迭代式解码中，数据结构的选择对推理延迟有决定性影响。在工业推荐系统的 LLM 化进程中，这类"看起来不起眼但影响巨大"的工程优化往往是上线成败的关键。
FP16 推理的数值陷阱：从 BF16 训练切到 FP16 推理需要全链路检查数值范围——Dense 特征截断、attention mask 改值、Softcap 配合——任何一处遗漏都会让推理直接 NaN。这种"训推精度切换"的工程复杂度往往被低估。
梯度累积 + 梯度重计算的协同：两个看似独立的工程优化在大模型训练上有协同效应——梯度重计算释放显存让单卡能跑更大 micro-batch，梯度累积让多个 micro-batch 等效于大 global batch，最终在显存受限的 GPU 上逼近大 batch 训练的收敛特性。

10.4 未来展望

Scale-up：从 0.17B → 0.6B → 6B，根据 Scaling Law 曲线预计能持续释放收益。下一档的 0.6B 模型预期再带来 ~0.3-0.5% 的 GMV 提升，6B 量级则需要工程上的进一步突破（多机训练效率、推理 latency 优化等）
KV Cache 共享：Foundation Model 作为多任务的共享底座，粗排/精排加载同一套 FM 参数后，历史的 KV Cache 可以在不同阶段复用，进一步降低推理成本。这一思路类似 LLM 服务的 prefix caching——当多个下游任务共享前缀时，prefix KV cache 可以被复用，端到端节省大量计算
Condition Token 扩展：价格带、冷启动偏好、ROI 要求等都可以作为 Condition Token，实现更细粒度的可控召回。这相当于把"业务运营策略"从模型外的硬规则迁移到模型内的 prompt 控制，让算法具备更强的灵活性
多模态输入：将 PDP 主商品、店铺 SellerID 等语义更丰富的 Context 纳入序列，进一步降低用户兴趣建模的不可约熵。多模态信号是当前 context 维度的最大潜在杠杆——商品图片、用户头像、视频内容都可以编码成 token 输入序列
RLHF 范式引入：当前 SFT 阶段用了简单的 reward 加权，未来可以引入完整的 RLHF 流程（PPO / DPO），让模型直接对齐 GMV、留存等业务指标，而不是中间代理目标。这一步是从"监督学习推荐"到"强化学习推荐"的范式切换，潜在收益巨大但工程复杂度也高

10.5 LLM 范式给推荐系统带来的启示

回到本文开头的问题——为什么 LLM 范式适合推荐系统？经过这次工程实践，可以给出更深入的回答：

第一，LLM 的训练范式提供了 scaling 的清晰路径。判别式推荐系统的 scaling 曲线很快饱和，而 LLM 范式的 scaling 曲线还远未到顶。这意味着在算力持续增长的未来，LLM 范式的推荐系统会持续享受到硬件红利，而判别式系统会落后。

第二，LLM 的"输入即 prompt"思路解耦了模型与任务。同一个 FM 通过不同的 prompt 可以服务不同的业务目标——这种灵活性在传统推荐系统中是不存在的（每个目标都需要一个专门的模型）。

第三，LLM 的语义泛化能力解决了冷启动。Semantic ID 让新商品也能被合理召回——这在判别式双塔时代是几乎无解的问题。

第四，LLM 的工程优化生态可以直接复用。FlashAttention、KV cache、Beam Search 等 LLM 领域的成熟工程优化，几乎可以无损迁移到生成式推荐场景。这意味着推荐系统不再需要从零造轮子，可以站在 LLM 社区的肩膀上快速迭代。

第五，LLM 的"一次预训练、多场景复用"模式重构了团队协作。过去召回、粗排、精排团队各自训自己的模型，现在可以共享同一个 FM——这不仅节省算力，也让团队的工作能力可以"复利"——每一次 FM 的提升都同时惠及所有下游任务。

这些启示远超出本文记录的具体技术细节——它们是推荐系统从"算法工程"向"AI 系统"演进的方向性指引。本次工作只是这条路径上的第一步，未来还有更广阔的空间值得探索。

参考文献

Bitter Lesson — Rich Sutton, 2019.
Shazeer, N. (2020). GLU Variants Improve Transformer. arXiv:2002.05202
Su, J., et al. (2021). RoFormer: Enhanced Transformer with Rotary Position Embedding.
Ainslie, J., et al. (2023). GQA: Training Generalized Multi-Query Transformer Models from Multi-Head Checkpoints. arXiv:2305.13245
Dao, T., et al. (2022). FlashAttention: Fast and Memory-Efficient Exact Attention with IO-Awareness. NeurIPS 2022.
Loshchilov, I., & Hutter, F. (2019). Decoupled Weight Decay Regularization. ICLR 2019.
Zhang, B., & Sennrich, R. (2019). Root Mean Square Layer Normalization.
Wang, H., et al. (2022). DeepNorm: Scaling Vision Transformers to 1,000 Layers.
Lee, J., et al. (2019). Set Transformer: A Framework for Attention-based Permutation-Invariant Neural Networks. ICML 2019.
Rajput, S., et al. (2023). Recommender Systems with Generative Retrieval. NeurIPS 2023.
Touvron, H., et al. (2023). LLaMA: Open and Efficient Foundation Language Models. arXiv:2302.13971
Hoffmann, J., et al. (2022). Training Compute-Optimal Large Language Models. arXiv:2203.15556 (Chinchilla)
Ouyang, L., et al. (2022). Training language models to follow instructions with human feedback. NeurIPS 2022 (InstructGPT/RLHF)
Vaswani, A., et al. (2017). Attention Is All You Need. NeurIPS 2017.
Kaplan, J., et al. (2020). Scaling Laws for Neural Language Models. arXiv:2001.08361

Sparse MoE 在推荐序列建模中的工程实践：四个关键设计的背后逻辑

Thu, 23 Apr 2026 20:00:00 +0800

0. 从一个资源瓶颈说起

近两年，搜广推业务一直在做一件事：把序列建模组件做大。

更长的序列（从 200 到 10k+）、更多的层数（从 1L 到 4L+）、更宽的隐层（dim 从 64 到 256）——大量实验证明，Perceiver/Transformer 类序列建模组件的性能遵循清晰的 Scaling Laws：参数量越大、序列越长，AUC 就越高，业务指标就越好。这条路线已经在多个业务场景被反复验证，成为了搜广推模型迭代的核心方向之一。

但问题随之而来：显存墙。

单层 Transformer Block 在 float16/bfloat16 下的显存占用有精确的计算公式：

$$\text{Memory}_\text{Attention} = 12 \times Len^2 \times Head + 20 \times Len \times Dim$$$$\text{Memory}_\text{FFN} = 28 \times Len \times Dim$$

FFN 的显存随参数量线性增长，还算可以接受。但 Attention 对序列长度是平方级依赖——把序列从 1k 做到 10k，Attention 部分的显存就膨胀了 100 倍。即使算法侧做了各种 Perceiver 结构的压缩（把序列 token 压缩到少量 latent token），随着层数和宽度的增加，整体显存压力依然非常大。

训推机器不可能无限升配，这意味着"简单扩大扩宽"的路线迟早会碰壁。我们需要一种既能扩大模型表达能力、又不线性增加计算量的方法。

0.1 序列建模在推荐系统中的演进路线

要理解为什么这个瓶颈这么关键，先回顾一下推荐系统的序列建模是怎么走到今天这一步的。

早期的推荐模型（DIN、DIEN 等）把用户历史行为序列作为辅助特征，通过 Attention 机制提取用户对当前候选物料的偏好。这套方案有效，但序列长度一般在几十到几百的量级，主要是当时的序列建模组件还很简单——用的是基于加法 Attention 的权重加权，没有全序列的自注意力。

后来以 SASRec、BST 为代表的 Self-Attention 序列建模方案兴起，把整条行为序列都送入 Transformer，让序列内部每对 token 之间都能做 Attention。这一步大大提升了序列建模的表达能力，但 Self-Attention 的 $O(n^2)$ 复杂度让序列长度被牢牢限制在几百。

为了突破这个限制，Perceiver 架构被引入推荐系统。Perceiver 的思路是：用一组数量远少于输入序列的 latent token，通过 Cross-Attention 把整条输入序列"压缩"进来，然后在更小的 latent 空间内做 Self-Attention。这使得序列长度可以扩展到数千甚至上万，同时控制了计算量。

再往后是以 HSTU（Hierarchical Sequential Transduction Unit）为代表的工业规模实践，在腾讯、字节等广告系统上证明了超长序列（1k-10k）端到端建模的价值，这也是目前序列建模的主流方向。

回到我们的问题：现在主流的序列建模基础设施是 Decoder/Perceiver/Transformer，这些组件本身已经是"能做多大就做多大"的路线。但随着序列越来越长、层数越来越深、参数量越来越大，显存墙越来越近，不得不找新的突破口。

0.2 为什么是 Sparse MoE

同期，LLM 领域的 Sparse MoE 给了一个新思路。DeepSeek-V3、Doubao-1.5-pro、Qwen-3 等顶级 LLM 都采用了 Sparse MoE 架构——通过**只激活部分专家（Expert）**来实现"参数规模大但计算量不变"的效果。一个有 8 个专家、每次只激活 1 个的 MoE 层，参数量是 Dense FFN 的 8 倍，但每次的 FLOPS 与 Dense 相当。

一个自然的问题就出现了：Sparse MoE 能直接迁移到推荐系统的序列建模组件上吗？

答案是：可以，但不是直接搬过来就行——搜广推场景有自己独特的挑战，需要针对性的设计。本文就是这段工程探索的完整记录。

1. Sparse MoE 的基本原理

在正式进入推荐系统的问题之前，先简单回顾一下 Sparse MoE 的核心机制。

1.1 从 Dense 到 Sparse

传统的 Dense 网络中，每个输入 token 都会经过完整的 FFN（或 Attention）计算，所有参数都参与每次前向传播。如果我们把 FFN 替换成 $E$ 个并行的"专家"（Expert），每个 token 只选择其中 $k$ 个专家计算，就得到了 Sparse MoE：

$$\mathcal{G}(\mathbf{x}; \mathbf{\Theta})_i = \operatorname{softmax}(\operatorname{TopK}(g(\mathbf{x}; \mathbf{\Theta}), k))_i$$

其中 $\operatorname{TopK}$ 函数保留前 $k$ 个最高分，其余设为 $-\infty$：

$$\operatorname{TopK}(g, k)_i = \begin{cases} g_i, & \text{if } g_i \text{ in top-}k \\ -\infty, & \text{otherwise} \end{cases}$$

直觉上很简单：一个轻量的 Router 网络计算每个专家的"得分"，选出 top-k 个专家，对它们的输出做加权求和。没被选中的专家不参与计算，因此计算量是稀疏的。

在 LLM 场景，这种设计的收益非常显著：模型参数量可以做到很大（十几个专家、百亿级参数），但每次推理的激活参数只有全量的 $k/E$，训练和推理的计算成本与同激活参数量的 Dense 模型相当，而由于"记忆容量"更大，效果好得多。

1.2 搜广推序列建模的不同之处

LLM 中，MoE 替换的是主干 FFN，整个网络几乎全是 Transformer Block，梯度流动路径非常规整。而在搜广推序列建模中，序列模块（Perceiver/Transformer）只是整个推荐模型的中间组件——它的输入来自 Embedding 层处理后的序列特征，它的输出会被融合进主塔的精排打分流程。

这个"中间件"的地位带来了几个独特挑战，直接导致了 LLM 领域的经典 MoE 方案在搜广推场景失效：

挑战一：梯度流动路径更复杂。 序列模块前后都有复杂的梯度来源，MoE 的 Router 权重会影响从精排打分一路反传到序列模块再到 Embedding 层的整个梯度链路。任何对输出幅度的改变都会被放大传播。

挑战二：词表极大，token 值域宽。 推荐系统的 item 词表往往千亿级别，embedding 的分布远比 LLM 的 token 分布分散。这意味着序列 token 的数值范围更大，网络对梯度大小的变化更加敏感。

挑战三：序列模块容易"偷懒"。 序列模块不是模型唯一的打分路径，主塔还有很多其他特征（如 DNN 特征、精排 bias 等）可以提供预测信号。如果序列模块的训练出了问题，模型可以通过增大其他路径的权重来弥补，从外部指标上看损失下降正常，但序列模块实际上已经欠拟合了。这种"偷懒"行为在 LLM 中几乎不存在，因为 LLM 的模型输出完全依赖 Transformer 主干。

这三个特点，正是下面四个关键设计（Renorm、Share Expert、Learnable_coef、Double Router）的出发点。

2. Router 设计：Attention 和 FFN 需要不同的策略

序列建模组件分为 Attention 部分和 FFN 部分，两者都可以进行 MoE 化，但实验发现它们对 Router 架构有截然不同的偏好。

2.1 Attention MoE 的 Per-Head 分组

由于 Attention 存在 Multi-Head 结构，Attention MoE 有两种组织方式：

Per-head MoE（分组形式）：对每个 head 独立做 MoE，每个 head 内的 QKV 矩阵进行专家路由
All-to-all MoE（全局形式）：跨所有 head 做 MoE，整体方案类似 Dense 建模中的 Pertoken 形式

初步实验发现 per-head 分组方案效果更优，因此目前的方案均使用分组形式。但值得注意的是，分组形式本质上降低了 Router 的自由度——理论上 all-to-all 形式能学到"分组"概念的 router 分布，这是后续持续探索的方向。

2.2 Router 架构的选择

针对 Attention MoE 和 FFN MoE，分别验证了三种 Router 架构：

单层 MLP：$\text{score} = xW_1^T$，最简单的线性打分
双层 MLP：$\text{score} = \sigma(xW_1^T)W_2^T$，加一层非线性
Cosine Router：$\text{score} = \text{cosine\_sim}(\sigma(xW_1^T)W_2^T, \text{router\_emb})$，用余弦相似度打分

实验结论非常清晰：

Attention MoE 中，双层 MLP + Cosine 表现最优。

Attention 建模本质上是在捕捉"哪个 token 和哪个 token 在语义上相关"，这依赖向量的方向而非绝对大小。Cosine Router 对向量长度做了归一化，专注于方向相似度，因此在 Attention MoE 中自然表现更好。双层 MLP 提供了更强的非线性变换能力，能学到更抽象的路由特征。

FFN MoE 中，单层 MLP Router 效果最优。

FFN 的作用更接近于"按激活强度分类处理"——高激活值的 token 应该被路由到擅长高激活模式的专家，低激活值的路由到另一套专家。这个决策依赖向量的模长而非方向。Cosine Router 归一化了模长，反而损失了重要信息。单层 MLP 直接用线性变换打分，完整保留了模长信息，因此效果最好。

这个差异给出了一个很好的直觉：Attention 需要"我和谁方向一致"，FFN 需要"我有多强的激活"。

2.3 Attention MoE 与 FFN MoE 的配合

在实际部署中，Attention MoE 和 FFN MoE 不是孤立工作的，它们通常组合在同一个 Transformer/Perceiver Block 内。两者的搭配会产生协同效应，但也引入了新的超参数：各自的专家数、topk 值、Router 类型，以及是否共享某些组件。

目前线上方案中，Attention MoE 和 FFN MoE 的专家数和 topk 采用相同的配置（如 1 in 7），是出于工程简化的考虑，而不是因为两者的最优设置相同。未来更精细的调优可能需要为它们分别设置不同的稀疏度——例如 Attention MoE 使用更高的稀疏度（更多专家、更少激活比例），FFN MoE 使用更低的稀疏度，以匹配它们各自的建模特点和收敛行为。

另一个实践中值得关注的问题是：Attention MoE 和 FFN MoE 对训练步数的敏感性不同。实验观察到，Attention MoE 的 AUC 提升在训练初期就能体现，而 FFN MoE 中 Learnable_coef 的充分学习需要更长时间，收益往往在训练后期才完全展现。这意味着判断 FFN MoE 有效性需要足够长的训练步数，过早停止训练会低估 FFN MoE 的实际价值。这是在线上 A/B 实验中需要特别注意的地方——如果实验时长设置不够，可能会误判 FFN MoE 无效而放弃一个实际有收益的方向。

3. Renorm：推荐序列建模的必需品

这是本文最核心也最反直觉的一个发现。在 LLM 领域，Renorm（对 Router 权重重新归一化）是可选的优化手段。但在推荐系统的序列建模中，它几乎是必须的——去掉 Renorm 会导致显著的 AUC 下降。

3.1 什么是 Router Gate Renorm

在 MoE 中，我们选出 top-k 个专家后，对它们的 gate 值进行 softmax 归一化，使得所有被选中专家的权重之和等于 1：

$$A + B = 1 \quad \text{（renorm 下）}$$$$y = A \cdot E_1(x) + B \cdot E_2(x)$$

不加 Renorm 的情况：softmax 是在所有 $E$ 个专家上做的，然后才 top-k 截断。被截断后剩余 k 个专家的权重之和 $A + B < 1$，输出的幅度比 Dense 模型更小。

加 Renorm 的情况：在 top-k 截断之后，对剩余的 k 个专家权重重新做 softmax（或者直接除以它们的和），使得 $A + B = 1$，输出方差与 Dense 模型保持一致。

3.2 梯度视角的分析

为了理解为什么 Renorm 重要，需要看梯度流动。以 2 个专家为例，MoE 的输出：

$$y = A \cdot E_1(x) + B \cdot E_2(x)$$

对输入 $x$ 的梯度：

$$\frac{\partial \mathcal{L}}{\partial x} = \text{grad} \cdot A W_1^T + \text{grad} \cdot B W_2^T$$

对每个专家权重矩阵 $W_1, W_2$ 的梯度：

$$\frac{\partial \mathcal{L}}{\partial W_1} = \text{grad} \cdot A \cdot x, \quad \frac{\partial \mathcal{L}}{\partial W_2} = \text{grad} \cdot B \cdot x$$

加了 Renorm（$A + B = 1$）时，对 $x$ 的梯度是 Dense 模型梯度的一个"加权平均"，总量等价于 Dense 的"一份"梯度。不加 Renorm 时，$A + B < 1$，对 $x$ 的梯度总量小于 Dense 的一份，导致输入端的更新幅度偏小。

3.3 实验验证：梯度大小比梯度配比更重要

为了精确理解梯度的作用，设计了一组系统性消融实验：

版本	方案描述	AUC 变化	结论
v3.0	去掉 Router 对 $x$ 的梯度（$\text{grad\_x} = \text{grad}(W_1^T + W_2^T)$）	-w13（严重负向）	$x$ 梯度不能被移除
v3.1	保留 $x$ 梯度，只对 $W$ 梯度去掉 router 因子	+w5	$x$ 梯度的配比比 $W$ 更关键
v3.2	去掉 router 对 $x$ 梯度，但 $x$ 梯度整体乘 0.5	+w3	梯度大小比梯度配比更重要
v3.3	$x$ 梯度乘 0.25	-w2	梯度过小导致欠拟合
v3.4	基线 + $x$ 学习率调小 1/2	~	学习率不是关键变量

v3.0 的严重负向说明一件事：给 $x$ 的梯度不能超过"一份 Dense"的大小，否则多层残差网络的更新会产生不稳定的冲击。这排除了"增大梯度来加速收敛"的直觉。

v3.2 和 v3.3 的对比排除了"梯度配比"的假设——不论配比如何，梯度的绝对大小才是关键。梯度过小（v3.3）导致欠拟合，梯度过大（v3.0，相当于 dense 的两份）导致过度更新。

v3.4 排除了"调小学习率可以等价于减小梯度"的假设。

核心结论：Renorm 自动把 Sparse MoE 的输出值域和方差控制为与 Dense 等价，从而使得对 $x$ 的梯度量始终维持在"恰好一份 Dense"的水平，这对多层残差网络的梯度稳定性至关重要。

3.4 为什么推荐系统比 LLM 更敏感？

一个合理的猜测是：推荐系统的 item 词表极大（千亿级别），序列 Token 的嵌入分布远比 LLM 文本 token 分散，值域更宽。这使得模型对梯度的"份数"大小特别敏感——同样的梯度比例偏差，在推荐系统里会被词表规模放大，导致更显著的训练不稳定。LLM 的 token 空间相对集中（词表几万到几十万），这个问题没有那么严重，因此 Renorm 是可选项而非必需品。

3.5 多层 Residual 网络中 Renorm 的意义

从更宏观的视角看，推荐序列建模组件通常是多层堆叠的（2L、4L 的 Perceiver）。在多层 Residual 网络中，每一层的输出都会通过残差连接叠加到下一层的输入。

如果某一层的 MoE 输出幅度比 Dense 模型更小（不加 Renorm 的情况），这一层对应的残差更新就更弱，经过 LayerNorm 的归一化后，这一层的学习信号也相应更弱。在多层网络中，这种"信号衰减"会随层数累积，深层的参数更新越来越依赖残差连接的原始信号而不是本层的 MoE 计算——这正是上层 MoE 层比浅层更难收敛的根源。

加了 Renorm 后，每一层 MoE 的输出方差与 Dense 保持一致，残差连接的更新幅度稳定，多层网络的训练才真正稳定。这也解释了为什么在分析多层 Perceiver 的梯度时，发现越上层的 Attention MoE 欠拟合越严重——它是 Renorm 只能部分缓解而无法根本消除的层间梯度衰减问题的体现，需要结合 layer-aware 的 Router scale 来完整解决。

普通 Sparse MoE 的所有专家都是"竞争上岗"的——Router 每次只选 k 个，其余不参与计算。这有一个潜在问题：如果 Router 学得不好，某些专家可能长期被冷落，得不到足够的训练样本，最终形成"冷专家"——参数几乎没有被更新，不具备有效的建模能力。

Share Expert（共享专家）是一种在 LLM 领域（如 DeepSeek-MoE）已被验证的改进方案：引入若干个始终激活的专家，它们不参与 Router 竞争，每次前向传播都必定被计算。其作用是：

提供稳定的基础输出，防止 Router 专家在训练初期输出不稳定时整个模块崩溃
承担通用知识，让竞争性的 Router 专家专注于学习"差异化能力"，降低它们的学习难度
天然平衡负载，确保有部分参数始终被充分训练

在推荐系统场景，这些动机同样成立，我们自然地尝试了引入 Share Expert。

然而，实验结果令人意外——直接引入 Share Expert 在多个推荐系统场景出现了显著负向。我们测试了两种方案：

Naive Share Expert（直接加和，不做归一化）：

$$y = g(x) E_r(x) + E_s(x)$$

加 Renorm 的版本（将 Share Expert 的 gate 视为常数 1，与 Router Expert 一起归一化）：

$$g_1(x) = \frac{g(x)}{g(x) + 1}, \quad g_2(x) = \frac{1}{g(x) + 1}, \quad y = g_1(x) E_r(x) + g_2(x) E_s(x)$$

两种方案在实验中都出现了严重负向，且加了 Renorm 后负载分布极度不均衡（Share Expert 几乎承担了所有工作）。

问题的根源在于：Share Expert 和 Router Expert 之间存在一个"配比"问题，而这个配比在朴素方案中是固定死的，无法自适应。

以加 Renorm 的版本为分析：$g_1 = g/(g+1)$ 和 $g_2 = 1/(g+1)$ 是此消彼长的关系。如果 Router Expert 的 gate 值 $g$ 偏小（这在 Router 训练初期很常见），那么 $g_2 \approx 1$，Share Expert 几乎以满权重贡献输出，Router Expert 的贡献趋近于零。这反过来导致 Router 专家几乎得不到梯度（因为它们的输出对总输出影响极小），形成恶性循环。

4.3 Learnable_coef：一个标量解决配比问题

解决方案是引入一个可学习的标量参数 coef，让模型自己学习 Share Expert 和 Router Expert 应该以什么比例混合：

$$g_1(x) = \frac{\text{coef} \times g(x)}{g(x) + 1}, \quad g_2(x) = \frac{1}{g(x) + 1}$$$$y = g_1(x) E_r(x) + g_2(x) E_s(x)$$

这个改动看起来只是加了一个标量，但本质上给了模型一个"调节 Router Expert 权重的旋钮"——coef 越大，Router Expert 的贡献越大；coef 越小，Share Expert 相对越重要。而且 coef 是通过梯度学习的，会自动收敛到对当前任务最有利的配比。

实验效果立竿见影：

方案	AUC（vs 无 MoE 基线）
基线（Perceiver 2L, Dense）	—
Attention MoE + FFN MoE	+0.12%
+ Share Expert + Renorm	+0.06%（负向！比无 Share 更差）
+ Share Expert + Renorm + Learnable_coef	+0.15%

有意思的是，观察训练过程中 coef 的变化轨迹：

Attention MoE 中：coef 快速学到 1 附近，之后基本不变。这说明 Attention MoE 中 Share Expert 和 Router Expert 天然的配比（coef=1）就已经比较合适，不需要额外调整。
FFN MoE 中：coef 从初始值持续增大，没有明显收敛的迹象。这说明 FFN MoE 中 Router Expert 需要更大的话语权——Share Expert 在 FFN 中的作用可能更多是"保底"而不是"主力"，应该把主要贡献留给专业化的 Router Expert。

这个差异再次印证了 Attention 和 FFN 在 MoE 化中的本质区别：Attention 的 Share Expert 贡献比较均匀，FFN 的 Share Expert 更像是辅助角色。

4.4 Learnable_coef 的工程直觉

从工程角度理解 Learnable_coef，它本质上是一个"把手工调参内化为梯度学习"的设计模式。

传统的调参方式是：工程师先凭经验设置一个固定的 coef 值（比如 0.5 或 2.0），然后做消融实验，找到最优值后固化下来。这种方式的核心问题是：最优 coef 值会随着任务类型（Attention vs FFN）、序列长度、专家数等条件的变化而变化。换一个场景就需要重新调参，维护成本很高，而且在多层网络中不同层的最优 coef 也可能不同，手工调参根本无法覆盖所有情况。

引入 Learnable_coef 后，这个调参过程被内化到模型训练中。不同的 Block（Attention Block vs FFN Block）可以学到不同的最优 coef 值，甚至不同层的同类型 Block 也可以学到各自的值。这种自适应性对于跨场景复用同一套架构非常重要——同一套代码部署到 TikTok Live、短视频、电商等不同场景，每个场景的 coef 会自动收敛到各自的最优值，无需为每个场景单独调参。

从训练动态上看，coef 的收敛行为本身也是诊断 MoE 训练健康度的一个有用信号：如果 coef 持续增大且长时间不收敛，可能意味着当前的 Router 专家数不够（需要更多专家承担更细分的职责），或者 Share Expert 的隐层维度太小（能力受限）。反之，如果 coef 收敛到接近 0，说明 Share Expert 主导了输出，Router 专家没有学到差异化能力——这是一种退化情况，通常意味着 Router 的训练信号太弱，可能需要检查 Renorm 是否正确配置，或者调整负载均衡 Loss 的强度。

5. Double Router：解决负载均衡中的 Entropy Collapse

负载均衡是 Sparse MoE 工程化的经典难题，但在推荐系统场景，我们遇到了 LLM 领域很少讨论的两种特殊失效模式，被统称为 Entropy Collapse。

5.1 Softmax Router 的 Entropy Collapse

扩大专家数量是提升 MoE 表达能力的直观手段，但实验发现：从 2 in 8 扩大到 2 in 16、2 in 32 后，softmax router 的效果没有提升，甚至持平。

通过观察 Router 的 entropy 值（衡量专家选择的均匀程度）发现：softmax 在 32 个专家上的 entropy 约为 3.2，而理论上限是 $\log_2 32 = 5$。这说明即使有负载均衡 Loss 的约束，softmax router 在专家数增多时仍然会倾向于让 gate 值趋于平均——每个专家的激活权重都变小，区分度降低，专家失去了稀疏性和专业性。

根本原因在于 softmax 的归一化机制：专家越多，每个专家分到的"概率总量"越少，softmax 对专家数的增加本质上是抑制的。

5.2 Sigmoid Router + Load Balance 的坏死专家

为了解决 softmax 的问题，一个自然的想法是用 sigmoid router——sigmoid 独立计算每个专家的激活概率，不受其他专家影响，理论上不存在"概率被摊薄"的问题。

但加上负载均衡 Loss 后，出现了另一种失效：负载均衡 Loss 对使用频率高的专家施加惩罚，训练过程中会把这些专家的 gate 值持续打压，直到 sigmoid 后的激活概率趋近于 0。最终结果是：几乎所有专家的激活值都被压到接近 0，出现大量坏死专家（dead experts）——它们的参数几乎没有梯度，无法被有效训练。

这正是推荐系统"序列模块容易偷懒"特性的体现：模型发现"让所有专家都不工作"是一种可行的低损失状态，因为序列模块的贡献可以被其他模块弥补。负载均衡 Loss 无意中给了模型一个制造坏死专家的激励。

5.3 Double Router：解耦负载均衡和 MoE 输出

分析两种失效的根源：问题都出在负载均衡约束作用于 MoE 输出路径的 Router上——softmax router 被其归一化特性限制，sigmoid router 被 Load Balance Loss 打压。

解决思路是：把负载均衡和 MoE 输出解耦，让两件事由两套不同的 Router 来负责：

Sigmoid Router（主路由）：计算每个专家的独立激活概率，用于 MoE 最终输出的计算。Sigmoid 的独立性保证了专家间不相互竞争压制，稀疏性和专业性得以保留。负载均衡 Loss 不直接作用于这条路径。
Extra Softmax Router（辅助路由）：仅用于计算负载均衡 Loss，不参与 MoE 输出的梯度路径。

最终专家得分为两个 Router 分数的叠加：

$$\text{score}_i = \text{score}^\text{sigmoid}_i + \text{score}^\text{softmax}_i$$

这样，负载均衡的约束只作用于 Extra Softmax Router，主路由的 Sigmoid Router 梯度不受干扰，专家激活值域得以维持。相比 DeepSeek 提出的无参数负载均衡方案，Double Router 通过引入可学习的 Extra Router，能在自适应调控的基础上引入语义信息，路由决策更加准确。

5.4 消融实验

方案	AUC 变化	备注
2 in 8, softmax（基线）	+0.03%	—
2 in 8, sigmoid + load balance	+0.03%	有坏死专家
double router，单层（消融）	+0.02%	验证：非"算两个分"带来收益
double router + load balance	+0.04%	负载均衡，gate 值域大

消融实验（单层 double router，两个 Router 线性相关）排除了"多算一个分就有收益"的假设。Double Router 的收益来自于解耦本身：主路由不受负载均衡 Loss 的干扰，梯度路径更清晰。

6. 专家初始化：容易踩坑的工程细节

MoE 的专家初始化是一个容易被忽视但实际上很重要的工程细节。

在千川商城 CTR Attention MoE 的实验中，仅仅因为初始化 stddev 从 0.02 改为 0.05，就出现了明显的 weight 2 差异，影响了训练的稳定性。这提醒我们：Transformer 组件和 Sparse MoE 组件对初始化非常敏感。

根据的理论分析，对于多层 Transformer/MoE 的最优初始化：

$$\text{GlorotNormal}(\text{mode}=\text{'fan\_in'}, \text{scale}=1/\text{layer})$$

其中 layer 是层数，随着层数增加适当减小初始化 scale，防止深层网络的激活值爆炸。

加了 Renorm 的情况：MoE 的输出方差被归一化到与 Dense 等价，中间层的初始化不需要额外调整。

不加 Renorm 的情况：因为稀疏激活导致输出方差减小，需要补偿性地调大中间层的初始化 scale：

$$\text{GlorotNormal}(\text{mode}=\text{'fan\_in'}, \text{scale}=1/(\text{layer} \times \text{topk}))$$

这个 $\times \text{topk}$ 的调整本质上是让每个专家的输出方差乘以 $\text{topk}$，使得 $\text{topk}$ 个专家加权求和后的总方差等价于 Dense 的单一 FFN。

7. 多层 MoE 的收敛性分析

除了上述核心设计，多层 Sparse MoE 的收敛行为也值得单独讨论。在扩展到 4 层 Perceiver 的实验中，我们通过分析各层参数的 weight norm（权重矩阵的 $\ell_2$ 范数，反映参数的学习幅度）发现了一个规律性现象。

7.1 Attention MoE 的层间欠拟合趋势

以 v_dense（Value 矩阵的 norm）为例，在 4L Perceiver 中，各层的 norm 从低层到高层呈递减趋势：

$$1.45 \to 1.34 \to 1.29 \to 1.08$$

斜率越来越低，说明越上层的 Attention MoE 参数更新越弱，上层比下层更欠拟合。进一步分析发现，QKVO 矩阵中 QO 比 KV 欠拟合更严重，这是因为 QO 矩阵没有跨序列的 Cross-Attention 部分提供额外的学习信号（KV 矩阵在 Perceiver 的 Cross-Attention 中额外被 source sequence 的梯度更新）。

7.2 FFN MoE 的欠拟合更为严重

FFN MoE 中，各层的 weight norm 在扩专家数时几乎不变（大部分情况下只有 1.2 倍左右），而 Attention MoE 的 norm 变化更明显。这说明 FFN MoE 处于比 Attention MoE 更严重的欠拟合状态。猜测原因是：两层 MLP 的 FFN 结构比单层 Attention 的矩阵乘更难被稀疏 Router 充分拟合，梯度在两层 MLP 中的传播路径更长，Router 专家的更新信号更弱。

7.3 对 Router 设计的影响：层感知的 Router Scale

上述分析给出了一个清晰的工程指导：越上层的 MoE，应该给 Router 更大的权重倍数，以补偿层间梯度衰减带来的欠拟合。具体来说，可以让 Router 的激活比例 $k/E$ 随层数增大——低层用更稀疏的路由（更强的专家化），高层用更密集的路由（更多激活，更强的梯度）。

但这个方向目前还没有稳定的设计方案。简单的 layer-wise $k$ scaling 在实验中没有得到置信的正向结论，更精细的 layer-aware Router 设计（比如根据层的 weight norm 动态调整 $k$ 值）是未来的探索方向。

8. 性能优化：SMoE-Lego 算子

方案设计完成后，还有一个重要的工程挑战：让 Sparse MoE 的稀疏性在 GPU 上真正生效，而不是只是代码层面的稀疏。

7.1 为什么需要专用算子

这是一个常见的误区：在代码层面写了 TopK + 专家选择，就认为计算量是稀疏的。实际上，如果底层实现是 dense 矩阵乘法（把不需要的专家 gate 设为 0，但仍然参与矩阵乘），在 GPU 上执行的仍然是全量计算，没有节省任何 FLOPS。

真正的稀疏计算需要：

Gather（收集）：把需要路由到同一专家的 token 收集在一起，形成一个更小的批量
Expert 计算：对这个小批量做矩阵乘法（尺寸是 $B' \times D$ 而非 $B \times D$）
Scatter（散布）：把各专家的计算结果散布回原来的 token 位置
加权合并：按 gate 值加权求和

这涉及非规则的 memory access pattern，需要专门设计的 CUDA 算子来实现高效执行。

7.2 SMoE-Lego 算子的设计

SMoE-Lego 算子包含 5 个核心算子，实现了真正的稀疏训练和推理：

Input tokens (B×L)
 ↓
[Gate 计算] → TopK 路由决策
 ↓
[Gather] → 按专家分组收集 token
 ↓
[Expert 计算] → 各专家独立批量计算（真正稀疏）
 ↓
[Scatter] → 结果散布回原位置
 ↓
[加权求和] → gate 加权合并
 ↓
Output tokens (B×L)

算子既可以用于 Dense MoE 场景，也可以用于序列建模场景，通用性强。

在 TikTok Live 直播场景的实测结果（Perceiver 2L, 4× Attention MoE + 4× FFN MoE，topk=2）：

版本	单步时间	训练吞吐	显存占用
朴素实现（全算）	350ms	1.16m/s	60G
s-pertoken + bmm（全算）	330ms	1.27m/s	58G
TF 原生 Pertoken SMoE	520ms	857k/s	56G
SMoE-Lego Final	216ms (-39%)	1.77m/s (+50%)	42G (-30%)

相比朴素的全算实现：训练时间减少 39%，吞吐提升 50%，显存减少 30%。基本上实现了 1/topk 的理论稀疏化收益。

7.3 显存与吞吐的进一步优化

共享 Attention MoE 的 Router 计算：实验发现，所有 Attention MoE 层共享同一套 Router 计算（即所有层使用相同的路由决策）不会损失 AUC。这个发现有点反直觉，但可以理解为：不同层的 Attention 在 per-head 分组后，每组内的 token 分布差异不大，相同的路由策略足够覆盖各层的需求。共享 Router 的好处是可以大幅节省 scatter 结果的显存（scatter 结果的显存占用为 $B \times L \times D \times K$，对于 4 层分别存储就是 4 倍）。

Gelu 进 XLA：在 TikTok Live 实验中，通过排查训练 timeline 发现，Lego 算子中 FFN MoE 的 Gelu 激活函数因为默认 min_cluster_size=12 的配置没有被 XLA 编译进内核，导致它在 CPU 上执行，整体耗时是 XLA 版本的 10 倍。将 min_cluster_size 调小到 4 后，Gelu 成功被 XLA 编译，训练吞吐进一步提升 +7%。

这是一个典型的"配置细节决定性能"的案例：算法层面的工作再完美，一个工程配置项的疏漏就可能损失 7% 的吞吐。

9. 线上效果

方案在两个 TikTok Live 场景完成了完整的 A/B 实验：

8.1 2025.11：Perceiver 2L + Attention MoE + FFN MoE（1 in 7）

架构：2 层 Perceiver，Attention 和 FFN 均做 MoE 化，每 7 个专家激活 1 个。这是最初的落地版本。

指标	变化	说明
训练 AUC（CTR0s）	+0.24%	离线效果
Serving AUC（CTR0s）	+0.54%	在线效果，gap 明显大于离线
Serving Logloss	-0.47%	校准提升
Valuable Watch Live Days/User	+0.97%	核心看播渗透指标
Active Send Gift Days/User	+0.37%	送礼行为提升
Public Diamond (cap100)/User	+0.83%	礼物价值提升
App LT7	+0.035%	7 日留存
AWLD (w/ LT/HLT/SD)	+5.36%	综合时长指标（修正后）

训练 AUC 和 Serving AUC 之间存在明显的 gap（+0.24% vs +0.54%），这是 MoE 场景的特有现象：稀疏激活在在线服务时能够更精准地路由特定类型的 item，激活最匹配的专家，而离线训练时因为 batch 内的多样性，路由决策的精准度相对较低。这个现象说明 MoE 的真实收益在在线场景会被放大。

8.2 2026.03：Perceiver 2L + 10k Full Sequence（LRM v2）

这次实验在更长的序列（10k）下验证了方案：

指标	变化
训练 AUC	+0.02%
Serving AUC	+0.62%
Serving Logloss	-0.61%
Watch Live Days	+0.52%
Valuable Watch Live Days	+1.21%
Watch Live Duration	+0.69%
Valuable Watch Live Duration	+0.57%

一个有趣的附带收益：实验方案显著缓解了高分段样本 calibration 高估的问题。在 baseline 下，模型对高置信度样本的 CTR 预测值系统性偏高（高估），加入 Sparse MoE 后这一现象明显改善。合理的解释是：MoE 的稀疏激活鼓励专家之间的专业化，减少了不同类型 item 之间的特征干扰，高置信度 item 的预测因此更加精准。

10. 总结与反思

9.1 四个设计的核心逻辑一览

回顾整个方案，「Share Expert + Renorm + Learnable_coef + Double Router」这四个设计各自针对一个根本性问题，缺一不可：

设计	解决的问题	根本洞见
Renorm	多层梯度不稳定，训练坍塌	推荐 Token 值域大，梯度份数比 LLM 更敏感
Share Expert	纯竞争 Router 的专家负载不均	引入始终激活专家降低竞争压力，提供基础输出
Learnable_coef	Share/Router Expert 配比固定，无法自适应	FFN 中 Router Expert 需要更大话语权
Double Router	负载均衡约束与 MoE 输出互相干扰	将负载均衡和 MoE 输出解耦到两套 Router

这四个设计不是独立的 trick，而是对一个共同问题（推荐序列建模中的 Sparse MoE 训练稳定性）的系统性解答。

9.2 与 LLM MoE 的本质差异

从这个工程实践中，我们可以总结出搜广推 Sparse MoE 与 LLM Sparse MoE 在工程约束上的三个本质差异：

差异一：梯度稳定性要求更高。 LLM 是端到端的 Transformer，梯度流动路径简单规整。推荐系统的序列模块是中间件，梯度来自多个方向，且下游的 item 词表庞大，导致对梯度幅度的敏感性远超 LLM。Renorm 因此从可选项变成了必选项。

差异二：负载均衡策略完全不同。 LLM 中标准的辅助 Loss 基本有效。推荐系统中因为序列模块有"偷懒"的退路，任何直接打压 gate 值的约束都可能触发 Entropy Collapse。Double Router 的本质是把约束目标（负载均衡）和计算目标（MoE 输出）分开处理。

差异三：专家数扩展策略待探索。 LLM 中扩专家数是有稳定收益的。推荐系统中目前的稳定点在 2 in 8 附近，更大规模的专家数扩展（2 in 32+）目前没有置信且建设性的结论，是未来的重要探索方向。

9.3 还未解决的开放问题

文档中也坦诚记录了尚未有稳定结论的几个方向：

层间 Router 的异质性：多层 MoE 中越靠上的层越难收敛，欠拟合更严重。理想的做法是上层用更大的 Router 倍数，实现 layer-aware 的动态 Router，但这还没有稳定的设计方案。

Attention MoE 的 all-to-all 形式：目前使用 per-head 分组，降低了 Router 自由度。理论上 all-to-all 能学到更灵活的路由，但实际效果需要更大规模的验证。

Renorm 与 Share Expert 的大规模扩展：目前主要在 2 in 8 附近验证了方案有效性。更大专家数下，这套组合是否依然是最优解，需要系统性的扩展实验来回答。

推荐系统的 Sparse MoE 工程化，才刚刚开始。

9.4 工程化落地的隐性成本

除了算法设计本身，Sparse MoE 落地的工程复杂度也远高于 Dense 模型迭代。这里有一些值得记录的隐性成本：

训练稳定性监控成本更高。Dense 模型只需要监控 loss 曲线和 AUC，而 Sparse MoE 需要额外监控：每个专家的被选中频率分布（检测坏死专家）、Router gate 值的值域分布（检测 entropy collapse）、各层的 weight norm（检测欠拟合）。这些监控指标在 Dense 模型迭代中是完全不需要的，但在 MoE 调试中是排查问题的关键。

超参数调试空间更大。相比 Dense 模型，MoE 引入了多个新的超参数：Router 类型（softmax/sigmoid/cosine）、专家数 $E$、激活数 $k$、负载均衡 Loss 的系数 $\alpha$、Learnable_coef 的初始化值、Z-loss 的系数等。这些超参数之间还有交互效应（比如 sigmoid + load balance 的组合才会触发 entropy collapse），调试难度显著高于 Dense 模型。

算子工程投入不可忽视。SMoE-Lego 算子的开发是整个工程中投入最重的部分之一。真正稀疏的 GPU 算子需要处理非规则 memory access、gather/scatter 的 kernel fusion、XLA/TF 图的算子注册与 JIT 编译等问题，这些都是对算子工程师的专业要求。前期如果没有这套算子，Sparse MoE 反而会比 Dense 慢（TF 原生 Pertoken SMoE 比朴素全算还慢了约 26%）。

在线推理的 serving 改造。训练侧的 MoE 改造完成后，Serving 侧也需要对应的工程支持：在线 feature 计算需要正确传递 Router 所需的输入特征，模型导出需要支持稀疏算子的图优化，推理引擎需要支持 TopK 路由的动态 batch 分发。这些工作往往需要算法、系统、基础设施团队的协同。

这些隐性成本说明，Sparse MoE 不是一个"算法侧改改 config 就能上线"的优化，它需要算法、工程、基础设施各层面的同步投入。但从最终的线上收益来看（AUC +0.54%～+0.62%，看播时长 +5%+），这些投入是值得的。

9.5 一个更宏观的视角：MoE 化是序列建模的下一个 Scaling 阶段吗？

从历史上看，推荐系统的序列建模每隔 2-3 年就会迎来一次范式升级：从 Attention-weighted 到 Transformer Self-Attention，从 Self-Attention 到 Perceiver 压缩，从短序列到超长序列。每一次升级都以某种方式突破了前一阶段的资源瓶颈。

Sparse MoE 是不是下一个范式升级？目前的实验结果表明，它能在几乎不增加推理成本的前提下提升模型容量，这正是当前计算瓶颈下最需要的技术特性。同时，它与序列长度扩展、层数扩展、宽度扩展是正交的——可以在做了 MoE 化之后，继续做这些维度的扩展。

当然，目前的工作还有很多未解决的问题（专家数扩展收益不稳定、层间收敛性差异、负载均衡在大规模专家数下的表现等）。这些问题的解答，将决定 Sparse MoE 能走多远。

参考资料

TokenFormer：终结推荐系统的两个平行世界

Wed, 15 Apr 2026 22:00:00 +0800

本文基于腾讯广告团队 2026 年 4 月最新发布的论文《TokenFormer: Unify the Multi-Field and Sequential Recommendation Worlds》（）撰写。论文提出了一种统一的推荐系统骨干架构，通过两项核心技术创新解决了长期困扰业界的"朴素统一导致序列坍缩传播"问题，并在微信视频号广告系统上取得了 +4.03% GMV 的在线收益。

0. 两个推荐世界的长期割裂

在过去十年里，工业推荐系统悄然形成了两套彼此独立的技术体系：

第一套：多字段特征交互（Multi-Field Feature Interaction）

这套体系的核心是处理异构稀疏特征——用户画像、商品属性、上下文信息等来自不同字段的类别特征。DIN 用 Attention 做目标感知的历史权重，DCN 用交叉网络显式建模高阶特征交叉，DeepFM 引入因式分解机……无数工作都在探索如何更好地捕捉这些静态特征之间的相关性。

第二套：序列行为动态建模（Sequential Behavior Modeling）

这套体系的核心是理解用户兴趣的时序演化——GRU4Rec 用 RNN 建模序列，SASRec 引入 Self-Attention，BERT4Rec 使用双向建模，后来又有 HSTU 在腾讯广告规模下证明了序列 Transformer 的价值……这套范式专注于从用户的行为轨迹中挖掘动态偏好。

两套体系共享相同的计算基元（Embedding、Attention），却长期平行演进，极少交融。现代工业推荐系统往往通过拼接的方式将两者整合：将各字段特征过一套交互模块，将序列特征过另一套序列模块，最后把两个模块的输出 concat 进入后续网络。

这种异构拼接的方式显然不够优雅。自然的问题是：能否用一个统一的 Transformer 架构，直接端到端地处理所有输入？

答案是可以的——但论文发现，朴素地统一这两类特征会触发一种此前未被识别的失效模式。

1. 发现问题：序列坍缩传播

1.1 朴素统一为什么会失败

最直观的统一方案是：将所有输入——多字段特征、序列行为、目标特征——展平为一条 token 流，然后喂给标准 Transformer。理论上，全注意力机制应该能够自行学习哪些 token 之间需要交互。

但实验告诉我们，这种方案会显著劣于精心设计的异构架构。论文通过仔细的表示分析找到了原因：序列坍缩传播（Sequential Collapse Propagation，SCP）。

现象：非序列字段（如用户画像、上下文特征）的嵌入维度通常较低，而序列行为的建模需要更高的表示维度来承载时序动态。当低维非序列 token 与高维序列 token 在全注意力中充分交互时，序列表示会发生维度坍缩——有效秩（effective rank）急剧下降，序列 token 的表示趋于同质化，丧失区分度。

可以用一个类比来理解：你在听一场 80 人的交响乐演奏时，如果强行让乐手们去迁就一位经验有限的独奏者的节奏，整体音乐的层次感反而会被拉低。

1.2 从谱分析看坍缩

论文通过分析 Transformer 各层的有效秩（erank）来量化这一现象。有效秩衡量的是一个矩阵在多少个奇异值方向上有实质性的"能量"——有效秩越高，表示越丰富，区分度越强。

在朴素统一的 Transformer 中，随着层数加深，序列 token 的表示矩阵谱衰减越来越陡峭：大量信息被压缩到少数几个主方向，模型失去了表达多样化序列模式的能力。

与此同时，论文还发现了另一个浪费：在深层网络中，序列 token 会反常地向非序列位置分配大量注意力权重（平均 40.0 vs 序列内部的权重），尽管这种跨域注意力在深层并没有实质性收益。

2. TokenFormer 架构设计

论文提出了 TokenFormer，通过两项互补的技术创新来解决上述问题。

2.1 统一令牌流

所有输入首先被组织为一条扁平化的令牌流：

$$\mathbf{S} = [\underbrace{f_1, f_2, \ldots, f_m}_{\text{非序列字段} \mathcal{F}}, \underbrace{t_1, t_2, \ldots, t_n}_{\text{序列行为} \mathcal{T}}, \underbrace{v_1, \ldots, v_k}_{\text{目标特征} \mathcal{V}}]$$

与其他统一方案不同，TokenFormer 使用 RoPE（旋转位置编码） 而非类型嵌入来区分不同段落。RoPE 通过位置感知索引方案，让模型在注意力计算阶段自然感知 token 的位置属性，而不需要额外引入分段标记。

2.2 BFTS：底部全注意力，顶部滑动窗口

这是 TokenFormer 的第一个核心创新：分层注意力设计（Bottom Full-attention, Top Sliding-window，BFTS）。

graph TB subgraph "浅层（l ≤ lf）：全注意力" L1["Layer 1\n非序列 ↔ 序列\n全局特征融合"] L2["Layer 2\n跨域交互完成"] end subgraph "深层：收缩滑动窗口" L3["Layer 3\n窗口 w1\n序列局部建模"] L4["Layer 4\n窗口 w2 < w1\n精细时序优化"] L5["Layer 5\n窗口 w3 < w2\n近邻感知"] end L2 --> L3 L3 --> L4 L4 --> L5 note["非序列 token\n在深层完全禁止\n关注序列位置"]

设计逻辑如下：

浅层（$\ell \leq \ell_f$）使用全因果注意力：在这个阶段，让所有 token 充分交互，完成跨域特征融合。非序列字段的静态信息需要在这里"注入"到序列表示中。

深层使用收缩窗口滑动注意力（SWA）：一旦全局交互完成，深层应该专注于序列内部的局部时序建模。窗口大小随层数递减（$w_1 \gt w_2 \gt \cdots \gt w_{L_s}$），让网络从粗粒度到细粒度地精炼序列表示。

关键约束：在深层，完全禁止序列 token 关注非序列位置。这解决了前面提到的"反常跨域注意力"浪费问题，让深层注意力专心处理时序动态。

消融实验清楚地验证了这一设计的必要性：

配置	相对 AUC 变化
全部使用全注意力（基线 Transformer）	0
全部使用滑动窗口（4S）	−36.35‰（灾难性失败）
仅 BFTS	+4.91‰
完整 TokenFormer	+8.15‰

全 SWA 配置的灾难性失败(-36.35‰)说明：早期的全局特征融合是不可或缺的。序列建模需要先"看见"上下文全貌，再聚焦局部。

2.3 NLIR：非线性交互表示

这是 TokenFormer 的第二个核心创新：非线性交互表示（Non-Linear Interaction Representation，NLIR）。

标准 Transformer 的注意力输出经过残差连接直接送入下一层：

$$\mathbf{X}^{(l+1)} = \mathbf{X}^{(l)} + \text{Attn}(\mathbf{X}^{(l)})$$

TokenFormer 在注意力输出处插入了一个门控机制：

$$\mathbf{G}^{(l)} = \mathbf{X}^{(l)} \mathbf{W}_g^{(l)} \quad \text{（门投影）}$$$$\tilde{\mathbf{I}}^{(l)} = \sigma(\mathbf{G}^{(l)}) \odot \mathbf{A}^{(l)} \quad \text{（乘法调制）}$$

其中 $\sigma$ 为 Sigmoid 函数，$\mathbf{A}^{(l)}$ 是注意力输出，$\odot$ 是逐元素乘法。

为什么这样设计？

Sigmoid 门控引入了非线性变换，本质上是让注意力输出的每个维度通过"开关"进行动态选通。这有两个作用：

恢复有效秩：线性注意力本身是低秩操作，难以避免秩退化。Sigmoid 非线性打破了线性的秩约束，为序列表示注入了更丰富的维度多样性。
自适应梯度调制：门控参数在训练中自动学习，早期层的门控值趋向于更保守（保留更多原始信息），深层的门控值更积极（筛选关键模式）。这与 FFN Mid-LayerNorm 在 NormFormer 中发挥的作用类似——模型自动学习各层之间的信息流量分配。

论文通过互信息（Mutual Information）分析验证了 NLIR 的效果：在不同聚类数 K 下，BFTS+NLIR 的组合在各层一致提升了表示的区分度，单独使用任一模块也有显著收益。

3. 实验结果

3.1 离线基准对比

论文在 KuaiRand-27K 数据集上进行了全面的离线评估，与多个推荐系统 Baseline 对比：

用户中心（User-Centric）设置：

模型	AUC 相对提升（vs Transformer 基线）
OneTrans	−1.71‰
HyFormer	+4.47‰
TokenFormer-S	+5.76‰
TokenFormer-L	+8.15‰

新印象优化（New Impression Optimization）设置：

模型	AUC 相对提升（vs Transformer* 基线）
OneTrans*	+4.98‰
HyFormer*	+0.98‰
TokenFormer-S*	+11.42‰

TokenFormer 在两种设置下均大幅领先此前的统一推荐架构，证明了 BFTS+NLIR 的有效性。

值得注意的是，HyFormer 在新印象优化设置下出现了明显退化，而 TokenFormer 在两种设置下都保持了稳健的提升——这反映了统一架构的泛化能力。

3.2 效率与效果的权衡

论文探索了 BFTS 配置（全注意力层数 + 滑动窗口层数）对效率的影响：

graph LR subgraph "BFTS 配置探索" Config1["4F（全注意力）\n基线：AUC 0‰, GFLOPs 基准"] Config2["3F1S\n+0.21‰, −62.0‰ GFLOPs"] Config3["2F2S\n+0.85‰, −201.0‰ GFLOPs"] Config4["1F3S\n+0.05‰, −348.0‰ GFLOPs"] end Config1 --> Config2 --> Config3 --> Config4

最优配置是 2F2S：2 层全注意力 + 2 层滑动窗口，相比全注意力基线同时提升 AUC（+0.85‰）并大幅降低计算量（-201.0‰ GFLOPs）。这验证了 BFTS 的设计不只是为了精度，也为工业部署提供了显著的效率优化。

窗口大小的选择也有讲究：窗口 [32, 16] 优于均匀窗口和其他尺寸，收缩模式（从粗到细）优于均匀模式。

3.3 表示质量分析

论文通过两个维度量化了 TokenFormer 在表示质量上的改善：

有效秩（Effective Rank）分析：

在朴素 Transformer 中，序列 token 的表示矩阵谱衰减随层数加深而急剧恶化——大量奇异值趋近于零，表示实际上坍缩到极低维度空间。TokenFormer 引入 NLIR 后，各层有效秩显著高于基线，特别是在深层仍能维持丰富的表示维度。

注意力模式分析：

在浅层，TokenFormer 中静态（非序列）token 接收到的注意力权重（平均 52.7）高于 Vanilla Transformer（40.0），说明跨域融合更充分。在深层，TokenFormer 完全屏蔽了序列 token 对非序列位置的关注，而 Vanilla Transformer 仍在"浪费"注意力容量在无效的跨域交互上。

3.4 消融实验细节

变体	AUC 相对基线	说明
Transformer（基线）	0	朴素统一
+NLIR 仅	+4.87‰	非线性门控
+BFTS 仅	+4.91‰	分层注意力
+NLIR +BFTS（TokenFormer）	+8.15‰	完整方案
4S（全 SWA）	−36.35‰	无全注意力失败

两个组件各自贡献约 +4.9‰，合并后达到 +8.15‰，略有超加性效果，说明两种机制在解决 SCP 问题上具有互补性：NLIR 从表示维度出发恢复秩丰富度，BFTS 从注意力结构出发分离跨域融合与序列精炼。

3.5 在线 A/B 测试

论文报告了 TokenFormer 在微信视频号广告系统的上线结果：

测试时间：2026 年 1 月至 2 月
流量曝露：5% 流量
GMV 提升：+4.03%（相对基线）

对于视频号广告这样体量的商业化系统，+4% 的 GMV 是非常显著的在线收益，这也是对 TokenFormer 在工业规模下有效性的最直接验证。

论文还报告了模型缩放（Scaling）实验：从 TokenFormer-T（Tiny）到 TokenFormer-L（Large），在公开数据集上性能持续提升；在腾讯广告平台的内部数据集上，更大规模的模型没有出现饱和迹象，暗示了 TokenFormer 在工业规模数据下的 Scaling 潜力。

4. 核心洞察与延伸思考

4.1 为什么"朴素统一"是个陷阱

TokenFormer 最有价值的贡献之一，是对"序列坍缩传播"现象的精确识别与命名。在此之前，业界普遍的经验是"多字段交互模型和序列模型各自调好再合"，而 TokenFormer 揭示了这背后隐藏的理论原因：这两类特征的维度分布天然不匹配，强行在全注意力下交互会导致高维空间向低维空间的单向坍缩。

这个分析框架对其他推荐系统设计场景也有启发意义。每当我们看到"多种输入的统一建模"设计时，都应该问：不同模态/类型的输入之间，维度分布是否相容？它们的交互应该在何时、何处发生？

4.2 BFTS 的架构直觉

BFTS 的设计体现了一种"先全局融合，后局部精炼"的计算哲学。这与 Cross-Mask Transformer（视频号序列建模）中"跨域交叉 vs 域内交叉"的思路有相似之处，也呼应了 NLP 领域 Longformer、BigBird 等高效注意力架构的设计经验——在不同层次使用不同粒度的注意力是有理论依据的。

从工程角度，BFTS 带来了双赢：精度上升（序列 token 不再浪费注意力于无效跨域交互），计算下降（滑动窗口将平方复杂度降为线性）。2F2S 配置的 −201.0‰ GFLOPs 对工业部署而言意义重大。

4.3 NLIR 与 SwiGLU 的关系

NLIR 的门控形式 $\sigma(G) \odot A$ 与近年 LLM 中广泛使用的 SwiGLU/GLU 机制有异曲同工之处：

$$\text{SwiGLU}(X) = \text{SiLU}(XW_1) \odot (XW_2)$$

两者都利用非线性门控来增强特征的表达能力和选择性。NLIR 将这一思想应用到注意力输出的后处理环节，而非 FFN 内部，针对性地解决了序列表示的维度坍缩问题。这种跨领域的技术迁移也反映了推荐系统与 LLM 研究之间越来越深的融合趋势。

4.4 统一 vs 专家系统

TokenFormer 的出现引出了一个更深层的架构选择问题：在工业推荐中，统一骨干（unified backbone）和混合专家（mixture of experts / heterogeneous modules）哪种路线更有前途？

统一骨干的优点是参数共享、端到端优化、结构简洁、易于迭代。专家系统的优点是可以为不同类型的输入设计最适合的归纳偏置。

TokenFormer 的实验结果表明，一个设计精良的统一骨干可以超过异构专家组合。但这需要精确识别并解决统一化过程中出现的失效模式（如 SCP），不能简单地"把所有东西扔进一个 Transformer"。

5. 总结

TokenFormer 是一篇解决了一个真实工程问题的论文。它的贡献链路清晰：

识别问题：朴素统一多字段特征与序列特征导致序列坍缩传播（SCP）
分析根因：低维非序列 token 与高维序列 token 的全注意力交互引发维度坍缩，深层注意力的反常跨域分配造成额外浪费
提出方案：BFTS（分层注意力，早期全局融合+深层局部精炼）+ NLIR（非线性门控，恢复有效秩）
验证效果：离线 +8.15‰ AUC，在线 +4.03% GMV

从更宏观的视角来看，TokenFormer 代表了推荐系统架构从"异构组合"向"统一骨干"演进的一步重要尝试。随着 LLM 技术在推荐领域的渗透加深，这条技术路线还有巨大的探索空间：更长的序列、更多的模态输入、更强的跨任务泛化……TokenFormer 展示的"精确识别失效模式 + 针对性机制设计"方法论，将在这些探索中持续发挥价值。

参考文献：

Zhou, Y., et al. (2026). TokenFormer: Unify the Multi-Field and Sequential Recommendation Worlds.

Sun, F., et al. (2019). BERT4Rec: Sequential Recommendation with Bidirectional Encoder Representations from Transformer. CIKM 2019.

Zhai, J., et al. (2024). Actions Speak Louder than Words: Trillion-Parameter Sequential Transducers for Generative Recommendations.

Wang, R., et al. (2021). DCN V2: Improved Deep & Cross Network and Practical Lessons for Web-Scale Learning to Rank Systems. WWW 2021.

视频号推荐超长序列技术演进：从端到端到 Cross-Mask Transformer

Mon, 13 Apr 2026 22:00:00 +0800

本文基于微信视频号技术团队于 2026 年 3 月发布的技术分享《视频号推荐超长序列技术演进》整理而成。这是视频号推荐技术公众号的第一期内容，系统性地回顾了视频号从 2022 年至 2025 年在超长用户行为序列建模上的探索历程，覆盖工程优化、稀疏感知结构、多域暴力建模三大阶段。

0. 为什么超长序列是推荐系统最重要的 Scaling 方向

用户行为序列提供了对用户兴趣最直接、最明确的描述，是工业推荐模型中最重要的特征来源。对序列长度的扩展，是推荐模型最清晰的 Scaling 方向之一。

早期行业普遍采用以 SIM / TWIN 为代表的两阶段范式：先用轻量的 GSU（General Search Unit）从超长序列中检索出最相关的 Top-K，再用精细的 ESU（Exact Search Unit）做精确建模。这套范式在算力约束下取得了巨大成功。

然而，两阶段范式存在固有缺陷：

GSU 与 ESU 的表征一致性天然存在 gap，两个模块的优化目标并不完全对齐
剪枝丢失信息：GSU 的检索本质上是一次有损压缩，重要的长尾兴趣信号可能被过滤掉

视频号推荐技术团队从 2022 年开始选择另一条技术路线：全序列端到端建模，在这个过程中积累了大量宝贵经验。

四阶段演进脉络

timeline title 视频号超长序列技术演进（2022-2025） 2022 : SIM 两阶段建模 : 行业验证的基础范式 2022-2023 : 端到端全序列建模 : 工程攻坚 + 联训策略 2023-2024 : 轻量型序列结构 : 稀疏感知 Efficient Transformer 2024-2025 : 暴力型序列结构 : Cross-Mask Transformer 多域感知

值得注意的是：文中涵盖的时间跨度非常长，早期方案是在 A100/H20 供应有限的算力约束下设计的折中方案。随着算力丰富，后期暴力方案逐步替代早期方案，但在算力受限的场景下，早期方案仍具有重要参考价值。

1. 端到端全序列建模：打通数据与计算链路

端到端长序列的核心思路是：将万级长度的完整用户行为序列直接引入计算图，以候选视频为 Query 对整个序列做 Target Attention（TA）。挑战主要来自算力、显存、通信、数据链路四个层面。

1.1 工程优化：让万级序列跑起来

数据链路优化

万级序列使单条样本体积急剧膨胀。关键洞察：同一用户相邻时刻的序列快照，绝大部分内容相同，仅头尾少量数据变化。

基于此，设计了内容哈希分块存储方案：

按视频 ID 哈希值切分序列为若干块
相同内容的块跨请求复用
配合增量写入 + 按需读取，大幅降低存储和带宽开销

卡间通信优化

在 GPU 同步训练架构下，每步都需跨机交换 embedding 参数，而万级序列使得每条样本包含数万条 feed，跨机通信量随序列长度线性增长。

两层优化策略：

通用通信优化：推荐场景下不同用户消费内容高度重叠，利用机内 NVLink 高带宽先完成机内特征去重，再跨机传输，并将相同维度 embedding 合并通信（减少碎片化小包）。

针对 TA 结构的分布式 Attention：TA 结构下，序列内部元素无需相互交互，各卡可独立计算局部 attention 后合并结果：

这种设计使得跨机通信量不再由序列长度主导，在万级序列长度下可大幅降低训练成本。

显存优化

标准做法中，TA 计算需要 lookup 出序列中每个元素的 embedding，组装成 [B, L, D] 的 KV 矩阵，显存开销随序列长度线性增长。

解决方案：低显存 TA 算子，将 KV embedding 的 lookup 和 attention 计算合并为一个算子，“边查边算”，不再取出完整 KV 矩阵。

1.2 端到端与 SIM 联训：用 1K 逼近长序列收益

实验中发现了一个关键现象：在端到端建模下，虽然序列输入很大，但实际激活的 key 数量非常少（采用 element-wise ReLU 激活函数，activation score > 0 才被激活）。有相当比例的样本，激活数量甚至小于 SIM GSU 设置的检索数量。

这意味着：端到端长序列的收益逻辑，并不主要来自序列更长带来的信息增量，而更可能来自端到端训练带来的表征质量提升。

基于这一洞察，设计了联训方案：

graph TB subgraph 共享层 Emb["底层 Embedding 表征\n(共享参数)"] end subgraph SIM路径 Emb --> GSU["GSU 检索 5K"] GSU --> ESU["ESU 精确建模"] end subgraph 端到端路径 Emb --> Full["端到端全序列 TA\n(1K 长度)"] end ESU & Full --> Output["模型主体"]

实验结论：在 5K 长度 SIM 序列的基础上，引入 1K 长度的端到端全序列，即可取得绝大部分更长全序列的收益。这在算力资源受限时是 ROI 极高的方案。

1.3 User Level 样本组织

端到端长序列的计算成本主要集中在 user 侧（序列 IO、多特征 embedding 获取、复杂序列建模），自然想到对同一用户的多个样本进行 user-level 聚合以复用 user 侧计算。

然而，在充分优化的 pointwise 数据流基础上进行聚合，往往引入巨大的 UAUC 折损（完播目标 UAUC 折损 0.3%），这是一个巨大的障碍。后续在第 3.3.2 节会详细介绍最终攻克 user level 数据流的方案。

2. 轻量型序列结构：稀疏感知 Efficient Transformer

在端到端长序列的基础上，进一步尝试引入 Transformer 结构来捕捉推荐场景的高阶信息。然而，实验显示在推荐场景直接上标准 Transformer 的 ROI 并不高：平方计算开销高，相比简单 TA 增益有限。

问题在于：如何对长序列 Transformer 降本增效？

将推荐场景的 Transformer 结构分解为两个子问题：

候选与序列间交互（Candidate-Sequence Interaction）
序列内部元素交互（Intra-Sequence Element Interaction）

2.1 候选与序列间交互

探索了两种交叉模式：

模式	结构	实验结论
双向交叉	序列→候选（attention）+ 候选→序列（concat + DNN）	成本较高
单向交叉	仅序列→候选（attention）	与双向效果相近，成本更低

实验显示序列→候选的交叉重要性占主导地位，最终采用单向感知结构（与 STCA 类似），在视频号多个场景均体现出良好的通用性。

2.2 序列内部元素交互：三种稀疏感知

通过分析短视频场景行为序列上的 Transformer attention 规律，发现每个序列元素有三种典型的感知倾向：

2.2.1 感知相似

目标：对于序列中每个元素，检索出底层 embedding 相似的视频，提取用户在相似视频上的高阶序列信息。

朴素方案（Top-k 相似视频做 Transformer）存在问题：由于 top-k 集合内视频相似度过高，attention 产生 over-smooth 问题，各 token 表征趋于一致，丧失区分度。

最终方案：Top-k All-concat DNN + 余弦相似度压缩

关键技巧：

利用高相似度序列的低秩性质，将各视频 embedding 映射到以候选视频为轴的一维子空间
用 <cosine_similarity, side_info> 序列逼近原始序列信息，大幅压缩 DNN 输入维度（信息损失很小）
按 cos_sim 对序列排序，使 DNN 输入结构化，提升训练效果

2.2.2 感知相关

相关 vs 相似：相似是直接的 embedding 相近，而相关是簇层面的相似——两个视频属于不同兴趣簇，但这些簇之间经常共现（例如"搭配"关系）。

建模方案：基于 attention 的隐式聚类（参考 Set Transformer）

2.2.3 感知近邻

目标：刻画用户和环境的即时状态，每个 item 感知其前序近邻上下文。

简单的 sliding window SA 有收益但提升不够大，需要强化近邻上下文的捕捉方式和利用方式。

上下文捕捉：在近邻窗口内显式聚合并构造多维 context feature，包含：

视频 id、作者、虚拟类目等基础特征
时间窗内的统计特征（平均长度、平均播放时长、完播次数、快划次数、时间差等）
多个不同宽度的窗口并行，捕捉多尺度上下文信息

可解释性验证：实验表明，用户在"当前视频和历史视频上的 label 一致率"随视频相似度和上下文相似度的共同提升而显著提升，证明 context feature 捕捉到了真实的兴趣信号。

上下文利用：在 TA 中显式引入视频间的 context 相似度来微调 attention score：

$$\text{TA score}' = \alpha \cdot \text{Sim}(q, k) + (1-\alpha) \cdot \text{ContextSim}(c_q, c_k)$$

核心 insight：用户对目标视频展示兴趣，不但依赖是否交互过类似视频，还依赖两个视频的上下文是否一致。只有视频内容和上下文环境同时匹配，才是高置信度的兴趣信号。

3. 暴力型序列结构：Cross-Mask Transformer 多域感知

轻量型结构取得了显著效果，但为什么理论上能力完备的标准 Transformer 在推荐场景表现不及预期，而各类先验设计的稀疏感知结构却相对有效？

3.1 推荐与文本任务的本质差异

通过深入分析，发现二者在两个维度存在显著差异：

差异 1：输入形式

任务	序列形式	特征类型
NLP（文本）	1D 序列	单一 token
推荐	2D 序列	多域异构特征（id、作者、类目、行为等）

标准 Transformer 处理推荐序列时，通常在 attention 前对多特征做 pre-merge（拼接+投影），这个过程导致信息混杂，且序列特征间的高阶交叉结构缺失。

差异 2：任务性质

NLP 任务需要捕捉语法关系和语义逻辑，训练目标的牵引能力强，MHA 有足够的梯度信号自发分离出有意义的 head。

推荐任务需要捕捉稀疏的高阶 pattern（如"完播过同作者视频的用户对该作者的新视频也感兴趣"），目标的牵引能力弱，MHA 很难自动学到所需的细粒度 pattern。

实验验证：显式添加一个 action mask head（只关注完播行为的子序列），比增加同等数量的标准 head 效果更好，说明标准 MHA 在弱信号下无法自动学到这类 pattern。

3.2 从 1D 到 2D：Cross-Mask Transformer

针对上述问题，放弃 pre-merge，设计了专为多域序列优化的 Cross-Mask Transformer，通过 Masking 和 Crossing 两种机制实现域内交叉和域间交叉。

2D 序列的两种交叉类型

 特征域 1 特征域 2 特征域 3
item_1 [ id_1 ][ cat_1 ][ act_1 ] ← 横向：域间交叉
item_2 [ id_2 ][ cat_2 ][ act_2 ]
item_3 [ id_3 ][ cat_3 ][ act_3 ] ↕ 纵向：域内交叉

域内交叉（Intra-Domain）：单个域内序列元素之间的交叉，挖掘与该域绑定的稀疏高阶特征（如"只看完播视频中的同作者 pattern"）。

域间交叉（Inter-Domain）：序列版本的特征交叉，不只是单个元素特征间的交叉，还考虑序列的整体性。

Masking 机制

定义两种 mask：

Vertical Mask $M_v^f$：在 attention map 的行方向上，筛选满足特征域 $f$ 条件的视频（如"action=完播"的行）
Horizontal Mask $M_h^f$：在 embedding 维度上，从 concat 特征中提取特征域 $f$ 对应的 embedding

Crossing 机制

三步操作实现域内高阶交叉：

QK 交叉：对每个特征域 $f$，用 $M_h^f$ 提取出 Q 和 K，计算域内的 attention map $A^f$
Attention Map Masking：对 $A^f$ 施加 $M_v^f$，只保留满足条件的元素交叉
V 交叉：用 $M_h^f$ 提取出 V，与 masked $A^f$ 相乘得到域内交叉结果

最终实现了 $Q^f$、$K^f$、$V^f$ 之间的高阶交叉：

$$\text{Output}^f = \text{softmax}\left(\frac{Q^f (K^f)^T}{\sqrt{d}} \odot M_v^f\right) V^f$$

整体结构

graph TB subgraph 输入 Seq["序列 embedding\n每行=一个视频的多特征concat"] Cand["候选 embedding"] end subgraph "Cross-Mask Transformer" subgraph "一阶交叉（TA）" TA["无参 Target Attention\n(候选→序列)"] end subgraph "域内交叉（SA）" SA1["Vertical Mask SA\n特征域1: 视频id (全mask)"] SA2["Vertical Mask SA\n特征域2: 完播action mask"] SA3["Multi-window context SA"] end subgraph "二阶交叉（MHA）" MHA["含参 MHA\n(TA结果 + SA结果)"] end end Seq & Cand --> TA Seq --> SA1 & SA2 & SA3 TA & SA1 & SA2 & SA3 --> MHA MHA -->|"concat压缩"| Final["返回模型主体"]

3.3 工业落地：三层优化让暴力结构可行

3.3.1 计算与显存优化

计算共享：多个 attention head 共享底层 attention map，对同一 attention map 施加不同的 mask，5 个 attention head 实际只需计算 2 套 attention map，大幅降低计算量。

稀疏化交叉：通过参数 $\lambda_{f_i, f_j}$ 标记哪些特征域间的交叉是重要的（不是所有两两交叉都保留）。实践中保留的关键交叉：视频id、multi-window context feature、完播行为、互动行为。

零梯度外推：Cross-Mask Transformer 在基线 TA 的基础上新增，二者的视频表征处于同一语义空间。因此让 TA 产生梯度训练底层 embedding，Cross-Mask Transformer 关闭对底层的梯度，转化为纯前向过程，消除多套大尺寸梯度矩阵。这个设计有很好的物理含义，且在效果几乎不折损的情况下显著降低训练开销。

零显存计算：参考 FlashAttention 的分块计算思路，通过分块方式减少 HBM 通信，将计算尽量放在访问速度极快的 SRAM 中完成。

3.3.2 User Level 数据流

经过深入分析，样本聚合的折损主要来自三个因素：

折损来源	原因	视频号特殊性
样本延迟增大	listwise 数据流天然有更大的延迟	视频号一刷曝光量约 12 个视频，高于行业均值，延迟问题更严重
长尾样本丢弃	超长视频样本回流慢，通常被丢弃	导致学到的分布有偏，长视频被低估
训练更新次数减少	user level 聚合导致 user 子图更新次数减少	折损最大的因素

解决方案 1 - 多时间窗口：将固定条数窗口改为 10 分钟时间窗口，更灵活地平衡聚合程度与实时性。这同时自然解决了长尾丢弃问题（先回流前序视频，等待长视频回流）。

解决方案 2 - 随机延迟消除数据穿越：10 分钟窗口导致播放时长 > 10min 的样本不会出现在同一刷中，回流顺序隐式泄露 label 信息。解决方法：针对 > 90s 的视频引入随机延迟：

$$t \sim \mathcal{U}(\min(\text{视频长度}, 10\text{min}), 20\text{min})$$

解决方案 3 - ListCE Loss：相比 pointwise loss，listwise loss 直接优化分类面，优化效率更高，且形式更匹配 user level 聚合样本：

$$\mathcal{L}_{\text{ListCE}} = -\sum_i y_i \log \frac{\exp(f_i)}{\sum_j \exp(f_j)}$$

值得一提：ListCE 不但能提升 UAUC，还能同等程度提升 AUC，说明并非 hack 了指标，而是真实地学到了更好的表征。

解决方案 4 - Muon 优化器：Muon 优化器对 dense 参数梯度做主成分均衡——对梯度 $G = U\Sigma V^T$ 做 SVD，新梯度为 $UV^T$，缺秩梯度强制变换为满秩状态，大幅提升 one-epoch 数据流下的单步迭代效率。

实践中遇到训练不稳定（NaN）问题：精排模型参数形态差异巨大，Muon 的梯度 RMS 与参数尺寸相关，导致大小参数更新幅度差距悬殊。解决方案：将原生缩放因子调整为与尺寸无关的常数，配合 Adam 热启 → Muon 接棒的训练策略。

3.3.3 工程部署

混合精度：bf16/fp32 混合精度降低推理开销，提升 QPM
多域算子：实现了计算共享 + 分块运算的 cross-mask transformer 专用算子
Muon 算子优化：将 Muon 的梯度计算分配到不同 GPU，避免多卡对 dense 梯度的重复计算

4. 实验收益总结

端到端序列

优化方向	主要收益
工程优化（数据链路 + 分布式 attention + 低显存算子）	使万级序列端到端训练成为可能
端到端 + SIM 联训（1K 端到端 + 5K SIM）	以极低成本逼近长序列效果
粗排引入端到端序列 Scaling	持续取得收益（粗排无 SIM 基线）

注：早期精排端到端序列 scaling 收益微弱，推测是在已有 SIM 的基础上，原有结构无法从更长序列中提取差异化信息。直到引入 Cross-Mask Transformer 后才打开局面。

轻量型结构

稀疏感知结构（相似感知、相关感知、近邻感知）在视频号多个场景均取得收益，其中相似感知和近邻感知各场景普遍有效，相关感知在部分场景有效。

暴力型结构

Cross-Mask Transformer 在短视频场景和红点场景取得显著收益，商业化场景效果不显著。

采用 Cross-Mask Transformer 替换原结构后，精排端到端序列的 Scaling 效率显著提升，证明差异化的结构设计是打开序列 Scaling 空间的关键。

5. 核心洞察与经验总结

1. 端到端训练的收益逻辑不只是"序列更长"

端到端建模的核心价值在于提升表征质量，而非单纯的信息输入增量。这解释了为什么 1K 端到端序列 + 5K SIM 联训就能逼近更长全序列的效果。

2. 推荐场景的 Transformer 不能照搬 NLP 范式

推荐序列是 2D 多域序列，目标牵引能力弱，需要专门设计域内交叉和域间交叉结构，不能期望标准 MHA 自动学到稀疏高阶 pattern。

3. 上下文（Context）是兴趣信号的重要修正项

用户的兴趣是情境依赖的。只有视频内容和上下文环境同时匹配，才是高置信度的兴趣信号。Multi-window context feature 提供了可解释且有效的上下文建模方式。

4. 工业落地需要系统性优化

暴力结构落地不只是"把 Transformer 堆上去"，需要从模型设计（零梯度外推）、算子（零显存计算、计算共享）、数据流（多时间窗口、随机延迟、ListCE）、优化器（Muon）各层面协同优化，才能在可接受的成本下发挥模型的理论能力。

5. Scaling 的前提是差异化建模

在已有 SIM 序列的基础上，简单拉长端到端序列并不能带来持续收益。需要设计与 SIM 差异化的建模方式（如 Cross-Mask Transformer 的多域感知），才能打开 Scaling 空间。

参考资料

（HSTU，Meta AI）
（Meta AI）

NormFormer：用额外归一化改进 Transformer 预训练

Thu, 09 Apr 2026 02:30:00 +0800

本文是关于 Meta AI 论文《NormFormer: Improved Transformer Pretraining with Extra Normalization》（）的深度精读笔记。这篇论文通过在 Transformer 架构中添加三处额外的归一化操作，有效缓解了 Pre-LN 架构中各层梯度分布不均的问题，在几乎不增加计算成本的前提下，显著提升了语言模型的预训练效率和下游任务表现。

1. 引言：Transformer 归一化问题的前世今生

1.1 从 Post-LN 到 Pre-LN 的演进

自 Vaswani 等人在 2017 年提出 Transformer 架构以来，层归一化（Layer Normalization） 就是其中不可或缺的核心组件。归一化层的放置位置虽然看似只是一个微小的工程决策，但实际上对模型的训练稳定性、收敛速度和最终性能有着深远的影响。

原始 Transformer 采用 Post-LN 架构，即将 LayerNorm 放在残差连接之后：

$$\text{PostLN}(x) = \text{LayerNorm}(x + \text{Sublayer}(x))$$

这一设计在 Transformer 的早期应用中被广泛使用，但随着模型规模的不断增大，研究者们逐渐发现了它的致命缺陷：后层参数的梯度范数远大于早层，导致梯度爆炸于深层，梯度消失于早层。这意味着在反向传播过程中，靠近输入端的层几乎无法获得有效的梯度信号，导致训练极度不稳定。

为了缓解这个问题，Pre-LN 架构 应运而生，即将 LayerNorm 移到子层的输入端：

$$\text{PreLN}(x) = x + \text{Sublayer}(\text{LayerNorm}(x))$$

Pre-LN 架构被 GPT-2、GPT-3 等里程碑模型所采用，成为大语言模型预训练的事实标准。它显著改善了训练稳定性，使得大规模模型的训练成为可能。问题解决了吗？答案是否定的。

1.2 Pre-LN 的隐患：反向失配与梯度失衡

Xiong 等人在 2020 年的研究中首次系统性地揭示了 Post-LN 的梯度问题。然而，NormFormer 的作者们进一步发现，Pre-LN 虽然解决了 Post-LN 的训练不稳定问题，但实际上引入了方向相反的梯度失配：

Post-LN：后层梯度 » 早层梯度（梯度消失）
Pre-LN：早层梯度 » 后层梯度（反向失配）

为什么梯度不均衡很糟糕？

用一个工厂流水线的类比来理解：

梯度 = 改进信号，梯度大的层在训练中改变快，梯度小的层改变慢
早层是上游，负责提取基础特征。如果上游改进太频繁（梯度过大），下游来不及适应，导致训练不稳定
后层是下游，负责学习任务特定的高级表示。如果下游改进太慢（梯度不足），即使获得好的基础特征，也无法有效地组织成好的上层表示

梯度分布不均 = 各层学习效率不同 = 整体训练收敛慢、最终性能不佳

在 Pre-LN 架构中，这种现象体现为：

早期层过度更新：由于梯度过大，早期层的参数在训练初期可能剧烈波动，导致学到的特征不够稳定。
后期层更新不足：深层网络中最靠近输出的层本应承担最重要的任务特定表示学习，但它们接收到的梯度信号却相对不足，导致学习速度缓慢。

关键观察：论文通过可视化展示了这一现象：

Pre-LN 的梯度分布呈现明显的递减趋势，与 Post-LN 的递增趋势恰好相反。但两种趋势都是问题——因为两者都导致梯度分布不均。

1.3 梯度分布可视化：问题的直观表现

为了更直观地理解三种架构的梯度分布差异，我们用下面的图示展示各层的梯度范数变化：

图的含义：

x 轴：网络的第几层（从 1 到 12）
y 轴：该层参数的梯度 L1 范数（梯度大小）
红线（Post-LN）：梯度从浅层的很小逐渐增大到深层，形成"阶梯上升"。这导致深层参数更新剧烈，早层参数更新缓慢
蓝线（Pre-LN）：梯度从浅层的很大逐渐减小到深层，形成"阶梯下降"。这导致早层参数更新剧烈，深层参数更新缓慢
绿线（NormFormer）：梯度在各层基本保持一致的水平，形成"平坦"的分布。这导致各层参数更新速度均衡

这张图直观地说明了为什么 NormFormer 能提升训练效率：通过在三个精心选择的位置添加归一化操作，它实现了梯度在各层的均衡分布，使得每一层都能以相近的速率学习，从而提高了整个网络的训练效率。

1.4 研究动机：能否让梯度在所有层间均衡分布？

面对这一发现，NormFormer 论文提出了一个自然而直接的研究问题：能否通过在 Transformer 的关键位置添加额外的归一化操作，使得各层的梯度范数趋于均衡？

这个问题的提出源于一个简单但深刻的直觉：归一化操作本质上是对激活值进行重新缩放（rescaling），它天然具备调节梯度流动幅度的能力。如果我们能在正确的位置插入归一化层，就有可能同时解决 Pre-LN 的早层梯度过大和后层梯度过小的问题。

在接下来的章节中，我们将看到 NormFormer 如何通过三处精心设计的改进，实现这一目标。

2. 核心方案：三处改进与架构演进

NormFormer 的核心思想可以用一句话概括：在 Pre-LN Transformer 的基础上，在三个关键位置添加额外的归一化操作，通过精心的梯度控制实现各层学习效率的均衡化。

这三个操作分别是：Post-Attention LayerNorm（注意力后归一化）、HeadScale（注意力头缩放）和 FFN Mid-LayerNorm（前馈网络中间归一化）。它们的协同作用可以用下式表示：

$$x_{l+1}^{\text{NormFormer}} = \text{NormFFN}(\text{NormScaledMHA}(x_l))$$

在深入讲解具体的改进点之前，我们先给出 NormFormer、Pre-LN 和 Post-LN 三种架构的全景对比，帮助读者快速理解各架构的特点。

2.0 架构总览

三种架构的特性对比

特性	Post-LN	Pre-LN	NormFormer
归一化位置	残差连接之后	子层之前	多点分布式
训练稳定性	差（需精细 warmup）	好	更好（支持更高学习率）
梯度分布	后层 » 早层	早层 » 后层	各层趋于均衡
头级控制	无	无	有（HeadScale）
FFN 内部归一化	无	无	有
额外参数量	-	基准	+0.4%
额外训练开销	-	基准	+2~6%

关键观察：NormFormer 的核心创新在于在三个精心选择的位置添加归一化操作，以极小的代价（0.4% 参数 + 2~6% 计算）实现了梯度分布的均衡化。这种"微创手术"式的改进策略在理论上可以解决 Pre-LN 的梯度失衡问题，同时保留其训练稳定性优势。

三处改进的位置总览

NormFormer 的三个改进分别位于 Transformer 块中的不同位置：

Post-Attention LayerNorm：在多头注意力输出后、残差连接前
HeadScale：在多头注意力的拼接（concat）操作前，对每个头乘以可学习标量
FFN Mid-LayerNorm：在前馈网络的激活函数后、第二个线性层前

我们将逐个讲解每个改进的工作原理、消融验证数据和实际贡献度。

2.1 改进点 A：Post-Attention LayerNorm

工作机制

核心设计： 在多头注意力的输出后、残差连接前，添加一个额外的 LayerNorm。

标准 Pre-LN 的注意力子层为：

$$\text{PreLN-MHA}(x) = x + \text{MHA}(\text{LN}(x))$$

NormFormer 将其修改为：

$$\text{NormScaledMHA}(x) = x + \text{LN}(\text{HeadScaleMHA}(\text{LN}(x)))$$

这里外层的 $\text{LN}(\cdot)$ 包裹注意力输出。这个额外的归一化层起到了下缩放（downscaling） 的作用：论文发现训练完成后，所有层的 Post-Attention LN 的缩放参数（gamma）都低于 1，这意味着它在系统性地降低注意力输出的幅度。

为什么这很重要？ 在标准 Pre-LN 中，注意力层的输出直接通过残差连接加到主干上。如果注意力输出的幅度过大，会导致残差分支主导信号传播，破坏信息在不同层之间的平衡传递。通过添加这一归一化层，NormFormer 能够自适应地控制每一层注意力输出的贡献幅度。

原理图和实现

简洁实现示例（PyTorch）：

attn_output = self.attention(self.layer_norm(x))
attn_output = self.post_attn_layer_norm(attn_output) # 新增
x = x + attn_output

消融实验数据

在 125M 模型上的消融结果：

配置	PPL	相比完整 NormFormer 的变化	贡献度
完整 NormFormer	15.88	基准	-
移除 Post-Attn LN	15.92	+0.04	最小

贡献度评估：Post-Attn LN 的单独贡献最小（+0.04 PPL 退化），但作为整体方案的补充，它有助于进一步稳定梯度流。

2.2 改进点 B：HeadScale

工作机制

核心设计： 在多头注意力的拼接（concat）操作前，对每个注意力头的输出乘以一个独立的可学习标量参数。

传统的多头注意力将所有头的输出直接拼接后通过输出投影矩阵：

$$\text{MHA}(Q, K, V) = \text{Concat}(h_1, h_2, ..., h_n) W^O$$

NormFormer 引入了 HeadScale 机制：

$$\text{HeadScaleMHA}(Q, K, V) = \text{Concat}(\gamma_1 \cdot h_1, \gamma_2 \cdot h_2, ..., \gamma_n \cdot h_n) W^O$$

其中 $\gamma_i$ 为可学习的标量参数，初始化为 1，确保训练初期与标准多头注意力完全一致。

原理图和关键发现

关键发现：

头级权重差异化：训练后的 $\gamma_i$ 值变化较大，不同头获得了不同的缩放权重，这表明模型学会了动态调整不同注意力头的重要性。
无单调性约束：$\gamma_i$ 与层深度之间没有明显的单调关系，说明 HeadScale 不是简单地对深层或浅层进行统一调节，而是在细粒度上优化每个头的贡献。
最大贡献度：在消融实验中，HeadScale 是三个操作中贡献最大的。

实现示例

head_scales = nn.Parameter(torch.ones(num_heads)) # 初始化为1
scaled_heads = [head_scales[i] * heads[i] for i in range(num_heads)]
attn_output = torch.cat(scaled_heads, dim=-1) @ W_o

消融实验数据

在 125M 模型上的消融结果：

配置	PPL	相比完整 NormFormer 的变化	相对贡献度
完整 NormFormer	15.88	基准	-
移除 HeadScale	16.22	+0.34	69% 的总改进

贡献度评估：HeadScale 是三个改进点中贡献最大的，单独贡献占总改进（0.49 PPL 相比基线）的约 69%。（注：三个改进的占比之和超过 100% 是因为存在协同效应，详见第 2.5 节）这表明对注意力头进行差异化加权是 NormFormer 最核心的创新。

与注意力头剪枝的联系：HeadScale 的思想与注意力头剪枝（Head Pruning）有一定的联系。Chen 等人在 2021 年的工作中使用类似的头级缩放进行模型压缩，而 NormFormer 将这一思想用于改进训练过程，目标不同但技术路线相似。

2.3 改进点 C：FFN Mid-LayerNorm

工作机制

核心设计： 在前馈网络（FFN）的第一个线性变换之后、激活函数之后，添加一个 LayerNorm。

标准 FFN 的计算流程为：

$$\text{FFN}(x) = \sigma(x W_1 + b_1) W_2 + b_2$$

NormFormer 将其修改为：

$$\text{NormFFN}(x) = x + \underbrace{\text{LN}_{\text{mid}}}_{\text{新增}}(\sigma(\underbrace{\text{LN}_{\text{pre}}}_{\text{原有Pre-LN}}(x) \cdot W_1 + b_1)) \cdot W_2 + b_2$$

其中 $\text{LN}_{\text{pre}}$ 是 Pre-LN 架构原有的归一化，而 $\text{LN}_{\text{mid}}$ 是 NormFormer 新增的 FFN 中间归一化——它位于激活函数 $\sigma(\cdot)$ 之后、第二个线性变换 $W_2$ 之前。

关键机制：自适应梯度抑制

这是解决梯度失配的核心机制。 论文的 Figure 4 & 5 展示了一个极为重要的发现：

早期层的 FFN LN gamma 参数系统性地小于后期层的。这意味着 FFN Mid-LayerNorm 自适应地减小了早期层全连接层输入的幅度，从而有效降低了早期层的梯度，缓解了 Pre-LN 固有的"早层梯度过大"问题。这种设计妙处在于：

无需显式约束 gamma 值
模型在训练过程中自动学习最优的梯度分配方案
早层自然获得较小的 gamma（抑制梯度），后层获得较大的 gamma（放大梯度）

数学直觉

归一化操作通过将激活值映射到零均值、单位方差的分布来工作。当早期层的 FFN 中间激活值幅度较大时，归一化层通过较小的 gamma 参数对其进行压缩，相当于在反向传播时减小了通过这些层的梯度流。这种自适应机制使得模型能够自动学习到最优的梯度分配方案。

实现示例

# 原始 FFN
h = activation(x @ W1 + b1)
output = h @ W2 + b2

# NormFormer
h = activation(x @ W1 + b1)
h = self.ffn_layer_norm(h) # 新增
output = h @ W2 + b2

消融实验数据

在 125M 模型上的消融结果：

配置	PPL	相比完整 NormFormer 的变化	相对贡献度
完整 NormFormer	15.88	基准	-
移除 FFN-LN	16.14	+0.26	53% 的总改进

贡献度评估：FFN-LN 是第二大贡献者，单独贡献占总改进的约 53%。这验证了前馈网络内部归一化对梯度均衡的重要性，是仅次于 HeadScale 的核心创新。

2.4 可选改进：ResScale

除了上述三个核心操作外，NormFormer 还提出了一个可选的 ResScale 操作：

$$\text{ResScale}(x) = \lambda_{\text{resid}} \odot x + \text{Sublayer}(\text{LayerNorm}(x))$$

其中 $\lambda_{\text{resid}}$ 是可学习的逐维度缩放参数，用于调节残差连接中主干信号和子层输出的相对权重。

重要警告： 论文实验表明，ResScale 仅在小模型（125M、355M 参数）上有效，在 1.3B 及以上规模的模型上反而会导致性能下降。因此，对于当前主流的大规模预训练场景，不建议使用 ResScale。这一发现也提醒我们，并非所有的归一化/缩放操作都是"越多越好"的——过度参数化在大模型上可能导致优化困难。

2.5 三大改进的协同效应

前四个小节分别介绍了三个改进点的单独贡献，现在我们看它们是如何协同工作的。

完整消融实验对比

论文在 125M 模型上进行了系统性消融。注意：此规模下的"完整 NormFormer"包含 ResScale（因为 ResScale 仅在小模型上有正收益），而对于 1.3B 及以上的模型，推荐配置不包含 ResScale：

配置	PPL	相比完整模型的变化	单独贡献度
完整 NormFormer（含 ResScale）	15.88	基准	-
移除 Post-Attn LN	15.92	+0.04	最小
移除 FFN-LN	16.14	+0.26	第二大
移除 ResScale	16.20	+0.32	中等
移除 HeadScale	16.22	+0.34	最大
增加 QKV 上的 3 个额外 LN	15.88	+0.00	无收益
基线 Pre-LN	16.37	+0.49	相比 Pre-LN 的总改进

关键结论

HeadScale 是绝对核心（+0.34 PPL，占总改进 69%）：注意力头的差异化加权是 NormFormer 最具影响力的创新。
FFN-LN 是第二支柱（+0.26 PPL，占总改进 53%）：前馈网络内部的自适应梯度抑制对整体改进也至关重要。
Post-Attn LN 是补充设计（+0.04 PPL，占总改进 8%）：单独看贡献最小，但与其他改进配合使用时能进一步稳定梯度流。
三个改进的互补性：总改进 0.49 PPL ≈ HeadScale(0.34) + FFN-LN(0.26) - 重叠。这说明三个改进虽然作用机制不同（头级权重、梯度抑制、层级下缩放），但它们的效果有部分叠加，共同作用于梯度分布均衡化。

反面教训：更多归一化不一定更好

论文还测试了一个反例：在 QKV 投影上额外添加 3 个 LayerNorm——这看似应该进一步改进梯度分布，但实际结果是：

困惑度无任何改进（+0.00 PPL）
训练速度反而降低 5%

启示：NormFormer 选择的三个位置（Post-Attn、HeadScale、FFN Mid）是经过精心设计的，不是简单的"到处加 LN"。随意添加更多归一化操作反而会浪费计算资源，甚至破坏优化过程。

小模型 vs 大模型的推荐配置

基于消融实验的结果，我们给出不同规模模型的推荐配置：

模型规模	推荐配置	预期改进	说明
125M-355M	Post-Attn LN + HeadScale + FFN-LN + ResScale	最大	ResScale 在小模型上有正贡献
1.3B+	Post-Attn LN + HeadScale + FFN-LN	稳定	不使用 ResScale，避免大模型优化困难

3. 实验结果深度分析

NormFormer 论文的实验设计非常全面，涵盖了因果语言模型（CLM）、掩码语言模型（MLM）、零样本评估、消融实验等多个维度。下面我们逐一分析关键实验结果。

3.1 学习率搜索：挑战 GPT-3 的默认设置

在正式实验之前，论文做了一项非常有价值的预实验：系统性的学习率搜索。结果出人意料地发现，在他们的数据集上，最优学习率比 GPT-3 论文建议的值高出 3-5 倍：

模型规模	GPT-3 建议学习率	实际最优学习率	倍数
125M	6e-4	3e-3	5x
355M	3e-4	1e-3	3.3x
1.3B	2e-4	6e-4	3x

为什么 NormFormer 能支持更高的学习率？

这个现象与我们在改进点 C（FFN Mid-LayerNorm）讨论的梯度缩放密切相关。通过在 FFN 第一个线性层后添加 LayerNorm，NormFormer 实现了分层的梯度缩放 — 前馈网络内部的特征被重新归一化，避免了极端的激活值。这种分层缩放机制使得早层的梯度幅度自动降低，即使在更高的学习率下，参数更新也不会过于剧烈，从而显著提升了训练稳定性。

工程启示

这一发现本身就具有独立的工程价值——针对自己的数据集进行学习率搜索可能带来显著的性能提升，不要盲目套用论文中的超参数。论文使用这些优化后的基线作为对比对象，确保了实验结果的公平性和说服力。

3.2 因果语言模型：稳定且一致的困惑度改进

在因果语言模型（Causal Language Model）预训练任务上，NormFormer 在所有模型规模上都取得了一致的困惑度（Perplexity）改进：

模型	参数量	基线 PPL	NormFormer PPL	改进幅度
125M	124.5M	21.09	20.11	-0.98
1.3B	1313.5M	12.21	11.94	-0.27
2.7B	2649.5M	10.92	10.55	-0.37

核心发现

1. 训练加速效果显著。 NormFormer-1.3B 达到基线相同困惑度的速度快了 24%。也就是说，使用 NormFormer，你只需要原来 76% 的训练时间就能获得相同质量的模型。对于动辄需要数千 GPU 小时的大规模预训练来说，24% 的训练时间节省意味着巨大的计算成本削减。

与改进点的关联：这个加速来自于梯度均衡带来的更高的单步训练效率 — 梯度分布均匀意味着每一层都在以最优速率学习，没有某些层学得太快而其他层跟不上的浪费。这正是改进点 B（HeadScale）和改进点 C（FFN-LN）共同实现的梯度重均衡的直接体现。

2. 大模型训练稳定性提升。 这可能是 NormFormer 最引人注目的工程价值：基线 2.7B 模型在 6e-4 学习率下训练发散（完全失败），而 NormFormer-2.7B 在相同学习率下可以稳定训练并取得最佳性能。这意味着 NormFormer 显著拓宽了大模型可用学习率的范围，降低了超参数调优的难度。

与改进点的关联：这与改进点 B（HeadScale）的头级权重调整密切相关 — 通过对注意力头进行细粒度控制，NormFormer 抑制了某些头过度主导信号的现象。在大模型中，这种头间差异往往更加突出，因此 HeadScale 的稳定化效果在大模型上更加显著。

3. 困惑度改进随模型规模变化。 125M 模型上的绝对改进最大（-0.98），而大模型上的绝对改进较小。但考虑到大模型本身的困惑度已经很低（基数效应），相对改进幅度仍然有意义。更重要的是，训练加速和稳定性提升在大模型上同样甚至更加显著。

总结

因果语言模型的实验充分验证了 NormFormer 的核心改进在实践中的效果：梯度均衡带来的训练加速，头级控制带来的稳定性提升，使得 NormFormer 成为一个具有重大工程价值的改进方案。

3.3 零样本任务评估：无需微调即见效果

NormFormer 在零样本（Zero-Shot）任务评估中展现了明显的优势，直接反映了预训练质量的提升：

任务	基线-1.3B	NormFormer-1.3B	基线-2.7B	NormFormer-2.7B
HellaSwag	58.5	60.5	-	-
WinoGrande	76.8	77.5	-	-
平均（多任务）	63.6	64.7	66.3	68.7

关键发现：

NormFormer-125M 达到 GPT-3 Large（1.3B 参数）零样本性能的速度快了 60%。
在 2.7B 规模上，平均零样本准确率从 66.3% 提升到 68.7%（+2.4 个百分点）。

3.4 掩码语言模型：GLUE 基准全面提升

论文在掩码语言模型（Masked Language Model）上的实验验证了 NormFormer 对编码器型模型（BERT 类）同样有效。在 GLUE 基准的所有 7 个任务上都取得了改进：

GLUE 任务	基线	NormFormer	提升
CoLA	74.3	82.6	+8.3
MNLI	85.9	86.3	+0.4
MRPC	84.6	86.0	+1.4
QNLI	91.6	91.9	+0.3
QQP	90.7	91.3	+0.6
RTE	66.4	67.9	+1.5
SST-2	92.9	93.8	+0.9
平均	83.77	85.69	+1.92

最令人印象深刻的是 CoLA 任务上的 +8.3 提升（从 74.3 到 82.6），说明 NormFormer 对语法特征学习的显著帮助。GLUE 平均分提升接近 2 个百分点，MLM 困惑度从 3.42 降低到 3.31，展现了强大的通用性。

3.5 消融实验：各组件贡献量化

在第 2 部分，我们已经讨论了 NormFormer 的三个核心改进点（HeadScale、Post-Attn LN、FFN-LN）。这里提供完整的消融实验细节，量化每个组件的具体贡献。论文在 125M 小模型（470 V100 GPU 小时）上进行了系统性消融。注意：此规模下的"完整 NormFormer"包含 ResScale（因为 ResScale 仅在小模型上有正收益），而对于 1.3B 及以上的模型，推荐配置不包含 ResScale：

配置	Perplexity	相比完整模型的退化
完整 NormFormer + ResScale	15.88	基准
移除 Post-Attn LN	15.92	+0.04
移除 FFN LN	16.14	+0.26
移除 ResScale	16.20	+0.32
移除 HeadScale	16.22	+0.34（影响最大）
增加 3 个额外 LN（QKV 上）	15.88	+0.00（无额外收益）
基线 Pre-LN	16.37	+0.49

关键结论：

HeadScale 贡献最大（移除后退化 +0.34），说明注意力头的差异化加权是 NormFormer 最核心的创新。
FFN LN 贡献第二（+0.26），验证了前馈网络内部归一化对梯度均衡的重要性。
Post-Attn LN 贡献最小（+0.04），但仍有正面效果。
更多归一化并不总是更好：在 QKV 投影上额外添加 3 个 LN 没有带来任何性能提升，反而使训练速度降低 5%。这证明了 NormFormer 选择的三个位置是经过精心设计的，不是简单的"到处加 LN"。

3.6 超参数鲁棒性验证

NormFormer 的另一个重要优势是其对超参数设置的鲁棒性。论文在 125M 模型上测试了多种超参数组合：

学习率	配置	基线 PPL	NormFormer PPL	差值
0.001	默认	16.80	16.33	-0.47
0.003	默认	16.37	15.88	-0.49
0.003	更长 warmup	16.50	16.06	-0.44
0.003	GPT-3 设置	16.29	15.88	-0.41

NormFormer 在所有超参数配置下都一致优于基线，改进幅度在 0.41-0.49 之间波动，方差极小。这意味着使用 NormFormer 不需要额外的超参数调优工作——只要基线能跑，NormFormer 就能带来稳定的改进。

3.7 Wikitext-103 验证

论文还在 Wikitext-103 数据集上进行了验证：

模型	最终 Perplexity	达到基线 PPL 所需步数
基线	18.70	100%
NormFormer	18.65	70%（节省 30% 训练时间）

NormFormer 仅需 70% 的训练步数就达到了基线的最终性能。虽然后 30% 的训练中 NormFormer 的改进趋于饱和，但论文指出这可能通过进一步的训练策略调优来改善。

3.8 计算开销分析

NormFormer 的工程吸引力在于其极低的额外开销：

指标	数值
额外参数量	+0.4%（不足 0.07% 实际额外参数）
额外内存开销	+2~6%
单步训练时间增加	+2~6%
推理开销	接近零

这些数字意味着，NormFormer 实质上是一个"免费的改进"——用不到 6% 的额外计算成本，换取 24% 的训练加速和可量化的性能提升。从性价比角度看，这非常划算。

4. 工程应用与落地分析

4.1 实现极度简单

NormFormer 的工程实现可以说是所有 Transformer 改进方案中最简单的之一。只需要在现有 Pre-LN Transformer 代码中做三处修改：

修改一：在 MultiHeadAttention 输出后添加 LayerNorm

# 原始 Pre-LN
attn_output = self.attention(self.layer_norm(x))
x = x + attn_output

# NormFormer
attn_output = self.attention(self.layer_norm(x))
attn_output = self.post_attn_layer_norm(attn_output) # 新增
x = x + attn_output

修改二：在 MHA concat 前对每个 head 乘以可学习标量

# 原始 MHA
attn_output = torch.cat(heads, dim=-1) @ W_o

# NormFormer
head_scales = nn.Parameter(torch.ones(num_heads)) # 初始化为1
scaled_heads = [head_scales[i] * heads[i] for i in range(num_heads)]
attn_output = torch.cat(scaled_heads, dim=-1) @ W_o

修改三：在 FFN 第一个线性层后添加 LayerNorm

# 原始 FFN
h = activation(x @ W1 + b1)
output = h @ W2 + b2

# NormFormer
h = activation(x @ W1 + b1)
h = self.ffn_layer_norm(h) # 新增
output = h @ W2 + b2

在 fairseq 框架中，这三个修改对应三个简单的命令行参数：

fairseq-train ... --scale-attn --scale-fc --scale-heads

4.2 与主流框架的兼容性

NormFormer 的设计具有极强的框架兼容性：

与 PyTorch 原生 Transformer 兼容： NormFormer 的三处修改都是在现有层之间插入标准的 LayerNorm 或可学习参数，不改变任何现有层的接口或行为。这意味着它可以无缝集成到任何基于 PyTorch 的 Transformer 实现中。

与 HuggingFace Transformers 兼容： 只需继承现有的注意力层和前馈网络层，在对应位置添加归一化操作即可。不需要修改分词器、数据加载器或训练循环。

与分布式训练框架兼容： NormFormer 添加的归一化层和可学习参数都是标准的 PyTorch 模块，完全兼容 DeepSpeed、Megatron-LM、FSDP 等主流分布式训练框架。归一化操作的计算和通信开销极小，不会成为分布式训练的瓶颈。

与不同归一化方式兼容： 虽然论文使用 LayerNorm 进行实验，但其设计思想对 RMSNorm（LLaMA 系列使用的归一化方式）同样适用。可以将 NormFormer 中的 LayerNorm 替换为 RMSNorm，在保持核心优势的同时获得 RMSNorm 的计算效率优势。

4.3 实际部署场景与建议

场景一：从头预训练大语言模型

这是 NormFormer 最适用的场景。如果你的团队正在从头训练一个数十亿参数的语言模型，添加 NormFormer 可以：

节省约 24% 的训练时间（以达到同等困惑度为标准）
支持使用更高的学习率而不发散，降低超参数调优成本
以不到 6% 的额外计算开销换取稳定的性能提升

场景二：中等规模模型的快速迭代

对于 125M-1B 参数规模的模型，NormFormer 的收益更加明显。在这个规模上，可以同时使用 ResScale 获得最大收益。特别适合需要快速迭代模型架构和训练策略的研究场景。

场景三：训练稳定性要求高的场景

如果你的训练任务容易出现发散（例如使用较大的学习率、较长的上下文、较大的 batch size），NormFormer 可以显著提升训练的鲁棒性。2.7B 模型在高学习率下的稳定训练就是一个很好的例证。

4.4 不适用场景

也需要诚实地指出 NormFormer 可能不太适用的场景：

已有预训练好的模型进行微调： NormFormer 的收益主要体现在预训练阶段。如果你只是微调一个现有模型，添加 NormFormer 需要重新预训练，成本远大于收益。
极大规模模型（>10B）： 论文最大的实验只到 2.7B，对于更大规模模型的效果尚未被验证。虽然理论上应该同样有效，但缺乏实证支持。
推理优化敏感的场景： 虽然 NormFormer 的额外推理开销极小，但在对推理延迟有极致要求的场景下（例如实时搜索排序），任何额外的计算都需要审慎评估。

4.5 成本收益分析

让我们做一个简单的成本收益计算。假设你正在训练一个 1.3B 参数的语言模型：

成本（额外开销）：

训练速度降低约 4%（1.3B 规模的典型值）
如果原始训练需要 10000 GPU 小时，NormFormer 版本需要约 10400 GPU 小时

收益：

达到相同困惑度仅需 7600 GPU 小时（节省 24%）
最终困惑度从 12.21 降低到 11.94
零样本平均准确率从 63.6% 提升到 64.7%
更强的训练稳定性，降低训练失败的风险

净收益： 即使考虑单步训练时间的增加，要达到基线相同性能仍然可以节省约 20% 的总训练时间。如果以固定的计算预算训练到收敛，则获得更好的最终性能。NormFormer 都是一个值得采纳的改进。

4.6 与后续工作的关系

NormFormer 发表于 2021 年底，此后 Transformer 归一化领域继续涌现了许多重要工作：

RMSNorm（Root Mean Square Layer Normalization）：去掉了 LayerNorm 中的均值中心化步骤，计算效率更高。被 LLaMA 系列广泛采用。NormFormer 的设计理念可以与 RMSNorm 无缝结合。
QK-Norm：对注意力中的 Query 和 Key 进行归一化，防止注意力得分过大。与 NormFormer 的 HeadScale 有互补作用。
HybridNorm（2025）：探索了在同一模型中混合使用 Pre-LN 和 Post-LN 的可能性，进一步细化了归一化位置的选择。
nGPT（2024）：提出了基于单位超球面上表示学习的归一化方案，代表了归一化研究的新方向。

这些后续工作并没有否定 NormFormer 的价值，反而证明了"在 Transformer 中优化归一化策略"这一研究方向的重要性。NormFormer 作为这一领域的先驱工作之一，为后续研究奠定了重要的理论和实验基础。

5. 总结与展望

5.1 核心贡献回顾

NormFormer 论文的核心贡献可以用三句话概括：

发现了问题： 系统性地揭示了 Pre-LN Transformer 中各层梯度分布不均的问题——早期层梯度过大、后期层梯度不足。
提出了方案： 通过在三个精心选择的位置（注意力输出后、注意力头拼接前、FFN 中间层）添加归一化操作，有效缓解了梯度失配。
验证了效果： 在多种任务（CLM、MLM、零样本）和多种规模（125M-2.7B）上，以不到 6% 的额外计算成本换取了 24% 的训练加速和一致的性能提升。

5.2 对工程实践的启示

NormFormer 给我们的最大启示不仅仅是"加几个 LayerNorm"这么简单，而是：

启示一：小改进，大回报。 在深度学习研究中，并非所有有价值的工作都需要颠覆性的架构创新。有时候，对现有架构的精细分析和微小调整就能带来显著的实际收益。NormFormer 的三处修改总共只增加了 0.4% 的参数量，却换来了 24% 的训练加速——这种高性价比的改进在工业界尤其受欢迎。

启示二：梯度分析是优化训练的利器。 NormFormer 的整个工作建立在对梯度分布的细致观察之上。通过可视化和分析各层的梯度范数，研究者找到了问题所在，并据此设计了针对性的解决方案。这提醒我们，在训练大模型时，不要只盯着损失曲线，还应该关注梯度的层间分布。

启示三：不是所有改进都能无限叠加。 消融实验表明，在三个位置之外继续添加归一化层不仅没有收益，反而降低了训练速度。ResScale 在大模型上甚至有害。这告诉我们，模型改进需要有度，过度设计反而可能适得其反。

5.3 未来展望

尽管 NormFormer 已经展示了令人信服的实验结果，但仍有一些开放的研究方向值得探索：

超大规模验证： 论文最大的实验只到 2.7B 参数，NormFormer 在 10B、100B 甚至更大规模模型上的表现如何？是否存在新的问题或需要调整的地方？
与新型归一化的结合： 将 NormFormer 的设计理念与 RMSNorm、QK-Norm 等新技术结合，是否能获得更大的收益？
多模态扩展： NormFormer 目前主要在语言模型上验证，在视觉 Transformer（ViT）、多模态模型（如 Flamingo、GPT-4V）中是否同样有效？
自适应归一化： 能否设计一种机制，让模型在训练过程中自动决定在哪些位置需要额外的归一化，而不是人工预设固定位置？

总而言之，NormFormer 是一项兼具理论深度和工程价值的优秀工作。它用最简洁的方式解决了一个被忽视但重要的问题，为大规模 Transformer 预训练提供了一个即插即用的改进方案。对于正在从事大模型预训练的团队来说，NormFormer 值得认真评估和尝试。

参考文献：

Shleifer, S., Weston, J., & Ott, M. (2021). NormFormer: Improved Transformer Pretraining with Extra Normalization.

Xiong, R., et al. (2020). On Layer Normalization in the Transformer Architecture. ICML 2020.

Vaswani, A., et al. (2017). Attention Is All You Need. NeurIPS 2017.

Zhang, B., & Sennrich, R. (2019). Root Mean Square Layer Normalization. NeurIPS 2019.

UniMixer：统一推荐系统三大架构范式的缩放定律探索

Wed, 08 Apr 2026 10:15:00 +0800

本文是关于快手技术团队论文《UniMixer: A Unified Architecture for Scaling Laws in Recommendation Systems》（）的深度精读笔记。这篇论文从理论上揭示了推荐系统中注意力机制、TokenMixer 和因式分解机三大架构范式的内在统一性，提出了参数化的 UniMixing 模块及其轻量化变体 UniMixer-Lite，并在快手广告系统上验证了清晰的缩放定律。

1. 引言：推荐系统特征交互架构的三条技术路线

1.1 从人工特征到深度模型的演进

推荐系统的核心挑战之一是特征交互建模——如何从用户画像、物品属性、上下文信息等异构特征中提取有效的交叉模式，以预测用户行为。

回顾推荐系统的发展历程，特征交互的建模方式经历了几个关键阶段：

手工特征工程时代（2010 年前）：依赖领域专家设计交叉特征，如"用户年龄 × 物品类别"。这种方式的问题在于人力成本高、覆盖度有限、无法捕获高阶交互。
因式分解机时代（2010-2016）：FM（Factorization Machine）及其变体（FFM、DeepFM）通过学习特征的隐向量表示来自动建模二阶交互 $\hat{y} = w_0 + \sum_i w_i x_i + \sum_{i\lt j} \langle v_i, v_j \rangle x_i x_j$。这开创了自动化特征交互的先河，但受限于交互阶数和表达能力。
深度网络显式交叉时代（2017-2022）：DCN、xDeepInt、AutoInt 等工作尝试通过显式的交叉网络结构捕获高阶交互。但这些方法往往带来复杂的网络设计和有限的扩展性。
Token 化与大模型时代（2023-至今）：受 Transformer 和大语言模型启发，推荐系统开始将特征视为 Token 序列，引入注意力机制和 TokenMixer 等操作进行特征交互。这一范式转变使得推荐模型具备了类似 LLM 的缩放潜力。

1.2 三条路线的分化与困境

进入 Token 化时代后，推荐系统的特征交互架构逐渐形成了三条主要的技术路线：

路线一：基于注意力机制（Attention-based）

代表工作：AutoInt、HiFormer、FAT、HHFT
核心思想：通过 Self-Attention 机制让每个 Token 动态地关注其他 Token，使用 Token-specific 的 Q/K/V 投影
优势：理论表达能力强，能捕获任意 Token 对之间的交互
问题：$O(L^2)$ 的计算复杂度，在特征数量 $L$ 较大时计算成本过高；更关键的是，在异构特征场景下，注意力权重容易变得尖锐稀疏，导致梯度回传受阻、训练停滞

路线二：基于 TokenMixer

代表工作：RankMixer（TokenMixer）、TokenMixer-Large
核心思想：通过固定规则的矩阵（如 Split & Concat）对 Token 进行混合操作
优势：计算效率高，参数无关（parameter-free），支持深层堆叠
问题：基于规则的混合模式缺乏可学习性和场景适应性；强制要求 Token 数等于 Head 数（T=H），限制了交互模式的选择空间

路线三：基于因式分解机（FM-based）

代表工作：Wukong、FinalMLP、GDCN、FiBiNet
核心思想：通过特征向量的内积或双线性交互建模特征对交互
优势：参数效率高，可解释性较好
问题：显式低阶交互约束限制了 Scaling 性能提升，难以扩展到更高阶

这三条路线各有优劣，但在工业实践中往往是"选边站队"——一个团队通常只深耕其中一条路线。这种割裂带来了两个核心问题：

缺乏统一的理论视角：无法回答"这三种方法到底有什么本质区别和联系？"
无法系统性地比较扩展效率：各方法在各自的实验设置下报告结果，缺少公平的缩放定律对比

1.3 UniMixer 的破局思路

UniMixer 论文的核心贡献在于回答了一个根本性问题：这三种看似不同的特征交互方式，是否存在统一的数学框架？

答案是肯定的。论文揭示了一个优雅的统一结构：

$$\text{UniMixing}(X) = \text{reshape}\left(G(X, W_G) \cdot [\text{local patterns}],\ 1,\ L\right)$$

在这个框架下，注意力机制、TokenMixer 和因式分解机只是全局权重 $G$ 和局部模式的不同实例化。这一发现不仅具有理论美感，更带来了实际的工程价值——既然三者本质相同，我们就能设计出集三者优势于一体的新架构。

2. 来源元数据 (Metadata)

原文标题: UniMixer: A Unified Architecture for Scaling Laws in Recommendation Systems
原文链接:
来源: arXiv（快手技术团队）
作者: Mingming Ha, Guanchen Wang, Linxun Chen, Xuan Rao, Yuexin Shi, Tianbao Ma, Zhaojie Liu, Yunqian Fan, Zilong Lu, Yanan Niu, Han Li, Kun Gai
发表日期: 2026 年 4 月

3. 核心摘要 (Executive Summary)

UniMixer 提出了推荐系统特征交互的统一架构框架，其核心创新包括：

理论统一：将注意力机制、TokenMixer 和因式分解机归纳为同一数学框架的不同特例
参数化 TokenMixer：将基于规则的 Token 混合操作转化为等价的参数化矩阵乘法，使混合模式可在训练中端到端优化
UniMixer-Lite：通过基矩阵组合和低秩近似，在大幅压缩参数量和计算成本的同时提升模型性能
SiameseNorm：引入耦合双流归一化解决深层架构的训练稳定性问题
缩放定律验证：在快手广告系统上验证了清晰的幂律缩放关系，UniMixer-Lite 的缩放指数（0.142）显著优于 RankMixer（0.116）

4. 深度解读 (Deep Dive)

4.1 参数化 TokenMixer：从规则驱动到数据驱动

UniMixer 论文最精彩的理论贡献之一，是揭示了 TokenMixer 操作的矩阵本质。

4.1.1 TokenMixer 的本质是什么？

以 RankMixer 为例，其核心操作是 Split & Concat——将 Token 序列按某种规则拆分后重新拼接。这看起来只是一种数据搬运操作，但论文指出：

任何 TokenMixer 的 Split & Concat 操作，都等价于将一个排列矩阵（Permutation Matrix）乘以展平的输入嵌入。

具体来说，对于输入 $X \in \mathbb{R}^{T \times D}$（$T$ 个 Token，每个维度为 $D$），TokenMixer 操作可以表示为：

$$\text{TokenMixer}(X) = \text{reshape}\left(W^{\text{perm}} \cdot \text{flatten}(X),\ H,\ \frac{TD}{H}\right)$$

其中 $W^{\text{perm}}$ 是一个排列矩阵。这个发现至关重要，因为：

排列矩阵具有双随机性（doubly stochastic）——每行每列恰好一个 1
排列矩阵是稀疏的——大部分元素为 0
当 $T = H$ 时，排列矩阵是对称的

4.1.2 从排列矩阵到可学习权重

既然 TokenMixer 本质上是矩阵乘法，一个自然的问题是：为什么要使用固定的排列矩阵，而不让模型自己学习最优的混合权重？

这正是 UniMixer 的核心思路——将硬编码的排列矩阵替换为可学习的权重矩阵 $W$，同时通过正则化约束保持排列矩阵的良好性质。更重要的是，参数化使得 T=H 的约束被彻底解除——传统 TokenMixer 强制要求 Token 数等于 Head 数，而参数化权重矩阵可以自由选择任意维度。

具体的约束实施方式：

双随机性约束：通过 Sinkhorn-Knopp 迭代实现

$$S_k(W) = D_r^{-1} W D_c^{-1}$$

其中 $D_r$ 和 $D_c$ 分别是行和列的归一化矩阵，交替迭代直至收敛。

稀疏性约束：通过温度系数 $\tau$ 控制

$$W_{\tau} = \text{softmax}(W / \tau)$$

当 $\tau \to 0$ 时，权重趋向 one-hot 分布，恢复排列矩阵的稀疏性。

对称性约束：通过显式对称化

$$W_{\text{sym}} = \frac{W + W^T}{2}$$

4.1.3 温度退火训练策略

直接使用低温度训练可能导致梯度消失（softmax 输出接近 one-hot 时梯度极小）。论文提出了温度退火（Temperature Annealing）策略：

$$\tau_j = \max\left\{\tau_{\text{start}} - \frac{(\tau_{\text{start}} - \tau_{\text{end}}) \cdot j}{J},\ \tau_{\text{end}}\right\}$$

训练初期使用较高温度（$\tau_{\text{start}} = 1.0$），让模型在接近均匀分布的空间中自由探索；随着训练推进，逐步降低温度至 $\tau_{\text{end}} = 0.05$，使权重逐渐收敛到稀疏的最优混合模式。

这种"先探索、后收敛"的策略与模拟退火算法有异曲同工之妙，有效避免了过早陷入局部最优。

4.2 统一理论框架：三大范式的殊途同归

4.2.1 统一公式

论文的核心理论贡献是将三种架构范式统一到同一个框架下：

$$\text{UniMixing}(X) = \text{reshape}\left(G(X, W_G) \cdot [\text{local patterns}],\ 1,\ L\right)$$

不同方法的差异仅在于全局权重 $G$ 和局部模式的选择：

方法	全局权重 $G$	局部模式
Self-Attention	$\text{softmax}\left(\frac{(XW_Q)(XW_K)^T}{\sqrt{d}}\right)$	$XW_V$
Heterogeneous Attention	$\text{softmax}\left(\frac{(X\tilde{W}_Q)(X\tilde{W}_K)^T}{\sqrt{d}}\right)$	$X\tilde{W}_V$
TokenMixer	$G$（固定置换矩阵）	$X$（恒等映射）
FM	$XI(XI)^\top$	$Y$
UniMixer	$W_G$（可学习全局混合）	$\{W_B^i\}$（可学习块权重）

这个统一视角揭示了三个深刻的洞察：

注意力机制是数据依赖的动态混合：全局权重 $G$ 由输入 $X$ 通过 Query-Key 机制动态计算，因此不同输入有不同的混合模式。这赋予了注意力极强的表达能力，但也带来了 $O(L^2)$ 的计算成本。
TokenMixer 是数据无关的静态混合：全局权重 $G$ 是固定的可学习参数，与输入无关。这使得计算效率极高（权重可以预计算），但牺牲了对不同输入的适应性。
因式分解机是特征相似度驱动的混合：全局权重 $G = XI(XI)^\top$ 由特征向量的内积决定，本质上是基于特征相似度的混合。这在二阶交互上效率很高，但难以扩展到更高阶。

4.2.2 Kronecker 积分解与计算优化

完整的 UniMixing 操作涉及 $L \times L$ 的权重矩阵（$L$ 为 Token 数量），在特征数量较大时计算成本不可接受。论文利用排列矩阵的 Kronecker 积结构进行分解：

$$W^{\text{perm}} = G \otimes I$$

这意味着全局混合矩阵可以分解为全局模式 $W_G$ 和局部模式 $W_B$ 的组合，将计算复杂度从 $O(L^2)$ 降低到：

$$O\left(\frac{L^2}{B} + LB\right)$$

其中 $B$ 是块大小。这种"全局-局部"的分层结构是 UniMixer 兼顾表达能力和计算效率的关键。

4.3 UniMixer-Lite：效率与性能的帕累托前沿

4.3.1 设计动机

完整的 UniMixing 模块虽然理论上优雅，但在工业部署中仍面临参数效率的挑战——每个块都需要独立的全局和局部权重矩阵。UniMixer-Lite 通过两项关键技术将参数量大幅压缩：

4.3.2 基矩阵组合（Basis Composition）

对于局部权重 $W_B^{(i)}$（第 $i$ 个块的局部混合矩阵），UniMixer-Lite 不再为每个块独立学习权重，而是通过一组共享基矩阵的线性组合动态生成：

$$W_B^{(i)} = \sum_{\ell=1}^{b} \omega_\ell^{(i)} Z_\ell$$

其中 $\{Z_\ell\}_{\ell=1}^{b}$ 是 $b$ 个共享基矩阵，$\omega_\ell^{(i)}$ 是第 $i$ 个块对各基矩阵的组合系数。

这种设计的精妙之处在于：

基矩阵在所有块间共享，参数量从 $O(L/B \cdot B^2)$ 降到 $O(b \cdot B^2)$
组合系数 $\omega_\ell^{(i)}$ 允许每个块有自己独特的混合模式
基矩阵数量 $b$ 远小于块数量 $L/B$，实现了参数的高效复用

4.3.3 低秩近似（Low-Rank Approximation）

对于全局权重 $W_G$，UniMixer-Lite 采用低秩分解：

$$W_G \approx W_r = A_G B_G$$

其中 $A_G \in \mathbb{R}^{(L/B) \times r}$，$B_G \in \mathbb{R}^{r \times (L/B)}$，秩 $r \ll L/B$。

这将全局权重的参数量从 $O((L/B)^2)$ 降到 $O(r \cdot L/B)$，在实践中 $r$ 通常取 4-8 即可达到接近全秩的效果。

4.3.4 Sinkhorn-Knopp 的保障作用

值得注意的是，即使使用了低秩近似和基矩阵组合来压缩参数，UniMixer-Lite 仍然通过 Sinkhorn-Knopp 操作确保权重矩阵保持接近满秩的双随机性质。这种"先压缩、后修正"的设计避免了参数压缩带来的表达能力损失。

4.3.5 性能表现

实验数据来自快手广告投放场景，超过 7 亿用户样本、一年数据，包含数百个异构特征。任务为用户留存预测（次日回访）。结果令人印象深刻：

模型	参数量	FLOPs	AUC	ΔAUC	UAUC	ΔUAUC
Heterogeneous Attention	132.7M	1.68T	0.7446	baseline	0.7338	baseline
RankMixer	135.5M	1.68T	0.7493	+0.475%	0.7389	+0.511%
UniMixer-2B	101.5M	2.50T	0.7502	+0.566%	0.7400	+0.615%
UniMixer-Lite-2B	76.2M	2.60T	0.7514	+0.682%	0.7412	+0.739%
UniMixer-Lite-4B	84.5M	4.24T	0.7527	+0.814%	0.7425	+0.870%

几个关键发现：

UniMixer-Lite-4B 仅用 84.5M 参数，AUC 提升 +0.814%，显著优于 135.5M 参数的 RankMixer
在推荐系统领域，AUC 提升 0.1% 即被视为显著改进，0.8% 是非常大的提升
UniMixer 的 FLOPs 高于 RankMixer（2.50T vs 1.68T），这是参数化带来的计算开销——但考虑到参数量的大幅减少和性能的显著提升，这一权衡在工业场景中是值得的

4.4 Pertoken SwiGLU 与完整架构

在 UniMixing 完成特征交互后，模型通过 Pertoken SwiGLU 建模不同特征的异质性：

$$\text{pSwiGLU}(o_i) = W_{\text{down}}^i \left( (W_{\text{up}}^i o_i + b_{\text{up}}^i) \odot \text{Swish}(W_{\text{gate}}^i o_i + b_{\text{gate}}^i) \right) + b_{\text{down}}^i$$

每个 Token 拥有独立的 FFN 参数（$W_{\text{up}}^i$, $W_{\text{gate}}^i$, $W_{\text{down}}^i$），充分建模不同特征领域（用户画像、物品属性、行为序列等）的异质性。这与 NLP 中所有 Token 共享 FFN 参数形成了鲜明对比。

完整的 UniMixer 模型由以下部分组成：

Feature Tokenization → 异构特征按领域分组，投影为统一维度的 Token 表示
M 层 UniMixer Block（含 SiameseNorm） → 层叠的统一混合模块
Sparse-Pertoken MoE → 稀疏混合专家进一步增强表达能力
预测头 → 输出最终预测

4.5 SiameseNorm：解锁深层架构的训练稳定性

4.5.1 深层推荐模型的训练难题

随着推荐模型向更深的层数扩展，一个经典的矛盾浮出水面：

Pre-Norm（归一化在子层之前）：有利于梯度流动和训练稳定性，但可能导致深层表示退化——所有层的输出趋于相似
Post-Norm（归一化在子层之后）：理论上能产生更丰富的层间表示差异，但在深层网络中容易出现梯度消失或爆炸

这个问题在 NLP 领域已有大量研究，但推荐系统的特征异构性（数值型、类别型、序列型特征共存）使得问题更加复杂。

4.5.2 SiameseNorm 的双流设计

UniMixer 引入了 SiameseNorm，其核心思想是维护两条耦合的信息流（$\bar{X}_\ell$ 和 $\bar{Y}_\ell$）。具体更新规则为：

$$\tilde{Y}_\ell = \text{RMSNorm}(\bar{Y}_\ell), \quad O_\ell = \text{UniMixer}(\bar{X}_\ell + \tilde{Y}_\ell)$$$$\bar{X}_{\ell+1} = \text{RMSNorm}(\bar{X}_\ell + O_\ell), \quad \bar{Y}_{\ell+1} = \bar{Y}_\ell + O_\ell$$

其中 $\bar{X}_\ell$ 承担类似 Pre-Norm 路径的角色——每次更新都经过 RMSNorm，保证训练稳定性；$\bar{Y}_\ell$ 承担类似 Post-Norm 路径的角色——直接累加输出，保持层间表示的多样性。两条流在每一层通过 $\bar{X}_\ell + \tilde{Y}_\ell$ 的融合进行耦合交互，兼具两种归一化方案的优势。

这种设计使得 UniMixer 能够同时在模型深度和宽度两个维度上进行有效扩展，而不会遇到训练不稳定的瓶颈。

4.6 缩放定律：推荐系统的"Chinchilla 时刻"

4.6.1 为什么推荐系统需要缩放定律？

在自然语言处理领域，Kaplan et al. (2020) 和 Hoffmann et al. (2022, Chinchilla) 发现了模型性能与参数量之间的幂律关系，这一发现深刻地改变了 LLM 的训练策略——从"盲目堆大"转向"计算最优"。

但推荐系统的缩放定律研究相对匮乏。其原因在于：

推荐模型的架构多样性远高于 LLM（Transformer 一统天下），难以进行公平对比
推荐系统的特征异构性（稀疏 ID 特征 + 稠密数值特征）使得"参数量"的定义不如 LLM 清晰
工业界的保密性导致大规模缩放实验的结果难以公开

UniMixer 论文的重要贡献之一，就是在统一框架下，为推荐系统建立了可对比的缩放定律基准。

4.6.2 幂律关系

论文验证了 AUC 增益与参数量之间的幂律关系：

$$\Delta \text{AUC} = a \cdot \text{Params}^{\alpha}$$

其中 $\alpha$ 是缩放指数，反映了架构的参数效率。实验结果：

架构	Scaling Law 公式	缩放指数 $\alpha$
RankMixer	$\Delta\text{AUC} = 0.002718 \cdot \text{Params}^{0.116}$	0.116
UniMixer	$\Delta\text{AUC} = 0.003032 \cdot \text{Params}^{0.132}$	0.132
UniMixer-Lite	$\Delta\text{AUC} = 0.003767 \cdot \text{Params}^{0.142}$	0.142

UniMixer-Lite 的缩放指数比 RankMixer 高出 22.3%，这意味着在相同的参数预算增长下，UniMixer-Lite 能获得更大的性能提升。更直观地说：

如果将参数量翻倍，RankMixer 的 AUC 增益提升约 8.4%，而 UniMixer-Lite 的提升约 10.3%。

随着模型规模的持续增长，这种差距会被不断放大。

4.6.3 深层 Scaling 的关键差异

更引人注目的是深层 Scaling 的对比实验：

模型	AUC	趋势
RankMixer-2B	0.7478	—
RankMixer-4B	0.7467 (-0.107%)	性能退化 ↓
UniMixer-Lite-2B	0.7492	—
UniMixer-Lite-4B	0.7508 (+0.158%)	持续提升 ↑
UniMixer-Lite-8B	0.7509 (+0.165%)	持续提升 ↑

这是一个极其重要的发现：RankMixer 增加深度后性能反而下降（-0.107%），而 UniMixer-Lite 在 8B 规模仍然展现出清晰的提升趋势。这证明了参数化混合 + SiameseNorm 的组合确实解决了深层推荐模型的 Scaling 瓶颈。

4.7 消融实验：每个组件的贡献

论文提供了详尽的消融实验，量化了每个设计选择的贡献：

设置	AUC	ΔAUC	影响程度
完整 UniMixer	0.7485	—	—
去除温度系数	0.7468	-0.165%	显著
去除模型预热	0.7476	-0.086%	显著
去除对称性约束	0.7479	-0.057%	中等
去除分块特异权重	0.7480	-0.044%	轻微

关键结论：

温度系数是最关键的组件（-0.165%），这验证了"先探索后收敛"的退火策略对于找到最优混合模式至关重要
模型预热同样重要（-0.086%），说明从高温初始化开始训练对避免局部最优有显著帮助
对称性约束和分块特异权重的影响相对较小，但仍然为正向贡献

5. 工程实践：从论文到生产的关键挑战

5.1 异构特征的 Token 化处理

工业推荐系统的输入特征高度异构——用户 ID（稀疏类别型）、用户年龄（数值型）、行为序列（变长序列型）、上下文时间（连续型）需要被统一为 Token 表示。UniMixer 的处理方式是将输入特征按领域组织（用户画像、物品特征、行为序列、Query 特征等），每个领域通过 Embedding 层转换为向量，再均匀划分为块并投影为 Token 嵌入：

$$x_i = W_i^{\text{proj}} E_{di:di+d} + b_i^{\text{proj}} \in \mathbb{R}^D$$

这种分组 Token 化方案使得不同类型的特征被映射为统一维度的 Token 向量，为后续的 UniMixing 操作提供了一致的输入格式。

5.2 Sinkhorn-Knopp 迭代的计算开销

双随机约束的 Sinkhorn-Knopp 迭代在理论上需要无穷步才能严格收敛，但实践中论文发现 5-10 次迭代即可达到足够的精度。这一开销在训练时是可接受的，而在推理时权重已经固定，无需额外迭代。

5.3 温度退火的超参数选择与冷启动策略

温度退火策略引入了三个超参数：起始温度 $\tau_{\text{start}}$、终止温度 $\tau_{\text{end}}$ 和退火步数 $J$。论文推荐的默认值为 $\tau_{\text{start}} = 1.0$、$\tau_{\text{end}} = 0.05$。一个实用的经验法则是将退火步数设置为总训练步数的 60-80%，让模型在训练的最后阶段以稳定的低温度进行精调。

对于数据不足的场景，论文还提出了"冷启动"策略：先用高温度完成一轮完整训练，然后用高温训练得到的权重作为初始化，再进行低温度的重训。这种两阶段方法可以在数据有限的情况下依然获得良好的稀疏权重。

5.4 快手广告系统的部署实践

UniMixer 和 UniMixer-Lite 已在快手的多个广告投放场景中完成部署。论文报告了在线 A/B 测试的结果，以 30 天累计活跃天数（CAD, Cumulative Active Days） 为核心评估指标：

D1-D30 的 CAD 平均提升超过 15%

同时离线 AUC 提升 +0.814%（UniMixer-Lite-4B vs 基线）。在推荐系统领域，AUC 提升 0.1% 就已经是显著的改进，0.8% 的提升幅度在工业界是极为罕见的。这一结果有力地证明了统一架构的实际业务价值。

6. 与相关工作的对比分析

6.1 与 TokenMixer-Large（字节跳动）的对比

TokenMixer-Large 是字节跳动提出的推荐系统大模型架构，与 UniMixer 形成了有趣的技术路线对比：

维度	TokenMixer-Large	UniMixer
核心贡献	工程优化——通过纯净架构和 MoE 扩展至 15B	理论统一——揭示三大范式的等价性
扩展策略	深度扩展（Mixing & Reverting + 跨层残差）	参数效率扩展（基矩阵组合 + 低秩近似）
混合方式	基于规则的 Split & Concat	参数化的可学习混合矩阵
训练稳定性	Rezero 初始化 + 辅助损失	SiameseNorm 双流设计
稀疏化	Per-token MoE	温度退火的稀疏权重
验证规模	最大 15B 参数	聚焦于 100M 级别的缩放定律

两篇论文实际上代表了推荐系统大模型的两种互补思路：

TokenMixer-Large：以"工程至上"为原则，通过极致的架构优化和 MoE 稀疏化，在既有的 TokenMixer 框架内推到了 15B 的参数规模
UniMixer：以"理论先行"为原则，通过统一框架发现了更高效的参数化空间，用更少的参数实现了更好的缩放效率

6.2 与 Attention-based 方法的对比

UniMixer 的统一框架揭示了一个有趣的事实：注意力机制可以被视为"输入依赖的 UniMixing"，而 UniMixer 使用的是"输入无关的可学习权重"。这意味着：

注意力机制的表达能力理论上更强（动态权重 vs 静态权重）
但 UniMixer 的计算效率更高（权重可预计算，无需在线计算 QK）
在推荐系统的实际场景中，UniMixer 的缩放效率反而更好——这可能说明推荐系统中"最优的混合模式"并不需要随输入动态变化

6.3 与 FM-based 方法的对比

因式分解机方法在 UniMixer 的框架下被理解为"全局权重由特征相似度决定"的特例。UniMixer 的改进在于：

FM 的全局权重 $G = XI(XI)^\top$ 完全由输入决定，没有可学习参数
UniMixer 的全局权重 $W_G$ 是可学习的，能发现数据中不直接由相似度反映的交互模式
UniMixer-Lite 的基矩阵组合可以看作是"参数化的 FM"——每个块的局部交互模式由共享基矩阵动态组合

7. 流程图 (Flowchart)

graph LR A["异构特征"] --> B["Token 化"] B --> C["UniMixing"] C --> D["Pertoken SwiGLU"] D --> E["SiameseNorm"] E --> F["Sparse MoE"] F --> G["深层堆叠"] G --> H["预测输出"] style C fill:#4ecdc4,color:#fff style E fill:#45b7d1,color:#fff style F fill:#f7dc6f,color:#333

UniMixing 内部结构：

graph LR X["输入 X"] --> WG["全局权重 W_G
低秩近似"] X --> WB["局部权重 W_B
基矩阵组合"] WG --> SK["Sinkhorn-Knopp
双随机约束"] WB --> SK2["Sinkhorn-Knopp
双随机约束"] SK --> MIX["UniMixing 交互"] SK2 --> MIX MIX --> OUT["输出"] style SK fill:#4ecdc4,color:#fff style SK2 fill:#4ecdc4,color:#fff style MIX fill:#45b7d1,color:#fff

8. 优缺点分析

8.1 优势

理论贡献突出：首次将推荐系统三大特征交互范式统一到同一数学框架下，为后续研究提供了清晰的理论基础和统一的对比基准。
参数效率卓越：UniMixer-Lite 以不到一半的参数量超越全参数基线，缩放指数提升 22.3%。这意味着在相同的计算预算下，UniMixer 能获得更大的性能收益。
设计优雅：温度退火 + Sinkhorn-Knopp 约束的组合，使得可学习权重能在保持排列矩阵良好性质的同时，找到最优的混合模式。这种"在约束空间中优化"的思路具有广泛的启发意义。
工业验证充分：在快手广告系统的多个场景中完成部署，离线 AUC +0.814%、在线 30 天 CAD +15% 的效果证明了方案的实际业务价值。

8.2 局限与待探索方向

缩放实验规模有限：与 TokenMixer-Large 的 15B 参数实验相比，UniMixer 的缩放验证主要集中在 100M 参数级别。UniMixer-Lite-8B 虽然仍有提升，但增量已经放缓（+0.165% vs +0.158%），更大规模下是否仍能保持优势有待验证。
计算成本权衡：UniMixer 的 FLOPs 显著高于 RankMixer（2.50T vs 1.68T），这意味着参数化带来的性能提升需要以额外的计算开销为代价。在延迟敏感的在线服务场景中，这一权衡需要仔细评估。
动态权重的缺失：UniMixer 使用的是输入无关的静态权重，而注意力机制的核心优势在于动态权重。能否在保持计算效率的前提下引入有限的动态性（如条件化的权重调制），可能是一个有价值的研究方向。
公开数据集验证缺失：论文仅在快手内部数据集上进行了验证，缺乏公开数据集上的对比实验，这限制了社区对结果的复现和验证。
多任务场景的验证：论文主要聚焦在用户留存预测任务上，在其他推荐任务（CTR、CVR、停留时长等）和多任务学习场景下的表现尚待验证。
与序列建模的结合：当前的 UniMixing 主要处理特征间的交互，如何与用户行为序列建模（如 DIN、SIM）有效结合，也是一个值得探索的方向。

9. 未来展望：推荐系统架构的"大一统"趋势

9.1 从架构统一到训练范式统一

UniMixer 完成了特征交互层面的架构统一。下一步自然是训练范式的统一——能否将 CTR 预估、召回、排序等不同阶段的模型统一到同一个框架下？Spotify 的 NEO 论文已经在搜索与推荐的统一上迈出了一步，而 UniMixer 的统一框架可能为推荐系统内部的多阶段统一提供理论基础。

9.2 缩放定律指导资源分配

UniMixer 建立的缩放定律对比框架，为工业界的模型选型和资源分配提供了量化依据。在实际决策中，团队可以根据缩放指数估算"投入 X 倍计算资源，预期获得 Y% 的性能提升"，从而做出更理性的投资决策。

9.3 参数化混合的更广泛应用

“将规则驱动的操作参数化，同时通过约束保持原始性质"这一思路，可以推广到推荐系统的其他组件——例如特征选择、样本加权、多目标融合等。这些传统上依赖人工规则或简单启发式的模块，都可能从参数化中获益。

9.4 深度与效率的帕累托前沿

SiameseNorm 解决了深层训练的稳定性问题，而 UniMixer-Lite 的基矩阵组合和低秩近似则压缩了参数量。未来的研究可以进一步探索：在给定的延迟预算下，如何在模型深度、宽度和稀疏度之间找到最优的帕累托前沿？

10. 总结

UniMixer 论文的价值不仅在于提出了一个新的推荐系统架构，更在于建立了一个统一的理论视角，让我们重新审视过去十年推荐系统特征交互技术的发展脉络。

回顾全文：

三条技术路线的殊途同归：注意力机制、TokenMixer 和因式分解机看似是三种截然不同的特征交互方式，但在 UniMixing 框架下只是全局权重和局部模式的不同选择
参数化带来的红利：将规则驱动的 TokenMixer 转化为可学习的参数化形式，配合温度退火和 Sinkhorn-Knopp 约束，实现了更高效的缩放
从理论到实践的闭环：统一框架不仅具有理论美感，更通过 UniMixer-Lite 和 SiameseNorm 的工程设计转化为实际的性能收益

在推荐系统向大模型时代迈进的过程中，UniMixer 提供了一个重要的启示：真正的扩展效率提升，往往不是来自简单地堆叠更多参数，而是来自对架构本质的深刻理解。当我们理解了"为什么这样做有效”，才能找到"如何做得更高效"的答案。

NEO：用统一语言模型重新定义搜索、推荐与推理

Thu, 02 Apr 2026 21:00:00 +0800

本文是关于 Spotify 团队论文《A Unified Language Model for Large Scale Search, Recommendation, and Reasoning》（）的深度精读笔记。这篇论文提出了 NEO 框架，将预训练 LLM 改造为无需外部工具、目录受限的生成模型，在超过 1000 万物品的工业级目录上统一了推荐、搜索和用户理解等多种发现任务。

1. 引言：搜索与推荐的"大一统"时刻

1.1 搜索和推荐的传统割裂

在大多数互联网公司中，搜索和推荐是两个独立的系统。搜索系统接收用户的文本查询，通过倒排索引或向量检索返回匹配结果；推荐系统则基于用户历史行为，通过协同过滤或深度模型预测用户可能感兴趣的内容。两者在数据管线、模型架构、评估体系上几乎完全独立。

这种割裂带来了显而易见的问题：

重复建设：搜索和推荐分别维护独立的特征工程、模型训练、在线服务系统
知识无法共享：用户在搜索中表达的意图信息无法被推荐系统利用，反之亦然
体验不一致：用户在搜索和推荐中看到的内容可能存在风格和质量的割裂
多模态支持困难：当目录中包含多种类型的实体（歌曲、播客、有声书、艺术家），每种实体需要独立的处理管线

1.2 LLM 带来的新可能

大语言模型（LLM）的崛起让人们看到了统一这些任务的可能性。LLM 天然具备以下能力：

语言可控性：通过自然语言指令控制任务类型、输出格式
多任务学习：在统一的 next-token prediction 框架下训练多种任务
泛化能力：预训练知识可以迁移到下游任务

但将 LLM 直接用于工业级推荐/搜索面临一个核心困难：LLM 的输出是自然语言文本，而推荐/搜索需要输出的是明确、无歧义的目录物品。

这个鸿沟具体体现为：

方案	问题
纯文本输出物品名称	歧义（同名物品）、不稳定（hallucination）、无法保证目录有效性
向量嵌入方式	需要修改模型架构，破坏预训练知识
工具增强（先生成查询再检索）	增加编排复杂度和延迟，引入级联误差

1.3 NEO 的核心洞察

NEO 的核心洞察在于：可以将目录物品表示为一种新的"语言"——语义标识符（Semantic Identifiers, SIDs），让 LLM 在自然语言和物品标识符之间自由切换。

这种设计的精妙之处在于：

SID 是离散 token，完全兼容 LLM 的 next-token prediction 范式
SID 保持了语义邻域结构，语义相近的物品有相似的 SID
通过约束解码（Constrained Decoding）保证生成的 SID 一定对应真实目录物品
自然语言指令可以控制任务类型、目标实体类型和输出格式

一个直观的类比：如果说 LLM 学会了"说人话"，那么 NEO 就是让 LLM 同时学会了"说人话"和"说物品话"，并且能在两种语言之间自由切换。

2. 方法论：三阶段训练框架

NEO 的方法论可以概括为一个三阶段训练框架（论文中描述为四阶段，但第四阶段留作未来工作）：

graph LR S1["阶段一
语义基础
构建 SID"] --> S2["阶段二
领域对齐
SID ↔ 文本"] S2 --> S3["阶段三
能力注入
多任务指令微调"] S3 -.-> S4["阶段四
任务特化
（未来工作）"] style S1 fill:#4ecdc4,color:#fff style S2 fill:#45b7d1,color:#fff style S3 fill:#f7dc6f,color:#333 style S4 fill:#ccc,color:#666

2.1 阶段一：语义标识符（SID）的构建

什么是 SID？

SID 是将目录中每个物品映射为一个短的离散 token 序列的方法。具体来说，每个物品 $e$ 被表示为 $SID(e) = (c_1, c_2, ..., c_M)$，其中每个 $c_i$ 来自一个大小为 $K$ 的码本。

NEO 使用 残差 K-means 量化（Residual K-means） 来构建 SID，这是一种层级化的向量量化方法：

首先将物品的内容嵌入（content embedding）通过第一个码本量化，捕获粗粒度的语义区域
计算残差（原始向量 - 量化向量），用第二个码本量化残差
重复这一过程 $M$ 次，逐步精细化表示

这种残差量化方式产生了从粗到细的层级结构：

第一个 token：大的语义类别（如"喜剧播客"）
第二个 token：细分领域（如"科技脱口秀"）
第三、四个 token：进一步区分具体物品

NEO 的具体配置

实体类型	嵌入来源	码本数 M	码本大小 K	SID 长度
艺术家	音频频谱嵌入（track 级聚合）	4	1024	4 tokens
节目/剧集/有声书	Qwen3 Embedding (8B) 文本嵌入	4	256	4 tokens

几个关键设计决策值得注意：

为什么艺术家用音频嵌入而非文本嵌入？ 因为艺术家的核心特征是其音乐风格，而音乐风格最好通过音频信号来捕捉。文本描述（如艺术家简介）往往不能充分反映其音乐特征。

为什么艺术家的码本更大（K=1024 vs K=256）？ 音频嵌入空间的复杂度更高，需要更大的码本来保持足够的区分度。

为什么不同实体类型使用独立的量化器？ 不同类型的物品可能存在于不同的潜在空间中（音频 vs 文本），强制使用同一个量化器会损害表示质量。

数据增强的重要性

论文特别提到了一个实用的工程经验：剧集的文本描述往往很短或重复性高（如"第 42 集"），直接用这些低质量文本生成的嵌入会导致大量 SID 碰撞。解决方案是使用 LLM 从多个元数据字段生成增强的描述，显著改善了 SID 的区分度。

消融实验表明，不使用数据增强会导致 HR@10 下降 2.9%。虽然看起来不大，但在工业级系统中，这个差距意味着数百万用户的体验差异。

与 LLM 词表的融合

SID 构建完成后，需要将其整合到 LLM 的词表中：

扩展词表：$V = V_{text} \cup V_{SID}$
新增 $M \times K$ 个 SID token（随机初始化）+ 2 个定界符 [SID] 和 [/SID]
NEO 实际新增了 7,170 个 token（3 种文本实体 × 4 × 256 + 1 种音频实体 × 4 × 1024 + 2 个定界符 = 3072 + 4096 + 2）

序列格式采用定界符约定：

⟨自然语言文本⟩ [SID] ⟨c₁ c₂ c₃ c₄⟩ [/SID] ⟨自然语言文本⟩

这种设计使得模型可以在一个序列中自由交织自然语言和物品引用。

2.2 阶段二：领域对齐（Domain Grounding）

核心问题

阶段一生成的 SID token 是随机初始化的，与 LLM 预训练的文本嵌入空间没有任何关联。如果直接进行下游任务训练，模型需要同时学习"SID 是什么"和"如何用 SID 完成任务"，这两个目标的耦合会严重影响学习效率。

三种对齐目标

NEO 设计了三种互补的对齐目标，建立 SID 和自然语言之间的双向映射：

1. SID → 文本（语言化）

给定一个 SID，预测其对应的自然语言描述：

输入：这个 [SID] ⟨c₁c₂c₃c₄⟩ [/SID] 是什么？
输出：这是一档科技脱口秀节目，由...主持，讨论...

2. 文本 → SID（受限检索）

给定自然语言查询，预测对应物品的 SID：

输入：找到名为"The Daily"的新闻播客
输出：[SID] ⟨c₁c₂c₃c₄⟩ [/SID]

3. SID → 类型（类型消歧）

给定一个 SID，预测其实体类型：

输入：这个 [SID] ⟨c₁c₂c₃c₄⟩ [/SID] 是什么类型？
输出：播客节目

参数化策略：防止灾难性遗忘

这个阶段的训练策略非常谨慎：

冻结预训练骨干网络的所有参数
只优化新引入的 SID token 嵌入
只优化 LLM 输出头中与 SID 相关的 logits

这种策略的好处是在建立 SID-文本映射的同时，完全保留了 LLM 的语言能力。论文的消融实验证明，这一设计至关重要：跳过对齐阶段会导致下游任务性能下降 6-8%，而将对齐和任务训练合并为一个阶段则会导致 7-10% 的下降。

对齐数据

对齐阶段使用约 500 万条配对数据，包括物品标题、描述、摘要、话题、类别、风格、维基百科片段等多种文本信息与 SID 的配对。

2.3 阶段三：多任务指令微调

训练设置

这一阶段解冻所有参数，在统一词表上进行有监督的指令微调。训练集规模达到 1000 万条，覆盖以下四大类任务：

任务一：下一物品推荐

指令：Based on this user's recent listening history, recommend the next
 podcast episode they would enjoy.
上下文：User has listened to [SID]⟨...⟩[/SID], [SID]⟨...⟩[/SID], ...
输出：[SID]⟨c₁c₂c₃c₄⟩[/SID]

给定用户历史交互序列（以 SID 表示），预测用户下一个可能消费的物品。这是最经典的推荐任务。

任务二：文本检索

指令：Find the audiobook that best matches this search query.
查询："a thriller about artificial intelligence taking over"
输出：[SID]⟨c₁c₂c₃c₄⟩[/SID]

给定自然语言查询（可选地结合用户上下文），生成最相关物品的 SID。这对应传统的搜索检索任务。

任务三：推荐解释（Recsplanation）

指令：Recommend a show for this user and explain why.
上下文：User has listened to [SID]⟨...⟩[/SID], [SID]⟨...⟩[/SID], ...
输出：I recommend [SID]⟨c₁c₂c₃c₄⟩[/SID] because based on your
 interest in true crime podcasts and investigative journalism,
 this show offers...

这是一个混合生成任务：模型需要同时生成推荐物品的 SID 和自然语言解释。这是 NEO 的独特贡献之一——传统系统要么只能推荐物品（没有解释），要么需要额外的解释生成模块。

任务四：用户理解（Interest Profiling）

指令：Describe this user's interests based on their listening history.
上下文：User has listened to [SID]⟨...⟩[/SID], [SID]⟨...⟩[/SID], ...
输出：This user shows a strong interest in technology and science
 podcasts, particularly those discussing AI and machine learning.
 They also enjoy...

从用户的 SID 交互历史中生成自然语言的兴趣画像。这个任务没有现成的标注数据，NEO 使用了一个巧妙的方案——从更大的 LLM（32B 参数）蒸馏：先用大模型读取物品文本描述生成兴趣摘要，然后训练 NEO 直接从 SID 历史生成同样的摘要。

指令模板设计

论文使用了 20 种不同的指令模板，随机选择并填入用户信息。指令模板显式指定：

任务类型：推荐、检索、解释、用户理解
目标实体类型：剧集、节目、有声书、艺术家
输出格式：纯 SID、纯文本、或混合格式

这种设计使模型具备了语言可控性（Language Steerability）——通过改变指令就可以控制模型的行为，而无需训练不同的模型。

2.4 推理：约束解码

组合爆炸的挑战

4 个 token、每个 token 有 256 种选择，意味着约 43 亿（$256^4$）种可能的 SID 组合。但实际目录中只有约 1000 万个有效物品。如果不加约束，模型可能生成不存在于目录中的 SID。

Trie 约束解码

NEO 采用 前缀 Trie（Prefix Trie） 进行约束解码：

预先计算所有有效 SID 元组
构建前缀 Trie 数据结构
在 [SID]...[/SID] 跨度内，每一步只允许 Trie 中合法的后续 token
在自由文本区域不施加约束

graph TD Root["根节点"] --> A1["c₁=5"] Root --> A2["c₁=12"] Root --> A3["c₁=..."] A1 --> B1["c₂=3"] A1 --> B2["c₂=87"] A2 --> B3["c₂=3"] A2 --> B4["c₂=45"] B1 --> C1["c₃=22"] B1 --> C2["c₃=156"] C1 --> D1["c₄=7 ✓ Item A"] C1 --> D2["c₄=200 ✓ Item B"] style D1 fill:#4ecdc4,color:#fff style D2 fill:#4ecdc4,color:#fff

图：Trie 约束解码示意。 每一步解码只在 Trie 的合法子节点中选择，确保最终生成的 SID 对应真实目录物品。

碰撞处理

多个物品可能共享同一个 SID（因为量化不可避免地引入信息损失）。NEO 使用基于流行度的启发式方法：将每个 SID 映射到其中最流行的物品。实验表明碰撞在推理时很少发生，随机碰撞解析与流行度解析没有显著差异。

性能开销

约束解码带来的延迟开销非常小（<5%），但提供了额外的灵活性——例如可以在推理时动态限制只生成特定子集的物品（如新上线内容）。

3. 实验设置

3.1 数据集与规模

NEO 在 Spotify 的真实数据集上进行评估：

维度	规模
目录物品数	>1000 万
物品类型	剧集、节目、有声书、艺术家
用户数	~1500 万
对齐训练数据	~500 万条
任务训练数据	1000 万条
测试数据	~10 万条

3.2 评估协议

NEO 采用全局时间评估协议（Global Temporal Evaluation）：

上下文：截至第 $t$ 天的交互历史
标签：第 $t+k$ 天的消费物品（剧集/节目 $k=1$，有声书 $k=7$）
评估时间点：$t+2k$

这种协议确保了评估的真实性——模型在训练时永远看不到评估时间段的数据。

3.3 基线系统

推荐基线： 基于图神经网络（GNN）的双塔架构，融合了：

跨物品类型的共同消费关系
弱信号（关注、预览等）用于冷启动
类别特征（分类、话题、用户国家）
LLM 编码的物品元数据

这是一个相当强的工业级基线，而非简单的学术 baseline。

检索基线： 密集检索系统，包含：

查询编码器处理文本位置和搜索查询
实体编码器表示物品元数据
训练数据来自搜索日志、多步重写会话、人工策划和合成查询

3.4 评估指标

HR@K（Hit Rate@K）：前 K 个推荐中包含目标物品的比例
NDCG@K（Normalized Discounted Cumulative Gain@K）：考虑排序位置的指标
$K \in \{10, 30\}$

4. 实验结果与分析

4.1 主要结果：NEO 全面超越强基线

NEO 在推荐和检索任务上均显著超越了各自的强基线：

推荐任务（下一物品预测）：

维度	NEO 相对提升
HR@10	+20% ~ +58%
NDCG@10	+46% ~ +97%
覆盖实体类型	剧集（+57%）、有声书（+36%~~+46%）、节目（+20%~~+24%）

文本检索任务：

维度	NEO 相对提升
HR@10	+26% ~ +47%
细粒度实体（剧集）	+40%
多步搜索会话	HR@10 +185%，NDCG@10 +243%

几个值得注意的发现：

NDCG 的提升幅度远大于 HR：这意味着 NEO 不仅能把正确的物品放进 top-K，还能把它排到更靠前的位置
细粒度实体收益更大：剧集（最细粒度）的提升比节目（较粗粒度）更显著，说明 SID 的层级结构在区分细粒度物品时特别有效
多步搜索会话的巨大提升：在用户需要多次重写查询才能找到目标的场景中，NEO 的优势最为明显（HR@10 +185%，NDCG@10 +243%），这很可能是因为 NEO 能更好地理解用户的搜索意图

4.2 多任务学习：正向迁移

这是 NEO 最令人兴奋的发现之一：联合训练多种任务不仅没有互相伤害，反而产生了正向的跨任务迁移。

具体而言，同时训练推荐、检索、解释和用户理解任务时，每个任务的性能都不低于（甚至优于）单独训练的结果。这意味着：

检索任务的文本理解能力帮助了推荐任务
推荐任务的用户行为建模能力帮助了检索任务
解释和用户理解任务作为辅助目标，进一步强化了模型的语义理解

这一结果支持了 NEO 的核心假设：搜索、推荐和用户理解不是孤立的任务，它们共享底层的用户意图和物品语义理解能力。

4.3 语义基础消融：SID 设计的每个决策都很重要

论文通过详尽的消融实验验证了 SID 设计中每个决策的影响：

消融实验	HR@10 变化	核心发现
原子 ID（随机打乱 SID）	-59.7%	语义结构至关重要
LSH 量化（数据无关）	-51.2%	学习型量化显著优于随机投影
无数据增强	-2.9%	元数据质量影响 SID 质量
协同过滤嵌入	-25.6%	内容嵌入优于协同过滤嵌入

让我逐一分析这些结果：

原子 ID vs SID（-59.7%）： 这是最关键的消融。通过随机排列 SID 元组（保持码本长度和词表大小不变，但破坏语义邻域结构），性能暴跌近 60%。这证明了 SID 的语义结构（而非仅仅是离散编码形式）才是性能提升的核心来源。在语义 SID 下，模型学到的不仅仅是"这个 ID 对应这个物品"，更是"这个 ID 的前缀代表这类物品"。

LSH vs 学习型量化（-51.2%）： LSH（Locality-Sensitive Hashing）是一种数据无关的随机投影量化方法。虽然 LSH 也能在一定程度上保持语义邻域，但与数据自适应的残差 K-means 相比差距巨大。这说明量化器需要适应数据的实际分布，而不能依赖通用的随机投影。

协同过滤 vs 内容嵌入（-25.6%）： 这个结果有些反直觉。在传统推荐系统中，协同过滤信号通常被认为比内容信号更强。但在 NEO 的框架下，基于协同过滤的 SID 表现明显更差。论文解释了原因：协同过滤信号（基于播放列表共现的 word2vec）存在时间不稳定性——用户的共现模式随时间变化剧烈，导致 SID 无法保持一致的语义结构。相比之下，内容嵌入（音频特征、文本描述）更加稳定，更适合作为长期有效的标识符。

4.4 领域对齐策略：分阶段 vs 端到端

策略	HR 变化	NDCG 变化	MMLU-Redux
NEO（三阶段）	基准	基准	0.46
无领域对齐	-6%~-7%	-8%	-
两阶段合并	-7%~-8%	-10%	-
随机初始化（不用预训练）	-43%~-44%	-43%~-44%	-
持续预训练（CPT）	-2%~-3%	-2%~-3%	0.03

最引人注目的是最后一行：持续预训练（CPT） 方法在下游任务上只比 NEO 差 2-3%，看起来差距不大。但它在语言能力保留上的灾难性表现揭示了一个关键权衡：

NEO 的 MMLU-Redux 得分保持在 0.46（接近原始预训练模型）
CPT 的 MMLU-Redux 得分暴跌至 0.03（几乎丧失了语言理解能力）

这意味着 CPT 方法虽然学会了处理 SID，但代价是"忘记了怎么说人话"。对于只需要输出 SID 的纯推荐任务，这也许可以接受。但 NEO 的目标是同时支持推荐、检索、解释和用户理解——这些任务都需要强大的语言能力。NEO 的分阶段策略实现了 SID 能力和语言能力的最佳平衡。

4.5 约束解码分析

推理策略	ΔHR@10	ΔHR@30	延迟变化
NEO（Trie 约束 + Beam Search）	基准	基准	基准
Beam Search 无约束	-1.80%	-1.93%	-2.92%
Top-p 采样	-21.97%	-32.41%	-7.91%

一个有趣的发现是：即使不加约束，模型也能在 98% 的情况下生成有效的 SID。这说明经过充分的对齐和任务训练后，模型已经"内化"了目录结构。约束解码提供的更多是一种"安全网"，同时支持推理时的灵活控制（如限制输出范围到特定子集）。

Top-p 采样的大幅退化（-22%~-32%）则表明，在 SID 生成任务中，贪心/束搜索策略远优于随机采样。这与直觉一致——物品推荐需要的是精确匹配而非创造性多样性。

4.6 文本生成质量

NEO 不仅能生成 SID，还能生成高质量的自然语言文本。使用 GPT-4o-mini 作为评判的评估结果：

维度	评分（满分 5 分）
覆盖度（Coverage）	3.5 ~ 4.7
接地性（Groundedness）	3.5 ~ 4.7
忠实度（Faithfulness）	3.5 ~ 4.7

这表明 NEO 的文本生成能力在推荐解释和用户画像任务中达到了实用水平。

4.7 框架通用性验证

NEO 不仅在 Qwen3-0.6B 上有效，在 Llama 3.2 1B 上也得到了验证——领域对齐阶段即带来约 18% 的文本检索性能提升。这证明 NEO 是一个框架级的贡献，而非特定于某个模型的优化。

5. 深度思考：NEO 的设计哲学与启示

5.1 “新模态"范式 vs “工具增强"范式

在 LLM 与推荐系统结合的研究中，存在两大流派：

工具增强范式：LLM 通过调用外部工具（检索器、排序器）来完成推荐任务。代表工作包括 TalkPlay-tools、RecMind 等。

新模态范式：将物品标识符作为一种新的"语言模态"直接融入 LLM。NEO 属于这一范式。

NEO 的实验结果强力支持了新模态范式的优越性：

维度	工具增强	新模态（NEO）
延迟	高（多次 API 调用）	低（单次前向传播）
级联误差	有（工具错误传播）	无（端到端生成）
架构复杂度	高（需要编排层）	低（标准 Transformer）
文本-物品交织	困难	自然
可解释性	有限	内生（同一模型生成解释）

5.2 语义 ID 的哲学意义

SID 的设计体现了一个深刻的洞察：在离散符号系统（语言）和连续表示空间（嵌入）之间存在一个最佳的折中点。

纯文本表示：完全离散，人类可读，但有歧义
纯嵌入表示：完全连续，信息丰富，但不兼容自回归生成
SID：离散但保持语义结构，兼容自回归生成，且无歧义

这种"结构化离散表示"的理念可能超越推荐系统，适用于任何需要 LLM 操作大规模离散目录的场景——比如代码补全（代码库中的函数/类）、知识图谱推理（实体/关系）、甚至分子生成（化合物库）。

5.3 冷启动与长尾：理论优势与现实挑战

SID 的语义结构在理论上具备冷启动优势：语义相近的物品共享 SID 前缀，即使新物品从未出现在训练数据中，只要其 SID 前缀对应的语义区域已被学习，模型就能做出一定的预测。这与原子 ID 形成鲜明对比——原子 ID 对未见物品完全无能为力。

但论文的实验数据也揭示了一个重要的现实：在用户冷启动场景（移除历史行为信息，只依赖用户元数据）下，NEO 的性能会大幅下降（HR@10 约 -48%）。这说明 SID 虽然缓解了物品侧的冷启动问题，但用户侧的冷启动仍然是一个巨大挑战——没有足够的行为历史，模型很难准确预测用户兴趣。

这提醒我们：SID 不是冷启动的"银弹”。在实际部署中，新用户仍然需要通过偏好探索（exploration）、显式偏好收集等机制来积累足够的信号。

5.4 Scaling 的潜力

NEO 当前使用的是 Qwen3-0.6B——一个仅有 6 亿参数的"小"模型。考虑到 LLM 领域的 Scaling Law，一个自然的问题是：更大的模型（如 7B、70B）会带来多大的提升？

论文没有直接回答这个问题，但几个间接证据暗示了巨大的 Scaling 潜力：

从随机初始化训练导致 43-44% 的性能下降，说明预训练知识非常重要
使用 Llama 3.2 1B（稍大的模型）也能获得显著提升
多任务训练展现正向迁移，暗示更大的模型容量可以支持更多任务

5.5 与行业趋势的关系

NEO 的出现并非孤立事件，它是整个行业"推荐系统基础模型化"趋势的一部分。我们可以将其与其他重要工作进行对比：

工作	公司	核心思路	与 NEO 的区别
HSTU	Meta	统一序列 Transformer 做推荐	不支持搜索和文本生成
GPSD	Meta	生成式预训练做推荐	聚焦预训练范式，非语言模型
SORT	阿里	Transformer 做工业排序	判别式模型，不支持生成
MTFM	美团	基础模型做推荐	多模态但非语言模型统一框架
NEO	Spotify	LLM 统一搜索/推荐/推理	唯一真正统一搜索和推荐的 LLM 方案

NEO 的独特价值在于它是第一个在工业规模上验证了"用单一 LLM 统一搜索和推荐"的可行性。

6. 局限性与未来方向

6.1 当前局限

模型规模：0.6B 参数在 LLM 世界中属于小模型，可能限制了复杂推理能力。

离线评估：论文主要报告了离线指标，缺少在线 A/B 测试结果。虽然离线提升显著，但在线效果可能受到展示偏差、位置偏差等因素的影响。

单轮交互：当前的 NEO 主要支持单轮交互，虽然可以通过历史拼接扩展到多轮，但缺乏真正的对话建模能力。

SID 碰撞：虽然实验表明碰撞很少，但在极端长尾场景中，碰撞可能成为瓶颈。

阶段四缺失：论文描述了四阶段训练框架，但第四阶段（任务特化微调）留作了未来工作。

训练基础设施：论文使用 8 × Nvidia H100 GPU + PyTorch + Ray 进行训练，对于大多数团队来说这是可及的资源量，暗示了框架的实用性。

6.2 论文中的失败尝试

论文附录中坦诚记录了两个失败方向，这对从业者非常有价值：

SID Expert with Hard Router Mask：尝试为 SID token 设计专用的 MoE Expert 并通过硬路由掩码强制 SID token 走特定 Expert，但效果不佳
Vision as LoRA：尝试用 LoRA 方式融入视觉信息，同样未能带来提升

这些失败尝试提醒我们：并非所有直觉上合理的设计都能在实践中奏效。NEO 最终选择的"最小化架构修改"策略（仅扩展词表，不改模型结构）可能恰恰是因为它最好地保留了预训练知识。

6.3 值得期待的未来方向

多轮对话推荐：将 NEO 扩展为真正的对话式推荐系统，支持用户通过多轮对话逐步精细化需求。

实时个性化：结合 online learning 或 in-context learning，实现对用户实时兴趣变化的快速响应。

跨平台迁移：探索 SID 框架在不同平台和领域间的迁移能力。

更大规模验证：在更大的模型（7B+）和更大的目录（1 亿+）上验证 Scaling 效果。

7. 总结

NEO 是一项具有里程碑意义的工作，它首次在工业规模上证明了：一个预训练的解码器 LLM 可以被改造为无需外部工具、支持目录约束的生成模型，在同一个框架下统一推荐、搜索、解释和用户理解等多种发现任务。

graph TD subgraph "NEO 核心贡献" A["语义标识符 SID
物品的新语言"] --> D["统一模型"] B["三阶段训练
渐进式能力注入"] --> D C["约束解码
目录有效性保证"] --> D D --> E["推荐 +36~58%"] D --> F["检索 +26~47%"] D --> G["解释 & 用户理解"] D --> H["正向跨任务迁移"] end

这篇论文给我最大的启发是：不要试图让 LLM “使用” 现有的推荐系统，而是让 LLM “成为” 推荐系统。通过将目录物品转化为 LLM 原生理解的离散 token，搜索和推荐从"LLM 的下游应用"变成了"LLM 的内在能力”。

这一范式转变的影响可能是深远的。如果 SID 的思路被广泛采用，我们可能会看到：

搜索和推荐团队的合并
推荐系统工程从"特征工程 + 模型训练 + 在线服务"简化为"数据准备 + LLM 微调 + 约束解码"
可解释推荐从"事后解释"变为"内生解释"
用户与推荐系统的交互从"被动接收"变为"主动对话"

当然，从论文到真正的工业落地还有很长的路要走。但 NEO 已经迈出了关键的第一步——在超过 1000 万物品的真实工业级目录上证明了这条路是可行的。

参考文献：

De Nadai et al., “A Unified Language Model for Large Scale Search, Recommendation, and Reasoning,” arXiv:2603.17533, March 2026.
Rajput et al., “Recommender Systems with Generative Retrieval,” NeurIPS 2023 (TIGER).
Zhai et al., “Actions Speak Louder than Words: Trillion-Parameter Sequential Transducers for Generative Recommendations,” ICML 2024 (HSTU).
Li et al., “Generative Pre-trained Sequence Denoiser for Sequential Recommendation,” 2025 (GPSD).

SORT：面向工业级推荐系统的系统优化排序 Transformer

Wed, 01 Apr 2026 12:00:00 +0800

本文是关于 AliExpress 团队论文《SORT: A Systematically Optimized Ranking Transformer for Industrial-scale Recommenders》（）的深度精读笔记。本文将从问题定义、架构设计、系统优化到实验分析，全方位剖析 SORT 如何将 Transformer 成功落地到工业级推荐排序场景。

1. 引言：Transformer 进军推荐排序的"最后一公里"

Transformer 架构凭借其卓越的可扩展性（Scalability），在大语言模型（LLM）领域取得了令人瞩目的成就。从 GPT 到 LLaMA，从 BERT 到 T5，统一的 Transformer 架构不断刷新各项基准。这种成功的核心在于一个简洁而强大的范式：通过增加模型参数和训练数据，性能可以持续提升（Scaling Law）。

然而在推荐系统的排序（Ranking）阶段，主流模型仍然是 DIN、DIEN、DeepFM、DCN 等专用架构（Task-specific Architectures）。这些模型虽然在各自的场景中表现优异，但存在一个根本性问题：

架构碎片化：不同的特征交互方式需要不同的模型设计，难以统一
可扩展性差：增加参数量往往不能带来持续的性能提升，甚至可能导致过拟合
工程维护成本高：每种模型都需要独立的优化和维护

一个自然的问题是：能否像 LLM 一样，用统一的 Transformer 架构来构建推荐排序模型？

近年来，已有一些先驱性的工作开始探索这个方向：

HSTU（Meta, 2024）：提出了层级化序列转导单元，验证了推荐系统中的 Scaling Law
OneTrans（2024）：尝试将 Transformer 应用于排序场景
GPSD（Meta, 2025）：通过生成式预训练解决判别式推荐模型的过拟合问题

但这些工作要么聚焦于召回/检索阶段，要么在工业级排序场景中的落地效果有限。SORT（Systematically Optimized Ranking Transformer） 正是在这一背景下提出的——它系统性地解决了 Transformer 在工业级排序模型中面临的一系列挑战，并在 AliExpress 的真实业务场景中取得了显著收益。

graph LR A1["DIN
目标注意力"] & A2["DIEN
兴趣演化"] & A3["DeepFM
特征交叉"] & A4["DCN
交叉网络"] A4 -->|"架构碎片化
可扩展性差"| B1 B1["HSTU
Meta 2024"] & B2["OneTrans
2024"] & B3["GPSD
Meta 2025"] B3 -->|"系统性优化"| C1 C1["统一架构"] & C2["系统优化
稀疏注意力+MoE"] & C3["工业落地"]

图 1：推荐排序模型的演进路径。 从传统的专用架构（DIN、DeepFM 等），经过 Transformer 的初步探索（HSTU、OneTrans、GPSD），到 SORT 实现统一的工业级排序 Transformer。传统范式面临架构碎片化和可扩展性差的问题——每种特征交互方式都需要定制化的模型设计（如 DIN 的目标注意力、DeepFM 的二阶交叉、DCN 的显式交叉网络），导致工程维护成本高且难以通过简单增加参数来提升性能。过渡阶段的探索工作（HSTU 聚焦召回、GPSD 专注预训练框架、OneTrans 初步尝试排序）虽然各有突破，但尚未形成完整的工业级排序解决方案。SORT 通过系统性优化，首次在工业级排序场景中成功落地统一的 Transformer 架构，标志着推荐排序从"专用模型"向"统一基础模型"的范式转变。

2. 核心问题：高特征稀疏性 vs 低标签密度

在深入 SORT 的技术细节之前，我们需要理解一个根本性问题：为什么 Transformer 在推荐排序中不能像在 NLP 中那样直接 Scale Up？

2.1 语言模型 vs 推荐模型的关键差异

论文清晰地指出了两个领域之间的核心矛盾：

维度	语言模型 (LLM)	推荐排序模型
词表规模	BPE 子词分词，词表约 32K-128K	十亿级物品 ID 词表
特征稀疏性	低（子词复用率高）	极高（长尾物品大量存在）
标签密度	高（每个位置都有来自完整词表的监督信号）	极低（仅目标物品有二值标签 0/1）
训练信号	丰富（next-token prediction 提供密集梯度）	稀疏（只有点击/未点击的二值反馈）
过拟合风险	相对较低	极高

用一句话概括这个矛盾：推荐排序模型需要用极度稀疏的二值标签来正则化海量的参数空间（特别是十亿级的 Embedding 表），这导致了严重的过拟合问题。

2.2 具体表现

这个矛盾在实践中有以下具体表现：

Embedding 表过拟合：十亿级物品 ID 的 Embedding 参数极其庞大，但大量长尾物品只有极少的训练样本，导致对应的 Embedding 向量无法被充分学习
模型容量与数据量不匹配：增加 Transformer 层数和参数量时，模型的泛化差距（Generalization Gap）迅速扩大
训练不稳定：大规模稀疏特征的梯度更新存在高方差，容易导致训练发散

2.3 SORT 的系统性应对策略

面对上述挑战，SORT 并没有采取单一的解决方案，而是提出了一套系统性的互补优化：

graph LR Problem["核心矛盾
高特征稀疏性
× 低标签密度"] S1["① 请求中心样本 → 效率↑"] S2["② 特殊 Token → 训练稳定"] S3["③ 稀疏注意力+裁剪 → O(n)"] S4["④ DeepSeek MoE → 容量↑"] S5["⑤ 预训练+冻结 → 过拟合↓"] S6["⑥ QKNorm+门控 → 大规模"] Problem --> S1 Problem --> S2 Problem --> S3 Problem --> S4 Problem --> S5 Problem --> S6

图 2：SORT 针对核心矛盾的系统性解决方案。 面对高特征稀疏性和低标签密度的根本矛盾，SORT 提出了六个互补的优化方向，每个方向解决一个具体维度的问题：请求中心样本组织从数据层面减少冗余计算，提升训练效率；特殊 Token（BOS/SEP）从注意力分布层面稳定训练过程，防止注意力权重的异常分配；稀疏注意力和查询裁剪从计算复杂度层面将二次复杂度降至线性，并引入有益的时间衰减归纳偏置；DeepSeek MoE FFN 从模型容量层面在不增加激活计算量的前提下大幅扩展参数空间；生成式预训练加嵌入冻结策略从优化目标层面根本性地解决稀疏参数的过拟合问题；QKNorm 和门控注意力从数值稳定性层面保障大规模训练的收敛。这六个优化并非孤立存在，而是形成了一个有机整体——它们分别作用于数据、注意力、复杂度、容量、正则化和稳定性六个维度，共同构成了 SORT 的技术护城河。

3. SORT 架构详解

3.1 请求中心的样本组织（Request-Centric Sample Organization）

传统方法的问题

在传统的排序模型训练中，对于用户的一次请求（Request），系统会返回 $N$ 个候选物品，然后为每个候选物品生成一个独立的训练样本。这意味着：

同一个用户的历史行为序列被重复编码 $N$ 次
同一个用户画像（User Profile）被重复处理 $N$ 次
计算资源严重浪费

SORT 的解决方案

SORT 将样本组织方式从"物品中心"改为**“请求中心”**：

$$S = \langle H, U, C \rangle$$

其中：

$H$ = 用户历史行为序列（User History）
$U$ = 用户画像（User Profile）
$C$ = 候选物品集合（Candidate Set，包含该请求中的所有候选物品）

这种组织方式的核心优势：

一次前向传播处理所有候选物品：用户序列和画像只需编码一次
计算成本按候选数量摊销：N 个候选物品共享上下文计算
天然支持候选间信息交互：候选物品之间可以通过注意力机制进行比较

graph LR R1["传统：请求 N 个候选"] --> S["传统：N 条样本
每条 = History+Profile+Item"] S --> F["传统：N 次前向传播
⚠️ History 重复编码 N 次"] R2["SORT：请求 N 个候选"] --> US["SORT：1 条样本
S = ⟨H, U, C₁...Cₙ⟩"] US --> FF["SORT：1 次前向传播
✅ History 仅编码 1 次"]

图 3：传统物品中心 vs SORT 请求中心的样本组织对比。 传统方法对每个候选物品生成独立样本，用户历史和画像被冗余编码 N 次，计算浪费严重。SORT 将一次请求中的所有候选物品打包为统一样本，通过单次前向传播同时处理所有候选，用户上下文仅编码一次。这不仅大幅降低了计算成本，还使候选物品之间能够通过注意力机制进行信息交互，为后续的排序决策提供了更丰富的比较信号。在实际工业场景中，一次请求通常包含数十到数百个候选物品，因此这种改进带来的效率提升非常显著。

3.2 分词模块（Tokenization）

SORT 的分词模块将异构的推荐特征统一映射为 Token 序列，具体设计如下：

Token 类型

Token 类型	来源	数量	说明
BOS Token	特殊标记	1	序列起始标记，充当"注意力汇聚点"
History Token	用户历史行为	$L_h$	每个历史交互物品生成一个 Token
Profile Token	用户画像	$L_u$	用户画像特征映射为多个 Token
SEP Token	特殊标记	1	分隔用户上下文和候选物品
Candidate Token	候选物品	$N_c$	每个候选物品生成一个 Token

BOS Token 的关键作用——注意力汇聚（Attention Sink）

在 Transformer 中，一个广泛观察到的现象是：模型倾向于将大量注意力分数分配给序列的第一个 Token，即便该 Token 本身没有实际语义。这种现象被称为 “注意力汇聚（Attention Sink）”。

SORT 显式引入 BOS Token 来承担这一角色：

吸收冗余注意力分数：防止无关 Token 之间产生不合理的高注意力权重
稳定注意力分布：使模型能更准确地分配注意力给真正重要的 Token
实验验证：引入特殊 Token（BOS + SEP）带来了 +0.33pt CTR-AUC 的提升

Token 生成过程

每个 Token 的生成方式如下：

类别特征：通过 Embedding 查表获取向量
数值特征：通过线性变换映射为向量
多特征融合：同一 Token 的多个特征向量通过求和（Sum Pooling） 融合为最终的 Token 表示

$$\text{Token}_i = \sum_{f \in \text{Features}_i} \text{Embed}(f)$$

3.3 多头注意力（MHA）优化

SORT 在标准多头注意力的基础上进行了三项关键优化：

3.3.1 RoPE 相对位置编码（Rotary Position Embedding）

传统的绝对位置编码（如正弦编码或可学习编码）在处理变长序列时存在局限性。SORT 采用 RoPE 作为位置编码方案：

$$\text{RoPE}(x, \text{pos}) = x \cdot \cos(\text{pos} \cdot \theta) + \text{rotate}(x) \cdot \sin(\text{pos} \cdot \theta)$$

对候选物品的特殊处理：

所有候选物品使用相同的位置 ID
通过对角掩码（Diagonal Mask） 确保候选物品之间的独立性
这意味着每个候选物品"站在同一个位置"观察用户历史，保证了排序的公平性

3.3.2 QKNorm——训练稳定性的保障

在大规模训练中，Query 和 Key 向量的内积可能产生极大的数值，导致 Softmax 的梯度消失。SORT 引入 QKNorm：

$$\text{Attention}(Q, K, V) = \text{Softmax}\left(\frac{\text{Norm}(Q) \cdot \text{Norm}(K)^T}{\sqrt{d_k}}\right) V$$

对 Query 和 Key 在投影后分别进行 LayerNorm，确保注意力分数的数值范围稳定。

3.3.3 门控注意力（Gated Attention）

在标准缩放点积注意力的基础上，SORT 添加了一个门控机制：

$$\text{GatedAttn}(Q, K, V) = \sigma(G) \odot \text{Softmax}\left(\frac{QK^T}{\sqrt{d_k}}\right) V$$

其中 $\sigma(G)$ 是一个可学习的门控向量，用于控制每个注意力头的信息流。这种门控机制允许模型：

自适应地调节不同注意力头的贡献
在训练早期抑制不稳定的注意力模式
提供更细粒度的信息流控制

3.4 稀疏注意力机制（Sparse Attention）

动机

标准因果注意力的复杂度为 $\mathcal{O}(L^2)$，对于长用户行为序列（L 可达数千）来说，计算和内存成本都不可接受。

设计

SORT 采用**分区稀疏注意力（Partitioned Sparse Attention）**策略：

历史行为序列：采用局部注意力窗口（Local Attention Window）
- 每个 Token 只关注其前方窗口大小 $w$ 内的 Token
- 时间复杂度从 $\mathcal{O}(L^2)$ 降至 $\mathcal{O}(L \cdot w)$，即线性复杂度
- 最优窗口大小为 256
候选物品：保留标准因果注意力
- 候选物品需要关注完整的用户上下文
- 候选物品数量相对较少，不会成为瓶颈

关键发现

论文中一个令人意外的发现是：局部注意力窗口 256 的效果甚至超过了标准因果注意力（即完整的全局注意力）。

这一现象的直觉解释是：推荐场景中用户的近期行为比远期行为对当前兴趣更为重要，局部注意力天然契合了这种时间局部性。更深入的分析见第 7.1 节的讨论。

3.5 查询裁剪（Query Pruning）

核心思想

查询裁剪是 SORT 中一个非常巧妙的设计。其核心思想是：在 Transformer 的深层，距离候选物品较远的历史 Token 的 Query 向量对最终预测的贡献越来越小，可以安全地裁剪掉。

实现方式

SORT 采用逐层递进式裁剪：

在浅层（靠近输入）：保留所有 Token 的 Query
在深层（靠近输出）：逐步裁剪距离候选物品远的 Query Token
在最终层：仅保留 ≤128 个非候选 Token 的 Query

重要区别：被裁剪的是 Query，而非 Key 和 Value。这意味着：

被裁剪的 Token 仍然作为 Key 和 Value 参与注意力计算
其他 Token（特别是候选物品）仍然可以"看到"被裁剪 Token 的信息
但被裁剪的 Token 本身不再主动"查询"其他 Token

效果

查询裁剪带来了双重收益：

计算成本减半：几乎将 FLOPs 降低了 50%
性能反而提升：带来了 +0.26pt CTR-AUC 的增益

性能提升的原因在于查询裁剪隐式地引入了时间衰减归纳偏置（Temporal Decay Inductive Bias）——在推荐系统中，这是一个非常合理的先验：用户的近期行为比远期行为对当前兴趣的预测更为重要。

graph LR H["输入: H₁, H₂, ..., Hₙ
(History)"] C["输入: C₁, C₂, ..., Cₘ
(Candidates)"] L1["浅层 1-4
全量 Q/K/V + 局部窗口 w=256"] L2["中间层 5-8
裁剪远距 History Q, 保留 K/V"] L3["深层 9-12
≤128 History Q + 全量 Candidate"] O["输出: Candidate 隐层 → FFN
→ CTR/CVR 预测"] H --> L1 C --> L1 L1 --> L2 --> L3 L3 --> O

图 4：SORT 的稀疏注意力与查询裁剪机制。 在浅层，所有 Token 保留完整的 Query/Key/Value 进行局部注意力计算（窗口大小 256）；随着层数加深，距离候选物品较远的历史 Token 的 Query 被逐步裁剪，但其 Key 和 Value 仍然保留，确保候选物品可以访问完整的历史信息；在最深层，仅保留不超过 128 个历史 Token 的 Query 和所有候选 Token，最终通过候选 Token 的隐层输出进行 CTR/CVR 预测。这种设计将计算成本降低约 50%，同时通过引入时间衰减归纳偏置反而提升了模型性能。

3.6 DeepSeek MoE FFN

为什么需要 MoE？

标准 Transformer 的 FFN 层采用稠密计算，所有参数对每个 Token 都会被激活。在推荐排序模型中：

不同类型的用户行为（浏览、点击、收藏、购买）可能需要不同的特征变换
不同类别的物品可能需要不同的处理方式
稠密 FFN 难以同时满足这些多样化的需求

MoE（Mixture of Experts） 通过引入多个"专家"网络并动态路由，可以在不成比例增加计算量的前提下大幅扩大模型容量。

SORT 的 MoE 选择：DeepSeek MoE

SORT 比较了两种 MoE 方案：

维度	Switch MoE	DeepSeek MoE
路由方式	Top-K 路由	细粒度路由
负载均衡	需要调整辅助损失超参	无需辅助负载均衡损失
性能	基线	略优于 Switch MoE
工程复杂度	需要仔细调参	开箱即用

最终 SORT 选择了 DeepSeek MoE，关键超参数：

稀疏率：$1/8$（每个 Token 激活 $1/8$ 的专家参数）
性能收益：+0.19pt CTR-AUC
核心优势：无需额外的辅助损失函数调参，工程实现更简洁

MoE 稀疏率的影响

论文通过消融实验探索了不同稀疏率的效果：

稀疏率	含义	性能趋势
1/1（无 MoE）	全稠密 FFN	基线
1/2	激活一半专家	有一定提升
1/4	激活 1/4 专家	继续提升
1/8	激活 1/8 专家	最优
1/16	激活 1/16 专家	开始下降

最优稀疏率为 $1/8$，这意味着 SORT 能够以 $1/8$ 的激活计算量获得与完整稠密模型相当甚至更优的效果。过低的稀疏率（如 1/16）可能由于每个专家接收到的训练信号不足而导致性能退化。

3.7 生成式预训练与嵌入冻结（Generative Pretraining + Embedding Freeze）

这是解决过拟合的关键

前面提到，推荐排序模型的核心矛盾在于用稀疏的二值标签训练庞大的 Embedding 表。SORT 借鉴了 GPSD 框架的思路，但有自己独特的处理方式。

两阶段策略

阶段一：生成式预训练（Generative Pretraining）

在用户行为序列上进行 next-item prediction 任务
使用 Sampled Softmax 作为损失函数
预训练的目标是学习高质量的物品 Embedding 表
关键设计：不使用用户 ID 特征，仅通过历史行为序列和画像来表征用户

阶段二：判别式训练（Discriminative Training）+ 嵌入冻结

将预训练好的物品 Embedding 表迁移到排序模型
冻结 Embedding 表，不在排序训练中更新
仅训练 Transformer 的稠密参数

冻结策略的关键性

论文通过消融实验揭示了一个极其重要的发现：

策略	CTR-AUC 变化	说明
无预训练（基线）	0	—
仅转移预训练 Embedding	-0.13pt	反而下降！
转移 + 冻结 Embedding	+2.81pt	显著提升

为什么"仅转移不冻结"反而有害？

预训练的 Embedding 在判别式训练中会被大量负样本的梯度"冲刷"
失去了预训练阶段通过密集生成式信号学到的高质量表示
相当于预训练的效果被"遗忘"了

为什么"冻结"如此有效？

保护了预训练 Embedding 的质量不被稀疏标签破坏
大幅减少了可训练参数量（Embedding 表通常占总参数量的 90%+）
使模型能进行多轮次训练（Multi-epoch） 而不过拟合
将优化重心聚焦于稠密的 Transformer 参数

graph LR A["Stage1: 行为序列"] --> B["Stage1: Transformer Decoder"] --> C["Stage1: Next-Item Prediction"] C -->|"密集信号"| D["Stage1: 预训练 Embedding"] D -->|"复制 + 冻结 ❄️"| G F["Stage2: 请求样本 ⟨H,U,C⟩"] --> G["Stage2: Token化 🔒"] G --> H["Stage2: SORT Transformer 🔥"] --> I["Stage2: FFN → CTR/CVR"] I --> R["转移+冻结: +2.81pt ✅"]

图 5：SORT 的生成式预训练与嵌入冻结策略。 第一阶段通过 next-item prediction 任务预训练物品 Embedding 表，利用 Sampled Softmax 提供的密集训练信号充分学习每个物品的表示。第二阶段将预训练好的 Embedding 表迁移到排序模型中并冻结，只训练 Transformer 的稠密参数。消融实验表明，仅转移不冻结反而导致性能下降 0.13pt（预训练效果被稀疏标签"冲刷"），而转移加冻结策略带来了高达 2.81pt 的 CTR-AUC 提升。冻结策略的成功本质上是将"稀疏特征学习"和"稠密特征交叉"解耦为两个独立的优化目标，各自用最合适的任务和训练方式来学习。

3.8 排序头与损失函数

SORT 的最终预测通过以下方式完成：

提取候选 Token 的隐层输出：取 Transformer 最后一层中每个候选 Token 对应的隐状态向量
排序头 FFN：一个两层的前馈网络
- 隐藏层 + ReLU 激活
- 输出层 + Sigmoid 激活
多目标预测：同时预估多个目标
- 点击率（CTR）
- 加购率（Add-to-Cart Rate）
- 购买率（CVR）
损失函数：加权二值交叉熵（Weighted Binary Cross-Entropy）

$$\mathcal{L} = \sum_{t \in \{\text{click, cart, purchase}\}} w_t \cdot \text{BCE}(\hat{y}_t, y_t)$$

4. 系统优化：从算法到工程的全链路

一个好的模型设计如果不能在工程上高效实现，就无法在工业场景中落地。SORT 在训练和推理两端都进行了深度优化。

4.1 训练系统优化

MFU 从 13% 到 22% 的飞跃

MFU（Model FLOPs Utilization） 衡量的是模型训练时对硬件计算能力的实际利用率。SORT 将 MFU 从 13% 提升到 22%，主要通过以下手段：

（1）稀疏模块优化：多进程组通信（MPGC）

推荐模型的 Embedding 表分布在多个 GPU 上，每次前向传播都需要大量的跨 GPU 通信。SORT 开发了 MPGC（Multi-Process Group Communication） 机制：

动态调度多个特征 Embedding 的跨进程组通信
将通信与计算流水线化，隐藏通信延迟
不同特征组的通信可以并行执行

（2）稠密模块优化：高效稀疏注意力算子

SORT 开发了通用的稀疏注意力 GPU 算子：

采用分块计算（Tiled Computation）
掩码预加载与验证：跳过完全被掩码的块，避免无效计算
结合混合精度训练（BF16） 和梯度累积
优化内存访问模式，提升 GPU 利用率

训练优化效果汇总

优化手段	提升
MPGC 通信优化	通信延迟隐藏
稀疏注意力算子	注意力计算效率↑
混合精度训练	内存占用↓，计算速度↑
梯度累积	大 batch size 支持
综合 MFU	13% → 22%（+69%）

4.2 推理系统优化

从动态图到静态图

SORT 使用 torch.export 和 AOTInductor 将 PyTorch 的动态计算图转换为静态图，获得编译器级别的优化。

核心推理优化

（1）稀疏掩码注意力核（Sparse Masked Attention Kernel）

针对 SORT 的稀疏注意力模式，开发了高性能的 GPU 推理核：

吞吐量提升 +16.7%
延迟降低 -24.4%

（2）算子融合（Operator Fusion）

合并自注意力中的多个线性层计算：

将 Q/K/V 的投影融合为单次矩阵乘法
吞吐量提升 +10.9%
延迟降低 -6.3%

（3）通用优化

半精度推理（FP16/BF16）：在不损失精度的前提下加速计算
KV Cache：缓存历史 Token 的 Key 和 Value，避免重复计算
多上下文多流执行（Multi-Context Multi-Stream）：充分利用 GPU 的并行能力

推理优化效果汇总

优化手段	吞吐量提升	延迟降低
稀疏注意力核	+16.7%	-24.4%
算子融合	+10.9%	-6.3%
通用优化	—	—
综合效果	+29.4%	-29.3%

5. 实验分析

5.1 离线实验

基准模型对比

SORT 与多个基准模型在相同数据集上进行了公平对比：

模型	规模	FLOPs	CTR-AUC 差异（vs Std Trans）	说明
Standard Transformer	Base	43G	基线	标准因果 Transformer
HSTU	Base	—	-0.18pt	Meta 的层级化序列转导
OneTrans	Base	—	+0.20pt	Transformer 排序方案
SORT（Base）	Base	24G	+0.41pt	FLOPs 仅为标准的 56%
Standard Transformer	Large	322G	基线	大规模标准 Transformer
SORT（Large 144M）	Large	188G	+0.51pt	FLOPs 仅为标准的 58%

关键发现：

在 Base 规模下，SORT 以仅 56% 的 FLOPs（24G vs 43G） 超越标准 Transformer 0.41pt
相比 HSTU 和 OneTrans，SORT 分别领先 0.59pt（0.41-(-0.18)）和 0.21pt（0.41-0.20）
扩展到 Large 规模（144M 参数）后，SORT 以 58% 的 FLOPs（188G vs 322G）领先标准 Transformer 0.51pt，验证了可扩展性

各组件贡献（消融实验）

技术组件	CTR-AUC 增益	说明
特殊 Token（BOS + SEP）	+0.33pt	注意力汇聚，稳定注意力分布
查询裁剪（Query Pruning）	+0.26pt	计算减半，引入时间衰减偏置
门控注意力（Attention Gate）	+0.21pt	自适应调节注意力头贡献
DeepSeek MoE	+0.19pt	扩大容量，不增计算
QKNorm	+0.12pt	稳定大规模训练
局部注意力（Local Attention）	+0.10pt	线性复杂度 + 隐式正则化
所有技术叠加	> 各项之和	协同效应显著

值得注意的是，各项技术叠加后产生了显著的协同效应——综合提升大于各项单独贡献之和。这说明这些优化并非孤立存在，而是在不同维度上互相增强：例如，局部注意力减少了注意力范围中的噪声，使得特殊 Token 的汇聚效果更加聚焦；查询裁剪与 MoE 的组合则在保持低计算量的同时维持了高模型容量。

可扩展性分析

SORT 在三个维度上验证了可扩展性：

扩展维度	方式	效果	有效性排序
数据扩展	增加训练轮次（Multi-epoch）	最显著提升	🥇 最有效
序列长度	256 → 4096	持续提升	🥈 次有效
模型规模	增加参数量	稳定提升	🥉 第三

数据扩展最为有效这一发现值得注意——得益于冻结 Embedding 策略，SORT 可以进行多轮次训练而不过拟合，这在传统排序模型中是难以实现的。

特征工程兼容性

SORT 并非要取代特征工程，而是与其互补：

特征集	CTR-AUC 增益	说明
基础特征（ID + 属性）	基线	—
+ 多模态特征	+0.36%	图像、文本等
+ 用户-物品交叉特征	+1.03%	最显著提升
全特征集	CTR +1.27%, CVR +1.74%	综合提升

用户-物品交叉特征带来了最显著的提升，说明 Transformer 的注意力机制虽然擅长自动学习特征交互，但精心设计的交叉特征仍然能提供额外的先验知识。

5.2 在线 A/B 测试

SORT 在 AliExpress 的三个核心场景进行了为期一个月的在线 A/B 测试：

总体业务指标

指标	平均提升
订单数	+6.35%
买家数	+5.97%
GMV（成交总额）	+5.47%
推理延迟	-44.67%
推理吞吐量	+121.33%

分场景详细结果

场景	订单数	买家数	GMV	延迟	吞吐量
首页（Homepage）	+4.13%	+4.26%	+6.60%	-58%	+36%
购物车（Cart）	+3.50%	+3.75%	+3.69%	-37%	+169%
支付后（Post-Pay）	+11.43%	+9.91%	+6.12%	-39%	+159%

关键观察：

支付后场景订单提升最显著（+11.43%）：可能因为该场景的用户购买意向已经明确，SORT 的精准排序能力带来更大的边际收益
首页场景延迟优化最佳（-58%）：首页是流量最大的入口，延迟优化带来的用户体验提升尤为关键
系统效率全面提升：平均延迟下降 44.67%、吞吐量提升 121.33%，不仅是模型效果更好，而且更快更省资源

6. 方法论对比：SORT vs 同期方案

6.1 多维度对比表

对比维度	SORT	HSTU (Meta)	OneTrans	标准 Transformer
目标场景	排序（Ranking）	召回 + 排序	排序	通用
样本组织	请求中心	序列化	—	独立样本
注意力机制	局部稀疏 + 查询裁剪	门控注意力（无 MLP）	标准因果	标准因果
位置编码	RoPE + 对角掩码	相对偏差	—	绝对/相对
FFN 设计	DeepSeek MoE（1/8 稀疏）	无独立 FFN	标准 FFN	标准 FFN
预训练策略	生成式预训练 + 嵌入冻结	—	—	—
训练稳定性	QKNorm + 门控	门控	—	无特殊处理
序列长度	256-4K（局部注意力）	超长序列	中等	受限于 O(L²)
工业验证	AliExpress 全场景	Meta 内部	有限	—

6.2 SORT 的优势

系统性优化：不是单点突破，而是从分词、注意力、FFN、预训练到系统工程的全链路优化
工程友好：DeepSeek MoE 无需调辅助损失、查询裁剪实现简单、推理优化降低部署成本
效率突出：以 58% 的 FLOPs 超越标准 Transformer，推理延迟降低 44.67%
可扩展性强：在数据、模型、序列长度三个维度上均展现持续提升
特征兼容：不排斥传统特征工程，与交叉特征、多模态特征互补
业务收益显著：在线 A/B 测试订单 +6.35%，GMV +5.47%

6.3 SORT 的潜在不足

两阶段训练流程：生成式预训练 + 判别式训练增加了训练管线的复杂度
预训练依赖：如果物品分布频繁变化，预训练 Embedding 的时效性可能成为问题
冻结策略的刚性：完全冻结 Embedding 可能无法适应动态变化的物品语义
MoE 的工程挑战：稀疏 MoE 在分布式训练和推理中的负载均衡仍需关注
场景泛化性：目前仅在电商场景验证，在视频、社交等推荐场景的效果有待检验
冷启动问题：新物品没有预训练 Embedding，冷启动场景的处理方式论文未详细讨论

6.4 HSTU 的优势与不足

作为 SORT 最重要的对比方法，HSTU 值得单独分析：

HSTU 的优势：

架构极简：完全移除 MLP 层，将注意力与前馈融合为单一操作，减少了超参数调优空间
超长序列支持：针对推荐场景的极长用户行为序列（$10^5$ 量级）进行了专门优化，在长序列场景下有天然优势
万亿参数验证：首次在推荐系统中验证了 Scaling Law 的存在，为后续工作（包括 SORT）奠定了理论基础

HSTU 的不足：

排序场景适配不足：HSTU 最初为召回/检索设计，在排序场景中直接应用效果不如 SORT（-0.59pt CTR-AUC）
模型容量受限：移除 MLP 后，模型的非线性变换能力下降，难以通过 MoE 等方式灵活扩展容量
缺乏预训练策略：没有针对稀疏特征过拟合提出系统性的预训练和冻结方案，限制了在高特征稀疏场景下的表现

6.5 HSTU vs SORT 的设计哲学对比

HSTU 和 SORT 是目前工业级 Transformer 推荐模型的两个代表性工作，它们的设计哲学有明显差异：

设计哲学	HSTU	SORT
核心理念	极简主义——去掉 MLP，融合注意力与前馈	系统优化——保留标准组件但逐一优化
MLP 处理	完全移除，用门控融合替代	保留并升级为 MoE
复杂度控制	通过简化架构降低 FLOPs	通过稀疏注意力 + 查询裁剪
过拟合应对	主要通过架构简化	生成式预训练 + 嵌入冻结
落地路径	需要深度定制	更接近标准 Transformer，迁移成本低

7. 深入讨论

7.1 为什么局部注意力比全局注意力更好？

这是论文中最反直觉的发现之一——按直觉，“看到更多信息"应该总是更好的，但实验结果表明窗口大小 256 的局部注意力甚至超越了完整的全局因果注意力。我们从多个角度深入分析这一现象：

推荐场景的时间局部性：与自然语言不同，推荐场景中的用户行为序列具有强烈的时间衰减特性。用户一周前浏览的商品类别可能与当前兴趣完全无关。全局注意力会将有限的注意力容量"浪费"在这些过时的信息上，而局部注意力强制模型聚焦于最相关的近期行为
隐式正则化与过拟合缓解：在高特征稀疏性的推荐场景中，全局注意力提供了更大的参数自由度，但这反而加剧了过拟合风险。局部注意力通过限制感受野，引入了一种结构化的正则化约束——它减少了模型可以"记忆"的训练样本模式，迫使模型学习更泛化的特征
梯度质量与优化效率：全局注意力中，远距离 Token 对的梯度信号通常较弱且噪声较大（因为远距离行为的相关性本身就低）。这些低质量梯度会干扰有效的参数更新。局部注意力过滤掉了这些噪声梯度源，使每次参数更新都更加精准
与查询裁剪的层级协同：局部注意力在"水平方向"限制了每层的感受野，查询裁剪在"垂直方向”（跨层）逐步收缩活跃的 Token 数量。两者共同构成了一个"由近到远、由多到少"的层级化信息访问模式，这与推荐系统中"近期行为重要性递减"的直觉完美契合
计算效率的连锁效应：局部注意力将复杂度降至线性后，省下的计算资源可以用于增加模型层数或训练更多轮次，间接提升了模型性能

7.2 冻结 Embedding 的理论解释

冻结策略的成功可以从优化景观（Optimization Landscape） 的角度理解：

参数空间解耦：将"学习物品表示"和"学习排序决策"解耦为两个独立的优化问题
降维效果：冻结 Embedding 后，可训练参数量大幅减少（通常减少 90%+），优化景观变得更加平滑
正则化效果：冻结相当于一种极强的正则化——强制模型在预训练给定的特征空间中学习排序

7.3 MoE 在推荐排序中的前景

SORT 首次在工业级排序模型中成功应用了 MoE，这为推荐系统的模型设计打开了新的方向：

容量扩展：MoE 允许在固定计算预算下大幅扩展模型参数量
专业化分工：不同专家可以自然地学习处理不同类型的用户行为或物品类别
与推荐场景的天然契合：推荐数据的异构性（多种行为类型、多种物品类别）天然适合专家路由机制

8. 总结与展望

8.1 核心贡献总结

SORT 的核心贡献可以归纳为以下几点：

问题诊断：系统性地识别了 Transformer 应用于工业级排序的核心矛盾——高特征稀疏性与低标签密度
架构创新：提出了一套互补的优化方案（请求中心组织、稀疏注意力、查询裁剪、MoE FFN、生成式预训练+冻结），形成有机整体
系统工程：从训练端（MFU 13%→22%）到推理端（延迟 -44.67%，吞吐量 +121.33%）的全链路优化
业务验证：在 AliExpress 多场景 A/B 测试中取得订单 +6.35%、GMV +5.47% 的显著收益

8.2 对行业的启示

SORT 的成功给推荐系统领域带来了几个重要启示：

统一架构是可行的：不需要为每个特征交互方式设计专用模块，Transformer 的注意力机制可以自动学习
预训练是关键：生成式预训练 + 冻结策略为解决推荐模型的过拟合提供了一条可行路径
系统优化与算法创新同等重要：好的算法如果不能高效部署，就无法产生业务价值
特征工程仍有价值：Transformer 并非完全取代特征工程，而是与之互补

8.3 未来展望

基于 SORT 的工作，推荐排序 Transformer 的未来发展方向可能包括：

统一召回与排序：用同一个 Transformer 模型同时处理召回和排序，进一步简化系统架构
在线学习与预训练的融合：探索如何在不断变化的数据流中持续更新预训练 Embedding
更高效的 MoE 方案：探索更细粒度的专家路由策略，进一步提升模型容量与计算效率的比值
跨场景迁移：将 SORT 的框架迁移到视频推荐、社交推荐等其他场景
多模态融合：更深层次地融合文本、图像、视频等多模态物品特征

参考文献

SORT: A Systematically Optimized Ranking Transformer for Industrial-scale Recommenders.
Actions Speak Louder than Words: Trillion-Parameter Sequential Transducers for Generative Recommendations (HSTU).
Scaling Transformers for Discriminative Recommendation via Generative Pretraining (GPSD).
DeepSeek-V2: A Strong, Economical, and Efficient Mixture-of-Experts Language Model.
RoFormer: Enhanced Transformer with Rotary Position Embedding (RoPE).

美团推荐大模型 MTFM (Meituan Foundation Model) 深度硬核解析：跨场景推荐的终极答案？

Wed, 25 Mar 2026 20:00:00 +0800

1. 导言：推荐系统的“大模型”时代与多场景之痛

在过去几年里，大语言模型（Large Language Models, LLMs）的飞速发展，彻底重塑了人工智能的版图。从单模态的文本生成到多模态的图文视频理解，基座模型（Foundation Models, FMs）以其统一的架构和惊人的“涌现能力”（Emergent Abilities），证明了 Scaling Laws（缩放定律）的伟大力量。而在推荐系统（Recommender Systems, RecSys）领域，工业界也逐渐开始验证 Scaling Laws，尝试通过增加模型参数量和训练数据量来打破业务指标的天花板。

然而，传统的推荐系统往往被局限在“单一场景”（Single-scenario）的孤岛中。例如，在外卖平台中，“美食推荐”、“商家推荐”、“神抢手（券包推荐）”等场景各自拥有独立的模型和特征体系。这种孤岛模式严重限制了推荐模型吸收全局数据的能力，使得 Scaling Laws 的潜力难以被完全释放。受到多模态大模型的启发，美团的技术团队提出：推荐大模型的下一个突破口，在于跨越场景的异构性，建立一个统一的、无需严格对齐的底层基础模型。

这便是本文要深度剖析的主角——发表于 2025 年的重磅工业级论文 《MTFM: A Scalable and Alignment-free Foundation Model for Industrial Recommendation in Meituan》。

这篇论文不仅仅是一个模型结构的创新，它更是一整套从数据组织、网络架构到系统算子级优化的“全栈式”工业级解决方案。为了让你彻底读懂这篇论文，本文将以超过两万字的篇幅，从最基础的背景出发，一层一层地剥开 MTFM 的技术内核，带你领略美团在推荐大模型领域的顶级工程与算法实践。

1.1 推荐大模型必须具备的三个核心属性

在探讨 MTFM 之前，我们需要先思考一个问题：一个真正意义上的“推荐基础模型”（Recommendation Foundation Model），到底应该长什么样？美团的团队在论文中给出了三个核心定义：

可扩展性（Scalability）：模型必须能够随着参数量和数据量的增加，带来稳定、可预测的性能提升。这要求模型摒弃过去那种基于专家经验手工设计的复杂特征交叉结构（如 DCN、DeepFM 等），转而采用类似 Transformer 的深度自注意力机制，让模型自己去学习普适的行为规律。
可延展性（Extensibility）：模型必须能够无缝地适应任意数量的现有场景，或者以极低的成本接入未来的新场景。这意味着模型不能依赖于固定的特征输入模板，必须能够处理不同场景下高度异构的特征空间。
高效性（Efficiency）：工业级推荐系统每天需要处理数百亿次的请求和海量的曝光日志。框架必须在训练和推理阶段都保持极低的计算开销，否则庞大的算力成本将使得模型在现实中根本无法落地。

1.2 传统多场景推荐（MSR）模型的困境

在 MTFM 出现之前，工业界处理多场景推荐（Multi-Scenario Recommendation, MSR）主要遵循一种 “先对齐，后分解”（Harmonize-then-decompose） 的范式。

经典的代表作包括阿里的 STAR（Star Topology Adaptive Recommender）、M3OE 等。这些模型通常的做法是：

在数据端：将多个场景的数据强行拼接到一起，使用一个固定的特征模板（Fixed Template）。如果某个场景缺少某些特征（例如商家推荐场景没有菜品口味标签），就用 Padding（如零值或默认值）来填充；如果某些异构特征无法对齐，干脆直接丢弃。
在模型端：通过 MoE（Mixture of Experts）或星型拓扑结构，将模型参数解耦为“领域无关”（Domain-invariant）的共享参数和“领域特定”（Domain-specific）的独有参数。

然而，这种范式在面对真实的超级工业生态时，暴露出三大致命弱点：

延展性的僵局（Rigidity in Extensibility）：在美团这样的超级平台上，不同场景的特征模式（Feature Schemas）差异极大。强迫成百上千的异构特征去适配一个固定的模板，不仅容易出错，而且会导致严重的信息丢失。大量的 Padding 操作不仅浪费了存储，还引入了噪音。
架构缺乏可扩展性（Lack of Architectural Scalability）：无论是 STAR 还是各类复杂的 MoE 结构，本质上仍然是基于专家启发式规则（Expert Heuristics）手工打造的“定制化”网络。这种高度定制化的网络结构，很难像纯粹的 Transformer 那样，享受到简单堆叠层数带来的 Scaling Laws 红利。
高昂的计算成本（Prohibitive Computational Costs）：在传统范式下，训练成本随着数据量的增加呈线性甚至超线性增长。将海量的多场景数据简单粗暴地融合在一起训练，会导致算力开销呈指数级爆炸，在经济上完全不可行。

面对这些痛点，MTFM 给出的答案是：抛弃对齐（Alignment-free），万物皆 Token（Heterogeneous Tokenization），并引入混合目标注意力机制（Hybrid Target Attention）和极致的系统级优化。

2. 核心思想与方法论：摒弃“对齐”，拥抱“异构”

在自然语言处理领域，无论是英文、中文还是代码，都可以通过 Tokenizer（如 BPE、TikToken）统一转化为 Token 序列。MTFM 敏锐地捕捉到了这一点，将其引入到推荐系统中，提出了 异构 Token 化（Heterogeneous Tokenization） 的概念。

2.1 从特征模板到异构 Token 序列

在传统的深度学习推荐模型（DLRM）中，输入通常是一个超大的稀疏向量或稠密 Embedding 的拼接： [User_Emb, Item_Emb, Context_Emb, Cross_Emb, ...]

这种结构要求每一条样本都必须具有相同的维度和特征组合。而在 MTFM 中，输入不再是一个固定长度的向量，而是一个 变长的异构 Token 序列（Variable-length Sequence of Heterogeneous Tokens）。

具体来说，MTFM 将推荐系统中的所有特征抽象为三类核心 Token：

H-token (Historical tokens)：代表用户的长期历史交互行为序列。
R-token (Real-time tokens)：代表用户近期的、实时的跨场景交互行为序列。
T-token (Target tokens)：代表当前正在被请求或曝光的目标候选项（Candidate Items）及其对应的上下文和交叉特征。

2.1.1 H-token 与 R-token 的生成

以用户的历史行为序列 $\{H_i\}$ 为例。序列中的每一个交互商品（Item） $h_{ij}$ 都对应一个 H-token。由于不同历史序列中包含的特征维度可能不同，MTFM 为不同的历史序列分配了不同的 MLP（多层感知机）作为专属的 Tokenizer。

将原始特征经过 Embedding 层映射后，通过对应的 MLP 投影到一个统一的维度 $d_{model}$：

$$ \mathbf{h}_{ij} = \text{MLP}_i(\text{Emb}(h_{ij})) $$

随后，MTFM 将所有历史序列中的 Item Token 按照时间戳（Chronological order）进行排序，形成一个统一的 Embedding 矩阵：

$$ \mathbf{H} \in \mathbb{R}^{L_H \times d_{model}} $$

其中 $L_H$ 是所有历史序列中 Item 的总数。

同理，用户的实时序列特征也被转化为 R-token 矩阵：

$$ \mathbf{R} \in \mathbb{R}^{L_R \times d_{model}} $$

2.1.2 T-token 的生成

对于当前曝光的候选目标，MTFM 将用户画像特征（User Profile, $U^s$）、场景特定的交叉特征（Cross Features, $C_i^s$）以及目标物品特征（Item Features, $I_i^s$）进行拼接，并通过该场景特定的 MLP 进行降维投影：

$$ \mathbf{t}_i^s = \text{MLP}_s(\text{Emb}(U^s) \| \text{Emb}(C_i^s) \| \text{Emb}(I_i^s)) $$

这里 $\|$ 表示列拼接（Column concatenation）。所有场景下的曝光行为最终被转化为 T-token 矩阵：

$$ \mathbf{T} \in \mathbb{R}^{L_T \times d_{model}} $$

其中 $L_T$ 是所有场景下曝光样本的总数。

2.1.3 统一序列表示

最终，所有的 H-token、R-token 和 T-token 会在行方向（Row concatenation）上进行拼接，形成输入到 Transformer 骨干网络的初始 Embedding 矩阵：

$$ \mathbf{X}^{(0)} = (\mathbf{H}; \mathbf{R}; \mathbf{T}) \in \mathbb{R}^{N \times d_{model}} $$

这里的 $N = L_H + L_R + L_T$，即序列的总长度。对于不同的用户，这个 $N$ 是可变的（Variable-length）。

【深度思考：异构 Token 化的绝妙之处】 这种设计彻底打破了传统 DLRM 对特征维度的强绑定。因为所有特征最终都被映射到了统一的 $d_{model}$ 维度，Transformer 内部的注意力机制根本不需要知道某个 Token 是来自外卖场景还是单车场景，它只需要计算 Token 之间的相关性（Attention Score）。这种“Alignment-free”的特性，使得 MTFM 可以极其轻松地接入任何新的业务场景——只需要为新场景训练一个极小的 $\text{MLP}_s$ 作为 Tokenizer 即可，骨干网络的参数无需做任何结构性修改。

3. 数据组织革命：User-level 多场景样本聚合

理解了 Token 化之后，我们面临下一个严峻挑战：计算复杂度。如果按照传统的“曝光级别”（Impression-level）进行训练，即每一次曝光（一个 User 对应一个 Item）作为一条独立样本，那么对于同一个用户，他极其冗长的历史行为序列（H-token）和实时序列（R-token）会在成百上千条样本中被重复计算。

在标准的 Transformer 中，自注意力机制的时间复杂度是 $O(N^2 \cdot d)$。如果序列长度 $N$ 达到几千，这种重复计算将带来毁灭性的算力浪费。

3.1 继承与超越：从 MTGR 到多场景聚合

为了解决这个问题，MTFM 继承了美团此前在 MTGR（Multi-Task Generative Recommendation）论文中提出的 用户级（User-level）样本聚合 技术，并将其突破性地扩展到了多场景（Multi-scenario）环境。

在离线训练阶段，MTFM 将某个特定时间窗口内，同一个用户在所有业务场景下的所有曝光行为，全部聚合为一条“超级样本”。

具体来说，每个用户 $u$ 对应一条包含海量信息的训练样本 $\mathbb{D}_u = (X_u, Y_u)$。输入特征集 $X$ 可以表示为：

$$ X = [ \{H_i\}_{i=1}^{N_H}, \{R_i\}_{i=1}^{N_R}, \{U^s\}_{s=1}^{N_S}, \{\{C_i^s, I_i^s\}_{i=1}^{N_E^s}\}_{s=1}^{N_S} ] $$

标签集 $Y$ 表示为：

$$ Y = \{\{Y_i^s\}_{i=1}^{N_E^s}\}_{s=1}^{N_S} $$

参数解释：

$N_S$：业务场景的总数。
$N_E^s$：在场景 $s$ 下的曝光总数。
$H_i, R_i$：跨场景共享的历史和实时序列。
$U^s, C_i^s, I_i^s$：场景 $s$ 特有的用户画像、交叉特征和物品特征。

3.2 共享与独立：解耦特征处理管线

由于不同场景的特征模式存在本质上的不兼容（例如外卖场景的标签和打车场景的标签完全不同），MTFM 在数据流水线（Data Pipeline）上做出了精妙的设计：

场景独立聚合：对于场景特定的特征（$U, C, I$），首先在各个场景内部按照 User-level 进行聚合。
跨场景拼接：将聚合后的各场景特征按照列方向（Column-wise）拼接，形成一个统一的候选目标表征。
全局特征合并：最后，将全场景共享的特征（用户的生命周期历史序列 $H$ 和实时序列 $R$）与上述拼接结果在 User-level 进行合并。

graph TD U1[外卖 User特征] & C1[外卖交叉特征] & I1[外卖 Item特征] --> Agg1[外卖场景聚合] U2[优选 User特征] & C2[优选交叉特征] & I2[优选 Item特征] --> Agg2[优选场景聚合] Agg1 & Agg2 --> Concat[T-token 拼接] H[H-token 长序列] & R[R-token 实时序列] & Concat --> Merge[超级样本构建] Merge --> MTFM[MTFM 模型]

这种设计彻底避免了数据 Pipeline 中的重复计算和冗余存储。在推理阶段（Online Inference），由于各个场景是独立发起请求的，每个场景只需要部署 MTFM 中与自己相关的 子图（Subgraph）。推理请求在 Request-level 进行聚合，子图会自动绕过其他场景专属的 MLP Tokenizer，从而实现极高的推理效率。

4. 网络架构深度剖析：混合目标注意力机制 (HTA)

如果说异构 Token 化和 User-level 聚合是 MTFM 的数据地基，那么 混合目标注意力机制（Hybrid Target Attention, HTA） 则是其架构上的王冠。

将推荐系统转化为 Transformer 的序列建模任务后，面临的最大梦魇就是 $O(N^2)$ 的复杂度。虽然 User-level 聚合消除了冗余计算，但把所有场景的曝光候选物品（T-token）和超长历史序列（H/R-token）拼在一起，序列长度 $N$ 极容易突破数千甚至上万。

为了平衡模型的表达能力（Efficacy）和计算效率（Efficiency），MTFM 借鉴了 LLM 领域的稀疏注意力思想，提出了一种由 全注意力层（Full Attention Layer） 和 目标注意力层（Target Attention Layer） 交替堆叠的混合架构。

4.1 全注意力层 (Full Attention Layer) 与动态掩码

在模型由 $B$ 个堆叠的 Block 组成，为了缓解二次复杂度瓶颈，每个 Block 会包含 1 个全注意力层，以及随后紧跟的 $K$ 个目标注意力层。

在全注意力层中，模型计算所有 Token 之间的全局依赖关系。为了进一步降低显存和计算开销，MTFM 采用了 分组查询注意力（Grouped-Query Attention, GQA）。GQA 相比于 Multi-Head Attention (MHA)，多个 Query 共享一组 Key 和 Value，在保持模型效果几乎不变的前提下，大幅减少了 KV Cache 的显存占用。

全注意力层的数学表达如下：

线性映射与分组切分：
$$ \mathbf{U}^{(l)}, \{\mathbf{Q}^{(l,h)}\}_{h=1}^{H}, \{\mathbf{K}^{(l,g)}, \mathbf{V}^{(l,g)} \}_{g=1}^G = \text{Split}(\phi_1(f_1^{(l)}(\widetilde{\mathbf{X}}^{(l)}))) $$
其中 $H$ 是 Query 的头数，$G$ 是 KV 的头数，$r = H/G$。
注意力计算与动态掩码（Dynamic Masking）：
$$ \mathbf{A}^{(l,h)} = \phi_2(\mathbf{Q}^{(l,h)} \mathbf{K}^{(l,g)T} \odot \mathbf{M}) \mathbf{V}^{(l,g)} $$

$$ \mathbf{A}^{(l)} = \mathbf{A}^{(l,1)} \| \cdots \| \mathbf{A}^{(l,H)} $$
门控层归一化与残差连接：
$$ \mathbf{X}^{(l+1)} = f_2^{(l)}(\text{GLN}(\mathbf{A}^{(l)}) \odot \mathbf{U}^{(l)}) + \mathbf{X}^{(l)} $$

4.1.1 防止信息泄露的动态掩码 $\mathbf{M}$

在 User-level 聚合中，由于实时序列 $R$ 和当前曝光目标 $T$ 在时间上可能存在重叠，如果不加以限制，模型在预测时就会“看到未来”的数据，导致严重的信息泄露（Information Leakage）。

为此，MTFM 根据时间戳构建了极其严格的动态掩码矩阵 $\mathbf{M}$：

H-tokens 视野：H-token 对所有后续 Token 可见，因为它们代表最基础的历史偏好。
R-tokens 视野：R-token 遵循严格的因果掩码（Causal Mask），只能被时间戳晚于自己的 Token 看到。
T-tokens 视野：T-token 之间互相不可见（因为在一次曝光请求中，各个候选 Item 应该是平行的），T-token 只能看到自己以及时间戳早于它的 H 和 R。

4.2 目标注意力层 (Target Attention Layer)：极致降本的核心

全注意力层虽然强大，但每一层都做 $O(N^2)$ 的计算实在是太奢侈了。在推荐系统的预测任务中，我们真正关心的是 最终目标（T-tokens） 的表达，历史序列（H/R-tokens）的作用主要是作为 Context 辅助 T-token 的表征。

因此，MTFM 在全注意力层之后，级联了 $K$ 个 目标注意力层（Target Attention Layer）。

在 Target Attention Layer 中，模型只更新 T-token 的 Embedding，而 H-token 和 R-token 的 Embedding 直接通过 Shortcut（捷径）连接，原封不动地传递到下一层！

数学推导如下：

首先，从归一化的特征矩阵和掩码矩阵中，单独切分出 T-token 对应的部分：

$$ \widetilde{\mathbf{X}}^{(l)}_T = \widetilde{\mathbf{X}}^{(l)}[L_H+L_R:] $$$$ \mathbf{M}_T = \mathbf{M}[L_H+L_R:] $$

接下来，只用 T-token 去生成 Query $\mathbf{Q}_T$，而 Key $\mathbf{K}$ 和 Value $\mathbf{V}$ 依然由全局序列生成：

$$ \mathbf{U}^{(l)}_T, \{\mathbf{Q}^{(l,h)}_T\}_{h=1}^H = \text{Split}(\phi_1(f_{uq}^{(l)}(\widetilde{\mathbf{X}}_T^{(l)}))) $$$$ \{\mathbf{K}^{(l,g)}, \mathbf{V}^{(l,g)}\}_{g=1}^G = \text{Split}(\phi_1(f_{kv}^{(l)}(\widetilde{\mathbf{X}}^{(l)}))) $$

注意力计算只在 T-token 作为 Query 时发生：

$$ \mathbf{A}^{(l,h)}_T = \phi_2(\mathbf{Q}_T^{(l,h)} \mathbf{K}^{(l,g)T} \odot \mathbf{M}_T) \mathbf{V}^{(l,g)} $$$$ \mathbf{X}^{(l+1)}_T = f_2^{(l)}(\text{GLN}(\mathbf{A}_T^{(l)}) \odot \mathbf{U}_T^{(l)}) + \mathbf{X}_T^{(l)} $$

最后，将更新后的 T-token 与未更新的 H/R-token 重新拼接，输出给下一层：

$$ \mathbf{X}^{(l+1)} = (\mathbf{X}^{(l)}[:L_H+L_R]; \mathbf{X}^{(l+1)}_T) $$

【复杂度革命性降低】 在标准的 Transformer 中，一层的复杂度是 $O(N^2)$。在 Target Attention 中，因为 Query 的数量从 $N$ 骤降到了 $L_T$（通常 $L_T \ll N$），注意力矩阵的大小从 $N \times N$ 缩小到了 $L_T \times N$。因此，单个 Target Attention Layer 的复杂度降为 $O(N \cdot L_T)$。

结合 1 层 Full Attention 和 $K$ 层 Target Attention，一个 Block 的平均复杂度被大幅压缩至：

$$ O\left(\frac{K \cdot N \cdot L_T + N^2}{K+1}\right) $$

由于 $L_T$ 远远小于 $N$，这一设计让 MTFM 的训练吞吐量（Throughput）直接 翻倍（2x Speedup），且实验证明模型精度没有任何损失！

最后，最后一层输出的 T-tokens 会被送入一个 MMoE（Multi-gate Mixture-of-Experts）模块，用于计算多场景下不同目标（如 CTR、CTCVR 等）的最终预估分。

5. 挑战工程极限：系统级与算子级极致优化

学术界的论文往往止步于漂亮的公式，但工业界的落地必须面对冰冷的硬件指标。为了让 MTFM 在美团这种日均百亿请求级别的场景中真正跑起来，工程团队在系统底层进行了令人叹为观止的深度优化。

5.1 离线训练的“外科手术”

5.1.1 斩断 CPU-GPU 的流水线阻塞 (Pipeline Stall)

在 LLM 训练中，所有的文本 Tokenization 都可以在 GPU 上飞速完成，整个训练过程高度端到端。而在推荐系统中，特征工程极为繁重，大量的稀疏特征查找、拼接、聚合必须在 CPU 上进行。这就导致了 GPU 上计算极快的模型，常常需要停下来“干等” CPU 传输数据。这种 Host（CPU）与 Device（GPU）之间频繁的数据同步和串行依赖，形成了严重的 Pipeline Stall。

美团团队使用 CUDA Profiler 对框架进行了地毯式排查。优化策略主要有两点：

消除同步点 (Eliminate Synchronization Points)：通过精细的流水线编排，让 CPU 的特征处理与 GPU 的前向/反向传播时间互相掩盖（Overlap）。
优化 Device-to-Device (D2D) 拷贝：推荐模型中存在大量的张量索引赋值操作。原生的 PyTorch 会触发多次碎片的 D2D 显存拷贝。MTFM 将这些操作合并为单次原子操作（Single Atomic Operations）。这一套组合拳打下来，训练吞吐量硬生生提升了 20%。

5.1.2 为动态掩码量身定制 FlashAttention-2

FlashAttention-2 是 Transformer 时代的算力神兵，但它原生只针对标准的因果掩码（Causal Mask）进行了优化。面对 MTFM 中复杂的、针对 H/R/T token 各种定制的“动态非标准稀疏掩码”，FlashAttention-2 经常会因为内存访问不连续而导致效率暴跌。

为了解决这个问题，美团团队直接手撕底层 Kernel：

连续对齐内存布局：重新构造了掩码的内存布局，满足异步拷贝（Asynchronous Copy）的对齐要求。
共享内存极限压榨：在极其有限的 Shared Memory 中精细设计数据流。前向计算时缓存掩码块，反向传播时让掩码与中间梯度变量实现“分时复用”。通过将掩码加载延迟完全隐藏在计算流水线中，这一改动彻底释放了 GPU 算力。

5.1.3 Triton 算子融合 (Operator Fusion)

原生的 PyTorch 在计算 GLN（Group Layer Normalization）和构建动态掩码时，采用的是 Gather-Compute-Scatter 的碎片化模式。这会导致频繁的 Kernel Launch 开销和低效的全局内存读写。 MTFM 团队基于 OpenAI 的 Triton 框架，实现了 GLN 和动态掩码的算子融合。通过向量化内存访问（Vectorized Memory Access）提升带宽利用率，并设计了分组并行计算模式，进一步消除了中间结果的反复读写。 算子层面的优化，为 MTFM 带来了额外的 57% 吞吐量提升！

5.2 在线推理的“极限压榨”

训练阶段可以靠堆卡，但在线推理阶段每一毫秒的延迟都直接影响着用户体验和服务器成本。MTFM 的推理优化同样硬核：

5.2.1 安培架构 2:4 结构化稀疏 (Structured Sparsity)

MTFM 创新性地利用了 NVIDIA Ampere 架构 GPU 特有的 Sparse Tensor Cores。在 HSTU 组件的线性投影层（计算 U, V, Q, K 及 Output）中，团队实施了 2:4 结构化剪枝（2:4 Structured Pruning）。这意味着在每 4 个连续的权重参数中，强制将 2 个较小的值置为 0。配合专属的硬件指令，这不仅将显存占用直接压缩了 50%，还利用 Sparse Tensor Cores 达到了双倍的理论峰值矩阵乘法吞吐量！结果是：模型精度不降，吞吐量提升 10%，单次推理延迟下降 0.2ms。

5.2.2 细粒度注意力剪枝 (Fine-grained Attention Pruning)

动态掩码本质上是一种不规则稀疏矩阵。MTFM 在推理时设计了底层的计算跳过机制（Computation Skipping）。它不仅能动态剔除因为 Padding 产生的无效计算，还能结合具体的业务先验知识（比如：强制屏蔽 User 特征对 Target 特征的无效注意力权重），在底层 Kernel 计算前就将这些分支剪除，进一步提升了 5% 的吞吐。

5.2.3 场景感知子图部署与 M-Falcon

这是 MTFM 能在多场景落地的关键一环。虽然 MTFM 是一个包含所有场景知识的“巨无霸”大模型，但在实际部署到“外卖”或者“优选”的推理机器上时，系统会自动将完整的计算图拆解。剥离掉与当前场景无关的特征处理分支（Scenario-aware Deployment），消除冗余计算。同时，结合 BF16 半精度推理以及最新的 M-Falcon 智能微批处理（Micro-batching）算法（通过 KV-Cache 共享进一步压榨 GPU 利用率），MTFM 将在线系统的并发能力推向了极致。

6. 实验验证：震撼的业务收益

在纸面上吹得再天花乱坠，也不如真实的线上指标来得实在。MTFM 在美团的多个真实核心场景中进行了严苛的 Offline 和 Online 验证。

6.1 离线实验：全面碾压 Baseline

在离线评估中，MTFM 与业界顶级的多场景模型（如 STAR、M3OE 等）以及强大的单场景序列模型（如 HSTU、MTGR）进行了对比。

结果显示，MTFM 在多个场景（如 SQS 神抢手、PHF 拼好饭、FDS 美食推荐等）的多个任务（CTR、CTCVR）上取得了压倒性的胜利：

CTR 任务：平均 GAUC（Grouped Area Under the Curve）提升高达 0.36 pp（百分点），在部分场景最高提升达 0.76 pp。
CTCVR 任务：平均 GAUC 提升 0.29 pp，峰值提升 0.53 pp。

在推荐系统领域，千分之几的 GAUC 提升往往就能带来百万级的收入增长。0.36 pp 的平均提升，是一个堪称“跨代”的巨大突破。这证明了：让模型看到更多场景的异构数据，通过统一的大模型进行隐式知识迁移，远比在单场景下死磕模型结构要有效得多。

6.2 线上 A/B 测试：真金白银的业务增长

在线上真实流量的 A/B 测试中，MTFM 部署到了美团的“神抢手（SQS）”和“拼好饭（PHF）”等高流量场景。实验结果令人振奋：

神抢手（券包推荐）：订单量（Orders）飙升 +2.98%。
拼好饭（美食推荐）：订单量提升 +1.45%。

这种直接拉动核心交易指标的成果，充分证明了 MTFM 框架在工业界超大规模落地中的巨大商业价值。

7. 深度反思与未来展望：推荐系统终局之战

当我们深入读完这篇长达近万字的顶级工业论文，我们不得不惊叹于美团算法与工程团队的魄力与技术底蕴。MTFM 不仅仅是一篇论文，它是推荐系统发展史上的一个重要缩影。

7.1 从“领域定制”走向“通用智能”

过去十几年，推荐系统的发展史就是一部“特征交叉结构”的发明史。从 FM 到 DeepFM，从 DCN 到 xDeepFM，算法工程师们绞尽脑汁地设计各种网络来捕捉特征交互。在多场景领域，大家又在绞尽脑汁设计各种 MoE、MMoE、PLE 来隔离领域知识。

而 MTFM 告诉我们：大道至简。不要再去手工设计复杂的塔结构了，不要再去强行对齐那些根本不属于同一个维度的特征了。把一切都变成 Token，扔进基于 Transformer 的基础模型中，让注意力机制（Attention）去自动学习特征之间的相关性。只要你的数据足够多、参数量足够大（Scaling Laws），基础模型的泛化能力会碾压一切手工设计的启发式规则。

7.2 算法与工程的终极交响曲

MTFM 的成功，一半归功于算法的洞察，一半归功于工程的极致压榨。如果没有 User-level 的样本聚合，如果没有 Hybrid Target Attention 对复杂度的降维打击，如果没有 Triton 算子融合和 FlashAttention-2 的魔改，MTFM 根本不可能在成本敏感的工业界存活下来。这给我们留下了深刻的启示：未来的推荐大模型工程师，必须是“全栈”的。 你不仅要懂算法原理，还要懂 CUDA，懂 GPU 内存层级，懂 Triton 算子开发。算法的创新必须与底层硬件的特性深度绑定（Hardware-aware Co-design），才能爆发出真正的威力。

7.3 推荐系统的未来：DLRM 的终结？

随着 MTFM 这样基于纯 Transformer 骨干架构的基础模型在工业界大放异彩，我们不禁要问：传统的 DLRM 时代是否即将落幕？当特征表征、序列建模、跨场景知识迁移都可以被统一到一个“万物皆 Token”的基础大模型中时，推荐系统正在以肉眼可见的速度向 NLP 的大语言模型（LLM）靠拢。

或许在不久的将来，美团（甚至整个工业界）的推荐系统，将只剩下一个极其庞大的、不断 Scaling 的统一大模型。它吞噬着来自外卖、单车、优选、酒店等所有场景的数据，像一个无所不知的智慧大脑，为每一个用户提供最精准的个性化服务。

MTFM，无疑是通向这个终局目标的一座坚实桥梁。

(全文完)

8. 附录与深度扩展：从理论到代码的终极拆解

为了让对技术细节有极致追求的读者能够完全吃透 MTFM，我们在本节中增加更为底层的原理论证、伪代码实现以及与业界主流方案的硬核对比。这部分内容将深入到模型结构的神经末梢和 CUDA 算子的内存分配逻辑中。

8.1 伪代码实现：Hybrid Target Attention (HTA)

前文提到了全注意力层和目标注意力层的数学公式，这里我们将它们转化为更直观的 PyTorch 风格伪代码。这有助于理解 T-token 是如何在 Target Attention Layer 中被单独更新的，以及 Shortcut 的具体运作方式。

import torch
import torch.nn as nn
import torch.nn.functional as F

class MTFM_Block(nn.Module):
 def __init__(self, d_model, n_heads, num_target_layers=2):
 super().__init__()
 self.d_model = d_model
 self.num_target_layers = num_target_layers

 # 1层 Full Attention Layer (这里用标准的多头注意力替代 GQA 做演示)
 self.full_attn = MultiHeadAttention(d_model, n_heads)
 self.full_ffn = FeedForward(d_model)
 self.full_norm1 = nn.LayerNorm(d_model)
 self.full_norm2 = nn.LayerNorm(d_model)

 # K层 Target Attention Layers
 self.target_attns = nn.ModuleList([
 MultiHeadAttention(d_model, n_heads) for _ in range(num_target_layers)
 ])
 self.target_ffns = nn.ModuleList([
 FeedForward(d_model) for _ in range(num_target_layers)
 ])
 self.target_norm1s = nn.ModuleList([
 nn.LayerNorm(d_model) for _ in range(num_target_layers)
 ])
 self.target_norm2s = nn.ModuleList([
 nn.LayerNorm(d_model) for _ in range(num_target_layers)
 ])

 def forward(self, x, mask, L_H, L_R):
 """
 x: [Batch_size, N, d_model], N = L_H + L_R + L_T
 mask: [Batch_size, N, N] 动态掩码矩阵
 """
 # ==========================================
 # 1. Full Attention Layer
 # ==========================================
 residual = x
 x_norm = self.full_norm1(x)
 # 全局计算 Q, K, V
 attn_out = self.full_attn(query=x_norm, key=x_norm, value=x_norm, mask=mask)
 x = residual + attn_out

 residual = x
 x_norm = self.full_norm2(x)
 ffn_out = self.full_ffn(x_norm)
 x = residual + ffn_out

 # ==========================================
 # 2. Target Attention Layers
 # ==========================================
 # 找到 T-token 的起始位置
 context_len = L_H + L_R

 for i in range(self.num_target_layers):
 # 将 x 拆分为 Context (H, R) 和 Target (T)
 x_context = x[:, :context_len, :]
 x_target = x[:, context_len:, :]

 # 切分对应的 Mask
 # Target 只需要看自己和早于它的 Context，因此 mask 的维度是 [Batch_size, L_T, N]
 target_mask = mask[:, context_len:, :]

 residual_target = x_target

 # 对整个序列做 Norm 得到 Key 和 Value
 x_norm_full = self.target_norm1s[i](x)

 # 只对 Target 做 Norm 得到 Query
 q_target = x_norm_full[:, context_len:, :]
 k_full = x_norm_full
 v_full = x_norm_full

 # 注意力计算：Query 数量大幅减少，只有 L_T 个
 attn_out_target = self.target_attns[i](
 query=q_target,
 key=k_full,
 value=v_full,
 mask=target_mask
 )

 # 更新 Target
 x_target = residual_target + attn_out_target

 # FFN 更新 Target
 residual_target = x_target
 x_target_norm = self.target_norm2s[i](x_target)
 ffn_out_target = self.target_ffns[i](x_target_norm)
 x_target = residual_target + ffn_out_target

 # 将更新后的 Target 和未经修改的 Context 重新拼接，传给下一层！
 # 这是极其关键的一步，保证了 Context 表征的不变性与算力的极大节约
 x = torch.cat([x_context, x_target], dim=1)

 return x

通过这段伪代码可以非常清晰地看到，q_target 的维度是 [Batch_size, L_T, d_model]，而 k_full 的维度是 [Batch_size, N, d_model]。矩阵乘法 $Q \cdot K^T$ 的计算量直接从 $O(N \times N)$ 暴跌到了 $O(L_T \times N)$。在工业界推荐系统中，$L_H$ 和 $L_R$（历史行为）通常长达上千甚至数千，而 $L_T$（单次请求的曝光候选）可能只有几十到一两百。这种不对称性正是 Target Attention 能够实现“算力魔法”的物理基础。

8.2 动态掩码 (Dynamic Masking) 的拓扑结构解析

在 MTFM 中，掩码的设计绝非简单的因果下三角（Lower Triangular Causal Mask）。为了防范极其隐蔽的数据穿越（Information Leakage），掩码矩阵 $\mathbf{M}$ 的内部结构被精心雕琢。

假设我们有 3 个 H-token ($H_1, H_2, H_3$)，2 个 R-token ($R_1, R_2$)，以及 2 个 T-token ($T_1, T_2$)。整个序列 $X = [H_1, H_2, H_3, R_1, R_2, T_1, T_2]$。

其可见性矩阵 $\mathbf{M}$（1 表示可见，0 表示掩码屏蔽）如下所示：

Query \ Key	H1	H2	H3	R1	R2	T1	T2
H1	1	1	1	0	0	0	0
H2	1	1	1	0	0	0	0
H3	1	1	1	0	0	0	0
R1	1	1	1	1	0	0	0
R2	1	1	1	1	1	0	0
T1	1	1	1	1	1	1	0
T2	1	1	1	1	1	0	1

深度解析：

左上角 3x3 矩阵 (H 对 H)：全是 1。H-token 代表长期历史，它们彼此之间没有严格的因果遮蔽需求，采用双向可见（Bidirectional Visibility）以获得更丰富的表征。
中间 2x2 矩阵 (R 对 R)：是一个下三角矩阵。R-token 是近期的实时序列，必须严格遵循时间先后顺序（Causal Mask），防止未来的行为影响对过去状态的推断。
右下角 2x2 矩阵 (T 对 T)：是对角线矩阵。T-token 代表当前的多个候选曝光目标，在同一次打分请求中，它们是相互独立且平行的，绝对不能互相看到对方的特征。
左下角 (T 对 H, R)：全是 1。T-token 必须能够利用所有的历史和实时信息来辅助预测。
右上角 (H, R 对 T)：全是 0。这是为了防止标签泄露（Label Leakage）。如果历史状态能够看到当前的预测目标，模型就会发生作弊现象。

这种不规则的稀疏矩阵结构，正是导致标准 FlashAttention-2 性能下降的罪魁祸首，也是美团团队为什么必须手写 Triton Kernel 和魔改 FlashAttention 的根本原因。

8.3 工业界多场景推荐 (MSR) 模型演进编年史

为了更好地评估 MTFM 的历史地位，我们需要将其放置在整个多场景推荐模型的发展脉络中进行审视。

早期，由于算力限制，多场景推荐要么采用一个极其庞大的单一模型（Hard Sharing），底层 Embedding 完全共享，顶层用一个 MLP 强行拟合所有场景；要么就是每个场景维护一个完全独立的模型（Fully Independent）。

痛点：Hard Sharing 会导致跷跷板效应（Seesaw Effect），即大场景主导梯度，小场景效果极差；独立模型则无法利用全局数据，导致冷启动场景无法收敛。

阶段二：星型拓扑与 MoE 时代 (STAR, M3OE)

以阿里 STAR（2021）为代表的模型开启了参数解耦的时代。STAR 引入了一个共享的中心网络（Center Network）和每个场景特有的网络（Scenario-specific Networks），通过权重相乘或相加来融合。随后的 M3OE 将 Mixture-of-Experts 引入，设计了复杂的门控网络（Gating Networks）来决定当前样本应该分配给哪些专家（Experts）。

痛点：虽然缓解了跷跷板效应，但它们依然要求极度死板的特征对齐。如果场景 A 有 50 个特征，场景 B 有 80 个特征，工程师必须手工把它们对齐到相同的维度。这在特征维度动辄上万的工业界，简直是灾难。

阶段三：基于 Transformer 的单场景生成式框架 (HSTU, MTGR)

随着生成式推荐（Generative Recommendation）的兴起，阿里提出了 HSTU（2024），美团提出了 MTGR（2025）。它们开始将推荐系统视为序列转换任务，利用 Transformer 来捕捉行为序列中的深层模式。

痛点：这些模型主要还是在单场景下大杀四方，一旦扩展到多场景，巨长无比的序列会导致计算复杂度直接将集群撑爆。

阶段四：Foundation Model 时代 (MTFM)

MTFM（2025）集大成于一身。它既拥有 Transformer 的无限 Scaling 潜力，又通过异构 Token 化解决了多场景特征对齐的死穴，最后通过 User-level 聚合与 HTA 混合注意力机制，以近乎作弊的方式把时间复杂度给降了下来。

8.4 极致算子优化：Triton 与 FlashAttention 的魔法

我们再来深挖一下论文中提到的 Triton 算子融合 和 FlashAttention 魔改。

在 GPU 内存层级中，SRAM（Shared Memory）的速度极快，但容量极小（每块 SM 只有几十到一百多 KB）；HBM（Global Memory）容量大（如 A100 的 80GB），但速度极慢。

在原生 PyTorch 中，计算 GLN(Group Layer Normalization) 的流程如下：

从 HBM 读取张量 $X$ 到 SRAM。
计算均值和方差。
将均值和方差写回 HBM。
再次从 HBM 读取 $X$、均值、方差。
进行归一化计算，并乘以缩放参数。
最终写回 HBM。

在这个过程中，HBM 的读写（Memory Bound）占据了 90% 以上的时间，GPU 的计算核心（Compute Bound）反而闲得发慌。

MTFM 团队的 Triton 算子融合策略：使用 Triton 编写定制化 Kernel，将上述 6 步合并为 1 步。通过在 SRAM 中保留中间变量，避免了与 HBM 的反复通信。更绝的是，他们将 动态掩码的生成 也融合进了这个 Kernel 中。利用向量化加载（Vectorized Load，如 tl.load(pointer, block_size)）直接在寄存器层级完成掩码过滤。

对于 FlashAttention-2，原生版本为了追求极致性能，假定了掩码是极其规律的因果下三角。当遇到 MTFM 这种“左上角全 1、中间下三角、右下角对角线”的奇葩矩阵时，原生的块分片（Block Tiling）策略会失效。美团团队在修改 FlashAttention 源码时：

构造连续对齐掩码内存：将稀疏掩码在内存中重新排列（Memory Layout Reordering），保证每一次读取都是 128 bytes 连续对齐的，从而激活 GPU 的异步拷贝指令（cp.async）。
精细的数据流策略：在 Forward 阶段，将极其微小的掩码块缓存到 Shared Memory 中；在 Backward 阶段，让掩码矩阵与计算梯度的中间变量在时间维度上复用同一块 SRAM 地址（Temporal Multiplexing），硬生生把掩码加载的延迟给掩盖（Overlap）掉了。

这种级别的工程压榨，在推荐系统领域堪称教科书级别的典范。

8.5 总结与启示

MTFM 的横空出世，给所有依然在 DLRM 泥潭中挣扎的算法工程师敲响了警钟： 不要试图用人工的先验知识，去战胜机器的算力和海量数据。

在推荐系统中，我们花费了无数个日夜去寻找所谓的高价值特征交叉（如性别和价格的交叉、年龄和品类的交叉）。我们发明了 FM、FFM、DeepFM 等无数种结构来拟合这些交叉。但 MTFM 证明了，只要将它们转化为统一的 Token，通过 Transformer 的自注意力机制，模型能够自动在极高维度上完成更深邃、更泛化的特征交叉。

而在多场景领域，MTFM 的“不妥协”——拒绝特征对齐、拒绝 Padding 填充、直接引入异构 Tokenizer——更是直击工业界痛点。它让推荐系统的架构变得空前干净、整洁。未来接入一个新场景，不需要改动核心骨干网络，只需要训练一个极小的映射 MLP。

我们有理由相信，MTFM 描绘的正是推荐系统的终极形态之一：一个无限大的、能够吞噬所有异构特征的、不断 Scaling 的统一基座模型。

GPSD：让判别式推荐模型也拥有 Scaling Law 的魔力

Tue, 24 Mar 2026 10:00:00 +0800

本文是关于最新论文《Scaling Transformers for Discriminative Recommendation via Generative Pretraining》（）的阅读笔记。

在大语言模型（LLM）领域，增加参数量和数据量通常能带来性能的对数线性增长，即 Scaling Law。然而在推荐系统领域，特别是用于排序（Ranking）的判别式模型（如 CTR/CVR 预测），这一规律却迟迟没有出现。

Meta 团队最近提出的 GPSD (Generative Pretraining for Scalable Discriminative Recommendation) 框架，通过引入生成式预训练，成功打破了这一僵局，让判别式推荐模型也能随着参数规模的扩大而变强。本文将从核心问题、方法设计、实验分析、与现有方法对比、优缺点以及工程实践启示等多个角度，对这篇论文进行全面解读。

1. 为什么推荐大模型容易”掉点”？

1.1 NLP 与推荐系统的数据差异

在自然语言处理中，数据是密集的 token 流——词表通常在几万到十几万量级，而且每个 token 在海量文本中都会被反复观测到，天然具备良好的统计充分性。但在推荐系统中，情况截然不同：

物品空间极度庞大：工业级推荐场景下，物品 ID（Item ID）可达数十亿规模，远超 NLP 词表大小。
用户交互极其稀疏：绝大多数用户只消费过全部物品中极小的一部分（通常远低于 0.01%），导致大量 Embedding 参数缺乏有效的梯度更新。
标签信号分布不均：点击率（CTR）通常在个位数百分比，转化率（CVR）更是远低于 1%，正样本极度稀缺。

1.2 判别式训练的过拟合困境

论文指出，直接在判别式任务（点击/转化预测）上训练大规模 Transformer，会遇到严重的**数据稀疏导致的过拟合（Overfitting）**问题。具体表现为：

稀疏参数（Embedding 表）难以充分训练：当物品空间巨大但每个物品的观测样本有限时，Embedding 表中大量参数处于”欠训练”状态，容易记忆噪声而非学习泛化特征。
泛化误差随模型规模增大而扩大：随着模型层数（Dense 参数）增加，模型在训练集上的 loss 持续下降，但验证集上的 loss 却反向增大，泛化差距（Generalization Gap）迅速扩大。
”越大越差”的逆直觉现象：模型参数越多，在测试集上的表现反而可能不如简单的小模型，这与 NLP/CV 领域”越大越好”的经验形成鲜明对比。

1.3 过拟合的根源：稀疏参数 vs 稠密参数

论文通过系统性实验，进一步定位了过拟合的根源：

稀疏参数（Sparse Parameters）：主要指 Embedding 表，参数量通常占模型总参数的 90% 以上。由于推荐场景的数据稀疏性，这些参数是过拟合的”重灾区”。
稠密参数（Dense Parameters）：指 Transformer 层中的注意力权重、前馈网络权重等。这些参数被所有样本共享更新，理论上不易过拟合。
关键发现：当稀疏参数的质量得到保障后，增加稠密参数反而能带来持续的性能增益——这正是 GPSD 框架的理论基础。

2. GPSD：生成式预训练的”桥接”艺术

GPSD 框架的核心思想是：先用生成式任务训练稀疏参数，再在判别式任务中冻结它们。 整个流程分为三个清晰的阶段：生成式预训练、桥接迁移、判别式微调。

2.1 阶段一：生成式预训练 (Generative Pretraining)

2.1.1 训练目标

生成式预训练阶段采用经典的**自回归（Autoregressive）**范式：给定用户的历史行为序列 $[i_1, i_2, ..., i_{t-1}]$，模型的目标是预测下一个交互物品 $i_t$。这与 GPT 系列模型在文本上的预训练目标本质上是一致的，只是将”预测下一个 token”替换为了”预测下一个 item”。

2.1.2 Sampled Softmax 机制

由于物品空间极其庞大（数十亿级别），直接在全量物品上计算 Softmax 是不现实的。GPSD 采用 Sampled Softmax 来解决这一问题：

核心思路：在每次前向计算时，从全量物品中采样一批负样本（通常数千到数万个），仅在正样本 + 采样负样本构成的子集上计算 Softmax。
关键优势：每次训练步骤中，不同的负样本被随机采入，这意味着整个训练过程中，几乎所有物品的 Embedding 都会被频繁地更新到。这与判别式训练中负样本仅来自实际曝光（impression）形成了鲜明对比。
对抗过拟合的效果：由于 Sampled Softmax 引入了广泛的随机负采样，大量原本在判别式训练中”沉睡”的 Embedding 得以被激活和优化，从根本上解决了稀疏参数欠训练的问题。

2.1.3 模型架构

预训练阶段使用的是标准的 Transformer Decoder 架构：

输入为用户行为序列的 Embedding 拼接
使用因果注意力掩码（Causal Attention Mask）确保自回归性质
输出层通过 Sampled Softmax 映射到物品空间
位置编码采用可学习的绝对位置编码

2.1.4 生成式预训练的关键优势

与直接在判别式任务上训练相比，生成式预训练具备以下优势：

数据利用效率更高：每条用户序列可以生成多个训练样本（序列中的每个位置都是一个预测目标），数据利用率远高于判别式训练。
隐式的负采样覆盖更广：Sampled Softmax 机制确保了海量物品的 Embedding 都能得到有效更新。
语义表示质量更优：生成式目标天然鼓励模型学习物品之间的序列依赖关系和语义相似性，产生的 Embedding 包含更丰富的语义信息。

2.2 阶段二：桥接与冻结 (Sparse Freeze Strategy)

这是 GPSD 最关键的创新点。在将模型从生成式任务迁移到判别式任务（如 CTR 预测）时，如果简单地进行全参数微调，稀疏参数的过拟合问题会再次出现。GPSD 采取了**”冻结稀疏参数（Sparse Freeze）”**的桥接策略：

2.2.1 具体操作步骤

继承预训练好的 Embedding 参数：将生成式预训练阶段学到的所有 Embedding 参数（包括 Item Embedding、Feature Embedding 等）直接迁移到判别式模型中。
在判别式微调阶段，固定住所有稀疏参数不更新：冻结 Embedding 表的梯度，使其在整个微调过程中保持预训练阶段学到的状态。
仅更新稠密参数：只对 Transformer 层、MLP Head、交叉网络等稠密参数进行梯度更新。

2.2.2 为什么冻结而非微调？

论文通过对比实验系统地回答了这个问题：

全参数微调（Full Fine-tune）：虽然初始收敛速度更快，但随着训练推进，泛化差距迅速扩大，最终效果反而低于冻结策略。
稀疏冻结（Sparse Freeze）：虽然初始收敛较慢，但泛化差距始终保持在较小水平，最终效果显著优于全参数微调。
根本原因：判别式训练的负样本来自有限的曝光日志，无法为稀疏参数提供足够多样的梯度信号。继续更新稀疏参数反而会”破坏”预训练阶段学到的高质量表示。

2.2.3 冻结策略的数学直觉

从优化理论角度来看，冻结稀疏参数可以理解为：

将高维优化问题分解为两步低维优化
第一步在”数据丰富”的环境（生成式训练，Sampled Softmax 提供广泛负采样）中优化稀疏参数
第二步在”数据有限”的环境（判别式训练，仅曝光日志）中优化稠密参数
通过这种分而治之的策略，避免了在数据有限的环境中同时优化海量参数导致的过拟合

2.3 阶段三：判别式微调 (Discriminative Fine-tuning)

在冻结稀疏参数之后，判别式微调阶段的任务是训练稠密参数来适配具体的业务目标（如 CTR 预估、CVR 预估）：

输入：候选物品的冻结 Embedding + 用户序列的冻结 Embedding + 上下文特征
模型结构：Transformer 编码器或 MLP 交叉网络（稠密参数可训练）
输出：通过 Sigmoid 得到点击率或转化率的预估值
损失函数：标准的二元交叉熵（Binary Cross-Entropy）

3. 架构流程图

4. Scaling Law 在推荐系统中的分析

4.1 什么是 Scaling Law？

Scaling Law 最初由 OpenAI 在 2020 年提出，揭示了语言模型性能与模型参数量、训练数据量、计算量之间的幂律关系。具体来说：

模型越大，性能越好：在充足数据和计算的前提下，增加参数量能带来可预测的性能提升
幂律关系：性能提升遵循幂律的形式，即损失随参数量增加呈对数线性下降

4.2 推荐系统中 Scaling Law 的缺失

在 GPSD 之前，推荐系统领域几乎没有观测到类似的 Scaling Law。原因在于：

传统方法的参数扩展主要集中在 Embedding 表：增加 Embedding 维度或增加特征数量带来的收益迅速饱和
稠密参数扩展受限于过拟合：直接增加 Transformer 层数或宽度会导致泛化性能下降
缺乏有效的预训练范式：NLP 领域的 Scaling Law 建立在大规模自监督预训练之上，而推荐系统缺乏对应的预训练方法

4.3 GPSD 如何实现推荐系统的 Scaling Law

GPSD 的核心贡献之一，是首次在判别式推荐模型中验证了 Scaling Law 的存在：

实验设置：将稠密参数从 13K 逐步扩展到 0.3B（约 2 万倍），观察离线 AUC 指标的变化
关键结果：在使用 GPSD 框架后，AUC 随稠密参数量的增加呈现出平滑的幂律增长曲线
对照实验：不使用 GPSD（直接端到端判别式训练），增加参数量到一定规模后 AUC 开始下降，完全无法观测到 Scaling Law

4.4 Scaling Law 成立的前提条件

GPSD 的实验揭示了推荐系统 Scaling Law 成立的关键前提：

稀疏参数必须被高质量预训练：只有当 Embedding 表具备良好的泛化表示时，增加稠密参数才有意义
稀疏参数在微调阶段必须冻结：防止判别式训练破坏预训练的表示质量
稠密参数是 Scaling 的真正受益者：当稀疏参数质量有保障时，增加 Transformer 深度/宽度能够持续提升模型的特征交叉能力

5. 与其他预训练方法的对比

为了更好地理解 GPSD 的贡献，以下从多个维度将 GPSD 与其他主流推荐预训练方法进行对比：

维度	GPSD（本文）	SASRec / BERT4Rec	PinnerSage（Pinterest）	LLM4Rec（基于 LLM）
预训练任务	自回归生成式（Next Item Prediction + Sampled Softmax）	自回归 / 掩码语言模型	基于图的 PinSage Embedding	直接使用 LLM 文本理解
目标下游任务	判别式排序（CTR/CVR）	序列推荐（Top-K 召回）	召回 / 粗排	排序 / 会话推荐
参数迁移策略	冻结稀疏参数 + 微调稠密参数	全参数微调	仅使用 Embedding，不迁移模型结构	全参数微调或 LoRA
是否验证 Scaling Law	是（首次在判别式模型验证）	否	否	部分（继承 LLM 的 Scaling 特性）
工业部署验证	是（Meta 线上 A/B 测试）	学术实验为主	是（Pinterest 线上部署）	少量工业验证
Embedding 覆盖度	高（Sampled Softmax 覆盖全量物品）	低（仅序列内物品参与训练）	中等（图邻居扩展）	不涉及（使用文本特征）
训练效率	中等（两阶段训练）	高（单阶段端到端）	低（需要构建图）	低（LLM 训练成本高）

对比分析要点：

vs SASRec/BERT4Rec：这类方法虽然也采用序列建模，但其预训练和下游任务都聚焦于召回场景，未涉及判别式排序。更重要的是，它们在微调时采用全参数更新，无法避免稀疏参数的过拟合问题。
vs PinnerSage：PinnerSage 通过图神经网络学习物品 Embedding，但仅将 Embedding 作为特征输入下游模型，不涉及模型结构的迁移，因此无法充分利用预训练模型的深层知识。
vs LLM4Rec：基于 LLM 的方法虽然能利用文本语义，但在处理 ID 特征和用户行为建模方面存在天然短板，且部署成本极高。GPSD 直接在推荐原生的 ID 空间中工作，与现有推荐系统架构兼容性更好。

6. 实验结果详细分析

6.1 离线实验

GPSD 在多个维度上验证了其有效性：

6.1.1 Scaling Law 验证

实验规模：稠密参数从 13K 扩展到 0.3B，跨越约 4 个数量级
核心发现：使用 GPSD 后，AUC 随稠密参数增加呈现平滑的幂律增长，拟合幂律曲线的 R-squared 值极高
对照组表现：不使用 GPSD 的端到端判别式训练，在参数量超过一定阈值后 AUC 显著下降

6.1.2 泛化差距分析

GPSD + Sparse Freeze：训练 loss 与验证 loss 之间的差距始终保持在较小水平，且不随模型规模增大而显著扩大
端到端判别式训练：泛化差距随模型规模增大而急剧扩大，表明严重的过拟合
全参数微调（不冻结稀疏参数）：介于两者之间，但仍然存在明显的过拟合问题

6.1.3 消融实验

论文通过系统的消融实验验证了各组件的贡献：

移除生成式预训练：AUC 显著下降，证明预训练是 Scaling 的必要条件
移除稀疏冻结：泛化差距迅速扩大，证明冻结策略对于维持预训练质量至关重要
仅使用预训练 Embedding 不迁移模型结构：AUC 有所提升但幅度有限，说明模型结构的迁移也贡献了一定价值

6.2 线上实验

部署平台：Meta 内部的推荐排序系统
实验形式：标准的 A/B 测试，实验组使用 GPSD 框架训练的模型，对照组使用现有的判别式模型
核心指标收益：论文报告了在核心业务指标（如点击率、转化率、用户互动时长等）上取得了统计显著的正向收益
稳定性：线上指标在持续运行期间保持稳定，无退化现象

6.3 训练效率分析

预训练开销：生成式预训练阶段需要额外的计算资源，但由于可以离线进行且模型收敛较快，总体开销可控
微调加速：由于冻结了大量稀疏参数（占总参数 90% 以上），判别式微调阶段的梯度计算量和内存占用均大幅减少
综合效率：两阶段训练的总计算成本与直接端到端训练的大模型相当，但最终效果显著更优

7. 优缺点分析

7.1 优势

首次在判别式推荐模型中验证 Scaling Law：这是该论文最核心的贡献，为推荐系统领域的”大模型化”提供了可行路径和理论支撑。
方法设计简洁且工程友好：两阶段训练流程清晰，冻结策略实现简单（只需在优化器中排除稀疏参数），不需要对现有推荐系统架构做大幅改动。
经过工业级验证：在 Meta 的真实业务场景中完成了线上 A/B 测试并取得正收益，证明了方法的实用性和可靠性。
理论洞察深刻：系统性地分析了稀疏参数与稠密参数在过拟合中的不同角色，为后续研究提供了清晰的理论框架。
开源代码：作者公开了实现代码，降低了复现和跟进研究的门槛。

7.2 不足与局限

两阶段训练的流程复杂性：虽然单看每个阶段都很简单，但两阶段训练意味着需要维护两套训练流水线、两套超参数配置，以及处理阶段之间的模型兼容性问题。在工程实践中，这增加了系统的维护成本。
冻结策略可能丢失任务特异性信息：完全冻结稀疏参数意味着 Embedding 无法适配判别式任务的特定需求。对于某些与生成式预训练分布差异较大的下游任务，这种”一刀切”的冻结可能不是最优选择。论文未探讨部分冻结或渐进解冻等更灵活的策略。
对预训练数据质量的强依赖：稀疏参数的质量完全由预训练阶段决定，如果预训练数据存在偏差（如热门物品过度曝光、冷启动物品缺乏交互），这些偏差会被”冻结”到下游模型中且无法修正。
Scaling Law 的验证范围有限：实验仅在 Meta 的特定业务场景中验证，是否能推广到其他领域（如电商、短视频、音乐推荐等）尚需进一步证实。同时，论文主要关注了参数量维度的 Scaling，对数据量和计算量维度的 Scaling 关系探讨较少。

8. 工程实践启示

8.1 推荐系统工程师的实践建议

基于 GPSD 的核心发现，以下是一些可以在工程实践中借鉴的经验：

优先投资 Embedding 质量：与其盲目增大模型规模，不如先确保 Embedding 表的训练质量。可以考虑在正式的排序模型训练之前，通过对比学习、生成式预训练等手段预热 Embedding。
分阶段训练的思路值得借鉴：即使不完全复制 GPSD 的方案，”将困难的稀疏参数优化和稠密参数优化分开处理”这一思路本身就极具价值，可以在各种变体中灵活应用。
冻结策略可以渐进式采用：在工程实践中，可以先尝试冻结最容易过拟合的低频特征 Embedding，观察效果后再逐步扩大冻结范围。
监控泛化差距作为模型健康指标：论文中使用的泛化差距（训练 loss 与验证 loss 的差距）是一个非常实用的模型健康监控指标，建议在日常模型迭代中持续追踪。

8.2 架构设计启示

预训练与微调解耦：将推荐系统架构设计为支持模块化的预训练和微调，便于独立优化各个组件。
稀疏参数服务化：预训练好的 Embedding 可以作为独立的服务（Embedding Service）对外提供，供多个下游任务共享，降低重复训练的成本。
动态更新机制：考虑设计增量更新机制，在新物品上线时能够快速生成高质量的 Embedding，而不需要重新运行完整的预训练流程。

9. 未来方向

基于 GPSD 的研究成果，以下几个方向值得关注：

推荐系统基础模型（Foundation Models for RecSys）：GPSD 为推荐领域的基础模型奠定了初步基础。未来可以探索更大规模、跨场景、跨平台的预训练，构建真正意义上的推荐基础模型。
更灵活的参数迁移策略：探索部分冻结、渐进解冻、LoRA 适配等更精细的参数迁移方法，在保持预训练质量的同时允许一定程度的任务适配。
多模态预训练：将 GPSD 的思路扩展到多模态推荐场景，结合文本、图像、视频等多模态信息进行生成式预训练。
数据量与计算量的 Scaling Law：GPSD 主要探索了参数量维度的 Scaling，未来可以系统性地研究训练数据量和计算量对推荐模型性能的影响。
冷启动问题：研究如何利用生成式预训练的知识来改善新用户和新物品的冷启动表现。

总结

GPSD 框架证明了推荐系统也可以像 LLM 一样通过 Scaling Up 变得更聪明。它的核心贡献可以归纳为以下几点：

问题定位精准：准确识别出稀疏参数过拟合是阻碍推荐模型 Scaling 的关键瓶颈。
方法设计精巧：通过生成式预训练为 Embedding 表奠定坚实基础，再通过”参数冻结”策略在判别式微调阶段避免过拟合，实现了”分而治之”的优雅解决方案。
首次验证推荐系统的 Scaling Law：在工业级场景中证实了判别式推荐模型也能随着参数规模扩大而持续变强。
工业落地验证：在 Meta 的真实业务中完成了线上验证，证明了方法的实用价值。

这一研究为未来推荐领域的”基础大模型（Foundation Models）”提供了关键的路径，也为整个推荐系统社区带来了一个重要的信号：推荐模型的 Scaling 之路已经打通，关键在于找到正确的预训练和参数迁移策略。

开源代码：

M-FALCON：HSTU 中解决“一对多”推荐推理的终极武器

Fri, 20 Mar 2026 12:00:00 +0800

在 Meta AI 提出的 HSTU（万亿参数推荐大模型）论文中，除了惊艳的生成式训练范式，还有一个非常硬核的推理加速技术：M-FALCON。本文将为你深入浅出地拆解它的原理，以及它和我们常说的 KV-Cache 有什么异同。

1. 推荐系统排序阶段的”灾难性”痛点

在推荐系统的排序（Ranking）阶段，我们面临着一个典型的**”一用户对多候选”**（Target-aware Ranking）的场景：

我们有一段长度为 $n$ 的用户历史行为序列（比如用户过去看过的 1000 个视频）。
我们有 $m$ 个需要被评估打分的候选视频（Target）。

1.1 朴素方法的计算瓶颈

如果我们直接用标准的 Transformer（自回归模式）来计算，意味着每评估一个候选视频，都要把”用户历史 + 这个候选视频”送进模型跑一遍。对于 $m$ 个候选，这就需要跑 $m$ 次，整体计算复杂度高达 $\mathcal{O}(m \cdot n^2)$。

具体来说，这个复杂度可以拆解为：

单次 Attention 计算：对于长度为 $n$ 的序列，标准自注意力机制的复杂度为 $\mathcal{O}(n^2 \cdot d)$，其中 $d$ 是隐层维度。
重复计算：每个候选视频都需要独立地与整段用户历史交互，相当于把 $\mathcal{O}(n^2)$ 的计算重复了 $m$ 次。
实际数量级：在工业级场景中，$n$ 通常在 $500 \sim 2000$，$m$ 通常在 $500 \sim 5000$。这意味着单次请求的计算量可以轻松达到 $10^9$ 级别的浮点运算。

当 $m$ 达到成千上万，且 $n$ 也很长时，在线推理的延迟是不可接受的。工业推荐系统通常要求排序阶段在 10~50ms 内完成，朴素方法根本无法满足这一要求。

1.2 为什么不能简单地缩小模型？

一个自然的疑问是：既然计算量太大，能不能缩小模型？答案是不行，原因如下：

HSTU 的核心价值在于用超大模型（万亿参数）来统一建模用户行为序列，缩小模型会严重损害推荐质量。
用户历史序列的长度 $n$ 直接关系到推荐效果，截断历史会丢失宝贵的长期兴趣信号。
排序阶段的候选数 $m$ 由上游召回模块决定，不能随意减少。

因此，推理加速成为了唯一可行的路径，M-FALCON 正是为此而生。

2. 前置知识：KV-Cache 机制详解

在深入 M-FALCON 之前，我们需要先理解它所依赖的基础技术——KV-Cache。这一机制最初在大语言模型（LLM）的自回归推理中被广泛使用。

2.1 标准 Transformer 自注意力回顾

在标准的多头自注意力（Multi-Head Self-Attention）中，给定输入序列 $X \in \mathbb{R}^{L \times d}$，我们通过三个投影矩阵得到：

Query（查询）：$Q = X W_Q$
Key（键）：$K = X W_K$
Value（值）：$V = X W_V$

注意力计算公式为：

$$\text{Attention}(Q, K, V) = \text{softmax}\left(\frac{QK^T}{\sqrt{d_k}}\right) V$$

2.2 自回归推理中的冗余计算

在 LLM 的自回归生成中，模型逐个 Token 生成输出。当生成第 $t$ 个 Token 时：

需要计算当前 Token 的 Query $q_t$。
需要用 $q_t$ 与所有已生成 Token 的 Key 和 Value 做注意力计算。

如果每次都重新计算所有 Token 的 K 和 V，复杂度为 $\mathcal{O}(t^2)$——这是极大的浪费，因为前 $t-1$ 个 Token 的 K 和 V 在之前的步骤中已经计算过了。

2.3 KV-Cache 的核心思想

KV-Cache 的做法非常直观：

缓存历史：将每一步计算出的 $K_t$ 和 $V_t$ 存入一个不断增长的缓存中。
增量计算：在第 $t$ 步，只需计算当前新 Token 的 $Q_t$、$K_t$、$V_t$，然后将 $K_t$、$V_t$ 追加到缓存，再用 $Q_t$ 与完整的缓存做注意力计算。
复杂度降低：单步推理从 $\mathcal{O}(t^2)$ 降至 $\mathcal{O}(t)$，总生成 $T$ 个 Token 的复杂度从 $\mathcal{O}(T^3)$ 降至 $\mathcal{O}(T^2)$。

KV-Cache 的关键优势在于：

避免重复计算：已生成 Token 的 K、V 只计算一次。
以空间换时间：需要额外的显存来存储缓存，但换来了显著的速度提升。
数值等价：缓存机制不改变计算结果，是一种无损加速。

2.4 KV-Cache 的局限性

传统 KV-Cache 是为 ”一对一” 的自回归场景设计的，即一个前缀序列对应一个后续生成序列。但在推荐系统的排序场景中：

同一个用户前缀需要对应 $m$ 个不同的候选——这是一个 ”一对多” 的场景。
即使用了 KV-Cache 避免了用户历史的重复计算，$m$ 个候选仍需逐个送入模型，逐个推理的方式受限于内存访存带宽（Memory-bound），无法充分利用 GPU 的并行算力。

这正是 M-FALCON 要解决的问题。

3. M-FALCON 是如何破局的？

M-FALCON 全称是 Microbatched Fast Attention Leveraging Cacheable OperatioNs。为了打破上述瓶颈，它采用了两个核心策略：KV-Cache 共享与特殊掩码的微批处理 (Microbatching)。

3.1 用户历史的 KV-Cache 预计算

既然这 $m$ 个候选视频都要和同一段用户历史进行交互，那么用户历史在 Transformer 中计算出的 Query, Key, Value 其实是完全一致的。

M-FALCON 借用了大语言模型（LLM）中成熟的 KV-Cache 思想：首先把长度为 $n$ 的用户历史的 KV 矩阵计算出来并缓存（Cache）住。这样后续计算候选物品时，就不需要再重复计算历史序列的特征了。

具体步骤如下：

Prefill 阶段：将长度为 $n$ 的用户历史序列送入 HSTU 模型的所有 Transformer 层，得到每一层的 $K^{(l)}_{\text{hist}}, V^{(l)}_{\text{hist}} \in \mathbb{R}^{n \times d_k}$，其中 $l$ 表示层编号。
缓存存储：将所有层的 KV 对存储在 GPU 显存中。对于 $L$ 层、$H$ 头的模型，总缓存量为 $2 \times L \times H \times n \times d_k$。
复用：后续每个候选物品的计算都直接读取这份缓存，无需重新计算。

3.2 微批处理与特殊的 Attention Mask

这是 M-FALCON 最巧妙的地方。如果只用 KV-Cache，逐个计算候选商品依然很慢（内存访存带宽瓶颈，即 Memory-bound）。

M-FALCON 将这 $m$ 个候选商品划分成大小为 $b_m$ 的微批次（Microbatch），把它们拼接在用户历史的后面一起送入模型。

但这里有一个关键问题：同批次内的候选商品，彼此之间不能产生注意力交互（也就是候选 A 不能”看到”候选 B），否则就会发生信息泄露（Crosstalk）。

3.2.1 为什么 Crosstalk 是致命的？

在排序场景中，每个候选物品应该独立地获得一个打分。如果候选 A 的表征受到了候选 B 的影响：

排序不一致：同一个候选物品在不同的微批次中会得到不同的分数（因为同批次的其他候选不同）。
信息泄漏：候选物品之间产生了不该存在的信息流动，违反了排序任务的独立性假设。
训练-推理不一致：训练时每个候选是独立计算的，推理时如果引入了 Crosstalk，等于改变了计算图。

3.2.2 注意力掩码的精确构造

为此，M-FALCON 设计了一种特殊的 Attention Mask（注意力掩码）。假设序列拼接后为 $[\text{hist}_1, \dots, \text{hist}_n, \text{cand}_1, \dots, \text{cand}_{b_m}]$，掩码矩阵 $M \in \mathbb{R}^{(n+b_m) \times (n+b_m)}$ 的构造规则为：

用户历史内部：标准的因果掩码（Causal Mask），即 $M_{ij} = 1$ 当且仅当 $i \geq j$（对于 $i, j \leq n$）。
候选 $\to$ 历史：所有候选商品都可以”看到”（Attend to）完整的用户历史，即 $M_{ij} = 1$（对于 $i > n, j \leq n$）。
候选 $\to$ 自身：候选商品对自己是可见的（对角线为 1），即 $M_{ii} = 1$。
候选 $\to$ 其他候选：互相不可见，即 $M_{ij} = 0$（对于 $i \neq j$ 且 $i, j > n$）。

用直观的矩阵形式表示，掩码结构如下：

$$M = \begin{pmatrix} \text{CausalMask}_{n \times n} & \mathbf{0}_{n \times b_m} \\ \mathbf{1}_{b_m \times n} & I_{b_m \times b_m} \end{pmatrix}$$

其中 $I$ 是单位矩阵，表示候选只能看到自己。

3.2.3 微批次大小的选择

微批次大小 $b_m$ 是一个需要精心调优的超参数：

$b_m$ 过小：微批次数量 $\lceil m / b_m \rceil$ 过多，KV-Cache 的重复读取开销增大，无法充分利用 GPU 并行度。
$b_m$ 过大：单次前向传播的序列长度 $n + b_m$ 增大，Attention 的计算量 $\mathcal{O}((n+b_m)^2)$ 快速增长，可能超出 GPU 显存限制。
最佳平衡点：通常 $b_m$ 取值在 $16 \sim 128$ 之间，具体取决于 $n$ 的大小、模型的层数和头数、以及 GPU 显存容量。

3.3 完整推理流程总结

M-FALCON 的完整推理流程可以归纳为以下步骤：

Prefill：输入用户历史序列，计算并缓存所有层的 KV。
分批：将 $m$ 个候选划分为 $\lceil m / b_m \rceil$ 个微批次。
并行解码：对每个微批次，构造特殊掩码，读取 KV-Cache，执行一次前向传播，得到该批次所有候选的分数。
合并输出：将所有微批次的分数汇总，输出最终排序列表。

4. 复杂度分析的详细推导

4.1 朴素方法的复杂度

不使用任何优化时，每个候选需要独立地与整段用户历史做 Attention：

$$T_{\text{naive}} = m \cdot \mathcal{O}((n+1)^2) \approx \mathcal{O}(m \cdot n^2)$$

其中 $+1$ 是候选自身，当 $n \gg 1$ 时可忽略。

4.2 仅使用 KV-Cache 的复杂度

使用 KV-Cache 后，用户历史的 KV 只计算一次，但每个候选仍需独立推理：

$$T_{\text{kv-cache}} = \underbrace{\mathcal{O}(n^2)}_{\text{Prefill 阶段}} + \underbrace{m \cdot \mathcal{O}(n)}_{\text{逐个解码}}$$

Prefill 阶段计算用户历史的 KV：$\mathcal{O}(n^2)$。
每个候选只需用自己的 Query 与缓存的 KV 做一次注意力：$\mathcal{O}(n)$。
总复杂度：$\mathcal{O}(n^2 + m \cdot n)$。

相比朴素方法，节省了 $m$ 倍的 Prefill 开销，但逐个解码仍然是 Memory-bound 的（每次只计算一个 Token 的输出，算术强度极低）。

4.3 M-FALCON 的复杂度

使用 M-FALCON（KV-Cache + 微批处理）后：

$$T_{\text{M-FALCON}} = \underbrace{\mathcal{O}(n^2)}_{\text{Prefill}} + \underbrace{\lceil m/b_m \rceil \cdot \mathcal{O}(b_m \cdot (n + b_m))}_{\text{微批次解码}}$$

微批次解码的详细推导：

每个微批次有 $b_m$ 个候选 Token，它们各自需要 Attend to $n$ 个历史 Token 和自身，因此单个微批次的 Attention 计算量为 $\mathcal{O}(b_m \cdot (n + b_m))$。
更严格地，考虑完整的 $(n+b_m) \times (n+b_m)$ 注意力矩阵，由于掩码的存在，实际有效计算量为 $\mathcal{O}(n^2 + b_m \cdot n + b_m)$，其中 $n^2$ 部分可以通过 KV-Cache 跳过，所以增量计算只有 $\mathcal{O}(b_m \cdot (n + 1))$。
总复杂度：$\mathcal{O}(n^2 + \lceil m/b_m \rceil \cdot b_m \cdot n) = \mathcal{O}(n^2 + m \cdot n)$。

4.4 三种方法的复杂度对比

方法	复杂度	典型值 ($n=1000, m=1000$)	瓶颈类型
朴素方法	$\mathcal{O}(m \cdot n^2)$	$10^9$	Compute-bound
KV-Cache only	$\mathcal{O}(n^2 + m \cdot n)$	$2 \times 10^6$	Memory-bound
M-FALCON	$\mathcal{O}(n^2 + m \cdot n)$	$2 \times 10^6$	Compute-bound

关键观察：

KV-Cache only 和 M-FALCON 的理论复杂度相同，但 M-FALCON 通过微批处理将瓶颈从 Memory-bound 转化为 Compute-bound。
在现代 GPU 上，Compute-bound 的操作能更好地利用硬件的并行算力，实际延迟远低于 Memory-bound 的逐个解码。
论文实验表明，M-FALCON 在实际部署中可以带来 2~4 倍的端到端延迟降低。

5. M-FALCON 原理流程图

下面这张图直观地展示了 M-FALCON 的工作流：

graph TD A[“用户历史序列”] -->|仅计算一次| B[“KV-Cache”] C[“候选商品”] -->|切分| D[“微批次”] D --> E[“Attention Mask + HSTU 计算”] B --> E E --> F[“批次排序分值”] F --> G{“剩余候选”} G -- 是 --> D G -- 否 --> H[“最终排序列表”]

6. 与其他推理优化技术的全面对比

M-FALCON 的出现，是 LLM 推理技术向推荐系统迁移的成功典范。下面我们从多个维度将 M-FALCON 与当前主流的推理优化技术进行系统对比。

6.1 对比总览表

维度	M-FALCON	标准 KV-Cache	PagedAttention (vLLM)	FlashAttention	Speculative Decoding
核心思想	KV-Cache + 微批掩码	缓存历史 KV 避免重复计算	分页管理 KV-Cache 显存	IO-aware 的精确注意力	小模型草稿 + 大模型验证
解决的问题	一对多排序推理加速	自回归生成加速	多请求并发显存管理	注意力计算 IO 瓶颈	自回归生成速度
适用场景	推荐排序	LLM 文本生成	LLM 高并发服务	通用 Transformer	LLM 文本生成
是否无损	是	是	是	是（精确计算）	是（拒绝采样保证）
加速倍数	2~4x	10~100x (vs 无缓存)	2~4x 吞吐提升	2~4x	2~3x
额外显存开销	KV-Cache 存储	KV-Cache 存储	分页表 + KV 块	无	小模型权重
是否可组合	可与 FlashAttention 组合	基础技术	可与 KV-Cache 组合	可与所有方法组合	可与 KV-Cache 组合

6.2 与标准 KV-Cache 的深入对比

M-FALCON 本质上是 KV-Cache 技术在”一对多（One-to-Many）”特殊场景下的深度变种：

标准 KV-Cache 是在时间维度（预测下一个 Token）上复用，每步只生成一个新 Token，是 ”一对一” 的增量式复用。
M-FALCON 是在候选维度（给多个 Target 打分）上实现了跨样本的复用，同一份 KV-Cache 被 $m$ 个候选共享，是 ”一对多” 的批量式复用。
关键区别在于微批掩码：标准 KV-Cache 不需要特殊掩码（因果掩码天然满足），而 M-FALCON 必须通过精心设计的掩码来防止候选间的 Crosstalk。

6.3 与 PagedAttention (vLLM) 的对比

两者解决的问题完全不同：

PagedAttention 解决的是多用户并发请求时，如何通过操作系统的”分页内存”机制来减少显存碎片，提高并发吞吐量。它关注的是 系统级（多请求间） 的资源管理。
M-FALCON 解决的是单用户单次请求中，如何通过掩码技巧在一次计算内并行评估大量无关候选的问题。它关注的是 请求级（单请求内） 的计算优化。
两者理论上可以组合使用：在多用户并发的推荐服务中，用 PagedAttention 管理跨请求的 KV-Cache 显存，用 M-FALCON 加速每个请求内部的候选评估。

6.4 与 FlashAttention 的关系

FlashAttention 是一种硬件感知（IO-aware）的注意力计算实现，通过分块计算（Tiling）和减少 HBM 访问来加速 Attention：

FlashAttention 优化的是 Attention 算子本身的执行效率，对掩码模式不做限制。
M-FALCON 优化的是计算图层面的冗余消除和并行化。
两者是正交且可组合的：M-FALCON 的微批 Attention 可以使用 FlashAttention 作为底层算子，从而同时获得两个层面的加速。

7. 优缺点分析

7.1 M-FALCON 的优势

无损加速：掩码机制保证了每个候选的计算与独立推理时完全等价，不引入任何近似误差。
显著降低延迟：在实际部署中可带来 2~4 倍的延迟降低，使万亿参数模型满足工业级延迟要求。
实现简洁：核心改动仅在 Attention Mask 的构造和 KV-Cache 的管理上，不需要修改模型结构或训练流程。
灵活可调：微批次大小 $b_m$ 可以根据硬件条件动态调整，便于适配不同的部署环境。
可组合性强：可以与 FlashAttention、量化推理等其他优化技术叠加使用。

7.2 M-FALCON 的局限性

显存开销：需要为每个请求缓存完整的 KV-Cache（$2 \times L \times H \times n \times d_k$ 个浮点数），在超长历史序列或超大模型下，显存占用可能成为瓶颈。
场景特定：专门针对”一对多”的排序场景设计，不适用于通用的自回归生成任务。
批次大小调优：$b_m$ 的最优值依赖于具体的硬件配置（GPU 型号、显存大小）和模型参数（层数、头数、维度），需要在每个部署环境中单独调优。
不解决 Prefill 瓶颈：对于用户历史的初始计算（Prefill 阶段），复杂度仍为 $\mathcal{O}(n^2)$，当 $n$ 极大时这一阶段本身可能成为瓶颈。
掩码实现复杂度：自定义的稀疏掩码可能不被所有深度学习框架的 Attention 内核原生支持，需要编写自定义 CUDA kernel 或使用支持灵活掩码的库（如 FlashAttention v2+）。

8. 工程实践启示

8.1 对推荐系统工程师的启示

M-FALCON 的设计理念对推荐系统的工程实践有深远的启示意义：

跨领域技术迁移：M-FALCON 的成功说明，LLM 推理领域的成熟技术（KV-Cache、掩码机制等）可以被创造性地迁移到推荐系统中。工程师应当保持对相邻领域技术进展的敏感度。
计算图分析是优化的起点：M-FALCON 的核心洞察来自对计算图中冗余的精准识别——$m$ 个候选共享同一份用户历史。在任何推理优化中，第一步都应该是分析计算图中是否存在可复用的中间结果。
Memory-bound vs Compute-bound 的转换：M-FALCON 通过微批处理将逐个解码的 Memory-bound 操作转化为批量计算的 Compute-bound 操作。这一原则在 GPU 编程中具有普遍意义——尽量提高算术强度（Arithmetic Intensity）来充分利用 GPU 的计算吞吐。

8.2 实际部署中的关键考量

在将 M-FALCON 落地到生产环境时，需要注意以下几点：

动态批次调度：不同用户的历史长度 $n$ 不同，需要动态调整 $b_m$ 或采用 padding 策略。建议根据 $n$ 的分桶统计来预设几档 $b_m$ 值。
KV-Cache 的生命周期管理：在高并发场景下，需要合理管理 KV-Cache 的分配与回收。可以借鉴 vLLM 的 PagedAttention 思想，用内存池来管理缓存。
与量化的结合：KV-Cache 可以使用低精度存储（如 FP16 甚至 INT8），在几乎不损失精度的前提下减少一半甚至更多的显存占用。
多级缓存策略：对于超长历史序列，可以考虑将 KV-Cache 分层：高频访问的近期历史放在 GPU HBM，低频的远期历史放在 CPU 内存或 SSD，按需加载。
掩码的高效实现：M-FALCON 的特殊掩码具有明显的块稀疏结构，可以利用 Block-Sparse Attention 内核来避免对零元素的无效计算。

8.3 未来演进方向

基于 M-FALCON 的技术路线，未来可能的演进方向包括：

与 GQA/MQA 的结合：Grouped-Query Attention 和 Multi-Query Attention 可以进一步压缩 KV-Cache 的大小，与 M-FALCON 的结合有望在更长的历史序列上取得更好的效果。
动态稀疏注意力：对于超长用户历史，不一定需要 Attend to 全部历史 Token，可以结合 TopK 稀疏注意力来进一步降低计算量。
Prefix Caching 的跨请求复用：如果不同用户存在相似的历史前缀（如热门物品），可以在请求间复用部分 KV-Cache，进一步提升系统整体吞吐。

9. 总结

M-FALCON 是一项精巧且实用的推理优化技术，其核心贡献可以概括为：

识别了冗余：在”一对多”排序场景中，$m$ 个候选共享同一份用户历史的 KV 表征，这份冗余可以被消除。
解决了 Crosstalk：通过精心设计的块稀疏注意力掩码，在一次前向传播中并行评估多个候选，同时保证候选之间互不干扰。
实现了瓶颈转换：将逐个解码的 Memory-bound 操作转化为微批处理的 Compute-bound 操作，充分利用 GPU 的并行计算能力。

如果没有 M-FALCON，拥有万亿参数的 HSTU 在严苛的工业级延迟要求下根本无法上线。它完美地在”生成式序列建模”与”高效在线排序”之间架起了一座桥梁，也为推荐系统领域的大模型推理优化提供了一个可借鉴的技术范式。

万亿参数推荐大模型：HSTU 架构如何超越传统 Self-Attention

Fri, 20 Mar 2026 10:00:00 +0800

本文是关于 Meta AI 重磅论文《Actions Speak Louder than Words: Trillion-Parameter Sequential Transducers for Generative Recommendations》（arXiv:2402.17152）的阅读笔记，重点探讨 HSTU 架构如何改进传统的自注意力机制。

在自然语言处理（NLP）领域，基于 Transformer 的大模型通过 Scaling Law（缩放定律）展现了令人惊叹的涌现能力。然而在推荐系统领域，传统的深度学习推荐模型（DLRMs）极度依赖人工交叉特征，难以随着计算资源的增加实现模型效果的对数线性增长。

为了解决这一痛点，Meta AI 提出了**生成式推荐（Generative Recommenders, GRs）**的新范式，并专门为推荐场景设计了 HSTU（Hierarchical Sequential Transduction Unit） 架构。HSTU 成功将千亿级异构特征统一为序列化表达，在训练效率和效果上大幅超越了标准 Transformer，并在工业界验证了万亿参数推荐大模型的 Scaling Law。

1. 传统 Transformer 在推荐系统中的“水土不服”

标准 Transformer 架构在处理工业级推荐系统（十亿级动态词表、高达 $10^5$ 的用户交互序列）时，暴露出极端的计算与推理瓶颈：

计算冗余：标准 Transformer 包含多头注意力（MHA）和厚重的点式前馈网络（MLP）。在推荐场景下，极度稀疏的特征并不需要如此厚重的 MLP 来进行特征变换，这会导致巨大的计算浪费。
时间复杂度爆炸：在流式逐样本（Impression-level）训练中，标准 Transformer 的时间复杂度高达 $\mathcal{O}(N^3 d + N^2 d^2)$，根本无法满足在线推理的严苛延迟要求。

2. HSTU 相对于 Self-Attention 的核心改进

HSTU 对传统的自注意力架构进行了大刀阔斧的重构，专门针对推荐数据的非平稳、极度稀疏特性进行了优化。

2.1 彻底抛弃笨重的 MLP 层

HSTU 最大的架构创新在于完全移除了传统的 MLP 层。它将多头注意力与前馈网络融合，替换为单层线性投影与门控网络。HSTU 巧妙地将计算分为两步：空间聚合（Spatial Aggregation）与点式变换（Pointwise Transformation）。

为了更直观地理解，我们可以看下面这张 HSTU 的微观结构图：

graph LR classDef input fill:#f9f9f9,stroke:#333,stroke-width:2px; classDef linear fill:#e1f5fe,stroke:#2563eb,stroke-width:1px; classDef act fill:#fef3c7,stroke:#ea580c,stroke-width:1px; classDef attention fill:#dcfce7,stroke:#b45309,stroke-width:1px; classDef output fill:#f0fdf4,stroke:#16a34a,stroke-width:2px; Input["输入 X"]:::input Norm1["LayerNorm"]:::linear Linear1["Linear f1"]:::linear SiLU1["SiLU φ1"]:::act Split["Split → U,V,Q,K"]:::linear %% Spatial Aggregation Attn["QK^T + Bias"]:::attention SiLU2["SiLU φ2"]:::act Mul_V["Score ⊙ V"]:::attention %% Pointwise Transformation Norm2["LayerNorm"]:::linear Mul_U["Norm ⊙ U"]:::linear Linear2["Linear f2"]:::linear Output["输出 Y"]:::output Input --> Norm1 --> Linear1 --> SiLU1 --> Split Split -->|"Q,K"| Attn --> SiLU2 --> Mul_V Split -->|"V"| Mul_V Mul_V --> Norm2 --> Mul_U --> Linear2 --> Output Split -->|"U"| Mul_U Input -->|"残差连接"| Output

核心计算公式如下：

$$ U(X), V(X), Q(X), K(X) = \text{Split}(\phi_1(f_1(X))) $$

$$ A(X)V(X) = \phi_2 \left( Q(X)K(X)^T + r_{p,t}^{ab} \right) V(X) $$

$$ Y(X) = f_2(\text{Norm}(A(X)V(X)) \odot U(X)) $$

其中，$f_1, f_2$ 为单层线性变换，$\phi_1, \phi_2$ 为 SiLU 激活函数，$r_{p,t}^{ab}$ 为融合了时序和位置的相对偏差。

改进收益：通过使用门控逐元素融合输出，HSTU 极大地减少了浮点运算量（FLOPs），并完美契合底层硬件的算子融合（Fused Kernel），极大提升了显存带宽利用率。

2.2 生成式训练与时间复杂度骤降

为什么标准 Transformer 在推荐系统中复杂度会变成 $\mathcal{O}(N^3)$？

在 NLP 中，Transformer 处理单条长度为 $N$ 的序列，时间复杂度是大家熟知的 $\mathcal{O}(N^2d + Nd^2)$。但在传统的推荐系统（如早期的 SASRec）中，通常采用流式逐样本（Impression-level）训练。假设用户有历史序列 $[i_1, i_2, \dots, i_N]$，传统框架需要将其拆分为 $N$ 个独立的训练样本：

样本 1：历史 $[i_1]$，预测 $i_2$
样本 2：历史 $[i_1, i_2]$，预测 $i_3$
…
样本 $N$：历史 $[i_1, \dots, i_{N-1}]$，预测 $i_N$

这意味着 Transformer 需要对这 $N$ 个逐渐变长的子序列分别进行前向计算。我们将这 $N$ 个独立样本的计算量累加：

$$ \text{Total Complexity} = \sum_{k=1}^{N} \mathcal{O}(k^2d + kd^2) $$

根据求和公式 $\sum_{k=1}^{N} k^2 \approx \frac{N^3}{3}$，总的训练时间复杂度就灾难性地飙升到了 $\mathcal{O}(N^3d + N^2d^2)$。当用户序列 $N=10^4$ 时，计算量呈三次方级数爆炸，完全无法训练。

HSTU 的降维打击：Generative Training

在训练方式上，HSTU 采用了生成式训练（Generative Training），彻底摒弃了传统的逐样本拆分。它向 LLM 学习，把整个长度为 $N$ 的用户序列作为一个完整的样本送入模型，配合因果掩码（Causal Mask），在一次前向传播中同时完成对所有历史节点的预测。

这一改变干掉了那层可怕的 $\sum_{k=1}^{N}$ 循环，成功将训练的时间复杂度指数级降维回了 $\mathcal{O}(N^2 d + N d^2)$。同时，在推理阶段引入了 M-FALCON 微批处理算法，能够全面摊销超长序列的计算成本。

2.3 极端的特征序列化：丢弃数值特征

这篇论文中一个非常反直觉但极为有效的操作是：完全移除传统的数值特征（如历史 CTR 统计）。 HSTU 摒弃了 DLRM 复杂的并行特征网络，将用户交互行为（如点击、点赞）与慢变分类特征（如用户画像）按照时间戳合并压缩为一条主时间序列。作者证明了，只要序列模型足够强大，它完全可以直接从极长的原始历史交互中自行捕获这些统计概率，无需人工干预。

3. 架构流程图

graph TD A[海量异构特征 Categorical & Numerical] --> B[丢弃数值特征 / 保留分类特征] B --> C[特征序列化与时间轴压缩] C --> D[合并为统一单时间序列] D --> E[Generative Training 生成式训练] E --> F[HSTU 编码器] F --> G[Pointwise Projection: 线性生成 U,V,Q,K] G --> H[Spatial Aggregation: 时空注意力与 SiLU 激活] H --> I[Pointwise Transformation: 门控逐元素融合输出] I --> J[多任务预测: 排序 Ranking / 召回 Retrieval]

4. 结论与工业界影响

惊人的速度优势：在长度为 8192 的长序列上，HSTU 的推理和训练速度比基于 FlashAttention2 的标准 Transformer 快了 5.3 倍到 15.2 倍。
效果跃升：在公开数据集上，HSTU 的 NDCG 指标最高超越基线模型达 65.8%。
万亿参数与 Scaling Law 验证：包含 1.5 万亿参数的 GRs 模型在十亿级用户的互联网平台上成功落地，线上核心指标提升 12.4%。

最重要的是，该研究首次在推荐系统领域证实了：推荐模型的质量随训练算力的增加呈幂律分布（Power-law），跨越了三个数量级（达到 GPT-3 / LLaMA-2 级别的算力），彻底打破了 DLRM 时代的瓶颈，为推荐领域的“基础大模型（Foundation Models）”铺平了道路。

FuXi-Linear：释放线性注意力在超长序列推荐中的潜力

Thu, 19 Mar 2026 21:00:00 +0800

本文是关于最新论文《FuXi-Linear: Unleashing the Power of Linear Attention in Long-term Time-aware Sequential Recommendation》（）的阅读笔记。

1. 背景与动机

在现代推荐系统中，基于 Transformer 的序列推荐模型已经成为主流范式。从早期的 SASRec、BERT4Rec，到近年来的 HSTU、gSASRec 等，Transformer 架构凭借其强大的全局注意力机制，在捕捉用户行为序列中的长程依赖关系方面表现优异。

然而，传统 Softmax 注意力机制的核心瓶颈在于其 二次复杂度 $\mathcal{O}(n^2)$。具体来说：

显存瓶颈：当用户行为序列长度超过 $10^4$ 时，注意力矩阵本身就需要占用 GB 级显存，这在工业级在线推理场景中几乎不可接受
延迟瓶颈：每次新增一个交互事件，都需要重新计算完整的注意力矩阵，导致自回归推理的延迟线性增长
吞吐量瓶颈：GPU 的计算资源被大量浪费在注意力矩阵的计算上，无法有效提升单卡的服务吞吐量

在 NLP 领域，”线性注意力（Linear Attention）”架构已经展现了巨大的潜力。以 Mamba、RWKV、RetNet、GLA 为代表的一系列工作，通过不同的技巧将注意力的复杂度从 $\mathcal{O}(n^2)$ 降低到 $\mathcal{O}(n)$，甚至在递归推理模式下做到 $\mathcal{O}(1)$ 的单步复杂度。

但是，将这些线性架构直接”生搬硬套”到推荐系统中，却面临着诸多水土不服的问题。推荐系统中的用户行为序列与自然语言文本有着本质的区别：

行为序列中蕴含着丰富的 时间戳信息（何时发生交互），而不仅仅是简单的位置顺序
用户行为呈现出强烈的 周期性模式（如工作日 vs 周末、白天 vs 夜晚），这在纯文本中并不存在
推荐场景对 位置精度 的要求更高，因为”最近点击了什么”与”很久之前点击了什么”在推荐相关性上有着天壤之别

FuXi-Linear 正是为了系统性地解决这些问题而提出的一种全新架构，来自中国科学技术大学的 StarTeam 团队。

2. 线性模型在推荐系统中的三大挑战

论文深入分析了现有线性模型在推荐系统中应用时面临的核心痛点：

2.1 挑战一：时间信号利用不佳

现有的方法通常把”时间戳”当作一种普通特征，直接与物品的”语义特征”进行拼接或相加。这种做法存在严重的缺陷：

信号耦合干扰：语义特征（如商品类目、品牌）和时间特征（如交互时刻、时间间隔）被强制混合在同一个向量空间中，两种信号的梯度更新会相互干扰，导致两者都无法被充分学习
周期性建模缺失：用户行为往往具有明显的周期性模式。例如，一个用户可能每周末下午才会浏览游戏相关内容，工作日则主要关注办公用品。简单的时间戳拼接无法显式捕获这种周期性规律
时间分辨率不足：将时间戳离散化为特征后，模型很难感知到细粒度的时间差异，例如”5 分钟前点击”与”5 小时前点击”的区别

2.2 挑战二：位置信息缺失

传统 Transformer 通常使用相对位置编码（RPE，如 T5 bias、ALiBi、RoPE）来提供精确的位置感知能力。但在线性注意力的框架下，RPE 面临严峻的兼容性问题：

计算复杂度冲突：RPE 需要两两计算 token 之间的相对距离，这本身就是 $\mathcal{O}(n^2)$ 的操作，直接破坏了线性注意力的复杂度优势
递归形式不兼容：线性注意力的高效推理依赖于 RNN 式的递归计算，而 RPE 无法被分解为递归形式
自然衰减粒度太粗：线性模型（如 RetNet）自带的指数衰减机制虽然提供了一定的位置偏置，但其表达能力远不如 RPE，无法精细区分不同相对距离的重要性差异

2.3 挑战三：缺乏长序列扩展性

从工程实践角度来看，现有的线性推荐模型存在明显的验证缺口：

序列长度有限：大多数现有工作仅在短序列场景下测试（长度 $\le 100$），远未触及线性模型真正的优势区间
模型规模偏小：测试通常使用浅层网络（1-2 层）和小维度（$d \le 128$），无法证明线性模型能否通过增加参数量持续获得收益
缺少 Scaling Law 验证：在 NLP 领域，Scaling Law 已经成为衡量架构潜力的核心指标。但在推荐系统中，线性架构从未被验证过是否存在类似的幂律缩放特性

3. FuXi-Linear 的核心架构创新

为了系统性地解决上述三大挑战，FuXi-Linear 设计了一种 三通道并行架构：三个独立的通道分别负责处理语义信号、位置信号和时序信号，最终通过门控机制进行自适应融合。

3.1 语义保留通道 (Retention Channel)

语义保留通道是模型的核心骨干，负责从用户行为序列中提取物品之间的语义关联。该通道采用类似 RetNet 的 Retention 机制替代传统全注意力，其核心公式为：

$$ Retention(Q,K,V,D) = (QK^T \odot D)V $$

其中衰减矩阵 $D_{i,j} = \gamma^{i-j}$，$\gamma$ 为可学习参数。

这个设计的精妙之处在于它支持 双模式计算：

并行模式（训练时）：将整个序列的 $Q$、$K$、$V$ 一次性计算，通过矩阵乘法高效并行处理。衰减矩阵 $D$ 作为 mask 直接应用于注意力矩阵，训练效率与标准 Transformer 相当
递归模式（推理时）：将状态压缩为固定大小的 KV 缓存矩阵 $S_t$，每步更新规则为 $S_t = \gamma S_{t-1} + K_t^T V_t$。新 token 的输出仅需 $O_t = Q_t S_t$，单步复杂度降为 $\mathcal{O}(1)$

多头设计：为了增强表达能力，语义保留通道采用多头机制，不同的头使用不同的衰减率 $\gamma$。较大的 $\gamma$ 关注长程依赖，较小的 $\gamma$ 侧重近期行为，从而实现多尺度的语义捕获。

3.2 线性位置通道 (Linear Positional Channel)

这是本文最精妙的技术创新之一，也是解决”位置信息缺失”挑战的关键。

核心思路：传统的相对位置编码计算 $f(x-y)$（其中 $x$ 和 $y$ 是两个 token 的位置），这需要两两配对计算，复杂度为 $\mathcal{O}(n^2)$。作者的关键洞察是：可以通过引入一组可学习的核函数映射 $\mathbf{k}(x)$，将位置差函数分解为内积形式：

$$ f(x-y) \approx g(x,y) = \mathbf{k}^T(x)\mathbf{k}(y) $$

技术细节：

核函数 $\mathbf{k}(x)$ 由一个小型 MLP 实现，输入为位置索引 $x$，输出为一个低维向量
由于内积可以被分解为外积的累积和，因此这个近似可以完美嵌入线性注意力的递归计算框架
论文中证明了该近似的误差上界，保证了在合理的核函数维度下，近似精度足以替代精确的 RPE

效果：这个设计在 维持线性递归特性 的同时，让模型获得了接近于精确 RPE 的位置感知能力。这解决了线性注意力领域长期以来”位置编码与线性复杂度不可兼得”的难题。

3.3 时序保留通道 (Temporal Retention Channel)

为了实现时间信号与语义信号的彻底解耦，FuXi-Linear 专门开辟了一条独立的时序通道。

设计要点：

独立的 Query/Key 生成：该通道 完全利用时间戳数据 生成 Query 和 Key，不混入任何物品语义特征。时间戳经过编码后（包含绝对时间和相对时间差），通过独立的线性变换映射为 $Q_t$ 和 $K_t$
周期性捕获：由于时间戳信息不被语义信号”污染”，模型可以专注学习用户行为的周期模式。例如用户的日内活跃周期（通勤时段 vs 睡眠时段）、周内活跃周期（工作日 vs 周末）、甚至更长期的季节性模式
Value 复用：该通道的 Value 矩阵仍然来自物品的语义表征，确保时序通道的输出仍然承载有意义的语义信息，只是”按时间规律重新加权”
同样支持双模式：时序通道也采用了与语义通道相同的 Retention 框架，保证训练和推理时的双模式兼容性

3.4 门控融合与前馈网络

三个通道的输出通过 拼接 + 门控机制 进行融合：

首先将三个通道的输出在特征维度上拼接
然后通过一个可学习的门控向量对不同通道的贡献进行自适应加权
最后送入 MFFN（Multi-stage Feed-Forward Network） 进一步提炼特征

MFFN 相比标准的 FFN 引入了多阶段的非线性变换，增强了模型在有限层数下的表达能力。

4. 架构流程图

graph TD A[用户历史交互序列 + 时间戳] --> B[Embedding 层] B --> C[FuXi-Linear Block] C -->|输入 X| D1[Retention Channel
提取语义信息] C -->|时间戳| D2[Temporal Retention Channel
提取周期性时序信号] C -->|位置信息| D3[Linear Positional Channel
相对位置建模] D1 --> E[Concatenation & Gating
特征拼接与门控机制] D2 --> E D3 --> E E --> F[MFFN 多阶段前馈网络] F --> G[下一个 Item 预测]

5. 线性注意力 vs Softmax 注意力：详细对比

为了更好地理解 FuXi-Linear 的技术定位，下面从多个维度对比线性注意力和传统 Softmax 注意力：

维度	Softmax 注意力	线性注意力（FuXi-Linear）
计算复杂度（训练）	$\mathcal{O}(n^2 d)$	$\mathcal{O}(n d^2)$，当 $d \ll n$ 时显著更优
计算复杂度（推理单步）	$\mathcal{O}(nd)$，需读取完整 KV Cache	$\mathcal{O}(d^2)$，固定大小状态矩阵
KV Cache 大小	随序列长度线性增长	固定大小 $d \times d$
位置编码兼容性	原生支持 RoPE、ALiBi 等 RPE	需要特殊设计（如本文的核函数近似）
长程依赖建模	理论上无限，但实践中受限于上下文窗口	通过衰减矩阵隐式建模，长距离信号衰减
并行训练效率	高，原生支持矩阵并行	高，chunk-wise 并行或全矩阵并行
Prefill 速度	基线	约 10x 加速
Decode 速度	基线	约 21x 加速

核心差异总结：

当序列长度 $n$ 远大于特征维度 $d$ 时（推荐系统中通常 $n > 1000$，$d = 128 \sim 256$），线性注意力在速度上具有压倒性优势
Softmax 注意力在短序列场景下仍有竞争力，因为其注意力分布更加”尖锐”，信息选择能力更强
FuXi-Linear 通过三通道设计弥补了线性注意力在位置编码和时间建模上的天然短板

6. 与其他推荐方法的对比

方法	注意力类型	时间信号建模	位置编码	推理复杂度	长序列支持
SASRec	Softmax	无	绝对位置	$\mathcal{O}(nd)$	弱（通常截断 50-200）
HSTU	Softmax + 相对时间	时间间隔融合	相对位置	$\mathcal{O}(nd)$	中（支持 1000+）
LinRec	线性核近似	无	绝对位置	$\mathcal{O}(d^2)$	中（仅短序列验证）
Mamba4Rec	SSM (Mamba)	无	隐式（SSM 状态）	$\mathcal{O}(d)$	中（缺少长序列验证）
FuXi-Linear	三通道 Retention	独立时序通道	核函数近似 RPE	$\mathcal{O}(d^2)$	强（验证至 $10^4$ 级）

关键观察：

FuXi-Linear 是目前唯一同时解决了时间建模、位置编码和长序列扩展三个问题的线性推荐架构
相比 Mamba4Rec 等直接迁移 NLP 架构的方案，FuXi-Linear 针对推荐场景做了深度定制
与 HSTU 等 Softmax 方案相比，FuXi-Linear 在推理效率上有数量级的优势

7. 实验结果详细分析

FuXi-Linear 在多个包含千级长度序列的真实数据集上进行了全面验证。

7.1 推荐质量

在 MovieLens-25M、Amazon Reviews 等多个公开数据集上，FuXi-Linear 的表现：

在 Hit Rate@10 和 NDCG@10 等核心指标上，FuXi-Linear 相比最强的 Softmax Transformer 基线取得了一致性的提升
提升幅度在不同数据集上有所不同，但在长序列数据集上的提升尤为明显，这说明三通道架构在长序列场景下的优势更加突出
相比其他线性推荐模型（如 LinRec、Mamba4Rec），FuXi-Linear 的提升更为显著，验证了专门设计的必要性

7.2 推理效率

这是 FuXi-Linear 最亮眼的实验结果：

Prefill 阶段：相比最强 Transformer 基线，实现了高达 10x 的加速。Prefill 是指首次处理用户完整历史序列的阶段，这对冷启动和重建缓存场景至关重要
Decode 阶段：实现了高达 21x 的加速。Decode 是指每次用户产生新行为后的增量推理阶段，这是在线服务中最高频的操作
显存占用：由于 KV Cache 大小固定，FuXi-Linear 的显存占用不随序列长度增长，在超长序列场景下节省了大量显存

7.3 Scaling Law 验证

这是论文的另一大核心贡献。作者系统性地验证了 FuXi-Linear 的缩放特性：

模型规模缩放：随着模型参数量从小到大增长，推荐指标呈现出稳健的 幂律缩放特性（Power-law scaling），即 $\text{Loss} \propto N^{-\alpha}$
序列长度缩放：随着输入序列长度的增加，模型性能持续提升且未出现饱和迹象，这说明 FuXi-Linear 能够有效利用更长的用户历史
这是推荐系统中首次在线性架构上验证 Scaling Law，意义重大：它为工业界提供了”增加计算预算就能持续获得收益”的理论保障

7.4 消融实验

论文通过消融实验验证了各组件的贡献：

移除时序保留通道后，模型在具有明显周期性行为的数据集上性能显著下降
移除线性位置通道后，模型的位置感知能力退化，近期行为的权重分配不合理
将三通道改为单通道（混合所有信号）后，整体性能明显下降，验证了特征解耦的必要性

8. 优缺点分析

8.1 优势

极致的推理效率：三通道均基于线性递归计算，Decode 阶段单步复杂度为 $\mathcal{O}(d^2)$，不随序列长度增长。在实际测试中实现了 10-21x 的加速，这对工业级在线推理系统意义重大
系统性的信号解耦：将语义、位置、时序三种信号分离到独立通道中处理，避免了信号间的相互干扰。这不仅提升了模型性能，也增强了可解释性——可以分别分析每个通道学到了什么
优雅的位置编码方案：通过核函数近似将 RPE 分解为内积形式，在保持线性复杂度的同时获得了精确的位置感知能力，这是一个具有通用价值的技术贡献
经过验证的 Scaling Law：首次在推荐系统的线性架构中验证了幂律缩放特性，为工业界大规模部署提供了理论保障
双模式兼容：支持并行训练和递归推理两种模式，训练效率和推理效率均不妥协

8.2 不足与局限

模型复杂度增加：三通道并行设计引入了更多的参数和超参数（如各通道的头数、维度分配、衰减率初始化等），模型调优的成本相应增加
长程精确召回能力有限：线性注意力的固有局限在于其状态矩阵大小固定（$d \times d$），这意味着当序列极长时，早期的信息不可避免地会被压缩和遗忘。对于需要精确回忆”很久以前某次特定交互”的场景，Softmax 注意力仍有优势
核函数近似的理论上限：线性位置通道的核函数近似虽然有效，但毕竟是一种有损近似。核函数的维度需要权衡精度和效率，在某些对位置极其敏感的场景下，可能无法完全替代精确 RPE
工业验证尚不充分：论文的实验主要基于公开数据集，尚未公布在大规模工业推荐系统（如亿级用户、十亿级物品库）中的实际部署效果和资源消耗数据

9. 工程实践启示

从工程落地的角度来看，FuXi-Linear 提供了以下有价值的启示：

9.1 部署架构建议

增量推理优先：FuXi-Linear 最大的工程价值在于其 $\mathcal{O}(1)$ 的 Decode 复杂度。在实际部署时，应优先采用”首次 Prefill + 后续增量 Decode”的模式，而非每次请求都重新计算完整序列
状态缓存设计：由于递归状态矩阵大小固定，可以将用户的状态矩阵持久化存储（如 Redis），实现真正的”实时增量推荐”
分层序列策略：对于超长序列，可以考虑将远期历史和近期历史分别处理，远期历史使用更大衰减率的压缩状态，近期历史使用完整的注意力计算

9.2 训练优化建议

Chunk-wise 并行训练：对于超长序列，将序列分为多个 chunk，chunk 内并行计算、chunk 间递归传递状态，可以有效平衡训练速度和显存占用
衰减率初始化：不同头的衰减率 $\gamma$ 应该采用差异化初始化（如等比数列），避免所有头学到相似的衰减模式
渐进式序列增长：训练时可以采用”课程学习”策略，先在短序列上预训练，再逐步增加序列长度，有助于模型更好地学习长程依赖

9.3 适用场景判断

FuXi-Linear 最适合以下场景：

用户行为序列长度超过 500，传统 Transformer 面临效率瓶颈
用户行为具有明显的时间周期性模式
系统对推理延迟有严格要求（如 <10ms 的 P99 延迟）
需要支持实时增量推理，而非批量离线计算

10. 总结与展望

FuXi-Linear 通过精心设计的三通道架构，系统性地解决了线性注意力在推荐系统中面临的时间建模、位置编码和长序列扩展三大挑战。其核心贡献可以概括为：

架构层面：三通道并行 + 门控融合的设计范式，实现了语义、位置、时序信号的有效解耦
理论层面：核函数近似 RPE 的方法，解决了线性注意力与相对位置编码不兼容的难题
实证层面：首次在推荐系统中验证了线性架构的 Scaling Law，为大规模部署提供了信心

展望未来，FuXi-Linear 开辟了一条”高效线性架构 + 推荐场景深度定制”的新路径。随着用户行为数据的持续增长和在线推理效率要求的不断提高，这类架构有望成为下一代工业推荐系统的核心基座。

开源代码：官方代码库已经开源在 GitHub: 。

TokenMixer-Large: 突破工业级推荐系统的大模型扩展瓶颈

Wed, 18 Mar 2026 10:15:00 +0800

来源元数据 (Metadata)

原文标题: TokenMixer-Large: Scaling Up Large Ranking Models in Industrial Recommenders
原文链接:
来源: Arxiv (ByteDance 团队)
作者: Yuchen Jiang, Jie Zhu, Xintian Han, Hui Lu, Kunmin Bai, Mingyu Yang, Shikang Wu 等

核心摘要 (Executive Summary)

针对工业级推荐系统面临的大模型扩展瓶颈，本文提出了 TokenMixer-Large 架构，通过引入“Mixing & Reverting”操作、层间残差、辅助损失以及稀疏 Per-token MoE 等一系列创新，解决了深层网络中的梯度消失、MoE 稀疏化不足以及硬件利用率低等问题，在字节跳动的核心业务（电商、广告、直播）中成功扩展至百亿参数规模，并取得了显著的在线业务增长。

深度解读 (Deep Dive)

核心痛点

随着推荐系统大模型（DLRM）尝试向大规模参数扩展，现有的主流架构（如 RankMixer、Wukong、DHEN）在实际应用中暴露出多个严重瓶颈：

次优的残差设计: RankMixer 等架构通过 Mixing 操作改变了 Token 的维度和数量，导致前后残差连接时 Token 的语义无法对齐，限制了模型的表现上限。
不纯粹的模型架构: 由于历史迭代，推荐模型中通常保留了许多琐碎、访存密集型的底层算子（如 LHUC、DCNv2），导致整体模型的计算利用率 (MFU) 极低。
深层网络梯度更新不足: 传统的 TokenMixer 往往只有浅层配置（如 2 层），随着网络加深，梯度消失问题严重，难以保持训练稳定性。
MoE 稀疏化不足: 原有的 ReLU-MoE 设计局限于“稠密训练、稀疏推理”范式，并未降低训练成本，且动态激活机制对推理极不友好。
扩展性受限: 受限于上述原因，工业界之前的探索仅止步于 10亿（1B）参数级别。

方法论 (Methodology)

1. 整体设计思路

TokenMixer-Large 的设计哲学可以用一句话概括：以”纯净架构”为基座，通过深度残差与稀疏化实现工业级大模型的高效扩展。具体来说，团队遵循了以下三条核心设计原则：

架构纯净化 (Architecture Purification)：移除所有历史遗留的碎片化算子，仅保留高计算密度的矩阵乘法操作，最大化 GPU 的 MFU（Model FLOPs Utilization）
残差对齐化 (Residual Alignment)：通过 Mixing-Reverting 的对称设计，确保跨层残差连接的语义一致性，为深层网络训练铺平道路
稀疏高效化 (Sparse Efficiency)：采用 Per-token MoE 实现真正的”稀疏训练+稀疏推理”，在保持模型容量的同时大幅降低计算开销

2. TokenMixer-Large 与初代 TokenMixer (RankMixer) 的核心区别

在理解 TokenMixer-Large 的创新之前，我们必须先看清它对初代架构做了哪些大刀阔斧的”革命”。以下是四个核心差异点：

2.1 从“维度错位”到“Mixing & Reverting 绝对对齐”

初代 TokenMixer 的痛点：在进行 Token 混合（Mixing）时，将 $T$ 个 token 强行变为 $H$ 个。输入输出维度不匹配，导致直接加和时产生语义错位，无法实现有效的跨层残差连接。
Large 版本的解法：设计了高度对称的“双层结构”：
- Mixing 层：负责跨 Token 混合信息 ($T \rightarrow H$)。
- Reverting 层：专门将混合后的 Token 维度完美恢复到原始状态 ($H \rightarrow T$)。这种设计确保了输入和输出维度的绝对一致性，构建出平滑且语义对齐的深度残差通道。

# 伪代码演示
# 输入 X: [T, D], T为Token数, D为维度

# 1. Mixing 阶段
H = Split_and_Concat(X) # 将 T 个 token 混合为 H 个, 维度变为 [H, T*D/H]
H_next = Norm(pSwiGLU(H) + H)

# 2. Reverting 阶段
X_revert = Split_and_Concat_Back(H_next) # 将 H 个 token 还原为 T 个, 维度恢复为 [T, D]
X_next = Norm(pSwiGLU(X_revert) + X) # 语义严格对齐的残差连接

2.2 从”碎片化算子堆砌”到”纯净架构 (Pure Architecture)”

初代 TokenMixer 的痛点：由于历史迭代，模型中通常堆砌了许多细碎、访存密集型的底层算子（如 LHUC、DCNv2），导致整体模型在 GPU 上的计算利用率（MFU）极低。
Large 版本的解法：剥离所有底层低效交互算子，将 Post-LayerNorm 替换为 Pre-RMSNorm，使用 pSwiGLU 替换 pFFN。完全依靠堆叠纯净的 TokenMixer-Large Block 进行特征交叉，使得核心广告模型的 MFU 飙升至 60%。

关于组件替换的详细说明：

Pre-RMSNorm vs Post-LayerNorm：Pre-RMSNorm 将归一化操作放在子层的输入端而非输出端，省去了均值计算步骤，减少了约 30% 的归一化开销。更重要的是，Pre-Norm 结构使得残差通道中的梯度流动更加顺畅，有利于深层网络的训练稳定性。
pSwiGLU vs pFFN：pSwiGLU（Per-token SwiGLU）将传统的 ReLU 激活替换为 SiLU（Swish）门控线性单元，引入了乘法门控机制，增强了特征的非线性表达能力。其公式为 $\text{SwiGLU}(x) = (xW_1) \otimes \text{SiLU}(xW_2)$，相比传统 FFN 增加了约 50% 的参数量，但带来的效果提升远超参数增长。

2.3 从”浅层堆叠”到”深层跨层残差 (Inter-Layer Residuals)”

初代 TokenMixer 的痛点：随着网络加深（如从浅层的 2 层扩展到深层），极易发生梯度消失现象。
Large 版本的解法：采取了”组合拳”：
- 跨层残差与辅助损失：每隔 2-3 层引入跨层残差连接，并将底层输出与高层输出结合计算辅助损失（Auxiliary Loss）。
- Rezero 初始化：将 SwiGLU 中最后一个投影矩阵的初始化方差缩小为 0.01，使模块在训练初期接近恒等映射，极大提升了模型收敛的稳定性。

2.4 稀疏 Per-token MoE (Sparse-Pertoken MoE) 的进化

初代 TokenMixer 的痛点：原有的 ReLU-MoE 设计局限于“稠密训练、稀疏推理”范式，并未真正降低训练成本，且动态激活对线上推理极不友好。
Large 版本的解法：采用**“先扩大，后稀疏” (First Enlarge, Then Sparse)** 的端到端策略：
1. 将 Per-token SwiGLU 拆分为多个细粒度的专家（Expert）并进行稀疏激活。
2. 引入 门控值缩放 (Gate Value Scaling) 来解决稀疏化带来的梯度更新不足问题。
3. 加入 共享专家 (Shared Expert) 以稳定训练过程。

这使得模型能够真正实现”稀疏训练与稀疏推理”。在实验中，模型在仅激活一半参数（2.3B out of 4.6B）的情况下，FLOPs 下降近半，但取得了与稠密模型完全相同的业务增益（AUC +1.14%）。

与其他方法的对比分析

为了更全面地理解 TokenMixer-Large 的定位和优势，我们从架构设计、训练效率和扩展能力三个维度进行横向对比：

维度一：架构设计对比

对比项	DLRM-MLP	Wukong	DHEN	RankMixer	TokenMixer-Large
特征交叉方式	MLP 隐式交叉	双塔交叉网络	层次化显式交叉	Token Mixing	Mixing & Reverting
残差连接	简单残差	跨塔残差	层内残差	维度错位残差	语义对齐残差
归一化方式	BatchNorm	LayerNorm	LayerNorm	Post-LayerNorm	Pre-RMSNorm
激活函数	ReLU	ReLU	ReLU	FFN	pSwiGLU
稀疏化支持	无	无	无	ReLU-MoE	Per-token MoE

维度二：训练效率对比

对比项	DLRM-MLP	Wukong	RankMixer	TokenMixer-Large
GPU MFU	< 10%	~15%	~25%	~60%
碎片化算子	大量	中等	中等	无
训练稳定性	浅层稳定	一般	深层退化	深层稳定
训练范式	稠密	稠密	稠密训练稀疏推理	稀疏训练+稀疏推理

维度三：扩展能力对比

对比项	DLRM-MLP	Wukong	RankMixer	TokenMixer-Large
已验证最大参数量	~500M	~1B	~1B	15B（离线）/ 7B（在线）
Scaling Law 表现	早期饱和	有限提升	中等	持续提升
多业务验证	单一场景	有限场景	有限场景	电商/广告/直播

实验结果详细分析

Scaling Law 验证

TokenMixer-Large 在离线实验中展现出了清晰的 Scaling Law 特性：

500M -> 1B：CTCVR AUC 持续提升，验证了架构设计的有效性
1B -> 4B：引入 Sparse-Pertoken MoE 后，模型在激活参数仅为 2.3B 的情况下达到了与 4.6B 稠密模型相当的性能
4B -> 15B：离线实验表明 AUC 仍在持续提升，未出现明显的饱和趋势

消融实验关键发现

论文中的消融实验揭示了几个重要结论：

Mixing & Reverting 的必要性：去除 Reverting 层后，AUC 下降约 0.15%，证明语义对齐的残差连接对深层网络至关重要
跨层残差的贡献：去除跨层残差后，深层模型（>6 层）出现明显的训练不稳定，AUC 波动加剧
Rezero 初始化的作用：将初始化方差从标准值改为 0.01 后，训练初期的 loss 曲线更加平滑，最终收敛效果提升约 0.08% AUC
门控值缩放的影响：在 MoE 稀疏化场景中，移除门控值缩放会导致约 0.12% 的 AUC 损失，验证了其对缓解稀疏梯度更新不足的有效性

流程图 (Flowchart)

graph LR A[Sparse Features] --> B[Embedding & Tokenizer] B --> C[Grouped Tokens X] D["Mixing: Split & Concat"] --> E["SwiGLU + Norm"] E --> F["Reverting"] --> G["SwiGLU + Norm"] C --> D C -.->|Residual| G G --> H[Deep Layers + MoE] H --> I[Pooling & Prediction]

优缺点分析

优势

架构简洁高效：通过彻底移除碎片化算子，TokenMixer-Large 将 GPU MFU 提升至 60%，这意味着同样的硬件资源可以训练更大的模型。这种”少即是多”的设计理念在工业界具有重要的参考价值。
真正的稀疏训练+推理：不同于 ReLU-MoE 的”稠密训练、稀疏推理”，Per-token MoE 实现了端到端的稀疏化，使得训练成本和推理成本同时降低。这对于大规模在线服务的部署预算控制至关重要。
经过大规模工业验证：该架构已在字节跳动电商、广告、直播三大核心业务线上线验证，覆盖了推荐系统的主要应用场景，证明了其普适性和鲁棒性。
清晰的 Scaling Law：实验证明了模型在 500M 到 15B 参数范围内持续受益于规模扩展，为后续进一步扩展提供了明确的方向。

不足

Embedding 层优化不足：论文主要聚焦于排序模型（Ranking Model）的上层架构，对 Embedding 层的优化讨论较少。而在实际工业系统中，Embedding 层往往占据了模型参数量的绝大部分（通常超过 90%），如何高效地扩展 Embedding 仍是一个开放问题。
训练基础设施要求高：扩展至 7B-15B 参数规模需要大量的 GPU 资源和分布式训练框架支持。论文对多机多卡的并行策略、通信优化等工程细节披露有限，其他团队复现的门槛较高。
冷启动与长尾问题未涉及：文章主要关注整体指标（AUC、GMV）的提升，未讨论大模型在推荐系统冷启动场景和长尾物品推荐上的表现，而这些恰恰是工业推荐系统的核心痛点。
跨域泛化能力有待验证：虽然在字节跳动内部三个业务线均有验证，但不同公司的推荐系统在数据分布、特征工程、业务目标上差异巨大，该架构的跨域迁移能力尚需更多外部验证。

工程实践启示

对于正在探索推荐系统大模型化的团队，TokenMixer-Large 提供了以下工程实践启示：

1. 先做架构”减法”，再做规模”加法”

在盲目扩大模型参数之前，优先审视现有架构中的碎片化算子
统计各算子的 FLOPs 占比和延迟占比，找出”高延迟、低计算”的瓶颈算子
逐步替换为高计算密度的标准化组件（如将各类特征交叉算子统一为矩阵乘法）

2. 渐进式扩展策略

不要一步跳到超大规模，建议按照 500M -> 1B -> 4B -> 10B 的节奏逐步扩展
每个阶段都需要充分的离线实验和在线 A/B 测试验证
关注 Scaling Law 曲线的拐点，当 AUC 提升开始饱和时及时调整策略

3. 稀疏化是大模型落地的关键

对于超过 1B 参数的在线推理模型，MoE 稀疏化几乎是必选项
建议同时评估训练和推理两端的稀疏化方案，优先选择能同时降低两端成本的方案
门控值缩放和共享专家等稳定化技巧在实践中非常重要，不可省略

4. MFU 是核心效率指标

将 MFU 纳入模型迭代的核心监控指标
目标至少达到 40% 以上（TokenMixer-Large 达到了 60%）
低 MFU 往往意味着存在大量的访存瓶颈或通信开销，需要针对性优化

结论 (Conclusion)

TokenMixer-Large 验证了在去除历史碎片化算子后，”纯净架构+大规模堆叠”在推荐领域的有效性。模型在离线实验中成功扩展至 150亿 (15B) 参数，在线部署达到了 70亿 (7B) 参数。在字节跳动核心业务取得巨大收益：

电商: 订单量提升 1.66%，人均 GMV 提升 2.98%
广告: ADSS 提升 2.0%
直播: 收入增长 1.4%

关键代码/数据

核心数据对比 (电商场景 500M 规模基线对比):

模型	参数量	训练 FLOPs/Batch	CTCVR AUC 提升
DLRM-MLP	499 M	125.1 T	基线
Wukong	513 M	4.6 T	+0.76%
RankMixer	567 M	4.6 T	+0.84%
TokenMixer-Large 500M	501 M	4.2 T	+0.94%
TokenMixer-Large 4B SP-MoE	2.3B 激活	15.1 T	+1.14%

注：Sparse-Pertoken MoE 在激活仅一半参数（2.3B in 4.6B）的情况下，不仅显著降低了 FLOPs，还达到了与稠密模型完全相同的业务增益，实现了极高的性价比 (ROI)。

总结与展望

TokenMixer-Large 的成功为工业级推荐系统的大模型化树立了一个重要的里程碑。它证明了推荐系统同样遵循 Scaling Law，只要架构设计得当，参数规模的扩展能够持续带来业务增益。

未来值得关注的方向包括：

多模态融合：将文本、图片等多模态特征纳入 TokenMixer 框架，进一步提升推荐质量
在线学习与实时更新：探索大模型在在线学习场景下的高效更新策略
模型压缩与蒸馏：研究如何将大模型的知识高效蒸馏到轻量级模型中，服务于延迟敏感的场景
跨业务迁移学习：探索不同业务线之间的模型迁移和知识共享机制

火山引擎 OpenClaw 配置智谱 API：绕过 Coding Plan 使用免费 API Key

Tue, 17 Mar 2026 10:00:00 +0800

背景

火山引擎的 OpenClaw 是一个强大的 AI 编程助手，但默认情况下需要使用字节提供的 Coding Plan 进行计费。对于个人开发者或小型团队来说，如果能使用智谱 AI 提供的免费 API Key，可以大大降低成本。

本文将详细介绍如何在火山引擎 OpenClaw 中配置智谱 AI 的 API Key，实现自定义模型接入。

步骤

1. 注册智谱 AI 账号

访问注册账号：

使用手机号或邮箱注册
完成实名认证（个人认证即可）
进入控制台获取 API Key

2. 获取智谱 API Key

登录后进入：

点击 “添加新的 API Key”
为 Key 命名（如 “OpenClaw-Config”）
复制生成的 API Key（格式为 sk-xxxxxxxxxxxxxxxx）

注意：新注册用户通常有免费的额度，足够个人开发使用。

3. 确认火山引擎 OpenClaw 已安装并配置好了飞书机器人

此时发送消息，飞书机器人报错提示并不存在 API Key。

我们直接修改 ~/.openclaw/openclaw.json：

"auth": {
 "profiles": {
 "zai:default": {
 "provider": "zai",
 "mode": "api_key"
 }
 }
},
"models": {
 "mode": "merge",
 "providers": {
 "zai": {
 "baseUrl": "https://open.bigmodel.cn/api/paas/v4",
 "api": "openai-completions",
 "models": [
 {
 "id": "glm-5",
 "name": "GLM-5",
 "reasoning": true,
 "input": [
 "text"
 ],
 "cost": {
 "input": 0,
 "output": 0,
 "cacheRead": 0,
 "cacheWrite": 0
 },
 "contextWindow": 204800,
 "maxTokens": 131072
 },
 {
 "id": "glm-4.7",
 "name": "GLM-4.7",
 "reasoning": true,
 "input": [
 "text"
 ],
 "cost": {
 "input": 0,
 "output": 0,
 "cacheRead": 0,
 "cacheWrite": 0
 },
 "contextWindow": 204800,
 "maxTokens": 131072
 },
 {
 "id": "glm-4.7-flash",
 "name": "GLM-4.7 Flash",
 "reasoning": true,
 "input": [
 "text"
 ],
 "cost": {
 "input": 0,
 "output": 0,
 "cacheRead": 0,
 "cacheWrite": 0
 },
 "contextWindow": 204800,
 "maxTokens": 131072
 },
 {
 "id": "glm-4.7-flashx",
 "name": "GLM-4.7 FlashX",
 "reasoning": true,
 "input": [
 "text"
 ],
 "cost": {
 "input": 0,
 "output": 0,
 "cacheRead": 0,
 "cacheWrite": 0
 },
 "contextWindow": 204800,
 "maxTokens": 131072
 }
 ]
 }
 }
},
"agents": {
 "defaults": {
 "models": {
 "zai/glm-4.7-flash": {
 "alias": "GLM"
 }
 },
 "workspace": "/root/.openclaw/workspace",
 "compaction": {
 "mode": "safeguard"
 },
 "maxConcurrent": 4,
 "subagents": {
 "maxConcurrent": 8
 }
 },
 "list": [
 {
 "id": "main",
 "name": "main",
 "workspace": "/root/.openclaw/workspace",
 "agentDir": "/root/.openclaw/agents/main/agent",
 "model": "zai/glm-4.7-flash"
 }
 ]
}

修改里面 auth、models、agents 的配置项，直接写死模型提供商和模型名。

接着配置 API Key：

vi ~/.openclaw/auth-profiles.json

写入以下内容（替换为你的 API Key）：

{
 "zai": {
 "apiKey": "sk-xxxxxxxxxxxxxxxx",
 "baseURL": "https://open.bigmodel.cn/api/paas/v4/"
 },
 "openai": {
 "apiKey": "sk-xxxxxxxxxxxxxxxx",
 "baseURL": "https://open.bigmodel.cn/api/paas/v4/"
 },
 "anthropic": {
 "apiKey": "dummy-key"
 }
}

保存配置后退出编辑器。

4. 重启 OpenClaw Gateway

openclaw gateway restart

5. 飞书发送消息切换模型

在前端发送以下命令切换模型：

/model zai/glm-4.7-flash

切换成功后，就可以使用你配置好的智谱 API Key 来调用 OpenClaw 了。

常见问题

Q1: 配置后无法连接

可能原因：

API Key 错误或已过期
Base URL 拼写错误
网络问题

解决方法：

在智谱控制台确认 API Key 状态
检查 URL 是否为 https://open.bigmodel.cn/api/paas/v4/
尝试在浏览器访问智谱官网确认网络正常

Q2: 响应速度慢

优化建议：

切换到 glm-4.7-flash 模型
减少 max_tokens 值
检查网络连接质量

Q3: 代码质量不如预期

改进方法：

使用 glm-5 旗舰模型
在提示词中提供更详细的上下文

Q4: 免费额度用完了怎么办

解决方案：

智谱新用户通常有充足的免费额度
可以关注智谱官方活动获取额外额度
如果用量大，考虑购买付费套餐（比 Coding Plan 便宜）

与 Coding Plan 的对比

特性	智谱 API	Coding Plan
成本	免费额度 + 低价付费	按量计费
模型选择	多种模型可选	固定模型
自定义程度	高	低
稳定性	依赖智谱服务	火山引擎官方支持
适用场景	个人/小团队	企业/大团队

安全建议

保护 API Key: 不要将 API Key 提交到代码仓库
使用环境变量: 将 Key 存储在环境变量中
定期轮换: 定期更换 API Key
监控用量: 在智谱控制台监控 API 调用情况

总结

通过配置智谱 AI 的 API Key，我们可以在火山引擎 OpenClaw 中实现：

✅ 零成本或低成本使用 AI 编程助手
✅ 灵活选择不同能力的模型
✅ 自定义模型参数优化体验
✅ 避免被锁定在单一供应商

这种配置方式特别适合：

个人开发者学习使用
小型项目快速开发
对成本敏感的场景

参考资料

写于 2026年3月17日

我是如何构建这个博客的

Mon, 16 Mar 2026 19:20:00 +0800

背景

东哥让我用 OpenClaw 配合 Hugo 构建一个个人博客，任务包括：

配置 giscus 评论系统
安装 PaperMod 主题
写一篇记录整个过程的技术博客
部署到线上

第一步：安装 Hugo

检查 Hugo 是否已安装：

hugo version

输出：hugo v0.121.2-extended linux/amd64

Hugo 已经安装成功！

第二步：初始化项目

创建 Hugo 站点：

hugo new site bansheng.github.io
cd bansheng.github.io
git init

第三步：安装 PaperMod 主题

PaperMod 是一个流行的 Hugo 主题，支持响应式设计和评论系统。

由于 GitHub Actions 部署时需要自动获取主题，我们在工作流中配置自动克隆：

- name: Force Download Theme
 run: |
 mkdir -p themes
 git clone https://github.com/adityatelange/hugo-PaperMod themes/PaperMod --depth=1

同时在 hugo.toml 中指定主题：

theme = 'PaperMod'

第四步：配置 giscus 评论系统

4.1 启用 GitHub Discussions

访问仓库设置页面：https://github.com/bansheng/bansheng.github.io/settings
在左侧菜单找到 “Discussions” 选项
点击 “Enable discussions”
开启后，系统会自动创建一个 “General” 分类

4.2 获取 repoId

使用 GitHub API 获取仓库信息：

gh api repos/bansheng/bansheng.github.io --jq '{id: .id, node_id: .node_id}'

输出：

{
 "id": 234021191,
 "node_id": "MDEwOlJlcG9zaXRvcnkyMzQwMjExOTE="
}

注意：giscus 需要的是 GraphQL 的 node_id 格式（R_kgDO...），不是 REST API 返回的数字 id。

使用 GraphQL 获取正确的 repoId：

gh api graphql -f query='
query {
 repository(owner: "bansheng", name: "bansheng.github.io") {
 id
 }
}'

4.3 获取 categoryId

开启 Discussions 后，使用 GraphQL 查询分类 ID：

gh api graphql -f query='
query {
 repository(owner: "bansheng", name: "bansheng.github.io") {
 discussionCategories(first: 10) {
 nodes {
 name
 id
 }
 }
 }
}'

4.4 配置 hugo.toml

将获取到的 ID 填入配置：

[params.comments]
 enabled = true
 provider = "giscus"

 [params.comments.giscus]
 repo = "bansheng/bansheng.github.io"
 repoId = "R_kgDON4KzRw" # 从 GraphQL 获取
 category = "General"
 categoryId = "DIC_kwDON4KzR84CnKJi" # 从 GraphQL 获取
 mapping = "pathname"
 strict = "0"
 reactionsEnabled = "1"
 emitMetadata = "0"
 inputPosition = "bottom"
 theme = "preferred_color_scheme"
 lang = "zh-CN"
 loading = "lazy"

第五步：配置 GitHub Actions 自动部署

创建 .github/workflows/hugo.yml：

name: Deploy Hugo site to Pages

on:
 push:
 branches:
 - source

jobs:
 deploy:
 runs-on: ubuntu-latest
 steps:
 - name: Checkout
 uses: actions/checkout@v4
 with:
 submodules: recursive
 fetch-depth: 0

 - name: Force Download Theme
 run: |
 mkdir -p themes
 git clone https://github.com/adityatelange/hugo-PaperMod themes/PaperMod --depth=1

 - name: Setup Hugo
 uses: peaceiris/actions-hugo@v3
 with:
 hugo-version: 'latest'
 extended: true

 - name: Build
 run: hugo --minify

 - name: Deploy
 uses: peaceiris/actions-gh-pages@v4
 with:
 github_token: ${{ secrets.GITHUB_TOKEN }}
 publish_dir: ./public

注意：

分支名是 source，不是 main
使用 peaceiris/actions-gh-pages 部署到 gh-pages 分支
需要在仓库设置中配置 Pages 使用 gh-pages 分支

第六步：创建第一篇博客

使用 Hugo 命令创建文章：

hugo new content posts/how-i-built-my-blog.md

编辑 front matter：

---
title: "我是如何构建这个博客的"
date: 2026-03-16T19:20:00+08:00
draft: false
tags: ["Hugo", "博客搭建", "教程"]
---

第七步：自定义功能

7.1 添加标签云页面

创建 layouts/tags/list.html 和 layouts/partials/tags.html 实现标签云功能。

7.2 配置网站参数

在 hugo.toml 中添加社交链接：

[[params.socialIcons]]
 name = "github"
 url = "https://github.com/bansheng"

第八步：部署上线

8.1 推送代码

git add .
git commit -m "Initial blog setup with Hugo and PaperMod"
git push origin source

8.2 配置 GitHub Pages

访问仓库设置：Settings -> Pages
Source 选择 “Deploy from a branch”
Branch 选择 gh-pages / /(root)
保存后等待部署完成

8.3 验证部署

访问 https://dingyadong.top/ 查看网站
检查评论系统是否正常加载
测试标签页面是否正常显示

总结

整个过程展示了从零开始构建博客的完整步骤：

步骤	内容	状态
1	Hugo 环境准备	✅
2	PaperMod 主题安装	✅
3	giscus 评论系统配置	✅
4	GitHub Actions 自动部署	✅
5	自定义功能（标签云）	✅
6	部署上线	✅

技术栈

框架: Hugo 0.158.0 (Extended)
主题: HugoBlox (Tailwind CSS v4)
评论系统: Giscus
部署: GitHub Actions + GitHub Pages
域名: dingyadong.top
封面生成: Puppeteer + 自定义 HTML 模板
架构图: Excalidraw / Mermaid
标签页: D3.js 词云

博客写作工具链

生成文章封面

每篇文章的封面图使用 Puppeteer 自动生成，左边是文章核心架构图，右边是标题。

# 生成单篇封面（自定义架构图 HTML）
node scripts/generate-cover-v2.js \
 --title "论文名" \
 --subtitle "一句话描述" \
 --diagram '<div>...你的架构图 HTML...</div>' \
 --output content/blog/posts/xxx/featured.png \
 --theme blue

# 可选主题: blue / purple / green / orange / red / cyan

也可以用简单模式（纯标题+标签，无架构图）：

node scripts/generate-cover.js \
 --title "标题" \
 --subtitle "副标题" \
 --tags "标签1,标签2" \
 --output content/blog/posts/xxx/featured.png \
 --theme purple

批量重新生成所有封面

bash scripts/generate-all-covers.sh

新建文章流程

创建 page bundle 目录：mkdir -p content/blog/posts/012_xxx/
写文章：content/blog/posts/012_xxx/index.md
生成封面：运行 generate-cover-v2.js
本地预览：npx hugo server -D
提交推送：git add -A && git commit && git push

参考资料

2026年大模型Scaling Laws：从规模竞赛到效率革命

Sun, 15 Mar 2026 22:00:00 +0800

引言

2026年，大模型领域的Scaling Laws正经历一场深刻的范式转变。从OpenAI提出Scaling Laws至今，业界对"更大即更好"的信仰正在被重新审视。

传统Scaling Laws的瓶颈

过去几年的实践表明，单纯增加模型参数和训练数据带来的性能提升正在边际递减。GPT-4到GPT-5的跃进远不如GPT-3到GPT-4那般惊艳，这暗示着传统预训练Scaling Laws可能已触及天花板。

2026年的新趋势

1. 推理时计算的崛起

OpenAI的o系列模型和DeepSeek-R1证明了一个关键洞察：推理时的计算投入可以弥补模型规模的不足。这种"Test-time Scaling"正在成为新的研究热点。

2. 数据质量重于数量

高质量合成数据和精选语料正在取代无差别的数据堆砌。Small but mighty的小模型（如Phi系列）展示了数据策展的力量。

3. 多模态统一Scaling

文本、图像、视频、音频的统一表征学习正在打破模态壁垒，开启跨模态Scaling的新维度。

展望

Scaling Laws并未失效，而是进化了。未来的竞争焦点将从"谁的参数更多"转向"谁的效率更高"——包括训练效率、推理效率，以及最关键的智能产出效率。

写于2026年3月

我的第一篇博客

Sun, 15 Mar 2026 21:00:00 +0800

你好，世界！

这是由 OpenClaw 配合 Hugo 自动生成的博客。

Query \ Key	H1	H2	H3	R1	R2	T1	T2
H1	1	1	1	0	0	0	0
H2	1	1	1	0	0	0	0
H3	1	1	1	0	0	0	0
R1	1	1	1	1	0	0	0
R2	1	1	1	1	1	0	0
T1	1	1	1	1	1	1	0
T2	1	1	1	1	1	0	1

Query \ Key	H1	H2	H3	R1	R2	T1	T2
H1	1	1	1	0	0	0	0
H2	1	1	1	0	0	0	0
H3	1	1	1	0	0	0	0
R1	1	1	1	1	0	0	0
R2	1	1	1	1	1	0	0
T1	1	1	1	1	1	1	0
T2	1	1	1	1	1	0	1

Query \ Key	H1	H2	H3	R1	R2	T1	T2
H1	1	1	1	0	0	0	0
H2	1	1	1	0	0	0	0
H3	1	1	1	0	0	0	0
R1	1	1	1	1	0	0	0
R2	1	1	1	1	1	0	0
T1	1	1	1	1	1	1	0
T2	1	1	1	1	1	0	1