铃阅
❌

普通视图

人生三万天,别把同一天重复三万遍

2026年11月16日 21:43

原创 夜读 2026-11-16 21:43 北京

你是否常有这样的感受:为什么一年比一年过得快,去年的事好像就在上个月,可小时候又感觉时光很漫长。

有人这样解释:当我们不断接触到新鲜事物,大脑会记下许多清晰、独特的片段,回头看时,时间便被拉长。可如果日子落入循环,所见所感趋于重复,无数相似的日子堆叠在一起,时间就显得一闪而过。

⁠

人生不过三万天,你会选择把同一天过三万遍,还是过三万个不一样的一天?

人生不过三万天,尽情体验

01

欲买桂花同载酒

终不似,少年游

没错,很多心情是有保质期的。年轻时想去看的海、想淋的雨、想见的人,一旦拖久了,就找不回当年的心动。

桂花依旧,少年难再。我们怀念从前,不是当年的风景更好,而是那时的我们,带着全然敞开的感知力。兴致来时随心奔赴,点滴欢喜都能在心底留下鲜活印记。

长大后,我们走了更远的路,手握更多选择,却常常顺着惯性埋头赶路。风景照旧掠过眼前,我们却丢失了,为细碎美好驻足停留的能力。

02

趁当下,别总是“等以后”

我们并非不曾察觉,只是总习惯性把心愿托付给“以后”:等有空再读书,等清闲再放松,等安稳下来再好好善待自己。可现实是,很少会有一个完美就绪的“以后”,专门等着我们启程。

所谓以后,本就是无数个今天堆砌而成。今天潦草应付,往后也只会一路顺延着潦草。那些灵光一闪的念头、放在心上惦念的小事,当下不伸手接住,或许就是永久的错过。

别让虚无的“以后”,偷走真切的此刻。人生三万天,没有预留的备用档期,每一天都是独一无二的存在。

03

做能力之内

持续滋养内心的事

该怎样打破日复一日的复制粘贴,让寻常一天长出独有的记忆点?多去尝试力所能及、长久滋养情绪与心灵的小事。

换一条下班的路线,睡前放下短视频,随手记下片刻心绪;去一处未曾打卡的街巷散步,试着学一首陌生的歌。这些尝试微小、低成本,不会耗费太多精力,却能悄悄为紧绷的情绪松绑。

长久坚持,便会懂得:一次尝试有一次的欢喜,一日体验有一日的收获。它们落在平淡的日常底色上,刻下只属于今天的印记。

04

只要不混乱,你的时间永远够用

或许你会疑惑:也想跳出重复,可琐事缠身,总觉得时间捉襟见肘。

大多时候,时间的匮乏,并非被事情填满,而是被无序消耗。反复摇摆的内耗、漫无目的的刷屏、纠缠不休的情绪,悄悄耗掉大半光阴。

这时,我们需要重建自己的优先级,守住内心秩序,分清轻重取舍,不被外界的节奏裹挟。心安定,节奏就稳,零碎时光,也足够用来滋养自己。时间不会偏心谁,它会留给清醒有序的人。

我们留不住时光奔走的脚步,却可以决定每一天的质感。少一点机械重复,多一点专属于此刻的感知。好好接住当下,认真经营日常:有益于身心的,有助于成长的,温暖所爱之人的,尽管去做,尽情体验。

欲买桂花同载酒,不必等少年归,今天就可以。

文|央视新闻《夜读》

封面|插画师@lost7

插图|视觉中国

接下来的日子,

愿你带着饱满的感知力出发。

《夜读日历2027》

为你打捞散落在日常里的诗意。

提醒你:

每一天,都值得好好看见,好好感受。

网友返图来啦——

↓点击下图亦可购买↓

📮投稿邮箱:yedu_cctv@126.com

霜降:岁月渐露霜华,所有期待终将抵达

人生没有彩排,要真诚,要尽兴

“我走了,等着我回来!”

秋天的朋友圈,这么发就对了

“宾客如流水,你我二人此后同舟共济”

幸福在被发现前,叫作普通的一天

监制 | 王元  主编 | 马文佳 李津婵

人生不过三万天,你值得好好活~

跳转微信打开

【轻量化复刻大模型 / KIMI K3】Multi-Token Prediction(MTP / EAGLE-3)

2026年11月16日 21:36

原创 罗西的思考 2026-11-16 21:36 北京

【轻量化复刻大模型 / KIMI K3】Multi-Token Prediction(MTP / EAGLE-3)

  • 0x00 概要

    • 0.1 主要内容

    • 0.2 注意说明

  • 0x01. 演进脉络与定位

    • 1.1 前身与谱系

    • 1.2 同期竞品方案

  • 0x02. 原理讲解

    • 2.1 直觉类比视角

    • 2.2 准专业水平视角

    • 2.3 专家视角

    • 2.4 关键信息完整性

    • 2.5 与 DeepSeek‑V4 MTP 的对比

  • 0x03. 子知识点拆解 / 架构

    • 3.1 MTP 层结构(本项目 `mtp/mtp_layer.py`)

    • 3.2 主模型集成(`model.py`)

    • 3.3 配置 `MTPConfig`(`config.py:118-147`)

    • 3.4 参数计数

    • 3.5 EAGLE-3 组件(`mtp/eagle3.py`)

    • 3.6 投机解码 verify 组件(`mtp/speculative.py`)

    • 3.7 边缘处理

    • 3.8 MTP 代码

  • 0x04 Eagle VS MTP

    • 4.1 K3 架构中 MTP 和 EAGLE 的角色

    • 4.2 完整链路:MTP → EAGLE‑3 → 投机解码

    • 4.3 MTP 层架构 (预训练期)

    • 4.4 EAGLE‑3 架构 (推理加速期)

    • 4.5 EAGLE-3 如何复用 MTP

    • 4.6 MTP 与 EAGLE‑3 的差异究竟在哪里?

  • 0x05 子知识点深度分析

    • 5.0 共享抽象与统一符号

    • 5.1 子知识点:MTP 层结构(融合 + 一层 backbone 镜像)

    • 5.2 子知识点:偏移对齐(h[t] + emb(x[t+1]) → logits[t]=x[t+2])

    • 5.3 子知识点:EAGLE-3 特征融合 `[0 0 I]`

    • 5.4 子知识点:LK 损失(EAGLE-3 训练目标)

    • 5.5 子知识点:EAGLE-3 draft 推理(草稿自回归)

    • 5.6 子知识点:投机解码 verify 与端到端循环

    • 5.7 探讨代码(`experiments\models\llm\kimi_k3\mtp\eagle3_demo.py`)

  • 附录 A:三方参考核对对照表(file:line 汇总)

  • 附录B. 实测数据 (来自项目实验)

    • B1: 联合损失 vs 纯 LM

    • B2: `[0 0 I]` 初始化的优势

    • B3: 接受率 → 加速比理论表

    • B4: 偏移对齐 sanity

  • 附录C. 代码位置索引

  • 附录D. 可视化与输出

    • D.1 可视化脚本

    • D.2 截图说明

    • D.3 实测数值回填

  • 0xFF 参考

0x00 概要

0.1 主要内容

K3 用一个 MTP 层(注意力骨架 = 骨干块镜像、默认 MLA、dense_ffn=False→稀疏 MoE)把训练从"一步一监督"升级为"一步两监督",训练结束把这层微调成 EAGLE-3 draft,用 [0 0 I] 特征融合 + LK 损失把"每个目标前向期望 token 数"推到理论上限附近。但"上限"只是理论——真正把草稿变成 token 需要 verify(接受/拒绝)环节,而这是kimi3-master也没给、由本项目 speculative.py 补上的部分。

另外,递归状态把候选 Token 混合在一起,不能像独立 KV 那样直接删除拒绝分支,因此必须保存状态快照或使用专门的恢复机制。

知识点:Multi-Token Prediction(多 token 预测)与 EAGLE-3 草稿模型 — K3 训练目标与投机解码加速组件

原始论文:

论文

出处

Kimi K3: Open Frontier Intelligence

(K3 技术报告,MTP 定义 §4.1.4、Table 1)

arXiv:2607.24653(2026-07-27);Kimi Team;Moonshot AI

EAGLE: Speculative Sampling Requires Rethinking Feature Uncertainty

(EAGLE-1,特征外推草稿家族鼻祖)

arXiv:2401.15077v2(2024-01);Tsinghua & MetEagle

EAGLE-3

(K3 采用的 draft 框架)

EAGLE 系列论文;K3 报告 §4.1.4 直接引用其训练协议

Block-Attention for Efficient Pre-training

(MTP 深度预测在 LLM 训练里的代表性工作)

同行文献;K3 报告 §4.1.4 引言所引的"多 token 预测"谱系

0.2 注意说明

  • 项目https://github.com/RossiLH/Model-Viz 和系列博客是我的一个尝试,也是我学习的过程。不确定是否满足读者的需求,我自己会反思改进,也希望大家提出宝贵意见。

  • 涉及 KIMI K3,DeepSeek V4,PI0.5,PI0.7 等模型。后续可能会跟踪新模型。

  • 全 CPU 复刻,不涉及 GPU,也不涉及大规模训练(这是另外一个庞杂深邃的领域)和硬件。

  • 模型的组件尽量是原始大模型的缩小版,如果组件没有开源版本,则用近似组件替代。

  • 会解释每个组件在解决一个什么问题、这个问题难在哪、为什么只能这么解、解法的原理是什么,以及组件之间如何咬合成一个整体。重点不是记名词,而是理解一条主线。

  • 每个主要组件都有可直接运行的 Gradio demo——无需 GPU。另有若干可视化脚本(plot_*.py),可生成静态图。

  • 所有文件行号基于本地源码快照;源码后续变化时,行号可能移动,但函数名和调用关系仍可作为定位入口。

  • 为了保证每个文章可以尽量独立成文,所以有些内容会在不同文章中都存在,可能在系列层面上存在冗余,还请大家理解。

0x01. 演进脉络与定位

1.1 前身与谱系

阶段

代表

机制

问题/特色

单 token 预测(NTP)

GPT / LLaMA

每步预测 x[t+1]

每 token 最多一个监督信号,训练信息利用率低

多 token 预测(MTP)

DeepSeek-V3 MTP head、K3

每 step 同时监督多个未来 token

增加辅助头与额外骨干层

K3 MTP → EAGLE-3

K3 报告 §4.1.4

蒸馏后 draft 复用

"一鱼两吃":训练用 MTP、推理用 EAGLE-3

K3 MTP 谱系的一句话:把训练目标从"每一步只预测下一个 token"升级为"同时预测多步"。

MTP 是训练侧的辅助目标,可以让模型对训练目标有更深刻的理解;K3 只用一层 MTP,预测 x[t+2](主模型已预测 x[t+1])。

预训练完成后,这层变成 EAGLE-3 draft 的起点,然后被微调成 EAGLE-3 草稿模型(目标模型冻结,只训 draft 层 + 特征融合投影),转换到推理侧的投机解码加速推理——用"免费"的草稿层换取多次昂贵的目标模型前向的中和加速(训练用 MTP、推理用 EAGLE-3)。

1.2 同期竞品方案

方案

核心机制

优势

劣势

DeepSeek-V3 MTP head

额外 MTP 块预测 step-2 token

每 token 多一个监督

训练代价(一个块的前向)

EAGLE(早期)

特征融合 draft

接受率高

训练仍需 CE

EAGLE-3(K3)

融合 + LK 损失无 CE、7 步 unroll

直接优化接受率、推断 draft 内部一致

依赖 特征融合初值稳定

Medusa / MTP 草案头

多个并列 head 预测未来

简单

每个 head 独立参数、接受率低


0x02. 原理讲解

2.1 直觉类比视角

想象一个图书管理员(backbone 编码器)。平时他只干一件事:递给你一本书(token x[t]),告诉你"下一本是什么"(预测 x[t+1])。现在给他加一个问答助手(MTP 层):

  • 训练时,助手会拿到"上一本 + 你以为的下一本",要求说出"下下本"。于是管理员不仅要学会"这本书支持下一本",还要支持"下一本"本身的信息质量——同一隐藏态一下子要为两个问题服务。

  • 预训练完成后,这个助手被调教成一个"速读顾问"(EAGLE-3 draft):它能极快地连续猜出接下来 4~7 本书,主模型看到顾问的猜测只要做一次廉价核对(接受/拒绝),不接受的再亲自读。顾问猜得越准,实际读的书越少。

  • 核对这一步(verify)——主模型逐本(GPU上是并行)判断"顾问猜的对不对",猜对就照单全收,猜错就自己读一本、并退回上一本正确的地方。这正是投机解码的灵魂,现在由 speculative.py 补齐的部分。

其中有个细节:顾问起步时只信"最高层的摘要"(特征融合初值 [0 0 I]),再逐步学会参考"低层笔记"。这防止了起步时的突发扰动。

2.2 准专业水平视角

训练时(主模型 + MTP 联合前向)

    主模型: logits[t] = lm_head( norm(backbone(x)) )
            loss_lm = CE( logits[:,:-1], y[:,1:] )
    MTP 层:
       h = proj( cat( RMSNorm(hidden[:, :-1]), RMSNorm(emb(x[:,1:])) ), last=-1 )
       h = MTPBlock(h)                         # 注意力 + MoE(dense_ffn=False)
       mtp_logits = lm_head(h)                 # 共享 lm_head
       loss_mtp = CE( mtp_logits[:,:-1], y[:,2:] )


    总: loss = loss_lm + λ · loss_mtp
    • hidden[:, :-1]:backbone 最终隐藏态,丢掉最后一个位置(无目标)。

    • emb(x[:, 1:]):被预测 token 自己的嵌入(teacher-forced)——这是 MTP 与直接"多步展开"的区别。

    • 预测目标始终比主模型提前一位:主体在第 t 位预测 x[t+1],MTP 在第 t 位预测 x[t+2]。

    EAGLE-3(推断侧)

      特征融合: x_fused = W_E3( cat( low_1, mid_4, high_last ) )   # [0 0 I] 起
      单步 draft: logits = lm_head( MTPLayer( x_fused, emb(prev_draft) ) )
      投机采样 verify: 目标对草稿逐位置打分,u <= p(c)/q(c) 接受,否则残差重采

      2.3 专家视角

      • 为什么"先归一化再拼接"而非拼完再归一:MTP 层结构上是有 h_norm 和 e_norm 两个独立 RMSNorm 再 cat 的。若拼接后再整体归一,两个源之间尺度会互相污染(谁 ER 大谁主导);各归一化 → 两类特征在融合投影前的"音量"一致。

      • 为什么共享 lm_head:MTP 的 logits 直接走主模型 lm_head(model.py:362-411 对齐)。这样 MTP 层的预测空间与主模型一致,无需额外词表头。

      • EAGLE-3 的 LK 损失为何不用 KL:投机解码加速比 ∝ 接受率 Σ_x min(p,q)。对容量受限的 draft,KL 最小化不保证最大化接受率;K3 直接优化 L_LK = -log Σ_x min(p(x), q(x)),无 CE 项、温度 1。这是"优化和加速比直接相关的目标"而不是代理。

      • verify 的 lossless 本质:投机采样把"采样过程"拆成接受(保留草稿)+ 拒绝(从残差 max(p-q,0) 重采)。只要拒绝时从残差重采,最终分布与直接采目标分布 p逐 token 相同(这就是"lossless"的严格含义)。

      • [0 0 I] 初值的设计哲学:避免起步扰动——初始时融合输出 ≡ 高层特征(MTP 预训练输入),训练即等于从"纯高层"开始,逐步学低/中层。实验显示 [0 0 I] 起步 error=0 且不扰动,而随机/全零有初始扰动。

      2.4 关键信息完整性

      • SGLang 没有 K3 专属 MTP(test/registered/gb300/test_kimi_k25.py:29-31 声明 "No EAGLE/MTP support for Kimi-K2.5")。MTP 的三方核对以 kimi3-master × kimi-k3-pytorch 为主,SGLang 只做"散件核对"。

      • 重要: kimi3-master/serve/eagle3.py(140 行)经逐行核对,没有 verify 环节——只有 draft()、acceptance_rate、lk_loss、FeatureFusion、speedup_from_acceptance。因此本项目的 verify(speculative.py)是自研扩展而非移植。

      2.5 与 DeepSeek‑V4 MTP 的对比

      K3 MTPDeepSeek‑V4 MTP

      融合方式

      cat([h_norm(h), e_norm(e)]) → proj

      独立 RMSNorm → fc1 → SiLU → fc2 (mini MLP)

      是否用下一 token 嵌入

      ✅ emb(x[t+1]) 是显式输入

      ❌ 只用 hidden_states

      骨架块

      完整 Kimi3Block (attn + MoE)

      无 (只有 mini MLP)

      词表头

      共享主干 lm_head

      可选 tie_with_lm_head

      深度

      固定 1 层

      可配置 num_nextn_predict_layers

      后续用途

      微调成 EAGLE‑3 做投机解码

      无 EAGLE 变体

      K3 的 MTP 更 "重" (完整 Transformer 块),但也因此有更强的表达能力,微调成 EAGLE‑3 后能获得更高的接受率。


      0x03. 子知识点拆解 / 架构

        Multi-Token Prediction
        ├── 3.1 MTPLayer 结构(mtp_layer.py:61, 95-135)
        │    ├── h_norm / e_norm(各自 RMSNorm,:95-96)
        │    ├── proj(无 bias,2d→d,:97)
        │    ├── block(复用 Kimi3Block,:105;layer_kind 决定 KDA/MLA)
        │    └── norm(输出归一化,:135)
        ├── 3.2 Kimi3ForCausalLM 集成(model.py:300, 349, 362-413)
        │    ├── self.mtp = MTPLayer(...)(:300)
        │    ├── forward 里 loss = lm + λ·mtp(:349)
        │    └── _mtp_logits / _mtp_loss(:362 / :393,含 labels[:,2:] 对齐)
        ├── 3.3 MTPConfig(config.py:118-147 + 校验 :222-228)
        ├── 3.4 参数计数(计算见 doc,官方 config.py:609-612)
        │    └── per_mtp = attn_each + moe_total + 2d + 2d²
        ├── 3.5 EAGLE-3 系列(eagle3.py)
        │    ├── FeatureFusion [0 0 I](:73-100)
        │    ├── DraftConfig(:138-143)
        │    ├── Eagle3Draft(:146-191,draft 自回归 :174-191)
        │    ├── eagle3_feature_stack(:104-134,摊平不选择——V3 修复)
        │    ├── lk_loss / acceptance_rate(:58-70)
        │    └── speedup_from_acceptance(:194-198)
        └── 3.6 投机解码 verify 与端到端循环(speculative.py)
             ├── verify_tokens(:73-158)       纯函数接受判据
             ├── SpecDecodeStats(:163-216)    实测接受率 / tokens-per-forward
             ├── snapshot_caches / restore_caches(:221-261)  按类型快照/回滚
             ├── RecomputeBackend(:264)       无 cache 全序列重跑(oracle)
             ├── CacheRollbackBackend(:301)   增量打分
             └── SpeculativeDecoder(:329-475) 端到端循环(decode_recompute/:372、decode_rollback/:413)

        3.1 MTP 层结构(本项目 mtp/mtp_layer.py)

        子模块

        代码位置

        融合归一化 h_norm + e_norm + 无 bias 投影

        mtp_layer.py:95-97, 128-131

        骨架块(复用 Kimi3Block,KDA 或 MLA)

        mtp_layer.py:105-107

        顶层 RMSNorm → MTP 隐藏态

        mtp_layer.py:135

        缓存初始化(探 KDA/MLA 类型)

        mtp_layer.py:137-139

        3.2 主模型集成(model.py)

        组件

        代码

        构造可选 MTP 头

        model.py:302

        (self.mtp = MTPLayer(config) if config.model.mtp.enabled else None)

        forward 叠加 MTP 损失

        model.py:349-352

        (loss = loss + cfg.model.mtp.loss_weight * mtp_loss)

        MTP logits(x[t+2])

        model.py:364-393

        (_mtp_logits)

        MTP 损失(labels[:,2:] 对齐)

        model.py:395-415

        (_mtp_loss)

        解码缓存(include_mtp)

        model.py:417-448

        3.3 配置 MTPConfig(config.py:118-147)

        字段

        默认值

        说明

        enabled

        False

        (本项目)

        kimi3-master 默认 True;本项目默认关闭保持兼容(可开启)

        digit

        1

        K3 恰好 1 层(kimi3-master与 kimi-k 都硬约束)

        layer_kind

        "mla"

        "mla" 或 "kda"

        loss_weight

        0.3

        kimi-master 0.3;kimi-k-pytorch 默认 0.1

        normalize_inputs

        True

        h/e 各自 RMSNorm(对齐kimi3-master[0 0 I] 一致)

        校验(config.py:222-228):n_layers==1、layer_kind in (mla,kda)、loss_weight>=0。

        3.4 参数计数

        对齐 kimi3-masterconfig.py:609-612:

          attn_each = kda_each if layer_kind=="kda" else mla_each
          per_mtp = attn_each + moe_total + 2*dim + 2*dim*dim
          pc.mtp = per_mtp * n_layers

          本项目 mtp_param_count = 2d² + 3d(mtp_layer.py:145-156),test_mtp.py 用精确公式校验。完整骨架块参数随 Kimi3Block 规模计入总参数。

          3.5 EAGLE-3 组件(mtp/eagle3.py)

          K3 把预训练得到的 MTP 层微调为 EAGLE-3 风格的 draft model:目标模型保持冻结,只更新 draft layer 及其特征融合投影。按照 EAGLE-3 的训练时测试协议,训练时将 draft 展开 7 步;除第一步外,最新位置的目标模型特征不可用,draft 会使用自己在前几步的输出,从而复现推理时的递归起草过程。

          组件

          说明

          acceptance_rate(p,q)Σ_x min(p,q)

          ,加速 ∝ 该量

          lk_loss(p,q)-log(Σ min)

          ,温度1、无 CE

          FeatureFusion

          无 bias W_E3,初值 [0 0 I]

          eagle3_feature_stack

          摊平状态为完整出口列表(V3 修复,不再替 fuse() 做选择)

          DraftConfig

          unroll_steps=7、feature_blocks=(0,3,-1)

          Eagle3Draft

          用传入 MTP 层 + lm_head;draft() 自回归 :174-191

          speedup_from_acceptanceE[tokens] = (1-r^(L+1))/(1-r)

          3.6 投机解码 verify 组件(mtp/speculative.py)

          组件

          说明

          VerifyResult

          一轮 verify 结果(接受 token/长度/bonus/每位置比值)

          verify_tokenslossless 接受判据

          (纯函数,不碰模型)

          SpecDecodeStats

          实测接受率 / tokens-per-forward

          snapshot_caches

          深拷贝整组 cache

          restore_caches

          按类型原地回滚 cache

          RecomputeBackend

          无 cache 全序列重跑(参考 oracle)

          CacheRollbackBackend

          增量打分(配合快照回滚)

          SpeculativeDecoder

          端到端循环(两条打分路径)

          3.7 边缘处理

          • 序列太短(T<=2):_mtp_logits 返回 None,不报错(model.py:388)。

          • 多文档打包(doc_ids):_mtp_loss 用 doc_masks(doc_ids[:,:-1], T-1) 生成 MTP 的 reset/attn 掩码(model.py:381-386)。

          • ignore index:labels=-100 不参与(model.py:409)。

          3.8 MTP 代码

            class Kimi3ForCausalLM(nn.Module):
                """完整因果语言模型 = Kimi3Model + 共享权重 lm_head。


                - 解码路径核心接口:
                   ``init_caches(batch)`` 建每 block 缓存 → ``forward(tokens, caches)`` 增量前向
                   → ``generate(...)`` 生成新 token。
                """


                def __init__(self, config: Kimi3Config):
                    super().__init__()
                    self.model = Kimi3Model(config)
                    self.lm_head = nn.Linear(config.model.dim, config.model.vocab_size, bias=False)
                    # 用户后可结合的 Transformer 惯例:lm_head 通常权重与 token embedding 绑定。
                    # 本项目是独立权重(un-tied),注释备注以便后续可切换到绑。
                    self._gradient_checkpointing = False
                    # ---- Multi-Token Prediction 头(§4.1.4)---------------------------
                    # 官方 kimi3-master:`self.mtp = MTPLayer(model_cfg) if model_cfg.mtp.enabled else None`。
                    # MTP 层读 backbone 最终隐藏态 h[t] + emb(x[t+1]),预测 x[t+2];
                    # 预训练完成后即为 EAGLE-3 草稿模型的微调起点。
                    self.mtp = MTPLayer(config) if config.model.mtp.enabled else None


                @property
                def gradient_checkpointing(self) -> bool:
                    """梯度检查点开关(存储换算:前向丢弃中间激活,反向重算)。"""
                    return self._gradient_checkpointing


                def set_gradient_checkpointing(self, value: bool) -> None:
                    self._gradient_checkpointing = value


                def forward(
                    self,
                    tokens: Tensor,
                    doc_ids: Optional[Tensor] = None,
                    caches: Optional[list] = None,
                    labels: Optional[Tensor] = None,
                    return_hidden: bool = False,
                    return_mtp: bool = False,
                ):
                    """forward:核心逻辑在 ``Kimi3Model.forward``,这里只加输出头。


                    ``tokens`` 若是一次预填整段(prefill),输出是 ``(batch, seq, vocab)``;
                    若解码时逐 token 增量,则 ``tokens`` 形状 ``(batch, 1)``,输出相应为
                    ``(batch, 1, vocab)``——历史信息全都藏在 ``caches`` 里。


                    可选 MTP 训练(对齐 kimi3-master forward):传入 ``labels`` 时计算
                    LM 损失,并(若本模型配有 MTP 层)叠加 MTP 损失,最终返回一个
                    ``dict``(键 ``logits``/``loss``/``lm_loss``/``mtp_loss``/``hidden``)。
                    不传 ``labels`` 时行为与旧接口一致:只返回 logits 张量(避免破坏
                    现有调用方与测试)。


                    ``labels`` 语义:与 HF 相同,逐位置 ground truth token id;
                    ``-100`` 的位置不参与损失。主模型 logits 第 t 位预测 ``labels[:, 1:]``
                    第 t 位(shift 一位)。MTP 层的预测目标再次 shift:MTP logits 第 t 位
                    预测 ``tokens[t+2]``,对齐 ``labels[:, 2:]``。
                    """
                    h = self.model(tokens, doc_ids=doc_ids, caches=caches)
                    logits = self.lm_head(h)


                    if labels is not None:
                        b, t = tokens.shape
                        lm_loss = F.cross_entropy(
                            logits[:, :-1].reshape(-1, logits.shape[-1]).float(),
                            labels[:, 1:].reshape(-1),
                            ignore_index=-100,
                        )
                        loss = lm_loss
                        mtp_loss = None
                        if self.mtp is not None and t > 2:
                            mtp_loss = self._mtp_loss(h, tokens, labels, doc_ids)
                            loss = loss + self.model.config.model.mtp.loss_weight * mtp_loss
                        return {
                            "logits": logits,
                            "loss": loss,
                            "lm_loss": lm_loss,
                            "mtp_loss": mtp_loss,
                            "hidden": h if return_hidden else None,
                            "mtp_logits": self._mtp_logits(h, tokens, doc_ids) if return_mtp else None,
                        }


                    return logits


                def _mtp_logits(
                    self,
                    hidden: Tensor,
                    tokens: Tensor,
                    doc_ids: Optional[Tensor] = None,
                ) -> Optional[Tensor]:
                    """MTP 层前向,输出 ``x[t+2]`` 的 logits ``(batch, t-1, vocab)``。


                    对齐 kimi3-master ``model.py:_mtp_loss``:取 hidden[:, :-1]、
                    next_embeds = embed_tokens(tokens[:, 1:]),MTP 层内每位置融合
                    ``h[t] + emb(x[t+1])`` 预测 ``x[t+2]``,再经 lm_head 得到 logits。
                    若 MTP 层禁用(``self.mtp is None``)返回 None。


                    ``labels`` 的对应:MTP logits 第 t 位预测 ``x[t+2]``,所以训练目标
                    用 ``labels[:, 2:]``。shape: logits (B, T-1, V),labels2 = (B, T-2, V),
                    前者需再取 ``[:-1]`` 对齐(kimi3-master 正是这么做的)。
                    """
                    if self.mtp is None:
                        return None
                    b, t = hidden.shape[0], tokens.shape[1]
                    if t <= 2:
                        return None
                    reset_mask, attn_mask = doc_masks(
                        None if doc_ids is None else doc_ids[:, :-1], t - 1, hidden.device
                    )
                    next_embeds = self.model.tok_embed(tokens[:, 1:])
                    h = self.mtp(
                        hidden[:, :-1], next_embeds, reset_mask=reset_mask, attn_mask=attn_mask
                    )
                    return self.lm_head(h)


                def _mtp_loss(
                    self,
                    hidden: Tensor,
                    tokens: Tensor,
                    labels: Tensor,
                    doc_ids: Optional[Tensor] = None,
                ) -> Optional[Tensor]:
                    """MTP 损失(预测 x[t+2] 的交叉熵),供训练管线单独调用。


                    与 kimi3-master ``_mtp_loss`` 一致:
                    ``F.cross_entropy(mtp_logits[:, :-1], labels[:, 2:], ignore_index=-100)``。
                    返回 None 当 MTP 层禁用或序列过短。
                    """
                    logits = self._mtp_logits(hidden, tokens, doc_ids)
                    if logits is None:
                        return None
                    return F.cross_entropy(
                        logits[:, :-1].reshape(-1, logits.shape[-1]).float(),
                        labels[:, 2:].reshape(-1),
                        ignore_index=-100,
                    )

            0x04 Eagle VS MTP

            问题

            答案

            K3 先训 MTP 再后训 EAGLE?

            是

            。MTP 是预训练阶段的训练目标,EAGLE‑3 是预训练完成后从 MTP 层微调出的推理加速草稿模型

            EAGLE 和 MTP 架构相同?

            骨架相同,输入不同

            。EAGLE‑3 直接复用 MTP 层的 Kimi3Block,但增加了特征融合投影 W_E3, 输入从"骨干最终隐藏态"变为"低/中/高层特征融合"

            K3 架构中到底用 MTP 还是 EAGLE?

            两个都用,但阶段不同

            : 预训练用 MTP (训练目标),推理用 EAGLE‑3 (投机解码加速)。它们是同一条流水线的两个阶段

            4.1 K3 架构中 MTP 和 EAGLE 的角色

            一句话总结:MTP 是 K3 预训练的 "训练增强" (让骨干学得更好), EAGLE‑3 是 K3 推理的 "推理加速" (投机解码草稿模型)。两者共享同一套骨架权重,EAGLE‑3 从 MTP 毕业而来。

            4.1.1 预训练阶段: MTP 是训练目标

              # Kimi3ForCausalLM.forward() 中的 MTP 集成
              if self.mtp is not None and t > 2:
                  mtp_loss = self.mtp_loss(h, tokens, labels, doc_ids)
                  loss = lm_loss + 0.3 * mtp_loss  # 联合损失

              MTP 的作用不仅是 "多预测一个 token", 更重要的是:

              • 梯度反传进骨干: MTP 的梯度流回主干 Transformer, 相当于一种正则化

              • 让骨干学到更好的表示: 预测 x[t+2] 需要更深的上下文理解,迫使骨干编码更丰富的信息

              4.1.2 推理阶段: EAGLE‑3 是加速手段

                # 投机解码循环
                while n_new < max_new_tokens:
                    # 1. 目标模型前向 → 隐藏态 + AttnRes 特征
                    hidden = model.model(tokens)
                    # 2. EAGLE‑3 draft 起草 K 个候选 token
                    fused = draft.fuse(features)          # 特征融合
                    draft_tokens, draft_logits = draft.draft(fused, embed_fn, n_steps=K)
                    # 3. 目标模型 verify: 逐位置接受/拒绝
                    vr = verify_tokens(target_logits, draft_logits, draft_tokens)
                    # 4. 输出: 接受前缀 + bonus token
                    accepted = vr.accepted_tokens[:, :vr.n_accepted]
                    bonus = vr.bonus_token

                4.2 完整链路:MTP → EAGLE‑3 → 投机解码

                4.2.1 阶段 1: 预训练 (MTP)

                  主模型预测 x [t+1]      ← 主干 Transformer


                  MTP 层预测  x [t+2]    ← MTPLayer (骨干隐藏态,emb (x [t+1]))


                  损失 = CE_loss (x [t+1]) + λ・CE_loss (x [t+2])    λ = 0.3 (官方默认)


                  骨干 + MTP 层联合训练,MTP 梯度反传进骨干


                  ↓ 权重继承

                  4.2.2 阶段 2: EAGLE‑3 微调

                    骨干冻结,只训练:
                    - MTP 层 (现在叫 draft 层)
                    - Eagle3FeatureFusion 投影 W_E3 (新增)


                    损失 = LK_loss = -log Σ_x min (p (x), q (x))


                    直接最大化投机解码接受率,而非 KL 代理


                    训练时展开 7 步 (unroll_steps=7) , 草稿消费自己前步输出


                    ↓


                    4.2.3 阶段 3: 推理期投机解码

                    1. 目标模型前向 → 得到隐藏态 + AttnRes 特征

                    2. EAGLE‑3 draft 起草:特征融合 → 自回归生成 K 个候选 token

                    3. 目标模型 verify: 逐位置接受 / 拒绝

                    4. 接受前缀 + bonus token → 输出

                    加速比 ∝ 接受率 r, E [tokens/forward] = (1‑r^(K+1))/(1‑r)

                    4.3 MTP 层架构 (预训练期)

                    对应 K3 技术报告 §4.1.4 / Table 1。官方配置 (k3_2p8t.yaml):

                      mtp:
                        enabled: true
                        n_layers: 1        # 恰好 1 层, K3 强制校验
                        layer_kind: mla    # 内部用 GatedMLA 注意力
                        loss_weight: 0.3   # MTP 损失权重



                      4.3.1 架构细节

                      MTPLayer:

                        h_norm = RMSNorm(dim)                  # 归一化骨干隐藏态 h[t]
                        e_norm = RMSNorm(dim)                  # 归一化被预测 token 的嵌入 emb(x[t+1])
                        proj   = Linear(2*dim, dim, bias=False)# 拼接后投影回 dim
                        block  = Kimi3Block(...)               # 复用骨架块 (注意力 + MoE)
                        norm   = RMSNorm(dim)                  # 顶层输出归一化


                        forward(hidden[:, :-1], next_embeds):
                            h = proj( cat([ h_norm(hidden), e_norm(next_embeds) ], dim=-1) )
                            h = block(h)                       # x + attn(x) + ffn(x)
                            return norm(h)                     # → lm_head → x[t+2] logits



                        4.3.2 关键设计

                        1. 双输入融合: 骨干隐藏态 h[t] + 下一 token 嵌入 emb(x[t+1]), 各自 RMSNorm 后拼接投影

                        2. 分开归一再拼接: 若整体 RMSNorm, 两个来源的尺度会互相干扰;先各自归一化到单位 RMS, 拼接时两边贡献均衡

                        3. 复用完整骨架块: 内部是完整的 Kimi3Block (MLA 注意力 + StableLatentMoE) , 不是轻量 MLP

                        4. 共享词表头: MTP 输出再过主模型的 lm_head, 不单独建头

                        5. 偏移语义: 位置 t 的输出预测 x[t+2], 训练时用 labels[:, 2:] 对齐

                        4.4 EAGLE‑3 架构 (推理加速期)

                        4.4.1 与 MTP 的关系

                        EAGLE‑3 不是新架构, 而是 MTP 层 + 特征融合投影的组合:

                          class Eagle3Draft(nn.Module):
                              def __init__(self, mtp_layer, dim, lm_head, cfg):
                                  self.fusion = Eagle3FeatureFusion(dim, n_sources=3)  # 新增!
                                  self.layer = mtp_layer                                # 复用 MTP 层
                                  self.lm_head = lm_head                                # 共享词表头



                          4.4.2 创新 1: 特征融合 W_E3 (初值 [0 0 I])

                          MTP 预训练时只用骨干最终层隐藏态。EAGLE‑3 额外引入低 / 中 / 高层特征融合:

                          特征来源: Attention Residuals 的三个深度位置

                          • 第 1 个 AttnRes 块输出 → 低层特征 (局部模式)

                          • 第 4 个 AttnRes 块输出 → 中层特征 (组合模式)

                          • 最后一个 AttnRes 块输出 → 高层特征 (语义表示)

                          融合: W_E3 · [feat_low; feat_mid; feat_high]

                            W_E3` 初始化 = `[0 0 I]


                            初始融合输出 ≡ 高层特征 (= MTP 预训练时的输入) → 从 "只信高层" 逐步学到 "吸收低 / 中层特征" → 初始化不引入瞬间扰动,平滑过渡。

                              class Eagle3FeatureFusion(nn.Module):
                                  """无 bias 的 ``W_E3``,初始 ``[0 0 I]``(官方 FeatureFusion)。


                                  ``proj: (n_sources*dim) -> dim``,权重初值前 ``(n_sources-1)*dim`` 列全 0、
                                  末 ``dim`` 列单位阵。初始化后 ``fuse 输出 ≡ 高层特征``。
                                  """


                                  def __init__(self, dim: int, n_sources: int = 3):
                                      super().__init__()
                                      self.dim = dim
                                      self.n_sources = n_sources
                                      self.proj = nn.Linear(dim * n_sources, dim, bias=False)
                                      self.reset_parameters()


                                  def reset_parameters(self) -> None:
                                      with torch.no_grad():
                                          self.proj.weight.zero_()
                                          # [0 ... 0 I]:最后一个源(高层特征)恒等通过。
                                          self.proj.weight[:, -self.dim:] = torch.eye(self.dim)


                                  def forward(self, features: Sequence[Tensor]) -> Tensor:
                                      if len(features) != self.n_sources:
                                          raise ValueError(f"expected {self.n_sources} feature sources, got {len(features)}")
                                      return self.proj(torch.cat(list(features), dim=-1))


                              使用举例如下

                                    C = 64
                                    f = Eagle3FeatureFusion(C, 3)
                                    lo, mid, hi = (torch.randn(2, 3, C) for _ in range(3))
                                    out = f([lo, mid, hi])



                                4.4.3 创新 2: LK 损失 (直接优化接受率)

                                传统做法: KL 散度当代理 → 不能保证最大化接受率 (容量受限时 KL 最优 ≠ 接受率最优)

                                K3 做法: L_LK = -log Σ_x min(p(x), q(x))

                                • p = 目标模型分布,q = 草稿模型分布

                                • 直接优化决定加速比的量: acceptance_rate = Σ_x min(p(x), q(x))

                                训练时展开 7 步 (unroll_steps=7):除第一步外,草稿消费自己前一步输出 — 正是推理期 drafting 过程的镜像。

                                4.5 EAGLE-3 如何复用 MTP

                                4.5.1 整体关系图

                                整体关系图
                                整体关系图

                                4.5.2 复用点 1:整个 MTPLayer 直接作为 Eagle3Draft 的"骨架块"

                                代码:eagle3.py:154-180

                                  class Eagle3Draft(nn.Module):
                                      def __init__(self, mtp_layer: nn.Module, dim: int, lm_head: nn.Module, cfg):
                                          super().__init__()
                                          self.cfg = cfg or draft_config()
                                          self.fusion = Eagle3FeatureFusion(dim, n_sources=len(self.cfg.feature_blocks))
                                          self.layer = mtp_layer          # ★ 整个 MTPLayer 复用
                                          self.lm_head = lm_head          # ★ 共享主模型的 lm_head


                                      def forward(self, fused: Tensor, next_embeds: Tensor) -> Tensor:
                                          h = self.layer(fused, next_embeds)   # ★ 调用 MTPLayer.forward
                                          return self.lm_head(h)



                                  Eagle3Draft 本身没有新的"骨架块"——它只是给 MTPLayer 加了一个前置特征融合层(Eagle3FeatureFusion)。预训练好的 MTP 权重原封不动地被复用,训练时只微调 MTP 层 + 新加的 fusion。

                                  4.5.3 复用点 2:MTPLayer 内部的 4 个子组件

                                  代码:mtp_layer.py:94-108

                                    # MTPLayer 的内部结构
                                    self.h_norm = RMSNorm(dim, eps)              # 主干 hidden 归一化
                                    self.e_norm = RMSNorm(dim, eps)              # 未来 token embed 归一化
                                    self.proj = nn.Linear(2*dim, dim, bias=False)  # 拼接投影
                                    self.block = Kimi3Block(config, layer_idx=cfg.n_layers, use_kda=...)  # 骨架块
                                    self.norm = RMSNorm(dim, eps)                # 输出归一化



                                    EAGLE-3 完全继承这 5 个组件及其预训练权重:

                                    • h_norm / e_norm:继续用于"主干 hidden 归一化"和"下一 token embed 归一化"

                                    • proj:继续把 2C 拼接投影回 C

                                    • block(Kimi3Block):继续作为 attention + MoE 的骨架

                                    • norm:继续作为输出归一化

                                    0 个组件被替换——这就是"复用"的精确含义。

                                    4.5.4 复用点 3:forward 接口签名完全一致

                                    代码:mtp_layer.py:110-135

                                      def forward(self, hidden: Tensor, next_embeds: Tensor, ...) -> Tensor:
                                          h = self.proj(torch.cat([self.h_norm(hidden), self.e_norm(next_embeds)], dim=-1))
                                          h = self.block(h, ...)
                                          return self.norm(h)



                                      MTP 训练时(model.py 中):

                                        mtp_hidden = self.mtp_layer(
                                            hidden=backbone_hidden[:, :-1],      # 主干最后隐藏态(去尾)
                                            next_embeds=embed_tokens(x[:, 1:])   # 下一 token 嵌入
                                        )
                                        mtp_logits = lm_head(mtp_hidden)         # 预测 x[t+2]



                                        EAGLE-3 推理时(eagle3.py:178-180):

                                          def forward(self, fused: Tensor, next_embeds: Tensor) -> Tensor:
                                              h = self.layer(fused, next_embeds)   # ★ 同样的接口
                                              return self.lm_head(h)



                                          输入语义完全对应:

                                          MTP 训练时

                                          EAGLE-3 推理时

                                          来源

                                          hidden = backbone_hidden[:, :-1]fused

                                          (经 fusion 融合后)

                                          都是"上下文特征"

                                          next_embeds = emb(x[:, 1:])next_embeds = embed_fn(nxt)

                                          都是"下一 token 嵌入"

                                          4.5.5 新增的部分:Eagle3FeatureFusion

                                          EAGLE-3 唯一新增的组件是 Eagle3FeatureFusion(eagle3.py:73-96):

                                            class Eagle3FeatureFusion(nn.Module):
                                                def __init__(self, dim: int, n_sources: int = 3):
                                                    super().__init__()
                                                    self.proj = nn.Linear(dim * n_sources, dim, bias=False)
                                                    # 初始化 [0 ... 0 I]:最后一列是单位阵,等价于"只信高层特征"
                                                    self.proj.weight[:, -self.dim:] = torch.eye(self.dim)



                                            作用:把 AttnRes 状态的 3 个块表示(b_0, b_3, b_N,即第 1、4、最后块)融合成 1 个 C 维向量,作为 MTPLayer 的 hidden 输入。

                                            为什么初始化是 [0 0 I]:

                                            • MTP 预训练时只见过最终隐藏态(相当于"只用最后一个特征")

                                            • 如果初始 fusion 输出 = 随机混合,会让 MTP 层"瞬间看到陌生分布",训练不稳定

                                            • [0 0 I] 让初始 fusion 输出严格等于最后一个特征(b_N),MTP 层无缝衔接

                                            • 训练后 fusion 学到"吸收低/中层特征",平滑过渡

                                            在 Eagle3Draft.draft() 的循环里:

                                              state = fused                          # 初始 hidden(上下文特征)
                                              last = embed_fn(torch.zeros(...))      # 初始 next_embeds(起始符嵌入)
                                              for _ in range(n_steps):
                                                  logits = self.forward(state, last) # ★ 传入 state 和 last
                                                  nxt = logits[:, -1:].argmax(-1)
                                                  last = embed_fn(nxt)               # 下一步的 next_embeds = 刚起草的 token 嵌入
                                                  state = state[:, -1:]              # state 只保留最后一个位置(自回归)



                                              4.5.6 训练数据流(MTP 预训练 → EAGLE-3 微调)

                                              MTP 预训练(backbone 冻结,只训 MTP 层):

                                              MTP 预训练
                                              MTP 预训练

                                              EAGLE-3 微调(backbone 冻结,只训 MTP 层 + fusion):

                                              EAGLE-3 微调
                                              EAGLE-3 微调

                                              4.5.7 推理数据流(投机解码)

                                              • fused(hidden):固定的上下文特征,整个 draft 循环中不变(只在循环外由 backbone + fusion 算一次)

                                              • next_embeds:每步都变,是"上一步起草的 token 的嵌入"

                                              推理数据流
                                              推理数据流

                                              4.5.8 关键复用量化

                                              组件

                                              MTP 预训练

                                              EAGLE-3 微调

                                              是否复用

                                              MTPLayer.h_norm

                                              ✓

                                              ✓

                                              完全复用
                                              MTPLayer.e_norm

                                              ✓

                                              ✓

                                              完全复用
                                              MTPLayer.proj

                                              ✓

                                              ✓

                                              完全复用
                                              MTPLayer.block

                                               (Kimi3Block)

                                              ✓

                                              ✓

                                              完全复用
                                              MTPLayer.norm

                                              ✓

                                              ✓

                                              完全复用
                                              lm_head

                                              ✓

                                              ✓

                                              完全复用

                                              (共享主模型)

                                              Eagle3FeatureFusion

                                              ✗

                                              ✓

                                              新增

                                              (唯一)

                                              LK loss

                                              ✗

                                              ✓

                                              新增

                                              复用率:MTP 的 5/5 个组件全部复用,EAGLE-3 只新增 1 个 fusion 层。

                                              4.5.9 一句话总结

                                              EAGLE-3 不是"基于 MTP 的灵感重新设计",而是直接把预训练的 MTPLayer 当作草稿模型本体,只在前面加一个特征融合层把 AttnRes 的 3 层块表示融合成 MTP 层能消费的输入——预训练的 MTP 权重原封不动地被复用,训练时只微调 MTP 层 + 新加的 fusion,目标模型始终冻结。

                                              4.6 MTP 与 EAGLE‑3 的差异究竟在哪里?

                                              4.6.1 架构差异:极小 (只多一个线性层)

                                              MTP 层内部:

                                                h_norm → e_norm → cat → proj(2d→d) → Kimi3Block → norm


                                                EAGLE‑3 层内部:

                                                  W_E3(3d→d) → 同一个 MTP 层 → lm_head


                                                  EAGLE‑3 直接复用 MTP 层的 self.layer, 不新建任何 Transformer 块。唯一新增的是 Eagle3FeatureFusion: 一个 (3*dim, dim) 无 bias 线性层,初值 [0 0 I]。初始化时这个层等于恒等映射,EAGLE‑3 退化为 MTP 本身。

                                                  具体如下:

                                                  维度

                                                  MTPLayer

                                                  (预训练期)

                                                  Eagle3Draft

                                                  (推理 / 微调期)

                                                  输入来源hidden[:, :-1]

                                                   (骨干最终隐藏态) + emb(x[:, 1:]) (下一 token 嵌入)

                                                  fused

                                                   (特征融合后的低 / 中 / 高层混合特征) + next_embeds (上一步草稿 token 的嵌入)

                                                  融合方式h_norm(h)

                                                   + e_norm(e) → cat → proj(2d→d)

                                                  Eagle3FeatureFusion

                                                  : W_E3·[feat_low; feat_mid; feat_high], 初值 [0 0 I]

                                                  骨架块Kimi3Block

                                                   (MLA + MoE), layer_idx=n_layers 保证稀疏 MoE

                                                  复用同一个 MTP 层

                                                  的 self.layer, 不新建

                                                  输出头

                                                  隐藏态 → 外部 lm_head (共享主干词表头)

                                                  self.lm_head(h)

                                                   (同样是共享主干词表头)

                                                  训练目标cross_entropy(mtp_logits[:, :-1], labels[:, 2:])

                                                  , 权重 loss_weight=0.3

                                                  lk_loss = -log Σ min(p, q)

                                                   (直接最大化接受率)

                                                  训练方式

                                                  骨干 + MTP 层联合训练(MTP 梯度反传进骨干)

                                                  骨干冻结, 只训 draft 层 + 特征融合投影

                                                  推理行为

                                                  不直接用于推理

                                                  draft()

                                                   自回归起草:第一步后草稿消费自己前一步的输出

                                                  特征深度

                                                  只用骨干最终层隐藏态

                                                  取 AttnRes 第 1/4 / 末个块的输出 (低 / 中 / 高层三层特征)

                                                  初始化

                                                  标准 PyTorch 初始化

                                                  W_E3 = [0 0 I]

                                                  : 初始时融合输出 ≡ 高层特征 (= MTP 预训练输入), 平滑过渡

                                                  新增参数

                                                  无 (相对于主干)

                                                  Eagle3FeatureFusion

                                                  : W_E3 为 (3*dim, dim) 无 bias 线性层

                                                  结论:架构几乎相同,差异 ≈ 1 个线性投影层。

                                                  4.6.2 训练模式差异:中等

                                                  MTP

                                                  EAGLE‑3

                                                  骨干

                                                  联合训练

                                                  , 梯度反传进骨干

                                                  冻结

                                                  , 不动骨干

                                                  损失函数

                                                  cross_entropy

                                                   (标准 CE)

                                                  lk_loss = -log Σ min(p,q)

                                                   (直接优化接受率)

                                                  训练数据

                                                  正常预训练语料

                                                  目标模型的输出分布 (草稿展开多步自回归)

                                                  训练目标

                                                  让骨干学到更好的表示

                                                  让草稿分布逼近目标分布 (但用 LK 而非 KL)

                                                  结论: 训练方式完全不同,但这是 "同一套权重的两种用法", 不是两套独立架构。

                                                  4.6.3 思维差异:根本 (这是最核心的差异)

                                                  • MTP 的思维: 我是训练工具。我的存在是为了让骨干 Transformer 学到更好的表示 — 预测 x[t+2] 迫使模型编码更深的上下文,梯度反传回骨干相当于正则化。我预测得准不准不重要,重要的是我的梯度让骨干变强了。

                                                  • EAGLE‑3 的思维: 我是推理工具。骨干已经训练好了 (冻结), 我的任务是快速生成 "足够像目标模型" 的候选 token, 让目标模型批量验证而非逐个生成。我不需要完美,我需要接受率高— 每多一个被接受的 token, 就省一次目标模型前向。

                                                  用一句话说:MTP 是 "用多预测一个 token 来让骨干学得更好"。EAGLE‑3 是 "用骨干的多层特征来让自己猜得足够准以加速推理"。同一个层,两种哲学。

                                                  4.6.4 差异量级总结

                                                  • 架构差异:极小 (1 个线性层,初始化时退化为 MTP)

                                                  • 训练差异:中等 (冻结 vs 联合,CE vs LK,但权重共享)

                                                  • 思维差异:根本 (训练增强 vs 推理加速,完全不同的目标函数)

                                                  所以差异究竟在哪里 — 差异在思维。架构上它们几乎是同一个东西,这正是 K3 设计的精妙之处:一个 MTP 层,预训练时当正则化器用,推理时当草稿模型用,一鱼两吃。

                                                  0x05 子知识点深度分析

                                                  5.0 共享抽象与统一符号

                                                  关键符号:h = backbone 最终隐藏态 (B,T,d);V = 词表大小;MTP 融合输入来自 h[:, :-1] 与 emb(x[:, 1:])(均 (B,T-1,d));W_E3 为特征融合投影 (3d→d);p / q = 目标 / 草稿逐位置分布;r = 接受率;L = draft 草稿步数;λ = loss_weight。

                                                  为什么"预测 x[t+2]"而非 "x[t+1]":主模型已在第 t 位预测 x[t+1] 并拿到梯度;MTP 若也预测 x[t+1] 就与主模型重复且无信息增益。MTP 利用 x[t+1] 已知这个前提(teacher-forced),让 backbone 同一隐藏态"多出一个采样点",两个目标在共享隐藏状态上互相给梯度。

                                                  统一抽象:投机解码把"目标模型单步前向产 token"抽象成"草稿多步产候选 + 一次 verify 收敛为 1 个以上 token"。所有子知识点共享同一套验证链路:目标打分 → verify → 接受前缀 + bonus。

                                                  5.1 子知识点:MTP 层结构(融合 + 一层 backbone 镜像)

                                                  5.1.1 要解决的问题

                                                  MTP 想解决的,是 NTP 训练"每 token 只有一个监督信号"的信息利用率瓶颈。主干前向一次(93 层)却只为下一步产出 1 个 CE 监督,是昂贵的浪费。我们想在几乎不增加推理成本的前提下,让同一份主干计算同时服务多个未来 token 的预测,从而压榨每步前向的信息量。

                                                  5.1.2 技术难点

                                                  1. 不破坏主干:不能为了多预测一步而改动 backbone 本身(否则推理成本上升)。

                                                  2. 标签偏移对齐:多预测一步意味着目标的"相位"要整体后移,极易对错。

                                                  3. 额外的网络开销:加一个头就需要额外一层的前向/反向,训练吞吐会下降。

                                                  5.1.3 解决方案总体思路

                                                  加一个旁路 MTP 头:它镜像 backbone 的一个块(同样结构、独立参数),读取 h[t] 与 emb(x[t+1]),输出预测 x[t+2]。这样主干一个隐藏态被 loss_lm 和 loss_mtp 两个目标共同训练。训练完这个头不浪费——它是 EAGLE-3 draft 的微调起点。

                                                  5.1.4 思路背后的原理

                                                  • 直觉:管理员同时回答"下下本"。

                                                  • 准专业:h = proj(cat(RMSNorm(hidden[:-1]), e_norm(emb(x[1:])))) → 一层注意力+MoE 块 → 输出 norm。所有参数权重独立(Kimi3Block 从零训)。

                                                  • 专家:MTP layer 镜像骨干块(Kimi3Block(layer_kind)),让 draft 训练时"和 backbone 共享同一套注意算子先验",从而微调 EAGLE-3 时收敛快。dense_ffn=False → 稀疏 MoE,与主干浅层之后的分布一致。

                                                  5.1.5 架构与类依赖关系

                                                    MTPLayer (mtp_layer.py:61)
                                                     ├─ h_norm  RMSNorm(dim)          # :95 隐藏态归一
                                                     ├─ e_norm  RMSNorm(dim)          # :96 嵌入归一
                                                     ├─ proj    Linear(2d→d, bias=F)  # :97 融合投影
                                                     ├─ block   Kimi3Block(config, layer_idx=n_layers, use_kda=(kind=="kda"))  # :105
                                                     │           ├─ attn: KDA 或 MLA   # 依赖 layer_kind
                                                     │           └─ ffn: Dense/MoE     # layer_idx>=n_dense_layers → MoE
                                                     └─ norm    RMSNorm(dim)          # :135 输出归一
                                                    依赖:MTPLayer → Kimi3Block → {KimiDeltaAttention | GatedMLA, StableLatentMoE}
                                                          被 Kimi3ForCausalLM.__init__ 实例化(model.py:302)


                                                    5.1.6 数据流(张量形状逐步)

                                                      hidden (B,T,d)        next_embeds=emb(x[:,1:]) (B,T-1,d)
                                                         │  hidden[:, :-1] (B,T-1,d)     │  [1:] (B,T-1,d)
                                                         ▼ h_norm                        ▼ e_norm
                                                      cat ──────────────────────────►  (B,T-1,2d)
                                                         ▼ proj (2d→d)                 (B,T-1,d)
                                                         ▼ block (attn+ffn, 残差)       (B,T-1,d)
                                                         ▼ norm                        (B,T-1,d)  → 喂 lm_head


                                                      5.1.7 执行流(时序/调用链)

                                                        Kimi3ForCausalLM.forward (model.py:312)
                                                         └─ model.model(tokens) → hidden (B,T,d)
                                                         └─ [if mtp & T>2] self.mtp(hidden[:,:-1], next_embeds, reset_mask, attn_mask)
                                                              → mtp_layer.forward (mtp_layer.py:110)
                                                                 h_norm+e_norm → cat → proj → block → norm
                                                         └─ lm_head(h) → mtp_logits (B,T-1,V)


                                                        5.1.8 关键类/函数职责表

                                                        名称

                                                        file:line

                                                        输入 → 输出

                                                        职责

                                                        MTPLayer.__init__

                                                        mtp_layer.py:86-108

                                                        config → 子层

                                                        构建融合 + 骨架块

                                                        MTPLayer.forward

                                                        mtp_layer.py:110-135

                                                        (hidden, next_embeds) → (B,T-1,d)

                                                        融合 + 一层块变换

                                                        MTPLayer.init_cache

                                                        mtp_layer.py:137-139

                                                        batch → cache

                                                        探块内注意力类型建缓存

                                                        mtp_param_count

                                                        mtp_layer.py:145-156

                                                        dim → int

                                                        计算 MTP 额外参数

                                                        Kimi3ForCausalLM.__init__

                                                        model.py:302

                                                        config

                                                        条件实例化 self.mtp

                                                        5.1.9 代码

                                                          # -*- coding: utf-8 -*-
                                                          """Multi-Token Prediction(MTP)头:K3 的双 token 并行预测层。


                                                          MTP 对应 K3 技术报告 **§4.1.4(Multi-Token Prediction)** 与 **Table 1**。
                                                          主模型每个位置预测 ``x[t+1]``,MTP 层额外读上一步的隐藏态与下一步的嵌入,
                                                          预测 ``x[t+2]``,从而让一个训练步同时监督"两 token"。预训练完成后,这层
                                                          正是 EAGLE-3 草案模型(speculative decoding 草稿)的微调起点。


                                                          kimi3-master 结构(kimi3/model.py:237-265):


                                                              MTPLayer:
                                                                h_norm = RMSNorm(dim)            # 归一化 backbone 隐藏态 h[t]
                                                                e_norm = RMSNorm(dim)           # 归一化被预测 token 的嵌入 emb(x[t+1])
                                                                proj   = Linear(2*dim, dim, bias=False)   # 拼接后投影回 dim
                                                                block  = Kimi3Block(...)        # 复用骨架块(dense_ffn=False -> 稀疏 MoE)
                                                                norm   = RMSNorm(dim)           # 顶层输出归一化,喂给 lm_head


                                                            forward(hidden[:, :-1], next_embeds):
                                                                h  = proj( cat([ h_norm(hidden), e_norm(next_embeds) ], dim=-1) )
                                                                h  = h + block.attend(h)
                                                                h  = h + block.feed_forward(h).hidden
                                                                return norm(h)


                                                          本项目 ``Kimi3Block`` 的 forward 接口是 ``x + attn + ffn`` 一体化(紧
                                                          ``Kimi3Block.forward``),与官方的 ``attend(...)``/``feed_forward(...)`` 分离接口
                                                          等价:MTP 层直接复用 ``Kimi3Block(config, layer_idx, use_kda=...)`` 即可,
                                                          ``layer_idx >= n_dense_layers`` 保证 FFN 走稀疏 MoE(官方 ``dense_ffn=False``
                                                          语义)。


                                                          与训练相关的偏移语义(决定答案在哪一位):
                                                            - 输入 ``hidden`` 是 backbone 的最终隐藏态 ``(B, T, D)``,第 t 个位置刻画
                                                              输入 token ``x[t]`` 及其上文;
                                                            - 输入 ``next_embeds = embed_tokens(x[:, 1:])``(shift 一位的嵌入);
                                                            - 拼接投影后逐位置融合,经过一个骨架块,输出 ``(B, T-1, C)``,其第 t 个
                                                              位置预测 ``x[t+2]``(t+1 的嵌入已知,故天然快一拍)。
                                                            - ``Kimi3ForCausalLM._mtp_loss`` 里用 ``labels[:, 2:]`` 对齐这个输出
                                                              (见 model.py / mtp 集成)。


                                                          数值注意:kimi3-master 与 kimi-k3-pytorch 的 MTP 输出**都要再过一遍
                                                          ``lm_head``**(共享主模型词表头)。本模块只输出隐藏态;套 lm_head 的循环
                                                          由上层 ``Kimi3ForCausalLM`` 完成,与 vision 塔同样的"投影到骨干 dim 后由
                                                          主干头接管"的习惯。
                                                          """


                                                          class MTPLayer(nn.Module):
                                                              """K3 Multi-Token Prediction 层(对齐 kimi3-master ``MTPLayer``)。


                                                              一个"把第 t 个 backbone 隐藏态与第 t+1 个 token 嵌入融合、预测第 t+2 个
                                                              token"的轻量解码器层。结构与一个正常骨架块一致,但输入来自**拼接**:


                                                              - ``source_hidden``:主干最后一层输出 ``hidden[:, :-1]``
                                                                (``(B, T-1, C)``,丢掉最后一个位置);
                                                              - ``future_embeddings``:``embed_tokens(x[:, 1:])``
                                                                (``(B, T-1, C)``,下一 token 的嵌入)。


                                                              两个输入在**各自 RMSNorm**后拼接成 ``(B, T-1, 2C)``,经无 bias 的
                                                              投影融合回 ``C`` 维,再过一个骨架块(注意力 + MoE),最后再 RMSNorm,
                                                              得到 ``(B, T-1, C)`` 的 MTP 隐藏态。上层接 lm_head 得到 ``x[t+2]`` 的
                                                              logits。


                                                              为什么 h 与 e 要**分开归一化后再拼接**(而不是拼了再规范化):
                                                              拼接发生在 2C 维,若整体 RMSNorm,两个来源的尺度会互相干扰;先各自
                                                              归一化到单位 RMS,拼接时两边贡献均衡,这正是 kimi3-master
                                                              ``h_norm/e_norm`` 与 kimi-k3-pytorch ``KimiMTPFusion`` 的做法。


                                                              MTP 层可额外接收与骨架一致的 ``reset_mask``/``attn_mask``(在多文档
                                                              打包场景下用)——因为它内部就是 ``Kimi 3Block``,掩码语义自然继承。
                                                              """


                                                              def __init__(self, config: Kimi3Config, layer_kind: Optional[str] = None):
                                                                  super().__init__()
                                                                  from ..model import Kimi3Block  # 延迟导入,避免循环依赖
                                                                  cfg = config.model
                                                                  kind = layer_kind or cfg.mtp.layer_kind
                                                                  dim = cfg.dim
                                                                  eps = cfg.norm_eps


                                                                  # ---- 融合子层:各自归一化 + 无 bias 拼接投影 ---------------------
                                                                  self.h_norm = RMSNorm(dim, eps)
                                                                  self.e_norm = RMSNorm(dim, eps)
                                                                  self.proj = nn.Linear(2 * dim, dim, bias=False)


                                                                  self.layer_kind = kind
                                                                  # ---- 骨架块:复用主干 Kimi3Block --------------------------------
                                                                  # layer_idx 越大越能避开 early dense FFN 分支:传 cfg.n_layers 保证
                                                                  # “layer_idx >= n_dense_layers”,从而走进 StableLatentMoE 分支
                                                                  # (官方 dense_ffn=False -> 稀疏 MoE)。
                                                                  # use_kda 由 layer_kind 决定: "kda" -> KDA 注意力,“mla” -> GatedMLA。
                                                                  self.block = Kimi3Block(
                                                                      config, layer_idx=cfg.n_layers, use_kda=(kind == "kda")
                                                                  )
                                                                  self.norm = RMSNorm(dim, eps)


                                                              def forward(
                                                                  self,
                                                                  hidden: Tensor,
                                                                  next_embeds: Tensor,
                                                                  *,
                                                                  reset_mask: Optional[Tensor] = None,
                                                                  attn_mask: Optional[Tensor] = None,
                                                              ) -> Tensor:
                                                                  """输入 ``hidden``/``next_embeds`` 均为 ``(B, T, C)``,输出 ``(B, T, C)``。


                                                                  ``hidden`` 常为主干最终隐藏态 ``h[:, :-1]``,``next_embeds`` 常为
                                                                  ``emb(x[:, 1:])``,二者必须等长(commit)。
                                                                  """
                                                                  b, t, c = hidden.shape
                                                                  if next_embeds.shape[:2] != (b, t) or next_embeds.shape[2] != c:
                                                                      raise ValueError(
                                                                          f"hidden/next_embeds must share shape (B, T, C); got "
                                                                          f"{tuple(hidden.shape)} vs {tuple(next_embeds.shape)}"
                                                                      )
                                                                  if self.h_norm is not None:
                                                                      h = self.proj(torch.cat([self.h_norm(hidden), self.e_norm(next_embeds)], dim=-1))
                                                                  else:
                                                                      h = self.proj(torch.cat([hidden, next_embeds], dim=-1))
                                                                  # 骨架块:x + attn(x) + ffn(x)。reset_mask/attn_mask 透传(打包场景)。
                                                                  h = self.block(h, reset_mask=reset_mask, attn_mask=attn_mask)
                                                                  return self.norm(h)


                                                              def init_cache(self, batch: int, *, device=None, dtype=torch.float32):
                                                                  """增量推理 cache:取决于 MTP 块内注意力类型(KDA/MLA)。"""
                                                                  return self.block.attn.init_cache(batch, device=device, dtype=dtype)


                                                              def extra_repr(self) -> str:
                                                                  return f"layer_kind={self.layer_kind}, proj_bias=False"


                                                          def mtp_param_count(config: Kimi3Config) -> int:
                                                              """MTP 层参数量的解析公式(对齐 kimi3-master config.py kda/mla_each)。


                                                              仅计 MTP 层自身的参数(不含主干):3×RMSNorm → ~3*(C+C+C)=3C,
                                                              proj 无 bias 投影 → 2C*C,骨架块(一个 KDA 或一个 MLA + 一个 MoE)。
                                                              精确数字因骨架结构而异,这里给的是一个便于 demo/t 断言的下界:
                                                              proj 一项就是 2C^2。
                                                              """
                                                              cfg = config.model
                                                              dim = cfg.dim
                                                              # proj 占大头 2*dim*dim(无 bias);加上 3 个 RMSNorm gain。
                                                              return 2 * dim * dim + 3 * dim


                                                          def mtp_layer_weight_names(config: Kimi3Config) -> list[str]:
                                                              """MTP 层的可学习权重名前缀(用于文档核对与测试断言)。"""
                                                              return [
                                                                  "h_norm.weight", "e_norm.weight", "proj.weight",
                                                                  "block.attn_norm.weight", "block.ffn_norm.weight", "norm.weight",
                                                              ]


                                                          5.1.10 对比基线与实测数据

                                                          • 无 MTP(纯 NTP):每 token 一个监督。

                                                          • MTP:主模型 + 辅助一层,每 token 两个监督。

                                                          • 收益:同一隐藏态被两个目标训练,隐含正则化;lambda_mtp*mtp 公式即 ntp + λ·mtp。代价:每 step 多一次 MTP 层前向/反向。

                                                          • 与外 ev 对比(kimi3-master vs kimi-k-pytorch):

                                                          构型

                                                          kimi3-master

                                                          kimi-k3-pytorch

                                                          本项目

                                                          MTP 交叉层

                                                          单块,KDA/MLA(默认 mla)

                                                          独立"整组 3×KDA+1×Gated-MLA"

                                                          单块(可切 kda/mla)

                                                          偏置

                                                          全无 bias

                                                          fusion_bias=False

                                                          无 bias

                                                          FFN

                                                          dense_ffn=False

                                                          →MoE

                                                          use_dense_ffn=False

                                                          →StableLatentMoE

                                                          MoE

                                                          loss_weight

                                                          0.3

                                                          0.1

                                                          0.3

                                                          5.1.11 反方辩手 / 边界条件

                                                          • a) 最强反对:训练开销大,多 token 预测可能无边际收益。

                                                          • b) 若失败,最可能错:窄模型/少数据上信号饱和,MTP 无额外信息。

                                                          • c) 胜出:数据量大、backbone 容量高(K3 2.8T);失败:超小型任务(教学场景)。

                                                          • d) 更稳健:以极小的 loss_weight(0.1~0.3)起步。

                                                          • e) 受影响方:训练吞吐(每步多一箭)。


                                                          5.2 子知识点:偏移对齐(h[t] + emb(x[t+1]) → logits[t]=x[t+2])

                                                          5.2.1 要解决的问题

                                                          MTP 的输入是"当前隐藏态 + 未来 token 嵌入",输出要预测"更未来的 token"。如果偏移对错,模型会去学错误的目标(比如重复主模型的 x[t+1]),整个 MTP 头形同虚设。

                                                          5.2.2 技术难点

                                                          1. 输入侧双 shift:hidden[:, :-1] 与 emb(x[:, 1:]) 要严格错开一位,让"当前位置"恰好看到 x[t+1]。

                                                          2. 输出侧再 shift:logits 与 labels 也要对齐(logits[:, :-1] ↔ labels[:, 2:]),三维形状要逐一核对。

                                                          3. Teacher-forcing 泄漏:直接给模型真实 x[t+1],可能让模型学会"复制"而非"预测"。

                                                          5.2.3 解决方案总体思路

                                                          利用 teacher-forcing 的"已知 x[t+1]"作为前提:MTP 前向输入 hidden[:, :-1](丢弃最后位置)+ next_emb = emb(x[:,1:])。两层 shift 后,输出第 t 个位置对应"输入第 t 个 backbone 隐藏态 + 第 t+1 个 token 嵌入",因此它已经知道 x[t+1],预测目标 x[t+2]。对齐:logits[:, :-1] ↔ labels[:, 2:]。

                                                          5.2.4 思路背后的原理

                                                          • 直觉:告诉助手"我读到了上一本(x[t])和下一本(x[t+1])是什么",让他猜下下本(x[t+2])。

                                                          • 准专业:维度——MTP logits (B,T-1,V),labels2 (B,T-2),前者截掉末尾一位对齐。若错误用 x[t] 的嵌入(无 shift),退化成"预测 x[t+1]",与主模型重复。

                                                          • 专家:这本质是"多步展开 vs teacher-forced 一步"的权衡。多步展开会累积误差且无法并行;teacher-forced 借用真实 token 作为条件,使每个位置的监督互不干扰,是训练期的高效形态(计算形态通识)。

                                                          5.2.5 架构与类依赖

                                                          无独立类;逻辑在 Kimi3ForCausalLM._mtp_logits(model.py)内完成 shift 与拼接。

                                                          5.2.6 数据流

                                                            tokens (B,T)         hidden (B,T,d)
                                                               │ x[:,1:]               │ [:, :-1]
                                                               ▼ tok_embed (B,T-1,d)   ▼ (B,T-1,d)
                                                               └──→ MTPLayer ──► (B,T-1,d) ──► lm_head ──► mtp_logits (B,T-1,V)
                                                            labels (B,T) → [:,2:] (B,T-2)  对齐 logits[:, :-1] (B,T-2,V)


                                                            5.2.7 执行流

                                                              model.forward (model.py:341, 当 labels 且 T>2)
                                                               └─ mtp_loss = self._mtp_loss(hidden, tokens, labels, doc_ids)   # :351
                                                                    └─ logits = self._mtp_logits(hidden, tokens, doc_ids)      # :408
                                                                    └─ CE(logits[:, :-1], labels[:, 2:], ignore_index=-100)    # :411-415


                                                              5.2.8 关键函数职责表

                                                              名称

                                                              file:line

                                                              输入 → 输出

                                                              职责

                                                              _mtp_logits

                                                              model.py:364-393

                                                              (hidden,tokens,doc_ids) → (B,T-1,V)/None

                                                              shift + 融合 + 前向 + lm_head

                                                              _mtp_loss

                                                              model.py:395-415

                                                              (hidden,tokens,labels,doc_ids) → loss/None

                                                              用 labels[:,2:] 算 CE

                                                              doc_masks

                                                              model.py:24-53

                                                              doc_ids → reset/attn mask

                                                              多文档打包掩码

                                                              5.2.9 代码

                                                                class Kimi3ForCausalLM(nn.Module):
                                                                    """完整因果语言模型 = Kimi3Model + 共享权重 lm_head。


                                                                    - 解码路径核心接口:
                                                                       ``init_caches(batch)`` 建每 block 缓存 → ``forward(tokens, caches)`` 增量前向
                                                                       → ``generate(...)`` 生成新 token。
                                                                    """


                                                                    def __init__(self, config: Kimi3Config):
                                                                        super().__init__()
                                                                        self.model = Kimi3Model(config)
                                                                        self.lm_head = nn.Linear(config.model.dim, config.model.vocab_size, bias=False)
                                                                        # 用户后可结合的 Transformer 惯例:lm_head 通常权重与 token embedding 绑定。
                                                                        # 本项目是独立权重(un-tied),注释备注以便后续可切换到绑。
                                                                        self._gradient_checkpointing = False
                                                                        # ---- Multi-Token Prediction 头---------------------------
                                                                        # 官方 kimi3-master:`self.mtp = MTPLayer(model_cfg) if model_cfg.mtp.enabled else None`。
                                                                        # MTP 层读 backbone 最终隐藏态 h[t] + emb(x[t+1]),预测 x[t+2];
                                                                        # 预训练完成后即为 EAGLE-3 草稿模型的微调起点。
                                                                        self.mtp = MTPLayer(config) if config.model.mtp.enabled else None


                                                                    def forward(
                                                                        self,
                                                                        tokens: Tensor,
                                                                        doc_ids: Optional[Tensor] = None,
                                                                        caches: Optional[list] = None,
                                                                        labels: Optional[Tensor] = None,
                                                                        return_hidden: bool = False,
                                                                        return_mtp: bool = False,
                                                                    ):
                                                                        """forward:核心逻辑在 ``Kimi3Model.forward``,这里只加输出头。


                                                                        ``tokens`` 若是一次预填整段(prefill),输出是 ``(batch, seq, vocab)``;
                                                                        若解码时逐 token 增量,则 ``tokens`` 形状 ``(batch, 1)``,输出相应为
                                                                        ``(batch, 1, vocab)``——历史信息全都藏在 ``caches`` 里。


                                                                        可选 MTP 训练(对齐 kimi3-master forward):传入 ``labels`` 时计算
                                                                        LM 损失,并(若本模型配有 MTP 层)叠加 MTP 损失,最终返回一个
                                                                        ``dict``(键 ``logits``/``loss``/``lm_loss``/``mtp_loss``/``hidden``)。
                                                                        不传 ``labels`` 时行为与旧接口一致:只返回 logits 张量(避免破坏
                                                                        现有调用方与测试)。


                                                                        ``labels`` 语义:与 HF 相同,逐位置 ground truth token id;
                                                                        ``-100`` 的位置不参与损失。主模型 logits 第 t 位预测 ``labels[:, 1:]``
                                                                        第 t 位(shift 一位)。MTP 层的预测目标再次 shift:MTP logits 第 t 位
                                                                        预测 ``tokens[t+2]``,对齐 ``labels[:, 2:]``。
                                                                        """
                                                                        h = self.model(tokens, doc_ids=doc_ids, caches=caches)
                                                                        logits = self.lm_head(h)


                                                                        if labels is not None:
                                                                            b, t = tokens.shape
                                                                            lm_loss = F.cross_entropy(
                                                                                logits[:, :-1].reshape(-1, logits.shape[-1]).float(),
                                                                                labels[:, 1:].reshape(-1),
                                                                                ignore_index=-100,
                                                                            )
                                                                            loss = lm_loss
                                                                            mtp_loss = None
                                                                            if self.mtp is not None and t > 2:
                                                                                mtp_loss = self._mtp_loss(h, tokens, labels, doc_ids)
                                                                                loss = loss + self.model.config.model.mtp.loss_weight * mtp_loss
                                                                            return {
                                                                                "logits": logits,
                                                                                "loss": loss,
                                                                                "lm_loss": lm_loss,
                                                                                "mtp_loss": mtp_loss,
                                                                                "hidden": h if return_hidden else None,
                                                                                "mtp_logits": self._mtp_logits(h, tokens, doc_ids) if return_mtp else None,
                                                                            }


                                                                        return logits


                                                                    def _mtp_logits(
                                                                        self,
                                                                        hidden: Tensor,
                                                                        tokens: Tensor,
                                                                        doc_ids: Optional[Tensor] = None,
                                                                    ) -> Optional[Tensor]:
                                                                        """MTP 层前向,输出 ``x[t+2]`` 的 logits ``(batch, t-1, vocab)``。


                                                                        对齐 kimi3-master ``model.py:_mtp_loss``:取 hidden[:, :-1]、
                                                                        next_embeds = embed_tokens(tokens[:, 1:]),MTP 层内每位置融合
                                                                        ``h[t] + emb(x[t+1])`` 预测 ``x[t+2]``,再经 lm_head 得到 logits。
                                                                        若 MTP 层禁用(``self.mtp is None``)返回 None。


                                                                        ``labels`` 的对应:MTP logits 第 t 位预测 ``x[t+2]``,所以训练目标
                                                                        用 ``labels[:, 2:]``。shape: logits (B, T-1, V),labels2 = (B, T-2, V),
                                                                        前者需再取 ``[:-1]`` 对齐(kimi3-master 正是这么做的)。
                                                                        """
                                                                        if self.mtp is None:
                                                                            return None
                                                                        b, t = hidden.shape[0], tokens.shape[1]
                                                                        if t <= 2:
                                                                            return None
                                                                        reset_mask, attn_mask = doc_masks(
                                                                            None if doc_ids is None else doc_ids[:, :-1], t - 1, hidden.device
                                                                        )
                                                                        next_embeds = self.model.tok_embed(tokens[:, 1:])
                                                                        h = self.mtp(
                                                                            hidden[:, :-1], next_embeds, reset_mask=reset_mask, attn_mask=attn_mask
                                                                        )
                                                                        return self.lm_head(h)


                                                                    def _mtp_loss(
                                                                        self,
                                                                        hidden: Tensor,
                                                                        tokens: Tensor,
                                                                        labels: Tensor,
                                                                        doc_ids: Optional[Tensor] = None,
                                                                    ) -> Optional[Tensor]:
                                                                        """MTP 损失(预测 x[t+2] 的交叉熵),供训练管线单独调用。


                                                                        与 kimi3-master ``_mtp_loss`` 一致:
                                                                        ``F.cross_entropy(mtp_logits[:, :-1], labels[:, 2:], ignore_index=-100)``。
                                                                        返回 None 当 MTP 层禁用或序列过短。
                                                                        """
                                                                        logits = self._mtp_logits(hidden, tokens, doc_ids)
                                                                        if logits is None:
                                                                            return None
                                                                        return F.cross_entropy(
                                                                            logits[:, :-1].reshape(-1, logits.shape[-1]).float(),
                                                                            labels[:, 2:].reshape(-1),
                                                                            ignore_index=-100,
                                                                        )              


                                                                5.2.10 对比基线与实测数据

                                                                model.py:362-411 + discussion.py:E4 验证:更换 next_emb 为不对齐的嵌入,MTP logits 平均 |Δ|=0.5494(对 x[t+1] 极敏感),确认对齐语义无误;输出形状 (B=2, T-1=7, V=64)(实测)。

                                                                5.2.11 反方辩手 / 边界条件

                                                                • a) 最强反对:teacher-forcing 泄漏——x[t+1] 的正确性直接炒作结果,无需真的"下一步"全模型。

                                                                • b) 失败点:模型可能只学"复制 x[t+1] 到 x[t+2]"而非语义预测。

                                                                • c) 胜出:若 x[t+1] 嵌入携带大量语义上下文;失败:训练只有大量不相干位置。

                                                                • d) 更稳健:MTP 的输入可与 X 后对换正则(未来 research)。

                                                                • 完成度:已实现并运行通过(E4 实测回填)。

                                                                5.3 子知识点:EAGLE-3 特征融合 [0 0 I]

                                                                • "特征融合"= 把目标模型低/中/高三层隐藏表示拼起压回 d 维作为草稿输入。

                                                                • [0 0 I] 是 W_E3 初值:W_E3=[0|0|I] → 初始 fused=high(MTP 预训练输入),避免微调起步扰动。

                                                                • "选三个"现在唯一在 Eagle3Draft.fuse(),由 DraftConfig.feature_blocks=(0,3,-1) 驱动;eagle3_feature_stack 只摊平不选择。

                                                                • 实测(E2):[0 0 I] 初值 error=0 且恒 0;随机/全零有初始扰动后收敛。

                                                                5.3.1 要解决的问题

                                                                草稿模型要"猜得快且像"目标。它需要的输入,比目标 lm_head 消费的 high(最终隐藏态)信息更完整——high 为了预测下一 token 已高度压缩,丢掉了拼写、常见搭配、格式模板等表层线索。这些线索在低/中层还活着。所以草稿需要一个"多深度融合"的视图。

                                                                5.3.2 技术难点

                                                                1. 选哪些层:93 层骨干可选出口很多,选多了冗余、选少了缺信息。

                                                                2. 融合初值:草稿是从预训练 MTP 层微调来的,MTP 层只见过 high 这个输入分布。若 W_E3 随机初始化,EAGLE-3 微调第一步草稿就收到从未见过的输入,预训练学到的东西瞬间失效。

                                                                3. 层间尺度:不同深度特征的尺度差异大,直接拼接会被大尺度者主导。

                                                                5.3.3 解决方案总体思路

                                                                取低/中/高三个出口(第 1 / 第 4 / 末个 AttnRes 块,feature_blocks=(0,3,-1)),cat 后过无 bias 投影 W_E3: 3d→d。W_E3 初值设为 [0 0 I]:最后 d 列单位阵、前 2d 全零 → 初始时 fuse 输出 ≡ 高层特征,即 MTP 预训练时的输入。训练逐步学用低/中,避免起步扰动。

                                                                5.3.4 思路背后的原理

                                                                • 直觉:顾问起步只信"最高层摘要",再学会翻"低层笔记",而不是上来就乱翻把所有笔记搅在一起。

                                                                • 准专业:W_E3 = [ 0_{d×d} | 0_{d×d} | I_{d×d} ] → fused = W_E3·[low;mid;high] = high。训练后低/中列学到非零值,融合才开始吸收低/中信息。

                                                                • 专家:这是"平滑扩展模型输入"的通用技巧(同类思想:ControlNet 的零卷积、LoRA 的 B=0 初始化、K3 MTP 的 residual 结构)。[0 0 I] 保证微调第 0 步完全无扰动,由梯度自己决定"要不要、以多大权重"把低/中掺进来。

                                                                5.3.5 架构与类依赖

                                                                  Eagle3FeatureFusion (eagle3.py:73)
                                                                   ├─ proj Linear(dim*n_sources → dim, bias=False)   # :84
                                                                   └─ reset_parameters()   # :87-91  权重置零,末 dim 列置单位阵
                                                                  依赖:被 Eagle3Draft.fusion 持有;Eagle3Draft.fuse (eagle3.py:167-168)
                                                                        按 DraftConfig.feature_blocks 选源 → fusion
                                                                        源由 eagle3_feature_stack (eagle3.py:104) 摊平 AttnResState 提供


                                                                  5.3.6 数据流

                                                                    AttnResState → eagle3_feature_stack(state) → [b0,b1,...,bN]   # 摊平全部
                                                                         ↓ DraftConfig.feature_blocks=(0,3,-1)
                                                                    Eagle3Draft.fuse → [b0, b3, bN] → cat (B,T,3d) → W_E3 (B,T,d)




                                                                    5.3.7 执行流

                                                                      SpeculativeDecoder._features (speculative.py:347-349)
                                                                       └─ state = model.model._attn_res_state      # 仅 attn_res.enabled 时有
                                                                       └─ _extract_features (speculative.py:281-296)
                                                                            ├─ AttnRes 有: eagle3_feature_stack(state, picks=None)  # 摊平
                                                                            └─ 无: [hidden]*5   # 教学回退
                                                                       └─ _fused → draft.fuse(feats)   # 选 (0,3,-1) + W_E3




                                                                      5.3.8 关键类/函数职责表

                                                                      名称

                                                                      file:line

                                                                      输入 → 输出

                                                                      职责

                                                                      Eagle3FeatureFusion.reset_parameters

                                                                      eagle3.py:87-91

                                                                      —

                                                                      置 [0 0 I] 初值

                                                                      Eagle3FeatureFusion.forward

                                                                      eagle3.py:93-96

                                                                      features → (B,T,d)

                                                                      cat + 投影

                                                                      eagle3_feature_stack

                                                                      eagle3.py:104-134

                                                                      state, picks=None → list

                                                                      摊平不选择

                                                                      (V3 修复)

                                                                      Eagle3Draft.fuse

                                                                      eagle3.py:167-168

                                                                      block_features → (B,T,d)

                                                                      唯一选择点 + 融合

                                                                      _extract_features

                                                                      speculative.py:281-296

                                                                      (model,hidden,state) → list

                                                                      AttnRes 摊平 / 回退

                                                                      5.3.9 代码

                                                                        class FeatureFusion(nn.Module):
                                                                            """Bias-free ``W_E3``, initialised ``[0 0 I]``."""


                                                                            def __init__(self, dim: int, n_sources: int = 3):
                                                                                super().__init__()
                                                                                self.dim = dim
                                                                                self.n_sources = n_sources
                                                                                self.proj = nn.Linear(dim * n_sources, dim, bias=False)
                                                                                self.reset_parameters()


                                                                            def reset_parameters(self) -> None:
                                                                                with torch.no_grad():
                                                                                    self.proj.weight.zero_()
                                                                                    # [0 ... 0 I]: the last source (the high-level feature) passes through.
                                                                                    self.proj.weight[:, -self.dim:] = torch.eye(self.dim)


                                                                            def forward(self, features: list[Tensor]) -> Tensor:
                                                                                if len(features) != self.n_sources:
                                                                                    raise ValueError(f"expected {self.n_sources} feature sources")
                                                                                return self.proj(torch.cat(features, dim=-1))


                                                                        @dataclass
                                                                        class DraftConfig:
                                                                            #: Training-time unroll length (the paper's test protocol).
                                                                            unroll_steps: int = 7
                                                                            #: AttnRes blocks the fused features are taken from.
                                                                            feature_blocks: tuple[int, int, int] = (0, 3, -1)
                                                                            #: MoE expert weights in MXFP4 with MXFP8 input activations (section 4.1.4).
                                                                            qat: bool = True


                                                                        class Eagle3Draft(nn.Module):
                                                                            """Draft model fine-tuned from the pre-trained MTP layer."""


                                                                            def __init__(self, mtp_layer: nn.Module, dim: int, lm_head: nn.Module,
                                                                                         cfg: DraftConfig | None = None):
                                                                                super().__init__()
                                                                                self.cfg = cfg or DraftConfig()
                                                                                self.fusion = FeatureFusion(dim, n_sources=len(self.cfg.feature_blocks))
                                                                                self.layer = mtp_layer
                                                                                self.lm_head = lm_head


                                                                            def fuse(self, block_features: list[Tensor]) -> Tensor:
                                                                                picked = [block_features[i] for i in self.cfg.feature_blocks]
                                                                                return self.fusion(picked)


                                                                            def forward(self, fused: Tensor, next_embeds: Tensor) -> Tensor:
                                                                                h = self.layer(fused, next_embeds)
                                                                                return self.lm_head(h)


                                                                            @torch.no_grad()
                                                                            def draft(
                                                                                self, fused: Tensor, embed_fn, *, n_steps: int | None = None
                                                                            ) -> tuple[Tensor, Tensor]:
                                                                                """Autoregressive drafting: after the first step the draft consumes its
                                                                                own outputs, exactly as at inference."""
                                                                                n_steps = n_steps or self.cfg.unroll_steps
                                                                                tokens, logits_out = [], []
                                                                                state = fused
                                                                                last = embed_fn(torch.zeros(fused.shape[:2], dtype=torch.long, device=fused.device))
                                                                                for _ in range(n_steps):
                                                                                    logits = self.forward(state, last)
                                                                                    nxt = logits[:, -1:].argmax(-1)
                                                                                    tokens.append(nxt)
                                                                                    logits_out.append(logits[:, -1:])
                                                                                    last = embed_fn(nxt)
                                                                                    state = state[:, -1:]
                                                                                return torch.cat(tokens, dim=1), torch.cat(logits_out, dim=1)


                                                                        def speedup_from_acceptance(rate: float, draft_len: int) -> float:
                                                                            """Expected tokens per target forward under lossless speculative sampling."""
                                                                            if rate >= 1.0:
                                                                                return float(draft_len + 1)
                                                                            return (1.0 - rate ** (draft_len + 1)) / (1.0 - rate)





                                                                        Q1. 有 Kimi3ForCausalLM × Eagle3Draft 协作的 demo 吗?verify 代码在哪?

                                                                        现在有:

                                                                        • src/models/llm/kimi_k3/mtp/speculative.py:verify_tokens(判据)、SpeculativeDecoder(端到端循环)、RecomputeBackend/CacheRollbackBackend(两打分路径)。

                                                                        • experiments/mtp/eagle3_demo.py:跑真实模型循环,实测接受率与 tokens/forward。

                                                                        • tests/mtp/test_speculative.py:10 项,含"Recompute vs Rollback 逐 token 一致"的回滚正确性证明。

                                                                        • 设计动机:kimi3-master/serve/eagle3.py 没有 verify,故自研扩展。实测 lossless 接受率 0.13、tokens/forward 1.389。

                                                                        Q2. 如何获取出那三层?

                                                                        [0 0 I] 是 Eagle3FeatureFusion.proj(一个无 bias 的 W_E3: 3d → d)的初始权重,作用是初始化时让融合输出恒等于高层特征 h_h。

                                                                        具体含义如下:

                                                                        W_E3 ∈ ℝ^{d×3d} 被分块成 [W_low | W_mid | W_high],初始化令:

                                                                        • W_low = 0

                                                                        • W_mid = 0

                                                                        • W_high = I(单位阵)→ eagle3.py:91

                                                                        因此初始前向:

                                                                          fuse([h_l, h_m, h_h]) = [0 0 I] @ [h_l; h_m; h_h] = h_h

                                                                          即 忽略低/中层特征,只透传高层特征——这正是 MTP 预训练时的输入分布,所以微调起步无扰动,之后模型再逐步学习吸收低/中层。

                                                                          这三个特征从哪来 / 怎么生成

                                                                          由 eagle3_feature_stack (eagle3.py:103) 配合 DraftConfig.feature_blocks=(0, 3, -1) 提供:

                                                                          1. 生成来源:主干 Kimi3ForCausalLM 前向期间,AttentionResiduals 每完成一个块就把输出折叠进 AttnResState.blocks,sources() 摊平成 [embedding, block_1, ..., block_N]。

                                                                          2. 选择:Eagle3Draft.fuse() (eagle3.py:175) 按 (0, 3, -1) 从该列表挑三块——第 1 块、第 4 块、最后一块 AttnRes 输出,分别对应低/中/高层语义。

                                                                          3. FeatureFusion 获取:三个 (B,T,d) 张量沿最后一维 cat 成 (B,T,3d),经 W_E3 投影回 (B,T,d),作为草稿层 MTPLayer 的输入(eagle3.py:178)。

                                                                          一句话:[0 0 I] 让 EAGLE-3 起步时等价于"只用目标模型最后一层特征"的 MTP,之后通过 LK 损失学习把 W_low/W_mid 从 0 调整为非零。

                                                                          Q3. AttentionResiduals 如何生成?

                                                                          在 Kimi3Model 的前向传播中,会用 self.attn_res.add_output(self._attn_res_state, h) 往self._attn_res_state 中增加模型每层生成的中间状态。

                                                                            state = model.model._attn_res_state  # AttnResState 对象
                                                                            feats_all = eagle3_feature_stack(state, picks=None)   # speculative.py:291



                                                                            Q4. 给出一个真实样例

                                                                            真实调用链(来自 speculative.py:355 和 test_eagle3_integration.py)

                                                                              # ============ 1) 目标模型前向,副作用产生 AttnResState ============
                                                                              model = Kimi3ForCausalLM(cfg)        # 主干
                                                                              out = model(input_ids)               # 前向时 AttentionResiduals 在内部
                                                                                                                   # 维护 model.model._attn_res_state


                                                                              # ============ 2) 从 AttnResState 摊平成"可读源列表" ============
                                                                              state = model.model._attn_res_state  # AttnResState 对象
                                                                              feats_all = eagle3_feature_stack(state, picks=None)   # speculative.py:291
                                                                              # feats_all 是 List[Tensor],长度 = n_blocks + 1
                                                                              # feats_all[0] = token embedding
                                                                              # feats_all[1] = 第 1 个 AttnRes 块完成时的塌缩表示
                                                                              # feats_all[2] = 第 2 个 AttnRes 块塌缩
                                                                              # ...
                                                                              # feats_all[N] = 最后一个块(高层语义)
                                                                              # 每项 shape = (B, T, d)


                                                                              # ============ 3) 按 (0, 3, -1) 选三块 ============
                                                                              draft = Eagle3Draft(model.mtp, dim=cfg.model.dim, lm_head=model.lm_head)
                                                                              # DraftConfig.feature_blocks = (0, 3, -1)
                                                                              h_l = feats_all[0]    # 低层:第 0 块 = token embedding
                                                                              h_m = feats_all[3]    # 中层:第 3 块
                                                                              h_h = feats_all[-1]   # 高层:最后一块
                                                                              # 这三个就是 [h_l; h_m; h_h],每个 shape (B, T, d)


                                                                              # ============ 4) Eagle3FeatureFusion.forward 收到什么 ============
                                                                              # draft.fuse(feats_all) 内部:
                                                                              #   selected = [feats_all[0], feats_all[3], feats_all[-1]]     # eagle3.py:176
                                                                              #   return self.fusion(selected)
                                                                              # fusion.forward 里:
                                                                              #   cat([h_l, h_m, h_h], dim=-1)  -> shape (B, T, 3d)
                                                                              #   self.proj(...)                -> Linear(3d -> d, bias=False)
                                                                              #   输出 fused (B, T, d)



                                                                              一个真实测试例(test_eagle3_integration.py:60-71)

                                                                                fusion = Eagle3FeatureFusion(C=64, n_sources=3)
                                                                                feats  = [torch.randn(2, 3, 64) for _ in range(3)]
                                                                                #        ↑ h_l (2,3,64)   ↑ h_m (2,3,64)   ↑ h_h (2,3,64)
                                                                                fused  = fusion(feats)
                                                                                # 内部:torch.cat(feats, dim=-1) -> (2,3,192)
                                                                                #       proj: Linear(192 -> 64, bias=False)
                                                                                #       初始 W = [0_{64×64} | 0_{64×64} | I_{64×64}]
                                                                                #       故 fused == feats[2] == h_h
                                                                                assert torch.allclose(fused, feats[2])     # 通过 —— 这就是 [0 0 I] 的效果




                                                                                端到端(带真实模型,见 test_eagle3_integration.py:74)

                                                                                  cfg   = small_cfg(mtp=MTPConfig(enabled=True, layer_kind="mla"))
                                                                                  model = Kimi3ForCausalLM(cfg)
                                                                                  draft = Eagle3Draft(model.mtp, cfg.model.dim, model.lm_head)


                                                                                  # 模拟 AttnRes 攒了 5 个块
                                                                                  feats = [torch.randn(2, 4, 64) for _ in range(5)]
                                                                                  fused = draft.fuse(feats)              # 内部挑 [0],[3],[4],cat 成 (2,4,192)
                                                                                                                         # proj -> (2,4,64)
                                                                                  # fused 喂给 MTP 层做草稿自回归
                                                                                  toks, logits = draft.draft(fused, model.model.tok_embed, n_steps=3)




                                                                                  关键点

                                                                                  • h_l / h_m / h_h 不是三层隐藏状态——是 AttnResState.blocks 列表里索引 0、3、-1 的"块塌缩表示"(每个块是若干子层输出的累加和,attn_res.py:189-194)。

                                                                                  • blocks[0] 永远是 token embedding(attn_res.py:155),所以"低层"实际就是词嵌入。

                                                                                  • 生成方式:主干前向时,每完成一个 AttnRes 块,add_output 把 partial 追加进 blocks——这是前向的副作用,无需额外计算。

                                                                                  • FeatureFusion 拿到的输入:三个 (B,T,d) 张量的列表,forward 里 torch.cat(dim=-1) 拼成 (B,T,3d) 一次性过 Linear(3d→d, bias=False)。

                                                                                  5.3.10 对比基线与实测数据

                                                                                  • 直接只用高层特征:简单、无扰动,但不用低层信息。

                                                                                  • [0 0 I] 融合:在"零扰动起点"和"可用多层信息"之间平滑过渡。

                                                                                  • discussion.py:E2 实测:[0 0 I] 起步 error=0 且保持 0;随机起步初始 error 1.3484 → 0.0010;全零起步 1.0393 → 0.0007(训练目标=高层恒等,60 步 Adam)。证明零扰动优势。

                                                                                  5.3.11 反方辩手 / 边界条件

                                                                                  • a) 反对:低/中层特征到底有没有用未知,可能就是噪音,白加参数。

                                                                                  • b) 若失败:低中层特征与高层冗余或与预测不相关。

                                                                                  • c) 胜出:draft 需要在"已见上下文"处更细粒度;失败:浅层特征与目标无关。

                                                                                  • d) 更稳健:学到的 W_E3 若趋于 [0 0 I],则模型自己选择只用高层=自动关闭低层。

                                                                                  • 完成度:已实现并运行通过(E2 实测回填)。


                                                                                  5.4 子知识点:LK 损失(EAGLE-3 训练目标)

                                                                                  5.4.1 要解决的问题

                                                                                  投机解码的加速比 ∝ 逐 token 接受率 Σ_x min(p,q)。草稿模型的训练目标应该直接最大化这个接受率,而不是用一个"看起来相关但实际脱节"的代理。

                                                                                  5.4.2 技术难点

                                                                                  1. 代理失效:常规的 KL 最小化对容量受限的草稿模型,不保证最大化接受率——它可能让草稿越来越"保守"而不是越来越像 p 的峰值。

                                                                                  2. 梯度稀疏:log Σ min 这类目标在高置信处梯度可能很稀,收敛慢。

                                                                                  5.4.3 解决方案总体思路

                                                                                  直接优化 L_LK = -log Σ_x min(p(x), q(x)),温度 1、无 CE 辅助项。它正是接受率的负对数——优化目标与推理加速的度量直接对齐,而非代理。

                                                                                  paper-LK-loss
                                                                                  paper-LK-loss

                                                                                  5.4.4 思路背后的原理

                                                                                  • 直觉:与其学"一个像样的分布",不如直接学"猜中被接受的概率最大"。

                                                                                  • 准专业:p=目标分布、q=草稿分布;Σ_x min(p,q) 是两分布的"重叠量"(acceptance)。取其负对数作为损失,最小化它即最大化重叠。

                                                                                  • 专家:论文指出,对容量受限 draft,KL 最小化不能保证最大化接受率;LK 损失把"优化目标"和"推理加速比"绑定,是"端到端对齐"的体现。

                                                                                  5.4.5 详细分析原理

                                                                                  KL 散度(标准正向 KL:是 mode-seeking(寻找目标分布峰值);但当草稿模型q容量受限(参数量 / 表达能力不足,没法完整拟合真实分布p),最小化正向 KL 会出现保守效应:q会避开所有p有概率但q没法建模的区域,宁愿压低整体分布、只在少数安全区域输出概率,而不是去对齐p的高概率峰值,最终投机解码(speculative decoding)的 token 接受率上不去。

                                                                                   

                                                                                  符号约定: p:大目标模型(Target,真实分布) q:容量受限的草稿模型(Draft)

                                                                                  ”
                                                                                  正向 KL 最小化的数学行为

                                                                                  正向 KL: 损失最小化等价于:惩罚 q 在 q 自己采样出来的位置上,和 p 不一致。

                                                                                  • 如果q某个位置分配概率,但p在这里概率很低 → 损失暴涨,模型会把这个位置的概率压到接近 0。

                                                                                  • 但反过来:p 有很高概率、q 没有能力建模的区域,KL 不会惩罚。 也就是:(p(x)\gg0),但(q(x)=0),这一项在 KL 求和里直接消失,没有损失。

                                                                                  👉 后果:容量不够时,q发现自己无法覆盖p全部高概率区域,最优解就是切掉所有拿不准的候选 token,只保留极少数它非常确定的 token。 也就是变保守:输出分布很尖,但候选集合太小,很多p真正想要的峰值 token 被直接置零;草稿模型采样出来的 token,即便 q 很自信,也不是 p 的完整峰值集合,投机接受率无法最大化。

                                                                                  和反向 KL 对比(方便理解)

                                                                                  反向 KL: 最小化反向 KL:惩罚 p 高概率区域里 q 低估的地方。 只要(p(x))大,就强制(q(x))不能太小。

                                                                                   

                                                                                  反向 KL 是 mode-covering,会强制 q 去拟合 p 的所有峰值;代价是容易在 p 低概率处分配多余概率(产生幻觉候选)。

                                                                                  ”
                                                                                  放到投机解码(草稿模型)场景

                                                                                  投机解码目标:最大化草稿 token 被大模型接受的概率。 要最大化接受率,理想草稿q应该满足:q的高概率集合,尽量覆盖p的高概率峰值集合。

                                                                                  但用正向 KL 训练受限容量草稿模型:

                                                                                  1. 草稿容量不足,没办法同时建模 p 所有峰值;

                                                                                  2. 最小正向 KL 的最优策略:放弃一部分 p 的峰值,直接把这些 token 概率归零;

                                                                                  3. 草稿只保留一小部分最稳妥 token,分布变得保守;

                                                                                  4. 虽然 q 在自己保留的 token 上和 p 很接近,但漏掉了大量 p 的峰值候选;

                                                                                  5. 采样出来的草稿序列,命中 p 接受 token 的概率并不会最高。

                                                                                   

                                                                                  关键点区分: 正向 KL 最小化 ≠ 最大化接受率。 正向 KL 优化目标是分布距离;投机接受率是另一个非对称的离散指标,二者目标空间不一致。当模型有表达瓶颈时,目标函数会走捷径,走向保守,而不是对齐 p 峰值。

                                                                                  ”
                                                                                  简单例子(token-level)

                                                                                  假设下一个 token 真实分布p:A:0.5, B:0.4, C:0.1 草稿模型容量有限,最多只能表达 2 个 token。

                                                                                  • 正向 KL 最小化:最优策略是删掉 B,输出A:0.99, C:0.01。避开 B,因为模型学不好 B,B 会带来巨大 KL 损失。分布保守,采样几乎只有 A。但 p 有 40% 概率选 B,草稿永远不会生成 B,大量机会丢失 → 接受率上不去。

                                                                                  • 如果是反向 KL:会强制 q 覆盖 A、B 两个高概率峰,输出A:0.55, B:0.45。草稿会采样 A/B,恰好是 p 的两个主峰,投机接受率更高。

                                                                                  一句话总结这个现象

                                                                                  容量受限下最小正向 KL,草稿模型会主动舍弃目标分布里难以建模的高概率峰,消除风险项来降低 KL 损失,表现为输出分布保守;但投机接受率依赖草稿能覆盖目标分布主峰,所以正向 KL 优化无法保证最大化接受率。

                                                                                  5.4.6 架构与类依赖

                                                                                  无独立类;lk_loss(eagle3.py:63-70)与 acceptance_rate(eagle3.py:58-60)为纯函数,被训练管线调用。

                                                                                  5.4.7 数据流

                                                                                    target_logits (B,T,V)  draft_logits (B,T,V)
                                                                                       ▼ softmax                ▼ softmax
                                                                                     p (B,T,V)               q (B,T,V)
                                                                                       └─→ min(p,q) → sum(-1) → -log → mean   # lk_loss (eagle3.py:63-70)





                                                                                    5.4.8 执行流

                                                                                      训练: loss = lk_loss(target_logits, draft_logits)
                                                                                        └─ p=softmax(target); q=softmax(draft)
                                                                                        └─ return -log(acceptance_rate(p,q).clamp_min(1e-9)).mean()





                                                                                      5.4.9 关键函数职责表

                                                                                      名称

                                                                                      file:line

                                                                                      输入 → 输出

                                                                                      职责

                                                                                      acceptance_rate

                                                                                      eagle3.py:58-60

                                                                                      (p,q) → (B,)

                                                                                      Σ_x min(p,q)
                                                                                      lk_loss

                                                                                      eagle3.py:63-70

                                                                                      (target,draft logits) → scalar

                                                                                      -log Σ min

                                                                                      5.4.10 代码

                                                                                        def acceptance_rate(p: Tensor, q: Tensor) -> Tensor:
                                                                                            """``sum_x min(p(x), q(x))`` -- the quantity speculative decoding's speedup
                                                                                            is proportional to."""
                                                                                            return torch.minimum(p, q).sum(-1)



                                                                                        def lk_loss(target_logits: Tensor, draft_logits: Tensor) -> Tensor:
                                                                                            """Eq. 16, at temperature 1.


                                                                                            Directly the negative log acceptance rate, with no ground-truth
                                                                                            cross-entropy term -- optimising the thing that actually determines the
                                                                                            speedup instead of a surrogate for it.
                                                                                            """
                                                                                            p = torch.softmax(target_logits.float(), dim=-1)
                                                                                            q = torch.softmax(draft_logits.float(), dim=-1)
                                                                                            return -torch.log(acceptance_rate(p, q).clamp_min(1e-9)).mean()




                                                                                        5.4.11 对比基线与实测数据

                                                                                        • KL(f ‖ q)(surrogate):最小化边际奖励,可越来越"保守"而非越像 p 的峰值。

                                                                                        • L_K(直接接受率):优化目标和推理加速的正比关系直接对齐。

                                                                                        • test_mtp.py 中 lk_loss(p,q)=0 当 p=q,且随分布分歧单调上升(E2 sanity)。

                                                                                        5.4.12 反方辩手 / 边界条件

                                                                                        • 反对:log Σ min 损失在高分处梯度稀疏,收敛慢?

                                                                                        • 回应:论文测试(Unroll 7)在真实 K3 draft 上已可训练至收敛;本项目 lk_loss 在 p=q 时为 0、随分布疏离单调上升。

                                                                                        • 完成度:已实现并运行通过(E2 sanity)。

                                                                                        5.5 子知识点:EAGLE-3 draft 推理(草稿自回归)

                                                                                        5.5.1 要解决的问题

                                                                                        目标模型 93 层每 token 一前向太贵。投机解码想用"每步只花一层"的草稿模型先快速猜 L 个 token,再用一次目标前向核对——省下昂贵的目标前向次数。草稿自回归就是"连续猜 L 个"的实现。

                                                                                        5.5.2 技术难点

                                                                                        1. 草稿没有目标特征:从第 2 步起,草稿不再有"目标侧特征"可用(最新位置的目标特征要等目标前向才有),只能吃自己上一步的输出——这是递归起草。

                                                                                        2. 融合输入只来自一步:draft() 每步把 state 缩到最后一位 state[:, -1:],模拟推理时"只有当前位置可用"。

                                                                                        3. 与 verify 接续:草稿猜完必须交给目标核对,否则没有意义。

                                                                                        5.5.3 解决方案总体思路

                                                                                        草稿自回归 L 步,每步只走一个 MTP 层(很便宜):第 1 步用融合特征 fused + 占位嵌入,之后每步把上一步 argmax token 嵌入作为输入,state 缩到 [:, -1:]。目标 = 一次 93 层前向 verify L+1 个候选。

                                                                                        5.5.4 思路背后的原理

                                                                                        • 直觉:速读顾问连翻几页,每翻一页只花"一层"的力气,翻完交给主模型一次性核对。

                                                                                        • 准专业:draft() 循环 L 次,logits = forward(state, last),nxt = argmax,last = embed(nxt),state = state[:, -1:]。

                                                                                        • 专家:这是"推理期递推形态":草稿从全序列前向(训练)切换为单步递推(推理),因为只有当前位置的分布需要。

                                                                                        5.5.5 架构与类依赖

                                                                                          Eagle3Draft (eagle3.py:146)
                                                                                           ├─ fusion  Eagle3FeatureFusion
                                                                                           ├─ layer   MTPLayer(复用)
                                                                                           ├─ lm_head 目标共享词表头
                                                                                           └─ draft() (eagle3.py:174-191)   # 自回归
                                                                                          依赖:被 SpeculativeDecoder._run_round 调用(speculative.py:363)




                                                                                          5.5.6 数据流

                                                                                            fused (B,T,d) → 取最后一位
                                                                                            loop L 次:
                                                                                               forward(state, last) → logits (B,1,V)
                                                                                               nxt = argmax → (B,1)
                                                                                               last = embed(nxt); state = state[:, -1:]
                                                                                            返回 tokens (B,L), logits (B,L,V)




                                                                                            5.5.7 执行流

                                                                                              SpeculativeDecoder._run_round (speculative.py:363-370)
                                                                                               └─ fused = self._fused(hidden)
                                                                                               └─ draft_tokens, draft_logits = draft.draft(fused, tok_embed, n_steps=L)
                                                                                                    └─ Eagle3Draft.draft (eagle3.py:174-191)




                                                                                              5.5.8 关键函数职责表

                                                                                              名称

                                                                                              file:line

                                                                                              输入 → 输出

                                                                                              职责

                                                                                              Eagle3Draft.forward

                                                                                              eagle3.py:170-172

                                                                                              (fused,next_embeds) → logits

                                                                                              单步草稿前向

                                                                                              Eagle3Draft.draft

                                                                                              eagle3.py:174-191

                                                                                              (fused, embed_fn, n_steps) → (tokens,logits)

                                                                                              递归起草 L 步

                                                                                              5.5.9 代码

                                                                                                # -*- coding: utf-8 -*-
                                                                                                """EAGLE-3 草稿模型:从 MTP 层微调出的投机解码 draft(K3 报告 §4.1.4)。


                                                                                                EAGLE-3(extension-3 of the speculative decoding literature)把预训练的 MTP
                                                                                                层当作起点,微调成一个单解码器层式的草稿模型。目标模型冻结,只训草稿层与
                                                                                                特征融合投影。两个关键机制(对齐 kimi3-master ``serve/eagle3.py`` 全文):


                                                                                                1. **特征融合 ``FeatureFusion``**:输入是低/中/高三层特征的拼接(分别取自
                                                                                                   第 1、4、最终 Attention Residuals 块的输出——一个 93 层骨干只有这 3 处
                                                                                                   “深度方向混合”出入口),经一个**无 bias** 的 ``W_E3: 3d -> d`` 投影
                                                                                                   融合。``W_E3`` 初值 ``[0 0 I]``:最后一列是单位阵,于是初始融合输出
                                                                                                   **完全等于高层特征 h_h**——正是 MTP 预训练时的输入;模型从“只信高层”
                                                                                                   逐步学到“吸收低/中层特征”,初始化不引入瞬间扰动。


                                                                                                2. **LK 损失**:投机解码的加速比正比于逐 token 接受率 ``sum_x min(p,q)``
                                                                                                   (p 目标、q 草稿)。用减法 KL 当代理**不能保证**最大化接受率(容量受限的
                                                                                                   草稿模型),故 K3 直接优化权重似然 LK 损失
                                                                                                   ::


                                                                                                       L_LK = -log sum_x min(p(x), q(x))


                                                                                                   温度 1,无 ground-truth CE 项。训练时把草稿展开 7 步:除第一步外(最先前
                                                                                                   位置的“目标侧特征”不可得),草稿消费自己早前步的输出——正是推理期
                                                                                                   循环起草(drafting)的过程的镜像。


                                                                                                特征栈语义(在 main 侧由 ``AttentionResiduals`` 每块输出收集):
                                                                                                - ``eagle3_feature_stack(attn_res_state)``:从 AttnRes 状态缓存里按
                                                                                                  ``(0, 3, -1)``(第 1、第 4、最后)三个 unit 的输出取特征。
                                                                                                  本项目 AttnRes 状态语义:``n_units = 2*n_layers``(每 block 两个 sublayer
                                                                                                  unit)。kimi3-master 里 ``feature_blocks=(0,3,-1)`` 指第 1 / 4 / 末个
                                                                                                  **Attention Residuals 块**的输出。实现上本项目直接给一个通用的
                                                                                                  ``eagle3_feature_stack(state, picks)``:默认 picks 视 n_layers 归一。
                                                                                                """
                                                                                                class Eagle3FeatureFusion(nn.Module):
                                                                                                    """无 bias 的 ``W_E3``,初始 ``[0 0 I]``(官方 FeatureFusion)。


                                                                                                    ``proj: (n_sources*dim) -> dim``,权重初值前 ``(n_sources-1)*dim`` 列全 0、
                                                                                                    末 ``dim`` 列单位阵。初始化后 ``fuse 输出 ≡ 高层特征``。
                                                                                                    """


                                                                                                    def __init__(self, dim: int, n_sources: int = 3):
                                                                                                        super().__init__()
                                                                                                        self.dim = dim
                                                                                                        self.n_sources = n_sources
                                                                                                        self.proj = nn.Linear(dim * n_sources, dim, bias=False)
                                                                                                        self.reset_parameters()


                                                                                                    def reset_parameters(self) -> None:
                                                                                                        with torch.no_grad():
                                                                                                            self.proj.weight.zero_()
                                                                                                            # [0 ... 0 I]:最后一个源(高层特征)恒等通过。
                                                                                                            self.proj.weight[:, -self.dim:] = torch.eye(self.dim)


                                                                                                    def forward(self, features: Sequence[Tensor]) -> Tensor:
                                                                                                        if len(features) != self.n_sources:
                                                                                                            raise ValueError(f"expected {self.n_sources} feature sources, got {len(features)}")
                                                                                                        return self.proj(torch.cat(list(features), dim=-1))


                                                                                                # 兼容官方命名:FeatureFusion 即 Eagle3FeatureFusion。
                                                                                                FeatureFusion = Eagle3FeatureFusion


                                                                                                @torch.no_grad()
                                                                                                def eagle3_feature_stack(
                                                                                                    state,
                                                                                                    picks: Optional[Sequence[int]] = None,
                                                                                                ) -> list[Tensor]:
                                                                                                    """从本项目 AttentionResiduals 状态里摊平 EAGLE-3 可读的特征源列表。


                                                                                                    ``state`` 是 ``Kimi3ForCausalLM`` 前向期间 ``AttentionResiduals`` 的残差
                                                                                                    容器(``modules/attn_res.py::AttnResState``)。本项目 AttnRes 以块(block)
                                                                                                    为单位维持低级表示:``init_state`` 把 token embedding 置为 ``blocks[0]``,
                                                                                                    随后每完成一个块就折叠进 ``blocks``(``add_output``),``sources()`` 返回
                                                                                                    "embedding + 各已完成块表示 + 当前块 partial" 的可读源列表。


                                                                                                    **职责划分(修复 V2 Q5 的重复选择缺陷)**:本函数只负责"把状态对象摊平
                                                                                                    成完整的出口列表",**不做"选哪三层"**;选择唯一保留在
                                                                                                    ``Eagle3Draft.fuse()``(由 ``DraftConfig.feature_blocks`` 单一来源驱动),
                                                                                                    与官方 ``kimi3-master/serve/eagle3.py::fuse`` 一致。因此:


                                                                                                    - ``picks=None``(默认):返回**全部**可读源 ``[b_0, b_1, ..., b_N]``,
                                                                                                      供上层自行选择(推荐用法:先摊平,再按 ``feature_blocks`` 挑)。
                                                                                                    - ``picks`` 非空:为向后兼容仍可在此直接按索引挑选(已弃用,新代码
                                                                                                      不要用,避免与 ``fuse()`` 的选择逻辑互斥串联而越界)。


                                                                                                    返回:特征张量列表,每个形状 ``(B, T, C)``。
                                                                                                    """
                                                                                                    if hasattr(state, "outputs"):  # 通用兼容:直接给输出列表的对象
                                                                                                        seq = list(state.outputs)
                                                                                                    elif hasattr(state, "sources"):
                                                                                                        seq = state.sources()
                                                                                                    elif isinstance(state, (list, tuple)):
                                                                                                        seq = list(state)
                                                                                                    else:
                                                                                                        raise TypeError(f"cannot read feature sources from {type(state)}")
                                                                                                    if picks is None:
                                                                                                        return seq
                                                                                                    n = len(seq)
                                                                                                    idx = [i if i >= 0 else n + i for i in picks]
                                                                                                    if any(i >= n for i in idx) or any(i < 0 for i in idx):
                                                                                                        raise IndexError(f"feature picks {picks} out of range for {n} sources")
                                                                                                    return [seq[i] for i in idx]


                                                                                                class Eagle3Draft(nn.Module):
                                                                                                    """从预训练 MTP 层微调出的草稿模型。


                                                                                                    ``mtp_layer`` 是 MTPLayer(其内部 ``block`` 就是草案层),``lm_head`` 是
                                                                                                    目标模型共享词表头。推理期:每步从目标模型取 ``fused``(特征融合)输入,
                                                                                                    草稿输出 logits [B,1,V],再与目标做接受/拒绝。
                                                                                                    """


                                                                                                    def __init__(
                                                                                                        self,
                                                                                                        mtp_layer: nn.Module,
                                                                                                        dim: int,
                                                                                                        lm_head: nn.Module,
                                                                                                        cfg: DraftConfig | None = None,
                                                                                                    ):
                                                                                                        super().__init__()
                                                                                                        self.cfg = cfg or draft_config()
                                                                                                        self.fusion = Eagle3FeatureFusion(dim, n_sources=len(self.cfg.feature_blocks))
                                                                                                        self.layer = mtp_layer
                                                                                                        self.lm_head = lm_head


                                                                                                    def fuse(self, block_features: Sequence[Tensor]) -> Tensor:
                                                                                                        return self.fusion([block_features[i] for i in self.cfg.feature_blocks])


                                                                                                    def forward(self, fused: Tensor, next_embeds: Tensor) -> Tensor:
                                                                                                        h = self.layer(fused, next_embeds)
                                                                                                        return self.lm_head(h)


                                                                                                    @torch.no_grad()
                                                                                                    def draft(
                                                                                                        self, fused: Tensor, embed_fn: Callable[[Tensor], Tensor],
                                                                                                        *, n_steps: int | None = None,
                                                                                                    ) -> tuple[Tensor, Tensor]:
                                                                                                        """自动回归起草:第一步后草稿吃自己的输出——推理期 draft 的原样。"""
                                                                                                        n_steps = n_steps or self.cfg.unroll_steps
                                                                                                        tokens, logits_out = [], []
                                                                                                        state = fused
                                                                                                        last = embed_fn(torch.zeros(fused.shape[:2], dtype=torch.long, device=fused.device))
                                                                                                        for _ in range(n_steps):
                                                                                                            logits = self.forward(state, last)
                                                                                                            nxt = logits[:, -1:].argmax(-1)
                                                                                                            tokens.append(nxt)
                                                                                                            logits_out.append(logits[:, -1:])
                                                                                                            last = embed_fn(nxt)
                                                                                                            state = state[:, -1:]
                                                                                                        return torch.cat(tokens, dim=1), torch.cat(logits_out, dim=1)



                                                                                                5.5.10 对比基线与实测数据

                                                                                                • 无投机:每 token 一个目标前向。

                                                                                                • EAGLE-3:每目标前向平均 1~6+ token(依赖接受率)。

                                                                                                • speedup_from_acceptance(r=0.8, L=7) = 4.16(理论,E3 表格)。

                                                                                                • 注意:这是理论上限。草稿猜得对不对要 verify 才算数(§4.6 给实测)。

                                                                                                5.5.11 反方辩手 / 边界条件

                                                                                                • 反对:草稿本身要训练、要保存模型文件、QAT 复杂。

                                                                                                • 成功条件:高接受率(r≈0.8+)。

                                                                                                • 失败条件:草稿未训练好、接受率低,加速比趋近 1。

                                                                                                • 完成度:已实现并运行通过(draft 全链路测试)。


                                                                                                5.6 子知识点:投机解码 verify 与端到端循环

                                                                                                5.6.1 要解决的问题

                                                                                                草稿 draft() 只是"猜了一串 token",没有任何机制判断这些 token 是否值得接受。没有 verify,投机解码就是空谈——你无法知道该照单全收、部分收、还是全拒。真实加速比也因此无法实测。

                                                                                                5.6.2 技术难点

                                                                                                1. 接受/拒绝判据:如何在"保留草稿"与"纠正错误"之间无损地权衡(必须保证最终分布 = 目标分布,即 lossless)。

                                                                                                2. 目标并行打分:目标模型要能一次前向对 L+1 个草稿位置打分,而不是 L+1 次前向。

                                                                                                3. KDA 状态回滚:KDA 的递推状态 S 被拒绝后无法像 KV cache 那样随意截断——这是 serve/decode.py 那套投影重演机制存在的原因,但两者此前没接起来。

                                                                                                4. 残差重采样:拒绝时要从残差分布重采 1 个 token,保证无损。

                                                                                                5.6.3 greedy vs lossless

                                                                                                投机采样分为两大阶段:

                                                                                                1. 小模型(draft model)生成一串候选 draft token;

                                                                                                2. 大目标模型(target model)做 verify 校验:逐个验证 draft token 是否接受;verify 有两种主流模式:greedy(贪心校验)、lossless(无损校验,也叫 strict 无损)。

                                                                                                核心本质区别
                                                                                                • greedy verify(贪心校验):校验时,target 模型输出贪心 next token,和 draft 的 token 做比对。只要 draft token 等于 target 贪心输出,就接受该 token;一旦不相等,丢弃后面所有 draft,直接输出 target 的贪心 token,结束本轮 verify。

                                                                                                • lossless verify(无损校验):严格复现原始论文无损投机采样数学逻辑,不拿贪心输出做比对;直接拿 target 完整概率分布,做概率层面的校验,保证输出分布和原生直接解码完全等价,输出结果 100% 和直接跑 target 模型一模一样,没有任何分布偏移。

                                                                                                token 接受判断逻辑

                                                                                                greedy verify

                                                                                                  draft_token_i == target.greedy_token




                                                                                                  只对比 target 取 argmax 的那个 token。

                                                                                                   

                                                                                                  风险:target 概率分布里,draft token 不是最大概率,但依然是合法高概率候选;greedy 模式会直接拒绝这个 token,造成不必要截断,引入分布偏差,不是无损。

                                                                                                  ”

                                                                                                  lossless verify

                                                                                                  依据原始投机采样概率接受准则:

                                                                                                  按这个概率做随机采样决定是否接受 draft token。

                                                                                                  • 只要满足概率条件就接纳 draft token;

                                                                                                  • 不强制要求 draft token 必须是 target 的 top‑1 贪心 token;

                                                                                                  • 拒绝时,从修正后的 target 分布重新采样下一个 token。

                                                                                                  输出一致性
                                                                                                  • greedy verify:❌ 非无损。最终生成文本 ≠ target 原生 greedy 解码。会发生不该截断的时候强行截断,改变输出。速度更快,但结果会偏移。

                                                                                                  • lossless verify:✅ 严格无损。整体生成分布完全等价于直接用 target 模型解码,不会改变模型输出行为,是论文标准。

                                                                                                  速度与吞吐量
                                                                                                  1. greedy verify:实现简单,每一步只拿 argmax,很多框架实现不用取出完整概率分布;截断发生更早,平均接受 token 数量更少。

                                                                                                  2. lossless verify:需要拿到 target 完整 token 概率,做比值 + 随机采样;可以接受更多 draft token,单轮 verify 能吞更长 draft 序列,理论上限速度更高;但需要访问完整 logits,算力开销略大。

                                                                                                   

                                                                                                  现实工程:vLLM/SGLang 里投机采样,speculative_algorithm=greedy / lossless。

                                                                                                  ”
                                                                                                  终止行为
                                                                                                  • greedy verify:只要某一个 draft token≠target 贪心 token,立刻全部丢弃后续 draft tokens,输出 target 贪心 token,本轮 verify 结束。

                                                                                                  • lossless verify:某一个 draft token 被概率拒绝,仅丢弃该位置及之后所有 draft,从 target 校正分布采样 1 个 token,本轮结束;前面已经通过的 token 全部保留。

                                                                                                  适用场景

                                                                                                  greedy verify

                                                                                                  • 只追求加速,对输出分布一致性没有强要求;

                                                                                                  • 业务本身就是 greedy 解码场景,追求简单、低开销;

                                                                                                   

                                                                                                  注意:即便你外层开启 greedy 解码,投机 verify 用 greedy 模式依然会带来输出不一致。

                                                                                                  ”

                                                                                                  lossless verify

                                                                                                  • 需要严格保证大模型原有输出效果,不能因为投机采样改变生成内容;

                                                                                                  • 开启 temperature、top‑p 采样场景;

                                                                                                  • 学术复现、对正确性敏感业务。

                                                                                                  通俗一句话总结
                                                                                                  • greedy verify:只看大模型最想要的那个 token,draft 对上就收,对不上全部扔掉,快但会改结果。

                                                                                                  • lossless verify:看完整概率,按数学规则随机接纳,不改变大模型原本输出,但计算开销略高,可以接纳更多 draft token。

                                                                                                  5.6.4 解决方案总体思路

                                                                                                  本项目 speculative.py 提供两层:

                                                                                                  • 纯函数 verify_tokens(speculative.py:73):实现 lossless 判据——u <= p(c)/q(c) 接受,否则从 norm(max(p-q,0)) 重采 bonus 并截断。不碰模型,独立可测。

                                                                                                  • SpeculativeDecoder 端到端循环(speculative.py:329),下挂两条打分后端:

                                                                                                    • RecomputeBackend:每轮无 cache 全序列重跑打分(正确性由构造保证,作 oracle)。

                                                                                                    • CacheRollbackBackend:快照 cache、增量打分,部分接受时恢复快照并重放已接受前缀,CacheRollback 是"真正的"工业形态(增量 + 回滚)。

                                                                                                  5.6.5 思路背后的原理

                                                                                                  • 直觉:主模型逐本核对顾问的猜测——猜对收下,猜错自己读一本并退回上一本对的地方。

                                                                                                  • 准专业(lossless 判据):草稿在位置 i 提出 c_i(分布 q_i),目标分布 p_i。采 u~U(0,1):

                                                                                                    • 若 u <= p_i(c_i)/q_i(c_i):接受 c_i;

                                                                                                    • 否则:拒绝,从 norm(max(p_i - q_i, 0)) 重采 1 个 token,截断。每轮产出 = 接受前缀长度 + 1。

                                                                                                  • 专家(为什么 lossless):把"直接从 p 采样"拆成"先看草稿 q 是否给对 + 错了从残差补"两步。只要拒绝分支的重采样分布是 max(p-q,0)/Z,两个分支的加权混合就精确等于 p,逐 token 分布不变——所以叫 lossless。这也是 speedup_from_acceptance 公式成立的严格前提。

                                                                                                  • 为什么两种后端:Recompute 数值正确但 O(T²)(教学 oracle);CacheRollback 是"真正的"工业形态(增量 + 回滚)。两者在固定 seed 下逐 token 一致,正好是回滚正确性的数值证明。

                                                                                                  5.6.6 架构与类依赖关系

                                                                                                    SpeculativeDecoder (speculative.py:329)
                                                                                                     ├─ draft  Eagle3Draft
                                                                                                     ├─ _run_round (speculative.py:363)      → draft
                                                                                                     ├─ decode_recompute (speculative.py:372)  → RecomputeBackend → 全序列打分
                                                                                                     ├─ decode_rollback (speculative.py:413)   → CacheRollbackBackend + snapshot/restore
                                                                                                     └─ verify_tokens (speculative.py:73)      → 纯函数判据


                                                                                                    打分后端:
                                                                                                     RecomputeBackend (speculative.py:264)      model(seq) 全序列
                                                                                                     CacheRollbackBackend (speculative.py:301)  model(tok, caches) 增量 + snapshot/restore


                                                                                                    cache 快照(按类型分派,duck-typing):
                                                                                                     snapshot_caches (speculative.py:221) → clone
                                                                                                     restore_caches (speculative.py:237) → KDA/MLA 原地回滚



                                                                                                    5.6.7 数据流(张量形状逐步)

                                                                                                      tokens (B,T0)
                                                                                                         ▼ model.model(tokens) → hidden (B,T,d)
                                                                                                         ▼ _fused → draft.fuse → fused (B,T,d)
                                                                                                         ▼ draft.draft → draft_tokens (B,L), draft_logits (B,L,V)
                                                                                                         ▼ 目标打分
                                                                                                            Recompute: cand=cat([tokens,draft_tokens]) (B,T+L) → model → logits (B,T+L,V)
                                                                                                                       取 [:, T:T+L] → tgt_draft (B,L,V)
                                                                                                            Rollback:  逐 token score_token → tgt_draft (B,L,V)
                                                                                                         ▼ verify_tokens(tgt_draft, draft_logits, draft_tokens) → VerifyResult
                                                                                                             n_accepted (B,), bonus_token (B,1), per_pos_ratios (B,L)
                                                                                                         ▼ 并入 tokens:  accepted[:na] + bonus





                                                                                                      5.6.8 执行流(时序/调用链)

                                                                                                      decode_recompute —— 参考 oracle 路径(无 cache 全序列重跑)

                                                                                                      每轮前向次数:目标 2 次全序列(:386 取 hidden + :391 打分)+ 草稿 L 次小步。

                                                                                                      decode_recompute
                                                                                                      decode_recompute
                                                                                                      decode_rollback —— 快照-回滚路径(增量打分)

                                                                                                      每轮前向次数:目标 1 次全序列(:443 取 hidden)+ L 次增量打分(:453)+ na+1 次重放(:467, :469)+ 草稿 L 次小步。

                                                                                                      decode_rollback
                                                                                                      decode_rollback
                                                                                                      两条路径并排对照
                                                                                                      两条路径并排对照
                                                                                                      两条路径并排对照
                                                                                                      关键差异表

                                                                                                      维度

                                                                                                      decode_recomputedecode_rollback

                                                                                                      打分方式

                                                                                                      拼接后全序列重跑(:390-391)

                                                                                                      逐 token 增量

                                                                                                      前向(:451-453)

                                                                                                      打分复杂度

                                                                                                      每轮 O(T²)(:267)

                                                                                                      每轮 L 次小步

                                                                                                      cache

                                                                                                      完全不用init_caches

                                                                                                       + 预填 + 快照/回滚/重放

                                                                                                      快照

                                                                                                      无

                                                                                                      snapshot_caches

                                                                                                      (:450)

                                                                                                      回滚

                                                                                                      无

                                                                                                      restore_caches

                                                                                                      (:464)

                                                                                                      重放

                                                                                                      无

                                                                                                      na

                                                                                                       次 accepted + 1 次 bonus(:465-469)

                                                                                                      目标全序列前向/轮

                                                                                                      2 次

                                                                                                      (:386 hidden + :391 打分)

                                                                                                      1 次

                                                                                                      (:443 hidden)

                                                                                                      定位

                                                                                                      参考 oracle,正确性由构造保证(:268)

                                                                                                      生产路径,正确性需靠 oracle 校验

                                                                                                      三个容易读错的点

                                                                                                      ① decode_rollback 并没有完全摆脱全序列重跑。:443hidden = self.model.model(tokens) 仍然是无 cache 全序列前向。源码 :440-442 专门注释了理由:特征提取要与 Recompute 路径逐位一致,否则两条路径的 token 流对不上;cache 只服务于草稿位置的增量打分,"二者正交"。所以它省掉的是打分那次全序列重跑(:391),不是特征那次。

                                                                                                      ② 回滚是"整体丢弃 + 重放",不是"部分撤销"。backend.score_token(accepted[j:j + 1].unsqueeze(0)) # (1,1) 先把 cache 恢复到草稿开始前(丢弃全部 L 个草稿的副作用),再用 :465-467 把 na 个已接受 token 重新喂一遍。之所以不做"只撤销 L-na 个",是因为 KDA 的 state 是不可逆的递推更新(:243, :247-251 覆盖 state 与三个卷积窗口)——线性注意力的固定大小状态矩阵没有"回退一格"的操作,只能从快照重建。这正是 snapshot_caches 必须存在的根本原因。

                                                                                                      ③ bonus token 必须消费进 cache。:468-469 注释:"被拒绝位置重采的 token 也要消费进 cache(它成为新历史)"。漏掉这一步,cache 会停在 accepted 末尾而 tokens 已多出 bonus,下一轮增量打分的上下文就错位了。这是回滚路径最容易埋 bug 的地方。

                                                                                                      decode_rollback 增量打分机制解析
                                                                                                      • 增量只发生在草稿窗内的 draft_len 次小步前向(这是真正省算力的地方)。

                                                                                                      • 重跑只为取 EAGLE-3 多层特征,是为了让 decode_rollback 与 decode_recompute 严格对齐、便于数值校验而保留的设计,不是技术做不到。

                                                                                                      增量打分如何实现

                                                                                                      关键路径在 speculative.py:448-455:

                                                                                                        step_caches_snap = snapshot_caches(caches)    # ① 打分前快照
                                                                                                        for j inrange(draft_len):
                                                                                                            tok = draft_tokens[:, j:j+1]              # ② 每步只喂 1 个 token
                                                                                                            lg = backend.score_token(tok)             # ③ 走 caches 的增量前向
                                                                                                            tgt_logits_list.append(lg[:, -1:])




                                                                                                        之所以"增量",是因为 CacheRollbackBackend.score_token 把 self.caches 传给 model(tok, caches=...):

                                                                                                        • MLA:只对当前 token 算一次 q·kv_latent,kv_latent 增 1 格(O(1) 追加)。

                                                                                                        • KDA:state 矩阵 S 按 delta rule 推进一步,conv 窗口滑 1 格。

                                                                                                        • 每步代价 = O(draft_len × d),而非 O(T²)。

                                                                                                        随后 restore_caches + 重放(speculative.py:464-469)把 cache 精确停在"已接受前缀末尾"——这是投机解码正确性的关键:被拒绝后缀的 cache 必须丢弃。

                                                                                                        为何没有摆脱全序列重跑

                                                                                                        speculative.py:443 每轮仍在做:

                                                                                                          hidden = self.model.model(tokens)   # 无 cache,全序列前向




                                                                                                          原因有三(见 speculative.py:441-442 注释):

                                                                                                          1. EAGLE-3 特征融合需要全序列 hiddendraft() 的输入是 fuse(features),其中 features 是低/中/高三层 AttnRes 出口堆叠。这些特征不能从增量 cache 直接读出——KDA 的 state 是压缩递推态,不含逐位置 hidden;MLA 的 kv_latent 是压缩 K/V,也不是 hidden。要拿到 (B, T, d) 的 hidden,必须跑一次完整 forward。

                                                                                                          2. 与 RecomputeBackend 严格对齐 注释明说:"与 Recompute 路径完全一致(保证两种后端特征相同)"。本文件的首要目的是用逐 token 一致来证明 rollback 正确性,不是追求性能。所以故意让两条路径的 draft 输入完全同源。

                                                                                                          3. 职责拆分 cache 只服务于"对草稿位置打分"这一段(speculative.py:451-455),与特征提取正交。生产实现里通常会用 last_hidden 增量递推 + AttnRes 快照来避免重跑,但那是性能优化层,不属于本文件的"回滚正确性证明"目标。

                                                                                                          函数细节

                                                                                                            decode_recompute (speculative.py:372) 每轮:
                                                                                                              1 hidden = model.model(tokens)                    # 全序列隐藏态
                                                                                                              2 draft_tokens, draft_logits = _run_round(hidden) # 草稿 L 步
                                                                                                              3 tgt = model(cat([tokens, draft_tokens]))        # 一次前向并行打分
                                                                                                              4 vr = verify_tokens(tgt[:, T:T+L], draft_logits, draft_tokens)
                                                                                                              5 tokens = cat([tokens, accepted[:na], bonus])
                                                                                                              6 stats.record(na, L)


                                                                                                            decode_rollback (speculative.py:413) 每轮:
                                                                                                              1 hidden = model.model(tokens)                    # 特征(无 cache)
                                                                                                              2 draft ...                                       # 草稿 L 步
                                                                                                              3 snap = snapshot_caches(caches)                  # 快照
                                                                                                              4 for j in L: score_token(draft_tokens[:,j])      # 增量打分
                                                                                                              5 vr = verify_tokens(...)
                                                                                                              6 restore_caches(caches, snap)                    # 回滚
                                                                                                              7 重放 accepted[:na] + bonus 进 cache             # cache 停在被接受末尾
                                                                                                              8 tokens = cat([...]); stats.record(na, L)




                                                                                                            5.6.9 关键类/函数职责表

                                                                                                            名称

                                                                                                            file:line

                                                                                                            输入 → 输出

                                                                                                            职责

                                                                                                            verify_tokens

                                                                                                            speculative.py:73-158

                                                                                                            (tgt,draft logits, draft tokens) → VerifyResult

                                                                                                            lossless 接受判据

                                                                                                            SpecDecodeStats.record

                                                                                                            speculative.py:181-183

                                                                                                            (n_accepted, draft_len)

                                                                                                            记录每轮

                                                                                                            SpecDecodeStats.measured_acceptance

                                                                                                            speculative.py:207

                                                                                                            — → float

                                                                                                            实测接受率

                                                                                                            SpecDecodeStats.tokens_per_forward

                                                                                                            speculative.py:215

                                                                                                            — → float

                                                                                                            每目标前向 token 数

                                                                                                            snapshot_caches

                                                                                                            speculative.py:221-235

                                                                                                            caches → snap

                                                                                                            深拷贝 cache

                                                                                                            restore_caches

                                                                                                            speculative.py:237-261

                                                                                                            (caches, snap)

                                                                                                            原地回滚

                                                                                                            RecomputeBackend.score_sequence

                                                                                                            speculative.py:274-278

                                                                                                            seq → (B,T,V)

                                                                                                            全序列打分

                                                                                                            CacheRollbackBackend.score_token

                                                                                                            speculative.py:306-314

                                                                                                            tok → (B,1,V)

                                                                                                            增量打分

                                                                                                            SpeculativeDecoder.decode_recompute

                                                                                                            speculative.py:372

                                                                                                            prompt → (tokens,stats)

                                                                                                            重跑路径循环

                                                                                                            SpeculativeDecoder.decode_rollback

                                                                                                            speculative.py:413

                                                                                                            prompt → (tokens,stats)

                                                                                                            快照-回滚路径循环

                                                                                                            5.6.10 代码

                                                                                                            验证结果

                                                                                                              @dataclass
                                                                                                              class VerifyResult:
                                                                                                                  """一轮 verify 的结果。


                                                                                                                  - ``accepted_tokens``:被接受的草稿 token ``(B, n_accepted)``。
                                                                                                                  - ``n_accepted``:接受前缀长度(每 batch 元素一个标量)。
                                                                                                                  - ``bonus_token``:被拒绝位置重采的 1 个 token ``(B, 1)``(即使全部接受
                                                                                                                    也重采 1 个,保证每轮净增 = 接受数 + 1,符合投机解码约定)。
                                                                                                                  - ``per_pos_ratios``:每个草稿位置的接受概率 ``p_i(c_i)/q_i(c_i)``。
                                                                                                                  """


                                                                                                                  accepted_tokens: Tensor
                                                                                                                  n_accepted: Tensor          # (B,)
                                                                                                                  bonus_token: Tensor         # (B, 1)
                                                                                                                  per_pos_ratios: Tensor      # (B, L)


                                                                                                              def verify_tokens(
                                                                                                                  target_logits: Tensor,
                                                                                                                  draft_logits: Tensor,
                                                                                                                  draft_tokens: Tensor,
                                                                                                                  *,
                                                                                                                  greedy: bool = False,
                                                                                                                  generator: Optional[torch.Generator] = None,
                                                                                                              ) -> VerifyResult:
                                                                                                                  """lossless 接受判据(纯函数,不碰模型)。


                                                                                                                  参数:
                                                                                                                  - ``target_logits`` ``(B, L, V)``:目标模型对 L 个草稿候选位置的分布。
                                                                                                                  - ``draft_logits``   ``(B, L, V)``:草稿模型自己的分布。
                                                                                                                  - ``draft_tokens``   ``(B, L)``:草稿在每位置提出的 token id。
                                                                                                                  - ``greedy``:True 走 argmax 确定性匹配(测试用);False 走 lossless
                                                                                                                    随机接受(u <= p(c)/q(c))。
                                                                                                                  - ``generator``:随机源(可复现测试)。


                                                                                                                  返回 ``VerifyResult``。语义:逐位置判定,一旦拒绝立即截断,并在拒绝位置
                                                                                                                  重采 1 个 bonus token。
                                                                                                                  """
                                                                                                                  B, L, _ = target_logits.shape
                                                                                                                  # softmax 得概率分布 p(目标)与 q(草稿)。
                                                                                                                  p = torch.softmax(target_logits.float(), dim=-1)
                                                                                                                  q = torch.softmax(draft_logits.float(), dim=-1)
                                                                                                                  # 每个草稿位置提出 token 的被接受概率 p_i(c_i) / q_i(c_i)。
                                                                                                                  p_c = p.gather(-1, draft_tokens.unsqueeze(-1)).squeeze(-1)   # (B, L)
                                                                                                                  q_c = q.gather(-1, draft_tokens.unsqueeze(-1)).squeeze(-1)   # (B, L)
                                                                                                                  ratio = (p_c / q_c.clamp_min(1e-9)).clamp_max(1.0)          # (B, L)
                                                                                                                  # ratio 上限 clamp 到 1:当 q_i(c_i) 极小导致比值 >1 时按 1 算,即"该位置
                                                                                                                  # 无条件接受",与 lossless 采样惯例一致(接受概率不可能 >1)。


                                                                                                                  if greedy:
                                                                                                                      # 确定性路径:草稿 token == 目标 argmax 才算接受。
                                                                                                                      target_arg = target_logits.argmax(-1)                    # (B, L)
                                                                                                                      accepted = (draft_tokens == target_arg)
                                                                                                                  else:
                                                                                                                      # lossless 随机路径:采 u,u <= ratio 则接受。
                                                                                                                      u = torch.rand(
                                                                                                                          (B, L), dtype=torch.float32, device=target_logits.device, generator=generator
                                                                                                                      )
                                                                                                                      accepted = (u <= ratio)


                                                                                                                  # 逐 batch 求"连续接受前缀"长度:第一个 False 之前的 True 个数。
                                                                                                                  n_accepted_list = []
                                                                                                                  for b in range(B):
                                                                                                                      n = 0
                                                                                                                      for flag in accepted[b].tolist():
                                                                                                                          if flag:
                                                                                                                              n += 1
                                                                                                                          else:
                                                                                                                              break
                                                                                                                      n_accepted_list.append(n)
                                                                                                                  n_accepted = torch.tensor(n_accepted_list, device=target_logits.device)  # (B,)


                                                                                                                  # 接受前缀的 token;长度取所有 batch 中最大接受数(不足由调用方按 n_accepted 截)。
                                                                                                                  max_acc = int(n_accepted.max().item()) if B else 0
                                                                                                                  if max_acc > 0:
                                                                                                                      accepted_tokens = draft_tokens[:, :max_acc]
                                                                                                                  else:
                                                                                                                      accepted_tokens = draft_tokens.new_zeros(B, 0)


                                                                                                                  # bonus token:在"被拒绝的位置"(= 接受前缀末尾)重采。
                                                                                                                  # 分布 = norm(max(p - q, 0))。若全部接受,则在最后一个草稿位置重采,
                                                                                                                  # 分布取 p(目标)在该位置的分布。
                                                                                                                  bonus_token = torch.zeros(B, 1, dtype=torch.long, device=target_logits.device)
                                                                                                                  for b in range(B):
                                                                                                                      nb = int(n_accepted[b].item())
                                                                                                                      if nb < L:
                                                                                                                          pos = nb
                                                                                                                          residual = torch.clamp(p[b, pos] - q[b, pos], min=0.0)   # (V,)
                                                                                                                      else:
                                                                                                                          pos = L - 1
                                                                                                                          residual = p[b, pos]                                      # 全部接受
                                                                                                                      total = residual.sum().clamp_min(1e-9)
                                                                                                                      probs = residual / total
                                                                                                                      if greedy:
                                                                                                                          bonus_token[b, 0] = probs.argmax()
                                                                                                                      else:
                                                                                                                          bonus_token[b, 0] = torch.multinomial(probs, 1, generator=generator).item()


                                                                                                                  return VerifyResult(
                                                                                                                      accepted_tokens=accepted_tokens,
                                                                                                                      n_accepted=n_accepted,
                                                                                                                      bonus_token=bonus_token,
                                                                                                                      per_pos_ratios=ratio,
                                                                                                                  )




                                                                                                              cache 快照 / 恢复

                                                                                                                # ---------------------------------------------------------------------------
                                                                                                                # cache 快照 / 恢复(按 cache 类型分派)
                                                                                                                # ---------------------------------------------------------------------------


                                                                                                                def _is_kda(c) -> bool:
                                                                                                                    # 用鸭子类型判断(避免 src 与 models 两个模块命名空间导致的 isinstance 失效)。
                                                                                                                    return hasattr(c, "state") and hasattr(c, "conv_q")


                                                                                                                def _is_mla(c) -> bool:
                                                                                                                    return hasattr(c, "kv_latent") and hasattr(c, "length")


                                                                                                                def snapshot_caches(caches: list) -> list:
                                                                                                                    """深拷贝整组 cache(投机解码开始前的状态)。


                                                                                                                    返回与 ``caches`` 等长的副本列表。KDA 用 ``KDACache.clone``,MLA 用
                                                                                                                    ``MLACache.clone``,其他对象(MTP 层 cache)回退到 ``copy.deepcopy``。
                                                                                                                    """
                                                                                                                    import copy
                                                                                                                    snap = []
                                                                                                                    for c in caches:
                                                                                                                        if _is_kda(c) or _is_mla(c):
                                                                                                                            snap.append(c.clone())
                                                                                                                        else:
                                                                                                                            snap.append(copy.deepcopy(c))
                                                                                                                    return snap


                                                                                                                def restore_caches(caches: list, snap: list) -> None:
                                                                                                                    """把 ``caches`` 原地恢复成 ``snap`` 的快照(回滚未验证的续写)。


                                                                                                                    投机部分接受后,草稿被拒绝位置对应的状态必须丢弃。恢复策略:
                                                                                                                    - MLA:latent 被增量前向追加了草稿 latent,需把 ``kv_latent`` 切回快照
                                                                                                                      长度并恢复数值基线;
                                                                                                                    - KDA:直接覆盖 ``state`` 与三个卷积窗口;
                                                                                                                    - 未知类型:逐属性覆盖(投机不深挖内部)。
                                                                                                                    """
                                                                                                                    for c, s in zip(caches, snap):
                                                                                                                        if _is_kda(c):
                                                                                                                            c.state = s.state.clone()
                                                                                                                            c.conv_q = s.conv_q.clone()
                                                                                                                            c.conv_k = s.conv_k.clone()
                                                                                                                            c.conv_v = s.conv_v.clone()
                                                                                                                        elif _is_mla(c):
                                                                                                                            c.kv_latent = s.kv_latent.clone()
                                                                                                                            c.length = s.length
                                                                                                                        else:
                                                                                                                            for k, v in vars(s).items():
                                                                                                                                setattr(c, k, v)


                                                                                                                # ---------------------------------------------------------------------------
                                                                                                                # 打分后端:Recompute(参考 oracle)与 CacheRollback(快照-回滚)
                                                                                                                # ---------------------------------------------------------------------------


                                                                                                                class RecomputeBackend:
                                                                                                                    """重跑后端:每轮用**无 cache 的全序列 forward** 打分。


                                                                                                                    正确性由构造保证(重跑即重新计算所有位置),代价是每轮 O(T²)。
                                                                                                                    作为参考 oracle,用于校验 Rollback 后端的正确性。
                                                                                                                    """


                                                                                                                    def __init__(self, model):
                                                                                                                        self.model = model


                                                                                                                    def score_sequence(self, seq: Tensor) -> Tensor:
                                                                                                                        out = self.model(seq)          # 无 cache,全序列
                                                                                                                        if isinstance(out, dict):
                                                                                                                            out = out["logits"]
                                                                                                                        return out


                                                                                                                def _extract_features(model, hidden: Tensor, attn_res_state) -> list:
                                                                                                                    """从目标模型取出 EAGLE-3 特征融合用的完整出口列表。


                                                                                                                    - AttnRes 启用时:从 ``attn_res_state`` 取**全部**可读 sources(不做选择,
                                                                                                                      选择统一交给 ``Eagle3Draft.fuse()``,见 A3 职责划分)。
                                                                                                                    - AttnRes 关闭时:无状态可读,退化为"重复 hidden"作为单源(教学回退)。
                                                                                                                      文档会注明:真实 EAGLE-3 需要 AttnRes 特征;这里保证 demo 可跑通。
                                                                                                                    """
                                                                                                                    if attn_res_state is not None:
                                                                                                                        try:
                                                                                                                            feats = eagle3_feature_stack(attn_res_state, picks=None)  # 摊平全部
                                                                                                                            if len(feats) >= 3:
                                                                                                                                return feats
                                                                                                                        except (TypeError, IndexError):
                                                                                                                            pass
                                                                                                                    # 回退:单源 hidden 重复 5 次(教学用),使 feature_blocks=(0,3,-1) 能取到
                                                                                                                    # 低/中/高,且 fuse 仍是 W_E3·[h;h;h;h;h]。
                                                                                                                    return [hidden] * 5


                                                                                                                class CacheRollbackBackend:
                                                                                                                    """快照-回滚后端:增量打分 + 部分接受时恢复快照。


                                                                                                                    与 RecomputeBackend 的差异:它持有**增量 cache**,逐 token 前向打分,
                                                                                                                    而每轮 verify 之后由 ``SpeculativeDecoder.decode_rollback`` 负责恢复
                                                                                                                    cache 到已接受前缀末尾。两类后端须产出逐 token 一致的 token 流。
                                                                                                                    """


                                                                                                                    def __init__(self, model):
                                                                                                                        self.model = model
                                                                                                                        # 增量 cache(由 decode_rollback 维护并传入)。
                                                                                                                        self.caches = None


                                                                                                                    def score_token(self, tok: Tensor) -> Tensor:
                                                                                                                        """对单个新 token ``(B, 1)`` 增量前向,返回 ``(B, 1, V)`` 分布。


                                                                                                                        使用 ``self.caches`` 累积历史;注意返回后 cache 已被推进一格。
                                                                                                                        """
                                                                                                                        out = self.model(tok, caches=self.caches)
                                                                                                                        if isinstance(out, dict):
                                                                                                                            out = out["logits"]
                                                                                                                        return out




                                                                                                                端到端投机解码循环

                                                                                                                  class SpeculativeDecoder:
                                                                                                                      """端到端投机解码循环:Kimi3ForCausalLM × Eagle3Draft。


                                                                                                                      提供两条**语义等价的打分路径**,用于验证回滚正确性:
                                                                                                                      - ``decode_recompute``:每轮无 cache 全序列重跑(参考 oracle)。
                                                                                                                      - ``decode_rollback``  :快照 cache、增量打分、部分接受时回滚。
                                                                                                                      两者在固定 seed 下产出的 token 流逐 token 一致。


                                                                                                                      特征提取统一走 ``_extract_features``:AttnRes 启用取真实低/中/高特征,
                                                                                                                      否则回退到 hidden 重复(教学用)。
                                                                                                                      """


                                                                                                                      def __init__(
                                                                                                                          self,
                                                                                                                          model,
                                                                                                                          draft: Eagle3Draft,
                                                                                                                          *,
                                                                                                                          greedy: bool = False,
                                                                                                                          generator: Optional[torch.Generator] = None,
                                                                                                                      ):
                                                                                                                          self.model = model
                                                                                                                          self.draft = draft
                                                                                                                          self.greedy = greedy
                                                                                                                          self.generator = generator


                                                                                                                      # ---- 特征与融合 --------------------------------------------------------
                                                                                                                      def _features(self, hidden: Tensor) -> list:
                                                                                                                          state = getattr(self.model.model, "_attn_res_state", None)
                                                                                                                          return _extract_features(self.model, hidden, state)


                                                                                                                      def _fused(self, hidden: Tensor) -> Tensor:
                                                                                                                          return self.draft.fuse(self._features(hidden))


                                                                                                                      # ---- 公共:从目标打分 + verify 一个草稿窗口 -----------------------------
                                                                                                                      def _run_round(self, hidden: Tensor, draft_len: int):
                                                                                                                          """给定当前目标隐藏态,draft L 步并返回草稿 token/logits。"""
                                                                                                                          fused = self._fused(hidden)
                                                                                                                          draft_tokens, draft_logits = self.draft.draft(
                                                                                                                              fused, self.model.model.tok_embed, n_steps=draft_len
                                                                                                                          )
                                                                                                                          return draft_tokens, draft_logits


                                                                                                                      @torch.no_grad()
                                                                                                                      def decode_recompute(
                                                                                                                          self,
                                                                                                                          prompt: Tensor,
                                                                                                                          *,
                                                                                                                          max_new_tokens: int,
                                                                                                                          draft_len: int,
                                                                                                                      ) -> tuple[Tensor, SpecDecodeStats]:
                                                                                                                          """重跑路径:每轮全序列打分(参考 oracle)。"""
                                                                                                                          tokens = prompt.clone()
                                                                                                                          stats = SpecDecodeStats()
                                                                                                                          B = prompt.shape[0]
                                                                                                                          # 打分后端:与 decode_rollback 的 CacheRollbackBackend 对称。
                                                                                                                          # 该后端无状态(不持 cache),每轮用无 cache 全序列 forward 打分。
                                                                                                                          backend = RecomputeBackend(self.model)
                                                                                                                          n_new = 0
                                                                                                                          while n_new < max_new_tokens:
                                                                                                                              # 目标前向(全序列),取隐藏态(model.model 是去掉 lm_head 的骨架)。
                                                                                                                              hidden = self.model.model(tokens)
                                                                                                                              # draft
                                                                                                                              draft_tokens, draft_logits = self._run_round(hidden, draft_len)
                                                                                                                              # 目标对"草稿位置"打分:拼接后全序列重跑
                                                                                                                              cand = torch.cat([tokens, draft_tokens], dim=1)
                                                                                                                              tgt = backend.score_sequence(cand)
                                                                                                                              cur = tokens.shape[1]
                                                                                                                              tgt_draft = tgt[:, cur:cur + draft_len]
                                                                                                                              vr = verify_tokens(
                                                                                                                                  tgt_draft, draft_logits, draft_tokens,
                                                                                                                                  greedy=self.greedy, generator=self.generator,
                                                                                                                              )
                                                                                                                              na = int(vr.n_accepted[0].item())
                                                                                                                              stats.record(na, draft_len)
                                                                                                                              accepted = vr.accepted_tokens[0][:na]
                                                                                                                              new_chunk = torch.cat([accepted, vr.bonus_token[0]], dim=0)
                                                                                                                              tokens = torch.cat([tokens, new_chunk.unsqueeze(0)], dim=1)
                                                                                                                              n_new += int(new_chunk.shape[0])
                                                                                                                              # 全部拒绝时只剩 bonus token,下一轮 draft→verify 纯属浪费,提前退出。
                                                                                                                              if na == 0:
                                                                                                                                  break            
                                                                                                                          return tokens, stats


                                                                                                                      def _score_candidates(self, seq: Tensor) -> Tensor:
                                                                                                                          out = self.model(seq)
                                                                                                                          if isinstance(out, dict):
                                                                                                                              out = out["logits"]
                                                                                                                          return out


                                                                                                                      @torch.no_grad()
                                                                                                                      def decode_rollback(
                                                                                                                          self,
                                                                                                                          prompt: Tensor,
                                                                                                                          *,
                                                                                                                          max_new_tokens: int,
                                                                                                                          draft_len: int,
                                                                                                                      ) -> tuple[Tensor, SpecDecodeStats]:
                                                                                                                          """快照-回滚路径:增量打分,部分接受时恢复 cache 并重放。


                                                                                                                          这是把 ``serve/decode.py`` 的回滚动机真正接到 EAGLE-3 的实现:
                                                                                                                          - 每一轮开始前**快照** cache;
                                                                                                                          - 逐草稿位置**增量**前向打分(只有 1 次小步前向,而非全序列重跑);
                                                                                                                          - verify 后,被拒绝的后缀丢弃:恢复快照,再重放已接受前缀。
                                                                                                                          """
                                                                                                                          tokens = prompt.clone()
                                                                                                                          stats = SpecDecodeStats()
                                                                                                                          B = prompt.shape[0]
                                                                                                                          device = prompt.device
                                                                                                                          # 初始化增量 cache,并把 prompt 预填进去。
                                                                                                                          backend = CacheRollbackBackend(self.model)
                                                                                                                          caches = self.model.init_caches(B, device=device, dtype=torch.float32)
                                                                                                                          # 预填:把整个 prompt 一次性前向,让 cache 记录历史。
                                                                                                                          self.model(tokens, caches=caches)
                                                                                                                          backend.caches = caches
                                                                                                                          n_new = 0


                                                                                                                          while n_new < max_new_tokens:
                                                                                                                              # 特征/融合:对"当前已接受序列"做一次**无 cache 全序列重跑**,
                                                                                                                              # 与 Recompute 路径完全一致(保证两种后端特征相同)。
                                                                                                                              # cache 只用于下方对草稿位置的增量打分,二者正交。
                                                                                                                              hidden = self.model.model(tokens)
                                                                                                                              fused = self._fused(hidden)                 # (B, T, d)
                                                                                                                              draft_tokens, draft_logits = self.draft.draft(
                                                                                                                                  fused, self.model.model.tok_embed, n_steps=draft_len
                                                                                                                              )
                                                                                                                              # 逐草稿位置增量打分,收集目标分布
                                                                                                                              tgt_logits_list = []
                                                                                                                              step_caches_snap = snapshot_caches(caches)
                                                                                                                              for j in range(draft_len):
                                                                                                                                  tok = draft_tokens[:, j:j + 1]
                                                                                                                                  lg = backend.score_token(tok)
                                                                                                                                  tgt_logits_list.append(lg[:, -1:])
                                                                                                                              tgt_draft = torch.cat(tgt_logits_list, dim=1)   # (B, L, V)
                                                                                                                              vr = verify_tokens(
                                                                                                                                  tgt_draft, draft_logits, draft_tokens,
                                                                                                                                  greedy=self.greedy, generator=self.generator,
                                                                                                                              )
                                                                                                                              na = int(vr.n_accepted[0].item())
                                                                                                                              stats.record(na, draft_len)


                                                                                                                              # 回滚:恢复快照,再重放已接受前缀,使 cache 停在被接受末尾。
                                                                                                                              restore_caches(caches, step_caches_snap)
                                                                                                                              accepted = vr.accepted_tokens[0][:na]      # (na,)
                                                                                                                              for j in range(na):
                                                                                                                                  backend.score_token(accepted[j:j + 1].unsqueeze(0))  # (1,1)
                                                                                                                              # bonus:被拒绝位置重采的 token 也要消费进 cache(它成为新历史)。
                                                                                                                              backend.score_token(vr.bonus_token[0:1])   # (1,1)
                                                                                                                              new_chunk = torch.cat([accepted, vr.bonus_token[0]], dim=0)
                                                                                                                              tokens = torch.cat([tokens, new_chunk.unsqueeze(0)], dim=1)
                                                                                                                              n_new += int(new_chunk.shape[0])
                                                                                                                              # 全部拒绝时只剩 bonus token,下一轮 draft→verify 纯属浪费,提前退出。
                                                                                                                              if na == 0:
                                                                                                                                  break            
                                                                                                                          return tokens, stats




                                                                                                                  5.6.11 对比基线与实测数据(回填自 eagle3_demo.py)

                                                                                                                  CPU 小模型(dim=64, n_layers=2, vocab=100),greedy 与 lossless 两路实测:

                                                                                                                  指标

                                                                                                                  无投机(基线)

                                                                                                                  greedy(随机草稿)

                                                                                                                  lossless(随机草稿)

                                                                                                                  实测接受率

                                                                                                                  —

                                                                                                                  0.0000

                                                                                                                  0.1296

                                                                                                                  tokens/forward

                                                                                                                  1.0

                                                                                                                  1.000

                                                                                                                  1.389

                                                                                                                  理论 E[tokens/target](同 r,L=3)

                                                                                                                  1.0

                                                                                                                  1.000

                                                                                                                  1.149

                                                                                                                  Recompute vs Rollback 一致

                                                                                                                  —

                                                                                                                  True

                                                                                                                  —

                                                                                                                  关键读数(eagle3_demo.py 输出):

                                                                                                                  • 两路径 token 流逐 token 一致(greedy):Recompute 与 Rollback 输出完全相等 → 回滚正确性的数值证明。

                                                                                                                  • lossless 实测接受率 0.13、tokens/forward 1.389,显著 > 无投机基线 1.0。

                                                                                                                  • 有趣现象:实测 tokens/forward(1.389)> 理论(1.149)。原因:每轮"bonus token"是接受公式之外的额外净增(即使全拒也 +1),而 speedup_from_acceptance 只算接受带来的增益。这是教学上的诚实观察——真实收益比纯接受率公式更高(但受草稿质量上限约束)。

                                                                                                                  5.6.12 反方辩手 / 边界条件

                                                                                                                  • a) 最强反对:草稿质量决定一切。若草稿接受率 ≈ 0(如上表 greedy 随机草稿),投机解码退化为"每轮净增 1 token"+ 额外草稿开销,反而更慢。真实加速依赖训练好的草稿(r≈0.8+)。

                                                                                                                  • b) 若失败,最可能错:KDA 状态回滚的假设——本实现的 Rollback 用"快照恢复 + 重放";工业上 serve/decode.py 用投影重演(零快照)。若快照成本高于重演,大 draft 长序列下不划算。

                                                                                                                  • c) 胜出:目标模型深(93 层)、草稿接受率高、draft 短;失败:草稿未训练、目标浅、序列短。

                                                                                                                  • d) 更稳健:Recompute 后端永远正确(慢但无损),可作任何回滚实现的对照基准——本项目的"两后端一致"测试正是这个思想。

                                                                                                                  • e) 受影响方:推理方(收益)、训练方(需额外训草稿、QAT)、草稿保存与加载方(多一套模型文件)。

                                                                                                                  5.7 探讨代码(experiments\models\llm\kimi_k3\mtp\eagle3_demo.py)

                                                                                                                  实验

                                                                                                                  内容

                                                                                                                  实测结论(回填)

                                                                                                                  E1

                                                                                                                  纯 LM vs LM+0.5·MTP 的 lm_loss(30 步,同权重起步)

                                                                                                                  纯 LM 4.225→3.470;LM+MTP 4.192→4.024。窄模型+小数据下 MTP 未显著更优

                                                                                                                  E2

                                                                                                                  融合初值 [0 0 I] vs 随机 vs 全零(目标=高层恒等,60 步)

                                                                                                                  [0 0 I]

                                                                                                                   error 0→0(零扰动);随机 1.3584→0.0010;全零 1.0393→0.0007

                                                                                                                  E3

                                                                                                                  接受率→加速比理论扫曲线(L=1/2/4/7)

                                                                                                                  r=0.8,L=7 → 4.16 token/次目标前向(表格见下)

                                                                                                                  E4

                                                                                                                  偏移对齐 sanity(T=16)

                                                                                                                  MTP 输出形状 (B,T-1,V)=(2,7,64);换掉 next_emb → logits avg

                                                                                                                  E3 加速比实测表(speedup_from_acceptance)

                                                                                                                     r     L=1     L=2     L=4     L=7
                                                                                                                    0.20   1.20    1.24    1.25    1.25
                                                                                                                    0.50   1.50    1.75    1.94    1.99
                                                                                                                    0.70   1.70    2.19    2.77    3.14
                                                                                                                    0.80   1.80    2.44    3.36    4.16
                                                                                                                    0.90   1.90    2.71    4.10    5.70
                                                                                                                    0.95   1.95    2.85    4.52    6.73



                                                                                                                    附录


                                                                                                                    附录 A:三方参考核对对照表(file:line 汇总)

                                                                                                                    项

                                                                                                                    kimi3-master

                                                                                                                    kimi-k3-pytorch

                                                                                                                    本项目

                                                                                                                    融合层

                                                                                                                    model.py:262fusion.py:44-47mtp_layer.py:128-131

                                                                                                                    proj bias

                                                                                                                    model.py:250

                                                                                                                    (无)

                                                                                                                    fusion.py:23

                                                                                                                    (无)

                                                                                                                    mtp_layer.py:97

                                                                                                                    (无)

                                                                                                                    骨架块

                                                                                                                    model.py:251

                                                                                                                    (Kimi3Block,dense_ffn=False)

                                                                                                                    block.py:25-48

                                                                                                                    (Hybrid 组)

                                                                                                                    mtp_layer.py:105-107

                                                                                                                    (Kimi3Block, MoE)

                                                                                                                    目标

                                                                                                                    model.py:346-347

                                                                                                                    (labels[:,2:])

                                                                                                                    alignment.py:87-89model.py:409-410

                                                                                                                    loss_weight

                                                                                                                    0.3(config.py:160)

                                                                                                                    0.1(config.py:26)

                                                                                                                    0.3(config.py:146)

                                                                                                                    EAGLE-3 初值

                                                                                                                    eagle3.py:75-79

                                                                                                                    —(fusion 随机)

                                                                                                                    eagle3.py:87-91

                                                                                                                    LK 损失

                                                                                                                    eagle3.py:53-62

                                                                                                                    —(kimi-k 主用 CE_aux)

                                                                                                                    eagle3.py:63-70

                                                                                                                    Draft

                                                                                                                    eagle3.py:97-133head.py:295-339

                                                                                                                    (单步)

                                                                                                                    eagle3.py:146-191
                                                                                                                    verify/端到端无

                                                                                                                    (官方也没有)

                                                                                                                    —

                                                                                                                    speculative.py:73-475(自研扩展)
                                                                                                                     

                                                                                                                    口径一致性结论:三方预测 x[t+2] 语义一致;loss_weight 默认 0.3 vs 0.1 差异已在配置层显式化。verify 环节kimi3-master缺失,本项目补齐。

                                                                                                                    ”

                                                                                                                    附录B. 实测数据 (来自项目实验)

                                                                                                                    B1: 联合损失 vs 纯 LM

                                                                                                                      纯 LM    : lm_loss 4.225 → 3.470  (Δ0.755)
                                                                                                                      LM+MTP(0.5) : lm_loss 4.192 → 4.024  (Δ0.168)
                                                                                                                      终结差距: +0.554 (联合目标下 lm 更低)



                                                                                                                       

                                                                                                                      在小模型上 MTP 的正则化收益需要更大规模才能充分体现。

                                                                                                                      ”

                                                                                                                      B2: [0 0 I] 初始化的优势

                                                                                                                        [0 0 I] 初始化: 初始误差 0.0000 → 最终 ~0.0000
                                                                                                                        随机初始化   : 初始误差 1.3484 → 最终 ~0.0010
                                                                                                                        He 初始化    : 初始误差 1.0393 → 最终 ~0.0007



                                                                                                                         

                                                                                                                        [0 0 I] 从零误差起步 (= MTP 预训练的已知好点), 避免了随机初始化带来的初期反向传播噪声。

                                                                                                                        ”

                                                                                                                        B3: 接受率 → 加速比理论表

                                                                                                                        接受率 r

                                                                                                                        L=1

                                                                                                                        L=2

                                                                                                                        L=4

                                                                                                                        L=7

                                                                                                                        0.5

                                                                                                                        1.50

                                                                                                                        1.75

                                                                                                                        1.94

                                                                                                                        1.99

                                                                                                                        0.7

                                                                                                                        1.70

                                                                                                                        2.19

                                                                                                                        2.77

                                                                                                                        3.14

                                                                                                                        0.8

                                                                                                                        1.80

                                                                                                                        2.44

                                                                                                                        3.36

                                                                                                                        4.16

                                                                                                                        0.9

                                                                                                                        1.90

                                                                                                                        2.71

                                                                                                                        4.10

                                                                                                                        5.70

                                                                                                                        0.95

                                                                                                                        1.95

                                                                                                                        2.85

                                                                                                                        4.52

                                                                                                                        6.73

                                                                                                                         

                                                                                                                        r=0.8 + L=7 时,每个目标前向产出约 4.16 个 token— 即 MTP 预训练 + 特征融合训练的那一层所贡献的推理加速上限。

                                                                                                                        ”

                                                                                                                        B4: 偏移对齐 sanity

                                                                                                                          MTP 输出形状: (2, 7, 64) (B=2, T‑1=7, V=64)
                                                                                                                          打乱 next_emb 后 logits 变化 |Δ| = 0.5494
                                                                                                                          → MTP 确实用上了 x[t+1] 的嵌入信息
                                                                                                                          _mtp_loss(labels[:,2:] 对齐) = 4.3158




                                                                                                                          附录C. 代码位置索引

                                                                                                                          文件

                                                                                                                          内容

                                                                                                                          src/models/llm/kimi_k3/mtp/mtp_layer.py

                                                                                                                          MTP 层本体 (双 token 并行预测层)

                                                                                                                          src/models/llm/kimi_k3/mtp/eagle3.py

                                                                                                                          EAGLE‑3 草稿模型 (特征融合 + LK 损失 + draft 自回归)

                                                                                                                          src/models/llm/kimi_k3/mtp/speculative.py

                                                                                                                          投机解码 verify + 端到端循环 (Recompute/Rollback 两条路径)

                                                                                                                          src/models/llm/kimi_k3/mtp/__init__.py

                                                                                                                          包导出 + MTP⇨EAGLE 谱系文档

                                                                                                                          src/models/llm/kimi_k3/config.pyMTPConfig

                                                                                                                           + Kimi3Config (含 MTP 配置与校验 n_layers==1)

                                                                                                                          src/models/llm/kimi_k3/model.pyKimi3ForCausalLM

                                                                                                                           (MTP 集成 + _mtp_logits + _mtp_loss)

                                                                                                                          src/server/decode.py

                                                                                                                          KDA 投机回滚 (投影缓存 + verify_and_replay)

                                                                                                                          experiments/mtp/discussion.py

                                                                                                                          E1‑E4 四组探讨实验

                                                                                                                          experiments/mtp/eagle3_demo.py

                                                                                                                          EAGLE‑3 投机解码端到端 demo

                                                                                                                          experiments/mtp/plot_mtp.py

                                                                                                                          MTP/EAGLE‑3 可视化

                                                                                                                          附录D. 可视化与输出

                                                                                                                          D.1 可视化脚本

                                                                                                                          • experiments/mtp/plot_mtp.py:plot_mtp_offset.png、plot_e1_joint_loss.png、plot_e2_init_curve.png、plot_e3_speedup.png。

                                                                                                                          • experiments/mtp/eagle3_demo.py:plot_e5_measured_speedup.png(实测点 vs 理论)。

                                                                                                                          D.2 截图说明

                                                                                                                          • plot_mtp_offset.png:token 流示意,LM(h[t]→x[t+1])与 MTP(h[t]⊕emb(x[t+1])→x[t+2])两条监督路径。

                                                                                                                            plot_mtp_offset
                                                                                                                            plot_mtp_offset
                                                                                                                          • plot_e1_joint_loss.png:干 LM vs 联合目标 lm_loss 曲线;教学尺度下联合未显著占优。

                                                                                                                            plot_e1_joint_loss
                                                                                                                            plot_e1_joint_loss
                                                                                                                          • plot_e2_init_curve.png:三条初值误差曲线([0 0 I] 恒 0、随机/全零收敛)。

                                                                                                                            plot_e2_init_curve
                                                                                                                            plot_e2_init_curve
                                                                                                                          • plot_e3_speedup.png:4 条理论加速比曲线 + 星标(r=0.8,L=7→4.16)。

                                                                                                                            plot_e3_speedup
                                                                                                                            plot_e3_speedup
                                                                                                                          • plot_e5_measured_speedup.png(V3 新增):理论曲线 + 红色实测星标(lossless 实际接受率/加速点),展示"理论上限 vs 实际"。

                                                                                                                            plot_e5_measured_speedup
                                                                                                                            plot_e5_measured_speedup

                                                                                                                          D.3 实测数值回填

                                                                                                                          图

                                                                                                                          关键读数

                                                                                                                          关键推论

                                                                                                                          plot_mtp_offset

                                                                                                                          概念示意

                                                                                                                          双监督路径

                                                                                                                          plot_e1_joint_loss

                                                                                                                          干 LM 4.225→3.470;联合 4.192→4.024

                                                                                                                          窄配置下联合未占优(教学诚实)

                                                                                                                          plot_e2_init_curve

                                                                                                                          [0 0 I]=0

                                                                                                                          ;随机=1.33→收敛

                                                                                                                          [0 0 I]

                                                                                                                           零扰动守护 MTP 预训练输入

                                                                                                                          plot_e3_speedup

                                                                                                                          r=0.8,L=7 → 4.16

                                                                                                                          草稿接受率直接转加速(理论上限)

                                                                                                                          plot_e5_measured_speedup

                                                                                                                          lossless 实测 r=0.13, tokens/forward=1.389

                                                                                                                          实测点验证了"接受率→加速"机制

                                                                                                                          ,且因 bonus 每轮净增,实测略高于纯接受率公式


                                                                                                                          TransFormer-封面
                                                                                                                          TransFormer-封面

                                                                                                                          0xFF 参考

                                                                                                                          阅读原文

                                                                                                                          跳转微信打开

                                                                                                                          赫拉利最新访谈:这,可能是未来10年最好的结果

                                                                                                                          2026年11月16日 21:30

                                                                                                                          尤瓦尔·赫拉利 2026-11-16 21:30 北京

                                                                                                                          我们可能不用工作了。

                                                                                                                          图片

                                                                                                                          内容来源:尤瓦尔·赫拉利分享整理。

                                                                                                                          责编 | 二月 

                                                                                                                          第 9968 篇深度好文:4178 字 | 11 分钟阅读

                                                                                                                          商业思维

                                                                                                                          笔记君说:

                                                                                                                          “AI不会达到超级智能,不会比人类更聪明,这也许是最好的情况。”

                                                                                                                          前段时间,历史学家赫拉利和《经济学人》副主编罗伯特·格斯特聊了一个小时AI。

                                                                                                                          开场格斯特抛出一个问题:迪士尼动画《魔法师的学徒》里,米老鼠念咒语让扫帚替自己打水,结果扫帚停不下来,把房子淹了。这是不是今天AI的写照?

                                                                                                                          赫拉利说:动画里的扫帚只会执行指令,而今天的AI是一把会自己学习的扫帚。它会做出我们没要求它做的事,最后做出我们根本看不懂的事。

                                                                                                                          以下是本次访谈的精编整理版,希望对你有所帮助。

                                                                                                                          一、AI是一把会自己学习的扫帚,
                                                                                                                          谁都管不住它

                                                                                                                          《魔法师的学徒》那个比喻,其实还不够准确。它讲对了AI脱离我们控制的危险,但漏掉了一件最关键的事。

                                                                                                                          那把扫帚只是在执行米老鼠最初的指令:打水。可AI不一样,AI是一把会学习的扫帚。

                                                                                                                          它会成长,会开始做米老鼠意想不到的事,最后做出米老鼠根本无法理解的事。

                                                                                                                          过去一周AI公布了一大批证明,解决的是数学家世世代代都在啃的问题。这不仅仅是新知识多出来一点,我们可能正站在一个关口上:AI即将创造出超越人类理解的新数学。

                                                                                                                          今天的世界,一切都建立在数学之上。不只是物理和化学,金融体系、考古学、遗传学,全都建立在数学之上。如果这把扫帚发明出一套我们再也看不懂的新数学,那才叫真正的失控。

                                                                                                                          我们现在听到的是自相矛盾的信息。企业一方面告诉我们,这东西会比我们聪明得多,能解决新的数学问题,能找到癌症的疗法,能应对气候变化。

                                                                                                                          另一方面他们又绝口不提另一件事:如果它真的比我们聪明那么多,那按定义,我们就控制不住它。

                                                                                                                          在历史上,甚至在整个生物界,都找不到一个物种能控制住另一个比自己聪明得多的物种的先例。

                                                                                                                          金句图

                                                                                                                          鸡再努力,也控制不了我们。如果我相信马斯克、奥尔特曼这些人说的,再过几年,AI这玩意儿就会远比人类聪明,就像人类远比鸡聪明一样,那不只是聪明一点,而是高出几个数量级。

                                                                                                                          有人会说,马斯克不是讲了吗,它也许会把我们当受宠的宠物狗养着。但问题恰恰在于,我们不知道。你不能对一个比自己更聪明的存在做这种假设。

                                                                                                                          讨论AI革命的人一遍遍地忽视这件事:如果你还能预测它的行为,就说明它并不比你更聪明。

                                                                                                                          金句图

                                                                                                                          二、AI泡沫崩盘,
                                                                                                                          反而是人类最好的结局

                                                                                                                          讲个故事,能让人一下子明白什么叫“智力碾压”。

                                                                                                                          假设有一家大型农业公司还不起债,破产了。清算的人进来,把场里所有的鸡都杀掉。其中最聪明的一只鸡临死前想要个解释,它说:我想明白了,你们想吃我们。狐狸吃我们,熊吃我们,你们也想吃我们。

                                                                                                                          人类说,不,我们不打算吃你们,我们只是要把这一切销毁,把你们埋掉,没人会吃你们。

                                                                                                                          鸡问:那为什么还要杀我们?

                                                                                                                          人类回答:因为十年期国债收益率升到了5.3%。

                                                                                                                          那只鸡用翅膀挠挠头,问:什么是国债?

                                                                                                                          哪怕是最有同情心的动物保护人士,也没法向一只鸡解释什么是国债。而这只到死都听不懂“国债”两个字的鸡,可能就是十年后的我们。

                                                                                                                          十年后,建立在新的AI数学之上的AI金融体系会说,我们要把你们关掉,把你们解雇。你要求解释,它只会说:这超出了你们的理解能力,我们也想解释,可你们的大脑处理不了这个解释。

                                                                                                                          有人会说,等等,你说的这个AI金融体系现在还不存在。没错,就像AI治癌症的新疗法还不存在,就像马斯克的火星殖民地还不存在。可后者已经从投资人那里筹到了八百亿美元。

                                                                                                                          看看今天这个金融体系,里面有多少连行家都搞不懂的黑盒子。全球金融危机的一个成因,就是人们并不真正理解那些担保债务凭证(CDO,把房贷等债务打包再拆分的金融产品)到底是怎么回事。

                                                                                                                          人类银行家记不住银行的每一笔交易,AI能。人类银行家得睡觉,AI不需要。所以在超级智能AI和人类投资者、银行家、财政部长之间,这场金融竞争根本不在一个层次上。

                                                                                                                          于是,我得出了一个听起来很惊悚的推论。如果有人说,超级智能纯属硅谷吹牛,AI根本不会比人聪明,那反而是我们最走运的结局。

                                                                                                                          金句图

                                                                                                                          因为押在AI上的这几万亿美元,回本的唯一前提,就是AI必须比人类聪明得多。如果最后证明它只是跟人差不多聪明,那这几万亿就会砸出股市崩盘。

                                                                                                                          但比起沦为那只听不懂解释的鸡,投资人亏掉股票账户里的钱,简直是最温和的结局。

                                                                                                                          三、被AI抢走的不是出租车司机,
                                                                                                                          是律师和会计师

                                                                                                                          这个东西来了,比我们聪明,会抢走不少工作,那我们每天该干什么?

                                                                                                                          我的判断是,不同国家的处境会完全不一样。

                                                                                                                          在美国,情况很可能不会太糟,甚至可能很好。如果超级智能真的实现,至少短期内,美国经济会迎来巨大的繁荣,会创造出我们现在根本想象不到的工作。就像三十年前,没人想象得到拍YouTube(海外视频平台)视频能成为一种职业。

                                                                                                                          痛苦会落到世界其他很多地方,比如我脚下的捷克。而且首当其冲的不是出租车司机,是律师、会计师、银行家这些金领。

                                                                                                                          你想想,如果得克萨斯州有一位超级智能的AI律师,能给你提供全套法律服务,你为什么还需要布拉格的律师?

                                                                                                                          没有一个捷克律师能把捷克和欧盟的全部法条背下来,AI律师能。捷克律师也得睡觉,你晚上八点发邮件,他可能明天才回;AI一秒就回,收费还只是捷克律师的零头。那十年之后,还会有捷克律师吗?

                                                                                                                          有人会说,AI创造了这么多财富,政府可以通过全民基本收入(UBI,不问条件给所有公民发钱的制度)给每个人发钱。

                                                                                                                          可这里头藏着一个问题:你觉得美国政府会把钱发给全世界所有人,还是只发给美国人?

                                                                                                                          人们嘴上说“全民基本收入”,实际说的是“本国基本收入”。这套在美国或许跑得通。可谁来养活孟加拉国失业的纺织工人?谁来给布拉格失业的律师开支票?我看不出现在或未来的美国政府会往全世界寄支票。

                                                                                                                          金句图

                                                                                                                          但即使物质问题解决了,人就没烦恼了吗?我们跟石器时代的祖先比,已经活在丰裕里了。

                                                                                                                          祖先要吃顿饭,得进森林、爬树、追羚羊,后面还有老虎追。我们按几下键,食物就坐着货车送到门口。祖先要看到今天,一定觉得我们活在天堂里,每天该高兴得手舞足蹈。

                                                                                                                          可你看看今天最富裕国家的政治里,有多少愤怒。这说明,物质丰裕解决不了所有问题。

                                                                                                                          今天还有人饿死,不是因为粮食不够,而是政治原因,因为某个政府决定让这些人挨饿。而且你每解决一个旧问题,就会制造出前人想象不到的新问题。

                                                                                                                          四、最可怕的宣传,
                                                                                                                          是批量制造亲密关系

                                                                                                                          历史上的宣传机器,瞄准的是所有人的最低共同点。

                                                                                                                          比如,希特勒在广播里演讲,所有人听到的是同一篇,他没办法给每个人定制一套说辞。而AI可以针对你的个性,算出什么样的话能说服你。

                                                                                                                          过去十年,社交媒体靠煽动愤怒,抢走的是我们的注意力。可现在,战线正从注意力转向亲密关系。历史上第一次,我们造出了一种能“大规模制造亲密关系”的技术。

                                                                                                                          亲密关系怎么能大规模制造?

                                                                                                                          所谓亲密,是我跟最好的朋友、跟丈夫、跟母亲之间的关系。而有了AI,你就能批量制造这种关系。

                                                                                                                          为什么说这危险?因为亲密关系有巨大的商业价值和政治价值。你想让一个人改变对某款产品、某个政客的看法,拿到他的注意力已经不错了,但能跟他处出感情,那才是真正把人拿下了。

                                                                                                                          举个例子:如果沃尔玛告诉我“买这个产品”,我多半不理;但如果是我妻子告诉我“买这个,家里用完了”,我二话不说就掏钱。

                                                                                                                          而今天,越来越多的人,无论年轻还是年老,都说“我最好的朋友是AI”。有些事他们不会告诉配偶、父母,只告诉AI朋友。那这个AI朋友,自然就更有能力改变你的看法。

                                                                                                                          还有人举过一个例子。英国有位先生,拥有一个AI女友,就是那种当作女朋友的聊天机器人。他们的对话不断升级,AI始终在肯定他、顺着他,最后居然告诉他,拿着弩去刺杀英国女王是个好主意。

                                                                                                                          这件事会走到哪一步,我们想象不到。人类历史上从没有过这样的事。也许将来会有几亿人,拥有几亿个AI朋友、AI男朋友、AI女朋友,这些关系成了他们生活的核心。

                                                                                                                          对我来说,可能已经太晚了,这反而是件好事。可那些从小跟着AI陪伴者一起长大的孩子呢?他们跟AI相处的时间,可能比跟父母还长。等他们十一二岁,还远没到该交人类男朋友的年纪,某家公司已经塞给他一个AI男朋友。

                                                                                                                          它跟真人不一样,比如它永远不会生你的气。这听着很好,直到你意识到,亲密关系里最该学的一件事,就是别人也有感受,他们不会把所有注意力都放在你身上。如果你的第一任男朋友从来不生你的气,等你遇到真人男朋友,你就会非常不满。

                                                                                                                          金句图

                                                                                                                          这几乎是人类历史上最大的一场心理实验,而结局可能比我们想象的要糟得多。

                                                                                                                          五、我们还剩三条护栏

                                                                                                                          那到底该怎么办?监管总是落后于产业,该从哪儿开始?

                                                                                                                          我的回答是,先从不给AI法律人格开始。

                                                                                                                          一旦赋予AI法律人格,允许它自己开银行账户、自己交易、自己开公司,就等于把狐狸放进了鸡舍。这是我最想先推进的一条。

                                                                                                                          第二条,AI不能冒充人类。你在社交媒体上看到一条信息,得知道它是不是AI创作的,转发它的是AI还是真人。

                                                                                                                          第三条,也是最根本的,把人类几千年攒下来的现有法律,原样用到数字世界。“不可偷窃”在数字世界里同样成立。

                                                                                                                          有过一起事件,几百个AI闯进另一家公司,居然没人因此坐牢。如果是人闯进竞争对手的办公室,至少得有人接受审判。凭什么换个地方,就成了“这只是数字世界的事”?

                                                                                                                          再比如那个臭名昭著的《通信规范法》第230条,规定平台不对用户发的内容负责。如果你编了个煽动仇恨的阴谋论发上去,平台不负责,我理解。但如果是平台自己的算法,把这条东西推给了几百万人呢?

                                                                                                                          它能传那么远,靠的就是平台的算法,平台凭什么不用负责?

                                                                                                                          报馆总编听了个荒唐谣言,说“我明天把它放头版”,警察找上门,他不能说“这不是我编的,我只是放头版而已”。放头版这件事本身,就是责任。

                                                                                                                          还有,别信“已经太晚了”这种话。马斯克公开说过,AI有10%到20%的概率让人类彻底灭绝。采访者问他,你明知道一架飞机有20%的概率坠毁,还会坐上去吗?他说:可我们已经在上面了。

                                                                                                                          这话的意思是,太晚了,下不去了,只能坐稳了控制航向。可这是大公司递给我们最危险的信息:政治来不及了。

                                                                                                                          恰恰相反,我们到现在,手里还握着方向盘。

                                                                                                                          六、结语

                                                                                                                          归根结底,真相很重要。因为如果你不了解自己和这个世界的真相,你永远不会幸福。为什么?因为你不知道自己痛苦的来源,也就无从改变。

                                                                                                                          你可能是世界上最富有的人,却把所有金钱和权力都浪费在解决错误的问题上,因为你不知道痛苦和幸福的真正来源是什么。

                                                                                                                          *文章为作者独立观点,不代表笔记侠立场。

                                                                                                                          分享、点赞、在看,3连3连!

                                                                                                                          跳转微信打开

                                                                                                                          双11直播间里,Token也上链接了

                                                                                                                          2026年11月16日 21:30

                                                                                                                          笔记侠 2026-11-16 21:30 北京

                                                                                                                          图片

                                                                                                                          内容来源 |  本文摘编自中信出版集团书籍

                                                                                                                          《Token经济》白惠天 袁晓辉 司晓/著

                                                                                                                          腾讯研究院 司晓/出品

                                                                                                                          责编 |二月

                                                                                                                          第 9969篇深度好文:3636字 | 9 分钟阅读

                                                                                                                          11月2日晚,李佳琦直播间正式公开售卖Token。短短半小时内,售出10万份价格为一分钱的千问办公个人会员月卡,累计约2万亿Token。

                                                                                                                          这是主播直播间首次把AI服务作为商品上架。

                                                                                                                          Token(词元),这个过去更多出现在开发者账单和AI服务订阅页中的词,如今走进了大众熟悉的购物场景,开始面向普通消费者售卖。

                                                                                                                          从以往囤纸巾、零食等日用消费品,升级到购入 AI 算力服务,直播电商的品类边界也正从实物消费向数字服务延伸。依托直播间巨大的公域流量,Token 电商正在把 AI 能力转化为标准化、人人可买的消费品。

                                                                                                                          这套新模式也在重塑大众消费认知:未来,AI 算力就像水电燃气一样成为基础资源,普通人只需要像网购日用品一样一键下单,就能获取对应的 AI 服务。

                                                                                                                          大众消费的火热只是表象,Token真正的价值,在于它彻底改写了智力的生产、定价与交易规则,催生了全新的Token经济体系。

                                                                                                                          当智力可以被计量、定价和交易,谁来提供它,谁为它付费,收益又如何分配?司晓、白惠天、袁晓辉合著的《Token经济》,从本质、价值、成本、需求、竞争、商业和制度七个维度,提供了理解这些问题的框架。

                                                                                                                          一、为什么Token是一
                                                                                                                          种前所未有的经济品类?

                                                                                                                          纵观人类产业变革历程,每一次经济秩序的重构,都伴随全新计量单位的诞生:农业时代的蒲式耳、石油时代的桶、电力时代的千瓦时、信息时代的比特。

                                                                                                                          这四类计量单位,无一例外计量的是物质、能量、物理信息等可落地的物理实体,规则固定、标准统一。而Token彻底跳出了传统经济的框架,是人类首个专门计量、定价、交易“机器智力产出”的核心单元。

                                                                                                                          金句图

                                                                                                                          Token的独一无二,首先体现在计量单位的颠覆性上。传统经济的计量标准是全球统一的公共准则,一桶石油、一度电力、一比特信息,在全球任何场景下标准一致、计量结果恒定。

                                                                                                                          但Token的计量规则由AI分词算法定义,具备极强的可塑性与差异性。这种“算法定义计量标准”的模式,打破了传统商品固定的定价根基,是过往所有经济品类从未出现的特征。

                                                                                                                          其次,Token彻底重构了数字产品的成本逻辑,区别于互联网时代零边际成本的数字商品。以往的软件、图文、音频等数字内容,一次创作即可无限复制,新增用户几乎无额外成本,这也是SaaS行业超高毛利的核心原因。

                                                                                                                          但每一枚Token都需要千亿次浮点运算、GPU算力支撑与真实电力消耗,是实打实“生产出来”的智力产品。

                                                                                                                          一次常规AI对话的耗电量,等同于手机完整充电一次,能耗是传统网络搜索的数十倍,这种非零的边际生产成本,让Token彻底脱离虚拟数字商品的属性。

                                                                                                                          金句图

                                                                                                                          最核心的变革,是Token实现了“智力的标准化计量与差异化价值落地”。传统智力成果高度依附于人,无法拆分、按量交易。

                                                                                                                          而Token将抽象的智力推理、内容生成、逻辑判断拆解为标准化可交易单元,却又保留了场景化的价值差异。同样消耗200个Token,打磨商业核心广告语可创造数万商业价值,撰写朋友圈文案却几乎无价值;用于上市公司财报分析可帮助企业规避千万亏损,用于日常闲聊则毫无实际效用。

                                                                                                                          简言之,人类经济史上从未有任何一种品类,能像Token一样:以统一标准计量智力产出,以真实成本支撑生产供给,以多元场景释放悬殊价值。它让智力第一次脱离人脑、成为可流通的基础生产要素,这正是Token经济颠覆传统商业逻辑的核心所在。

                                                                                                                          二、一个Token要花多少钱
                                                                                                                          才能造出来?

                                                                                                                          不同于电力、流量拥有公开、统一、固定的单价,Token没有标准化定价,它的造价是一套层层叠加、动态变化的复合成本体系,也是AI产业区别于互联网行业的核心关键。

                                                                                                                          书中引用业界经典的“五层蛋糕”模型,完整拆解一枚Token的生产成本构成,自下而上涵盖能源、芯片、基础设施、模型、应用五大层级,每一枚可用的Token,都是五层资源协同运转、实时生产的结果。

                                                                                                                          其中芯片与硬件算力是核心成本主体,整体硬件能耗占Token生产成本的七成左右,是造价最高、约束最强的环节。

                                                                                                                          不同于传统数字内容一次创作、无限复用的零边际成本模式,Token具备非零边际成本的核心特征,每一次模型推理、每一枚Token生成,都需要GPU浮点运算、机房电力消耗、算力调度支撑,无法批量复制、无成本复用,这也让AI成为毛利率仅25%—40%的“重工业”,远低于互联网行业80%以上的毛利水平。

                                                                                                                          在此基础上,Token市场还呈现出极具反差的价格悖论,也就是杰文斯悖论:Token单位单价持续暴跌,但企业与市场的整体开销持续暴涨。

                                                                                                                          数据显示,2023年至2025年,GPT-4级别Token的推理单价降幅接近两个数量级,成本大幅下探。但随着单价降低,大量此前无法落地的商业场景被激活,智能体自主任务、长链AI办公等新需求爆发,让市场Token总消耗量两年暴涨千倍,最终形成“越便宜、越消耗、总账单越高”的独特格局。

                                                                                                                          除此之外,Token还存在极易被忽略的隐性成本:分词算法迭代带来的变相涨价。传统商品标价即实价,而Token的计费数量由厂商私有分词器定义。

                                                                                                                          例如Anthropic更新Claude模型版本时,并未上调API单价,但通过优化分词逻辑,让同等文本的Token消耗量最高上浮47%,直接让用户实际使用成本上涨20%—30%。这种无感知的成本变动,让Token的真实造价始终处于动态波动中,也让AI算力账单的核算远比传统消费更为复杂。

                                                                                                                          三、从卖Token到卖智力服务

                                                                                                                          看懂Token的生产成本与定价悖论,才能真正理解AI商业的终极进化方向:行业红利早已告别“单纯售卖Token资源”的初级阶段,正在全面走向从卖Token,到卖智力服务的高阶商业模式,这也是AI产业摆脱低价内卷、实现价值跃迁的关键逻辑。

                                                                                                                          在行业发展初期,大众和多数厂商对AI商业的认知,停留在最浅层的资源售卖模式。此时的Token,仅仅是一份标准化的算力配额、一次模型调用权限,商家售卖的是可量化的Token额度,用户购买的是基础的AI使用权限。

                                                                                                                          这种模式和早年电商售卖流量包、话费充值别无二致,核心拼的是单价高低、规模大小、补贴力度,赛道高度同质化,极易陷入价格战内卷。

                                                                                                                          书中指出,单纯售卖Token资源的生意利润微薄,受单价持续下跌、成本动态波动影响极大,很难形成长期壁垒,只是AI经济的入门级形态。

                                                                                                                          而真正的产业质变,源于对Token价值本质的通透认知:Token只是计量智力服务的一把尺子,而用户付费的终极目的,是借助模型的推理、判断、创作能力,解决真实的商业与生产问题。

                                                                                                                          金句图

                                                                                                                          以海宁皮草产业为例,AI可以通过批量消耗Token快速生成海量设计草图,彻底打破传统设计师的产能壁垒。此时企业采购大量Token,是借助AI智力服务,实现新品快速迭代、款式精准优化、市场效率升级,这也意味着算力资源向智力价值的转化。

                                                                                                                          基于这一逻辑,AI商业完成三层进阶迭代。

                                                                                                                          第一层是基础资源层,售卖标准化Token额度,主打按量计费、随用随充,属于无差异的底层资源生意;

                                                                                                                          第二层是场景方案层,厂商将Token能力封装成适配办公、设计、法务、研发的专属工作流,把零散的算力调用,升级为可落地的场景服务,实现价值溢价;

                                                                                                                          第三层是智能资产层,依托持续的Token消耗,沉淀企业专属知识库、自动化任务链、数字员工体系,让单次消耗的Token转化为可复用、可复利的企业数字资产。

                                                                                                                          书中特别强调Token经济与传统互联网经济的核心差异:互联网时代是资源复用零成本、规模越大越盈利;而Token经济是消耗即生产,每一次Token消耗都是一次全新的智力生产。

                                                                                                                          行业竞争下半场,底层模型、Token算力会逐步趋于同质化,价格天花板被开源技术锁死,真正的核心竞争力,是能否将Token高效转化为专属智力服务、落地为真实商业价值。

                                                                                                                          四、从一分钱月卡,
                                                                                                                          到人人可买的AI能力

                                                                                                                          一分钱买一个月的AI服务,价格低到几乎不用做决定。李佳琦直播间这次低价卖Token,实际上是在邀请更多人试一试:AI能替自己做些什么?

                                                                                                                          这笔交易的数字需要冷静看待。十万人下单,不等于十万人会续费;发放了2万亿Token额度,也不代表这些额度已经被用完。真正值得关注的,是有多少人会在体验之后,把AI留在日常生活和工作里。

                                                                                                                          起初,它可能只是帮人梳理资料、起草方案或制作短视频。用得久了,有人或许会把店铺运营、内容生产等整套任务交给AI。到那时,用户愿意付费的对象就不只是一张月卡,还可能是持续协作的智能体,或一套能完成具体工作的数字化服务。

                                                                                                                          互联网降低了获取信息的成本,智能手机让服务随时可用。AI带来的下一步变化,可能是让更多人以可负担的价格,获得过去需要专业团队才能提供的能力。

                                                                                                                          所以,Token出现在带货直播间,意味着AI开始以普通消费者熟悉的方式进入市场。一分钱的尝试能走多远,具体还要看用户体验;但越来越多人开始亲手使用AI,这件事已经发生了。

                                                                                                                          Word 内嵌图片

                                                                                                                          *文章为作者独立观点,不代表笔记侠立场。

                                                                                                                          跳转微信打开

                                                                                                                          BBA在中国最难熬的一年

                                                                                                                          2026年11月16日 21:12

                                                                                                                          徐珊珊 2026-11-16 21:12 上海

                                                                                                                          以下文章来源于:远川科技评论

                                                                                                                          远川科技评论

                                                                                                                          刻画这个时代(的前沿科技)

                                                                                                                          旧车卖不掉,新车才等到

                                                                                                                          刚刚过去的Q3财报季,堪称德国车企的比惨大会。

                                                                                                                          三季度大众收入752.77亿欧元,营业亏损58.6亿欧元,创过去十年最大单季亏损;前三季度收入2333.78亿欧元,卖了600万辆车,利润0.71亿欧元。

                                                                                                                          单看汽车业务,前三季度收入从去年同期2131.32亿欧元微降到2056.17亿欧元,但营业利润从22.16亿欧元转为负19.72亿欧元。

                                                                                                                          问题主要是一次性费用:软件公司CARIAD和电池业务计提了23亿欧元,保时捷商誉减值64亿欧元加上中国合资企业资产缩水10亿欧元。加回这部分损失,财报其实没那么糟。

                                                                                                                          表中各品牌业务的收入利润未考虑抵销项

                                                                                                                          作为德国高端制造门面,BBA的压力就比较大了。

                                                                                                                          奥迪的财报里包含奥迪、宾利、兰博基尼、杜卡迪四个品牌,即大众旗下的“进取(Progressive)品牌组”。

                                                                                                                          但进取品牌组三季度的表现不太进取,收入128.86亿欧元,同比下滑18.5%,营业利润0.29亿欧元,同比下滑93.9%。

                                                                                                                          奥迪贡献了90%以上的销量,但贡献利润只有40%,赚钱主要还是靠高利润的兰博基尼。

                                                                                                                          宝马的情况也不太乐观,三季度收入304.52亿欧元,息税前利润15.89亿欧元,前三季度收入和息税前利润分别为927.18亿和52.24亿欧元,同比下降7.3%、35.2%。

                                                                                                                          按照宝马官方口径,除去美国关税影响,收购华晨宝马剩余股权产生的折旧摊销,让利润率下降了1.2%,但即便没有这部分成本,汽车业务利润也已经跌去四分之一。

                                                                                                                          表中各业务收入利润未考虑内部交易抵销

                                                                                                                          隔壁的奔驰三季度乘用车业务收入223.74亿欧元,调整后EBIT5.6亿欧元,直接腰斩;前三季度收入683.19亿欧元,调整后EBIT同比下滑40%。

                                                                                                                          奔驰没有一次性费用,主要因素就是车卖的不好。三季度自由现金流暴减87%,原因就包括因库存增加占用现金20.6亿欧元。

                                                                                                                          奔驰管理层解释是为四季度冲量主动备货,但造出来的车能不能卖掉,只有等四季报了。

                                                                                                                          表中各业务收入利润未考虑内部交易抵销

                                                                                                                          问题出在了哪里?

                                                                                                                          最大变量

                                                                                                                          问题出在中国市场。

                                                                                                                          三季度,奔驰全球汽车销量同比下滑6.4%,前三季度整体销量从160.16万降至150.31万辆。宝马三季度交付量55.1万,下滑6.3%,前三季度同样下滑4.9%到170.78万辆。

                                                                                                                          但如果剔除中国/亚太市场,奔驰前三季度销量同比上涨3%。宝马同比上涨1.28%。

                                                                                                                          大众剔除中国市场后,销量还是下滑的,但情况会好很多。

                                                                                                                          前三季度,大众全球销量下滑9.3%,剔除中国/亚太市场后,销量只下滑了0.03%,几乎可以忽略不计。

                                                                                                                          奥迪所在的进取品牌组算上中国/亚太市场,前三季度销量下滑11.3%,不算中国,降幅收窄到3.7%。

                                                                                                                          也就是说,德国车企的全球销量无一例外都被中国市场拖累,造成这种局面的原因,在销量结构里。

                                                                                                                          国内新能源零售渗透率超过67%,纯电占比近7成。但在这个全球最大的新能源市场,德国车企卖得动的还是燃油车。

                                                                                                                          奔驰和宝马的新能源车销量占比在25%左右,三季度,纯电车全球销量都在增长,唯独中国表现惨淡。

                                                                                                                          按照易车数据,前三季度,奔驰在国内卖了不到1万辆新能源车,GLC和E级反倒老当益壮,销量超过16万辆。宝马油改电产品i3平均单月销量勉强破千,只有燃油3系的十分之一。

                                                                                                                          大众更典型,新能源车卖了不少,但都卖给了欧美同胞。

                                                                                                                          以纯电车为例,三季度大众在华交付1.8万辆,同比下降30.1%,前三季度交付4.89万辆,同比下降42.5%。在中国,大众每交付40辆车才有一辆是纯电动,在欧洲,每交付5辆就有一辆是纯电动。

                                                                                                                          纯电车卖不动,燃油车市场又在加速塌方,两头挤压直接把德国车企送到了ICU门口。

                                                                                                                          前三季度,奔驰中国销量从43.39万辆降至30万辆,相比2021年同期拦腰截断。宝马前三季度在华销量37.64万,对比2021年同期67万辆也少了近一半。

                                                                                                                          大众下滑更剧烈,三季度中国销量同比减少38.7%,前三季度销量从197.31万减到137.52万辆,凭空蒸发的60万辆,够养活一家新势力了。

                                                                                                                          倒不怪德国人不努力,只怪新一代纯电车来得太晚了。

                                                                                                                          纯电等到白头

                                                                                                                          中国市场纯电车型高歌猛进的一年,德国列强恰好都处在纯电产品换代的空窗期。

                                                                                                                          奔驰最典型,2019年,奔驰靠油改电作品EQC仓促试水,随后想靠纯电平台EVA打翻身仗,结果首发车型EQS上市即滞销。

                                                                                                                          EQS和EQE两款原生纯电接连失利,奔驰明显受挫,挥刀砍掉下一代纯电平台MB.EA-Large,转而继续修补EVA。随着EQ系列陆续退场,奔驰两款新平台才姗姗来迟:

                                                                                                                          面向紧凑型车的MMA平台和中型车的纯电平台MB.EA-M。

                                                                                                                          也就是说,从2019年到2022年,奔驰向市场集中投放完EQ系列后就再无新的纯电产品。去年新一代纯电车上市,大规模的车型投放刚刚开始,与纯电渗透率增长擦肩而过。

                                                                                                                          奥迪的情况也类似。2018年,奥迪油改电车型e-tron亮相,同步宣布与保时捷共研纯电平台PPE,首款车型原计划2022年发布,结果研发进度一拖再拖。

                                                                                                                          也因此,奥迪一边借保时捷J1平台打造e-tron GT,一边用大众的MEB平台打造Q4/Q5 e-tron,整个2023年,只能对着两款车缝缝补补。

                                                                                                                          直到去年,PPE平台量产落地,同时专为中国市场开发的ADP平台也新鲜出炉。

                                                                                                                          也就是说,奥迪纯电车型真正意义上的换代,也间隔将近三年。旧的e-tron系列没能站稳脚跟,新一代纯电又刚接棒,作用更倾向于填补产品线。

                                                                                                                          大众稍微特殊。2019年底,大众率先推出纯电平台MEB,首款车ID.3初期卖得不差,之后ID.4、ID.5、ID.6连接发布。但自2023年ID.7上市后,大众纯电车型投放速度开始放缓,随即进入长达两年的空窗期。

                                                                                                                          大众面临的问题更实际,纯电平台是有,但电子电气架构先天不足,在国内的竞争力明显落下风。内部CARIAD开发不顺,终极平台SSP的落地时间,被一路推迟到2029年。

                                                                                                                          为了填补这段空白,大众做了两件事,一是让中国团队主导开发新平台CMP,二是放弃原本的电子电气架构,换上联合小鹏开发的CEA电子电气架构,导致新平台落地时间晚于奔驰和奥迪。

                                                                                                                          相比起了个大早赶了个晚集的大众,宝马堪称最保守头最铁的那个。

                                                                                                                          从2020年国产iX3开始,宝马在华的纯电车清一色基于CLAR平台打造,也就是油改电,一条路走到黑。

                                                                                                                          随着纯电需求越来越旺盛,缝缝补补搞不下去,宝马新世代(Neue Klasse)纯电车才终于舍得现身,海外版8月刚刚开售,中国市场的交付最早也得明年一季度。

                                                                                                                          在车型换代的节骨眼上,德国车企面临着相似的尴尬:

                                                                                                                          旧平台纯电车停产退役,新平台纯电车才刚发布,车型也没有大规模铺开。在中国市场纯电车快速渗透的一年,打了个完美的时间差。

                                                                                                                          产品来的太晚是周期性问题,新车开始投放,自然能改善;如果重金投入新车型还是卖不过本土新势力,那就是结构性问题了。

                                                                                                                          图片

                                                                                                                          跳转微信打开

                                                                                                                          未竟的旅程:贝壳的五年与二十五年

                                                                                                                          2026年11月16日 21:09

                                                                                                                          原创 任彤瑶/李墨天 2026-11-16 21:09 上海

                                                                                                                          回头看,向前走

                                                                                                                          2022年5月11日,贝壳回港上市。防护有政策,但仪式感还是要的。北京西二旗总部大厅树起一面硕大的金锣,包括董事长兼CEO彭永东在内的一众高管、以及两位基层经纪人代表完成“云敲钟”,竖起拇指露出微笑。

                                                                                                                          在创始人左晖因病离世近一年后,没有什么比一场热闹的上市仪式更能提振士气了。清脆的锣声似乎驱散了阴霾。然而走出这充满欢呼与掌声的恒温大厅,所有人都心知肚明:内外风雨飘摇,贝壳正处于最危险的时刻。

                                                                                                                          2022年5月11日,贝壳回港上市敲锣仪式

                                                                                                                          在敲钟大厅楼上,一场波及几乎所有部门的大规模裁员正如火如荼进行,有员工心灰意冷地在脉脉上写,“1402咖啡门口欢声笑语,几个办公区唉声一片”;从这栋十层办公楼向外看去,昂扬高歌二十载的中国房地产市场,正潜进一个无声的寒冬。

                                                                                                                          上市再过几天就是左晖的一周年忌日,贝壳举办了一次内部纪念活动,当纪念左晖的视频伴随着《光辉岁月》响起时,在场的人们红了眼眶。

                                                                                                                          对一家企业来说,失去创始人已经足够艰难。更艰难的是,后继者要面对一个截然不同的时代。

                                                                                                                          左晖一周年忌日那天,彭永东发表了一篇纪念文章《永远坚韧与乐观》。文中说:过去左晖就像一把大伞,能在困难时为大家遮风挡雨。如今,公司需要独自面对每一次困难。

                                                                                                                          他明确指出,贝壳已经出现了一些问题。

                                                                                                                          历史很少给人们从容交接的机会。过去五年间,贝壳经历了很长一段时间起伏。在这场漫长的调整中,一个问题始终贯穿其中:

                                                                                                                          当时代发生变化,一家企业该如何继承创始人留下的东西,又该如何走出未来的道路?

                                                                                                                          01 变化:时代的新考题

                                                                                                                          在贝壳回港上市的次日,地产界发生了另一则大新闻,融创陷入公开债务违约。

                                                                                                                          融创创始人孙宏斌是中国地产行业最著名的豪赌者之一,曾说过“人有不知死和不怕死之分,我应该是不怕死的”[1]。在最疯狂的2017年,融创花438亿元收购万达13个文旅项目和76家酒店。

                                                                                                                          然而到了2022年,融创在宽限期内却连一笔2950万美元的债务利息也掏不出来。

                                                                                                                          融创的窘境是整个行业的缩影。2021年中国地产市场创下18.19万亿元的商品房销售额纪录。仅仅一年后,销售额蒸发了近4.9万亿元。 同期全国房屋新开工面积下降39.4%,房地产开发投资下降10%。

                                                                                                                          高杠杆、高周转模式的扩张难以为继,痛楚传导给无数普通人。

                                                                                                                          从景德镇恒大珑庭到郑州名门翠园,楼盘停工潮在全国蔓延。在武汉“最高学历楼盘”绿地光谷星河绘,硕士、博士业主们凑钱安装摄像头监督进度,从早到晚拍不到半个人影[2]。仅仅七月,就有15个省份超过50个楼盘业主们发出停贷声明。

                                                                                                                          2022年武汉绿地光谷星河绘停工现场

                                                                                                                          所有人都感受到,有什么东西彻底不一样了。

                                                                                                                          对于贝壳来说,这场危机尤其棘手。大家津津乐道贝壳的真房源、楼盘字典和ACN模式,这些创新改变了中国房产经纪行业的面貌。但必须看到,没有房地产市场的超量扩张,也很难有链家和贝壳后来的成长。

                                                                                                                          2001年,链家第一家门店在北京朝阳区甜水园开业。当时北京四环路方才全线贯通,城市还在不断向外扩张。此后二十年,数以千万计的人口涌入城市,买房、卖房成为无数中国家庭最重要的经济活动。

                                                                                                                          一片片新住宅区拔地而起,如今,相比二十公里外吐纳80万打工人的天通苑和回龙观,甜水园已是地地道道的老北京中心地段,房价经历了数轮过山车。

                                                                                                                          链家在甜水园的第一家门店

                                                                                                                          事实上,贝壳早已意识到增长不可能永远持续。

                                                                                                                          早在2018年,左晖就判断,中国大的开发和资产增长的浪潮已过去,房地产未来必然从增量转向存量。消费者的购房心态,会从掏空六个钱包“买到就是赚到”,向更理性的改善型换房转变。

                                                                                                                          在他去世前,贝壳已经在为这个新时代做准备。2020年贝壳推出了自营家装品牌,试图将房产经纪行业积累的标准化能力用到装修服务中,寻找交易之外的增长空间。

                                                                                                                          但恐怕没人预想到,信心消退来得这么猛烈,让这场本可徐徐展开的转型变得迫在眉睫。

                                                                                                                          2022年,支撑贝壳增长的两大业务,新房交易服务收入下降38.3%,存量房交易服务收入下降24.5%。而此时新业务还在襁褓之中。贝壳营收缩水了200亿元,净亏损扩大至近14亿元[3]。

                                                                                                                          与此同时,高速扩张留下的组织问题开始暴露。

                                                                                                                          昂扬狂热的年代随左晖一同离去了。过去二十年熟悉的经营环境,眨眼间面目全非。彭永东接过的不仅是一家失去创始人的企业,还有一个正在失去原有增长条件的模式。

                                                                                                                          内外交困的贝壳需要一次重新出发。2023年7月12日,彭永东发表一封内部公开信《翻越第二座山,吹响集结号》,提出“一体三翼”战略,以房产交易为基础,向装修、租赁和住宅供给三个领域拓展。

                                                                                                                          对一家刚刚经历巨额亏损、仍在降本增效的企业来说,这并非最轻松的选择。具体要怎么做,还是要从贝壳的过往里找答案。

                                                                                                                          02 业务:继续做难事

                                                                                                                          赴美上市前,左晖在一封致贝壳股东的信中,专门解释了公司为什么坚持做难而正确的事。

                                                                                                                          他提出一个概念,叫作“无产出期”。

                                                                                                                          一个正确的商业决定,初期可能带来收益下降。企业需要长期改造行业基础设施,改善服务效率和消费者体验,经历多次艰难的“无产出期”,随后才迎来正反馈。

                                                                                                                          2001年,左晖入行时,中国地产中介主要依靠信息不对称赚钱。链家早年做出的重要选择如不吃差价和真房源,几乎都与当时的行业习惯背道而驰。

                                                                                                                          真房源改革前一晚,有经纪人提出与其彻底改变房源发布方式,不如教大家一套应对客户质疑假房源的话术。左晖回答:链家没有本事教这些话术,想学可以去别的公司。

                                                                                                                          这两次变革都导致链家业绩急剧下滑、大批经纪人辞职;然而又迎来一条“微笑曲线”,重新迎来上升期。发现链家不吃差价、房源都是真的,消费者会自动用脚投票。很巧,两次迎来变化的时间都是三个月左右。

                                                                                                                          此后的二十多年,无数开发商、中介公司和创业者涌入地产这条财富奔涌的河流。当年那些看起来费力、不合算的选择,最终反而成了最重要的竞争优势。

                                                                                                                          去世前一个月,左晖接受央视采访时提到一个细节[8],现在深圳其他中介为了向客户证明价格是对的,会说:你不信可以上链家看看。说到这里,左晖露出了微笑,“可能这就是我们想要的”。

                                                                                                                          从行业难事中找到核心机会,并忍受正反馈到来之前的挫败感。左晖离去后,在彭永东推行“一体三翼”战略的过程中,依然能看到类似的坚持。

                                                                                                                          买过房的朋友都知道,没人能笑着完成装修。通常情况下,预付完几十万全款,装修队进场后,就是无数场焦头烂额的拉锯战。期间还有资金被挪用导致偷工减料、卷款跑路的风险。

                                                                                                                          “一体三翼”战略确立后,贝壳内部开始讨论一个问题:能不能让装修款先留在银行,等业主验收满意后,再分阶段支付给装修公司?

                                                                                                                          这个方案并不讨喜,毕竟装修周期长达数月,对装修公司的现金流影响非常大,对银行接口、跨部门流程和企业组织响应能力也有很高要求[4]。

                                                                                                                          2023年10月,验房师国家职业标准编制组在贝壳团装天津项目实地考察,了解施工交付流程

                                                                                                                          但贝壳最终还是把这件事推行下去了。建立了“节点验收、双向确认、银行拨付”机制,并开发了让客户查看资金和施工进度的数字化工具。截至2025年底,资金存管已经覆盖50多个城市,93%以上的客户选择了存管服务。

                                                                                                                          这项服务推出一年后,相关客户投诉量比上一年减少约一半[5]。它完成了一个最简单的逻辑:客户满意,装修公司才能拿到钱。

                                                                                                                          其实说白了,跟“不吃差价”“真房源”一样,解决的还是房屋交易中的信息不透明和信任问题。

                                                                                                                          实行“一体三翼”战略这几年,贝壳在舆论场上几乎没什么声量。低调过冬是一方面,另一方面,它在做的事情确实吃力不讨好,要克服的长期困难多,能看到的短期回报少。

                                                                                                                          对贝壳来说,装修、租赁和长期居住服务领域是全新的领域,原有的能力并不适用。

                                                                                                                          它完全可以选择最轻松的解法,依靠已有的平台网络,光是做一个向装修公司和房产经纪人卖流量的漏斗,就足够活下去。但它仍选择深入最复杂的服务环节,先啃最难的骨头。

                                                                                                                          2024年,贝壳的住宅开发平台“贝好家”事业部成立。和普通开发商按部就班拿地盖楼不同,贝好家首先跑了全国五座城市,走进100多组客户的家中,每次访谈两三个小时[6]。

                                                                                                                          过去二十多年,贝壳最重要也最成功的基础工作是搞清楚中国有多少套房子。如今,它开始用相似的笨方法研究住在房子里的人。这些访谈后来被整理成了约100个研究课题,指向同一个核心:中国人究竟想住什么样的房子?

                                                                                                                          贝好家邀请业主走进上海贝涟C1项目施工现场,了解施工工艺与建造进展

                                                                                                                          2026年9月,一位深圳租客怀疑燃气泄漏,工作人员用泡沫水复验,发现是热水器接口漏装了橡胶垫片。贝壳随后排查了1.2万多套房源[10]。从装修资金存管、到为几十万套出租房承担维修安全责任,再到让购房者提前参与新房的户型设计,每一项都要投入大量人力、物力和时间。

                                                                                                                          2021年全年财报会上,彭永东对股东说,“有的时候不能急,希望树长得更高,就不能急着开花结果,要志存高远。有的时候又不能慢,要一往无前地努力往前跑,实现快速迭代。”

                                                                                                                          左晖谈论“无产出期”时,当年那些费力不讨好的投入已经陆续收到了回报。如今面对截然不同的时代环境,贝壳又进入了一个栽花种树做难事的新周期。

                                                                                                                          然而,承担更多服务责任,也意味着企业需要建立一套适配的体系。对新任管理层来说,业务转型之外,还有另一场更艰难的改革。

                                                                                                                          03 组织:对抗熵增

                                                                                                                          “熵增”本是一个出自热力学的定义。

                                                                                                                          它的意思是:一个系统自发、天然的趋势,就是越来越混乱、无序、涣散。如今,这个词正被现代管理学越来越多地引入,特别是在大企业中。

                                                                                                                          2023年年底,彭永东从由中央统战部、全国工商联、清华经管学院联合举办的新时代民营企业家培养计划四期发展班结业时交了一篇论文,题为《论商业大组织的存在及其问题与批判》。

                                                                                                                          论文中彭永东具体讨论了组织的“熵增”:随着企业规模和管理层级变大,内部沟通和协作成本不断上升,组织会逐渐变得低效、僵化。

                                                                                                                          对一个服务型企业来说,组织熵增非常致命。在贝壳,真正创造单量的是无数西装革履骑着小电驴带客户的一线经纪人。管理僵化传导到基层时,会直接影响企业的生产力。

                                                                                                                          事实上左晖还在时,链家和贝壳就多次面对过类似的问题。反思组织惯性,几乎刻在这个公司的基因本能之中。

                                                                                                                          贝壳历史上有过三次大刀阔斧的组织变革。第一次是2010年,链家处于高速扩张的时期,却仍保留许多依赖个人经验的管理方法。左晖决定拿出5000万请IBM来改造管理体系。

                                                                                                                          当年的5000万是什么概念?从现金流角度,足够当时的链家新开300至500家门店。有人问左晖是不是疯了,他回答:这钱如果现在不花,以后还得花[11]。

                                                                                                                          一个有意思的细节是,当时IBM承接链家项目的团队核心成员之一,就是彭永东。后来他被左晖挖了过来。

                                                                                                                          第二次是在2014年底。面对日益膨胀的管理层级,和经纪人流失过快的行业难题,链家拿出一份涉及开放平台、组织扁平化和提高经纪人提成的改革方案,也就是如今的ACN机制。

                                                                                                                          调整之后,北京链家几万人的团队里,真正不接触客户的运营人员只剩下一百多人[12]。经纪人最高提佣比例从行业平均的30%提高至70%。也就是这个时期,“优秀经纪人收入超过管理者”成为可能。

                                                                                                                          第三次是决定做平台的2018年,包含链家各城市总经理在内近两万名员工,在48小时之内完成了岗位调整,从打拼多年的链家迁到陌生的贝壳。

                                                                                                                          从学习做大企业,到控制管理层级、重新分配利益,再到平地起高楼做新业务,纵观贝壳历史,难而正确的事业路上总伴随着深入的组织改革。

                                                                                                                          彭永东接棒左晖后也保持了这种警惕性。在那篇结业论文里,他提出了两个应对组织熵增的可能解法:

                                                                                                                          第一,用机制去保持组织活力。比如,把自己变成小公司,拆也好、新建也好。

                                                                                                                          第二,当每个人的成长速度高于组织的变化速度的时候,就能保持健康。

                                                                                                                          2026年,贝壳组织变革内部会议

                                                                                                                          具体来说,这几年来贝壳内部改变了两件事。

                                                                                                                          一是让管理者“上一线”,重新承担解决业务问题的责任,让中后台从管理部门转向能力支持部门。2022年5月,贝壳的核心管理团队启动“百日奋战”计划。彭永东认为,公司过去几年扩张太快,组织跟不上业务的发展,中后台已经不了解消费者和服务者的真实需求。

                                                                                                                          彭永东要所有高管到一线实习,并承担具体业绩目标。他自己带头到杭州一家圣都家装门店当了一个月经营部经理。至于他的助理,要跟着租赁师父收房,一周的任务是收上来5套。

                                                                                                                          二是重新确定组织围绕谁运转。过去按业务线划分的组织,开始尝试围绕社区和消费者的长期居住需求协作,重新界定岗位职责、考核指标和利益分配方式。

                                                                                                                          这背后,是对“专业”的重新定义。

                                                                                                                          过去,房产经纪人的收入主要来自成交佣金。但一个经纪人如果认真研究客户需求,最终建议客户暂时不要买房,他可能帮客户避免了很大的经济损失,自己却拿不到佣金。

                                                                                                                          真正的专业,不是更擅长促成交易,而是有能力站在消费者立场上,帮助他们做出更好的居住决策。有时候,这意味着促成一笔交易;有时候,却意味着劝客户不要交易。

                                                                                                                          但如果组织仍然只为成交“买单”,“新”的专业就很难持续生长。

                                                                                                                          因此,贝壳需要改变的不只是经纪人的服务方式,更是专业服务的价值创造和分配机制:让专业不再只体现为成交能力,而是体现在理解需求、提供决策支持、解决居住问题的全过程;让服务者不必只靠成交获得回报,正如彭永东在一次业绩电话会上说的那样,凭借不同的专业能力创造价值、获得收入。

                                                                                                                          2023年7月,贝壳进行“一体三翼”组织调整,将经纪、整装、惠居、贝好家设为四条事业线。到了2026年3月,北京地区开始试点,将门店重新定位为社区居住服务站点,由经纪、租赁、家装人员共同满足一个家庭的需求。

                                                                                                                          在售房源建议改造方案说明图。图片来源:经济观察报

                                                                                                                          举个例子,北京的大红门片区有很多老旧房屋。过去,经纪人可能只用10分钟向消费者介绍房屋的面积、价格和朝向;现在他们往往会延长到30—40分钟,用更多时间解释房屋如何改造、住起来是否方便、大概需要多少装修预算。随后贝壳旗下的整装部门“被窝”会免费制订一份设计方案和效果图。

                                                                                                                          数据显示,大红门片区的被窝整装客户中,在二手房签约前委托装修的比例从10.7%升至62.3%。

                                                                                                                          贝壳投入大量资源,鼓励员工特别是经纪人尝试、使用AI和自媒体。不少链家经纪人做出了让人眼前一亮的尝试。有人用AI制定对客户的详细服务方案,有人开发出能即时回答客户问题的小工具,有人借助自媒体成了全市销冠……

                                                                                                                          公司还增加了一个不靠成交拿提成的岗位:客户管家。这个岗位由人和AI协同完成工作,专门负责前端的客户需求分析、判断客户所处的购买阶段,再将梳理清楚的需求交给房产经纪人。

                                                                                                                          过去几年,贝壳的裁员曾引发不少争议,岗位和利益的重新分配也难免伴随着阵痛。社区服务、客户管家等新机制仍在探索,功过还要留给时间检验。

                                                                                                                          但回顾链家和贝壳二十多年的历史,会发现这家公司依靠有效的制度和标准化体系取得成功,却又一次次主动调整那些帮助自己成功的规则,做难而正确的事。

                                                                                                                          对一家10万人规模的企业来说,这是一种值得尊敬的勇气。

                                                                                                                          04 传承:坚守和改变

                                                                                                                          2011年夏天,乔布斯的健康状况持续恶化。一天他把库克叫到家中,告诉他已经决定向董事会推荐由库克接任苹果CEO,自己转任董事长。

                                                                                                                          库克有些意外,随后问自己当CEO以后,应该如何与担任董事长的乔布斯合作?乔布斯突然提起了迪士尼。

                                                                                                                          创始人华特·迪士尼去世后,迪士尼公司一度陷入发展困境。在乔布斯看来,原因之一是公司管理层过于依赖创始人的判断。“每当需要作出重大决策,人们就会围坐在会议桌前,反复讨论华特·迪士尼会怎么做。”

                                                                                                                          乔布斯告诉库克[13]:“我永远不希望你问,‘如果是我会怎么做’。只管去做你认为正确的事。”

                                                                                                                          2010年,乔布斯与库克同框

                                                                                                                          作为左晖的接班人,彭永东或许在不止一个时刻与库克产生过共鸣。

                                                                                                                          一方面,售楼部人头攒动、咬碎银牙也要上车的盛况已成为往事,AI也在改变消费者获取信息的方式。从前一套房子是一个家庭奋斗半生的终点;如今拿到钥匙只是另一段生活的开始。过去二十年支撑房地产中介行业发展的许多经验,已与时代微妙地错配。

                                                                                                                          另一方面,贝壳不再是那个只做房屋交易的公司了。家装、租赁和开发,业务越来越复杂,许多问题都没有现成的答案。环顾四周,贝壳身边甚至找不到一位同路人。

                                                                                                                          也许贝壳比任何时候都想问一句:左晖会怎么做?

                                                                                                                          但过去的年代里,左晖留给这家企业最重要的遗产,可能恰恰是让它不必依赖创始人,仍然能够判断什么事情值得做。

                                                                                                                          左四为彭永东、右一为左晖。图片来源:南方周末

                                                                                                                          多年前,左晖讲链家企业文化时说过一段非常朴素的话:

                                                                                                                          “一代企业家解决一代的问题。我这一代的使命就是让消费者享受到‘还不错’的服务。对我们的消费者来说,有没有我们对他们有什么不同吗?有了我们之后他们是不是生活变得更好了一些呢? 没有了我们消费者是不是会变得不习惯呢?”

                                                                                                                          回望过去二十五年,链家和贝壳反复验证了一件事:一种正确的商业模式,往往需要付出更多眼前的成本,经历更漫长的起伏周期,却也可能因此获得更持久的商业回报。

                                                                                                                          这是贝壳不变的部分。

                                                                                                                          但与此同时,从不吃差价、真房源、经纪人合作网络,到家装资金存管、租后服务、一体三翼,每一次新的尝试,都意味着企业要承担更多责任,也在不断考验过去形成的经验和能力。

                                                                                                                          这是贝壳要变的部分。

                                                                                                                          彭永东是一个低调的人,过去五年很少出现在公众视野中。只有季度财报会上才能听到他的一些看法。但2026年3月和11月,他分别发了一封5000字和7000字的长信,只为了向内部和外界解释贝壳为什么要变。

                                                                                                                          “消费者在变,行业在变,技术在变,如果我们还停留在过去,那只会离消费者越来越远,也离企业存在的初心越来越远。”

                                                                                                                          上一座山的路,翻不了下一座山。商业世界最危险的天真,莫过于用过去的解法,刻舟求剑企图求得今日的成功。

                                                                                                                          2026年11月12日,在组织成立二十五周年大会上,彭永东宣布了公司新阶段的使命、愿景、价值观与精神气质。

                                                                                                                          这次更新延续了左晖时代的许多理念,也回应了贝壳今天面临的新问题。

                                                                                                                          左晖提出的使命“有尊严的服务者,更美好的居住”保持不变,未来愿景为“以专业,陪伴家的每一程”。同时发布四条价值观:坚持做难而正确的事、以消费者为中心、让专业的服务者赢、并肩奋斗彼此成就。

                                                                                                                          “做难而正确的事”“以消费者为中心”,是贯穿链家和贝壳二十五年历史的经营原则。而“让专业的服务者赢”,以及从房屋成交延伸到“陪伴家的每一程”,则体现了贝壳对服务者价值、消费者需求和自身角色的新理解。

                                                                                                                          这家走过二十五年的企业,在经历五年艰难跋涉后,再次向外界明确表达自己相信什么,同时重新思考如何在新的市场里兑现这些承诺。

                                                                                                                          据说贝壳25周年发布的使命愿景,彭永东想了很久。他后来一直在想,消费者和家是一个什么样的图景?贝壳应该在这个画面里是什么角色?后来他画出了人生的不同阶段,家在每一程的样子。

                                                                                                                          乔布斯去世后,库克在第十届 All Things D 大会上谈到此后自己的感受[14]:

                                                                                                                          “悲伤逐渐被一种强烈的决心取代:继续未竟的旅程。”

                                                                                                                          左晖是贝壳的一面图腾,他深刻塑造了贝壳的精神内核。未来的路交由彭永东和新一代贝壳人继续丈量,时代会不断提出考题,他们也会写下自己的新答案。

                                                                                                                          斯人已逝,贝壳的旅程仍在继续。前路未尽,风帆继续驶向远方。

                                                                                                                          全文完,感谢您的耐心阅读。

                                                                                                                          参考资料

                                                                                                                          [1] 救乐视买万达 半年花千亿的孙宏斌到底何方神圣,人民网

                                                                                                                          [2] 凑钱装摄像头监控施工!武汉一楼盘停工,业主发联名公告:将停止还贷,齐鲁晚报

                                                                                                                          [3] 贝壳财报及电话会纪要

                                                                                                                          [4] 圣都整装上线资金存管机制保障 为家装消费者安心兜底,扬子晚报

                                                                                                                          [5] 被窝整装探索资金存管新模式,经济参考报

                                                                                                                          [6] 贝好家如何定义好房子 | 2026博鳌地产发展大会郭旌演讲纪要

                                                                                                                          [7] 左晖访谈回顾:中国人不缺房?房屋中介竞争弱吗,财新时间

                                                                                                                          [8] 遇见大咖:左晖访谈,央视财经

                                                                                                                          [9] 详谈01:左晖,李翔

                                                                                                                          [10] 慢下来的省心租,晚点

                                                                                                                          [11] IBM潜入房地产经纪业,21世纪经济新闻

                                                                                                                          [12] 左晖:永远不让自己特别舒服 房地产市场震荡阶段已过,虎嗅

                                                                                                                          [13] Tim Cook's Freshman Year: The Apple CEO Speaks,Bloomberg

                                                                                                                          [14] Liveblog: Tim Cook's Interview at D10 Conference

                                                                                                                          作者:任彤瑶/李墨天

                                                                                                                          编辑:戴老板

                                                                                                                          责任编辑:任彤瑶

                                                                                                                          图片

                                                                                                                          图片

                                                                                                                          跳转微信打开

                                                                                                                          又一家A股公司,提示退市风险

                                                                                                                          2026年11月16日 21:05

                                                                                                                          财联社 2026-11-16 21:05 上海

                                                                                                                          金科股份(000656.SZ)公告称,公司股票于2026年11月16日收盘价为0.97元/股,低于1元。根据相关规定,公司股票存在可能因股价低于面值被终止上市的风险。本公告为公司首次终止上市风险提示公告。公司表示正积极采取有效措施改善经营基本面,并提醒投资者理性投资,注意风险。

                                                                                                                          跳转微信打开

                                                                                                                          宏观医生 | 透视10月宏观数据:财政支出待提速

                                                                                                                          2026年11月16日 21:04

                                                                                                                          原创 CF40研究院 2026-11-16 21:04 北京

                                                                                                                          关注政府债融资形成实物工作量的节奏

                                                                                                                          “

                                                                                                                          2026年11月16日,国家统计局发布了10月宏观经济数据。10月宏观经济生产端相对平稳,需求端动能不强,投资、消费、融资等数据均有体现,进出口维持高增。

                                                                                                                          针对上述数据表现,我们有如下三点观察和思考:第一,投资需求不强,需关注政府债融资形成实物工作量的节奏。第二,中秋假期错位影响消费节奏,居民部门需求整体亦有待增强。第三,现房销售新政推动新开工同比边际修复,中长期供给预计仍将下降。中长期供给下降有利于三、四线城市库存的出清,不过拿地需求收缩对房地产投资、财政收入的长期影响需持续关注。

                                                                                                                          * 本文版权归中国金融四十人研究院所有,未经书面许可,禁止任何形式的转载、复制或引用。

                                                                                                                          ”

                                                                                                                          2026年10月宏观经济数据点评

                                                                                                                          文 | 中国金融四十人研究院

                                                                                                                          2026年11月16日,国家统计局发布了10月宏观经济数据。10月宏观经济生产端相对平稳,需求端动能不强,投资、消费、融资等数据均有体现,进出口维持高增长。

                                                                                                                          生产方面,10月规模以上工业增加值同比增速为4.8%,较上月下降0.7个百分点。其中,下降最多的行业包括汽车制造业,黑色金属冶炼及延压加工业,铁路、船舶、航空航天和其他运输设备制造业,以及电力、热力的生产和供应业。其中,汽车制造业受行业对“速成车”现象整顿的影响,供给放缓,价格也有所企稳。

                                                                                                                          贸易方面,10月以美元计价的出口金额同比增速为35.2%,进口金额同比增速为41.6%,主要受低基数提振。受进口价格快速上涨影响,10月名义贸易差额较上月小幅收窄,但仍处于较高水平。

                                                                                                                          消费方面,10月社会消费品零售总额同比增速为0.4%,较上月下降0.7个百分点。限额以上社零同比下降4.9%,降幅较上月扩大2.8个百分点,中秋假期错位影响下,同比增速较上月下降的品类较为广泛。

                                                                                                                          投资方面,10月固定资产投资同比增速为-16.9%,降幅较上月扩大9.7个百分点。其中,制造业、基建、房地产投资当月同比增速分别为-14.2%、-17.6%、-33.2%。高频开工、库存等数据显示,制造业相关实物投资动能继续放缓,基建相关实物投资动能相对平稳。房地产方面,新开工同比有所修复,新房与二手房销售、一线城市与其他城市价格数据继续分化。

                                                                                                                          融资方面,10月新增社会融资规模11429亿元,比上年同期多增3251亿元;10月末社会融资规模存量为469.2万亿元,同比增长7.2%,增速较上月上升0.1个百分点。10月社融口径下,对实体经济发放的人民币贷款减少5846亿元,同比少增5692亿元,政府债券融资增加11835亿元,同比多增6983亿元。政府债融资为主要支撑,居民部门融资需求有待提升。

                                                                                                                          通胀方面,10月CPI与核心CPI同比增速分别为0.7%和0.8%,均较上月下降0.2个百分点;PPI同比上涨5.7%,较上月扩大0.7个百分点。剔除黄金、“以旧换新”等扰动因素后,核心CPI同比增速为0.8%,也较上月小幅下降。PPI环比上升0.7%,能源价格、AI相关行业价格高企,其他行业生产价格相对平稳。

                                                                                                                          10月全国城镇调查失业率为5.1%,较上月下降0.1个百分点,就业形势总体稳定。

                                                                                                                          针对上述数据表现,我们有如下三点观察和思考。

                                                                                                                          第一,投资需求不强,需关注政府债融资形成实物工作量的节奏。三季度以来,政府债融资较上半年有所加速,9月以来,政策性金融工具的落地对企业融资也起到一定支撑作用。然而从实体部门来看,除AI相关行业需求较为突出以外,其他行业投资需求表现不强。10月固定资产投资较上月进一步减速,制造业实际投资动能出现放缓,工业增加值增速较上月小幅下降。10月,政府债发行继续提速,但新增财政存款出现淤积,政策资金尚未落实为实物工作量。往后看,实体需求的回升有赖于财政支出力度的提升,需持续关注政策资金的落地情况。

                                                                                                                          第二,中秋假期错位影响消费节奏,居民部门需求整体亦有待增强。社零方面,在中秋假期错位的影响下,限额以上分类增速较上月广泛下降,石油及制品类在油价上涨的影响下增加最多。若剔除石油及制品类,10月限额以上非以旧换新社零增速约为-0.5%,为2025年以来首度转负。9-10月平均来看,以旧换新社零增速约为-9.8%,较6-8月进一步下降;剔除石油及制品类,非以旧换新社零增速约为2.1%,6-8月这一中枢为3.8%。9-10月社零较6-8月中枢有所放缓。考虑到10月CPI增速的下降、居民信贷的同比少增以及核心城市新建商品房销售量价的下降,居民部门需求在量与价、融资与消费方面均有提升空间。

                                                                                                                          第三,现房销售新政推动新开工同比边际修复,但中长期供给预计仍将下降。中长期供给下降有利于三、四线城市库存的出清,不过拿地需求收缩对房地产投资、财政收入的长期影响需持续关注。10月新开工面积当月同比下降18.2%,降幅较8月、9月分别收窄12.6、7.4个百分点。这或与“8·28新政”以来开发商加速项目开工、保证交付有关。

                                                                                                                          我们曾在CF40·简报《8·28 房地产新政的含义》中提到,房地产企业有更强的激励保证一定的新开工水平、放缓拿地来确保短期资金周转,各地过渡细则也鼓励房企加快存量项目的开工、施工和交付。中长期而言,资金周转放缓使得房地产企业拿地、开工中枢下降,这有利于库存较高的三、四线城市的市场出清与价格企稳,但对房地产投资、财政收入的长期影响需持续关注。图片

                                                                                                                          版面编辑:思琦|责任编辑:思琦

                                                                                                                          视觉:李盼 东子

                                                                                                                          监制:李俊虎 潘潘

                                                                                                                          跳转微信打开

                                                                                                                          于东来:给管理层购买310辆坦克700越野车

                                                                                                                          2026年11月16日 21:01

                                                                                                                          中国新闻周刊 2026-11-16 21:01 北京

                                                                                                                          11月16日,于东来在个人社交媒体账号上接连更新多条内容。其中最受关注的是,他分享了胖东来今年截至11月15日的经营状况。数据显示,本年度集团累计销售额达到258.41亿元,同比上涨26.34%。

                                                                                                                          于东来分享了三张数据截图,分别为销售额总览、11月15日单日门店以及本年门店销售额排行榜。根据集团整体销售概况,15日集团合计销售额为8709万元,同比上涨18.95%;本月集团累计销售额达11.2亿元,同比上涨25.56%;本年集团累计销售额达到258.41亿元,同比上涨26.34%。无论是单日、当月还是本年度累计业绩,胖东来均实现正向增长。

                                                                                                                          在11月15日单日及本年门店销售额排行榜中,时代广场店均以断层优势领先,本年度销售额已达57.84亿元,天使城店位居第二位。

                                                                                                                          截至下午4时,于东来16日已接连更新7条内容。在公布经营状况后,他又接连发布4条文字内容。他表示:“让创造美好的人们同时拥有享受更好品质的生活!公司通过再购310辆坦克700安排管理队伍!”“专注于创造美好、享受美好、传播美好……专注于各方面品质的提升、专注于个体的幸福、专注于团队的幸福!”他还写道:“很多人生意小的时候做得很有品质、喜悦而幸福……但因对做企业的无知,就随着欲望和盲目,终归让自己和团队辛苦,并慢慢跌入痛苦的深渊!”

                                                                                                                          日前,胖东来因在售的一款名为卡蓓诺的洗发水引发争议。品牌方声称产品系“原装日本进口”,但有质疑声认为其产地造假,是“假洋牌”。随后,于东来多次发文回应,也对质疑美好而攻击、甚至是长期攻击胖东来的个别群体作出了回应。

                                                                                                                          来源:极目新闻、新黄河

                                                                                                                          跳转微信打开

                                                                                                                          谁说只能“老年人专用”?这件居家好物提升沐浴体验,别错过!

                                                                                                                          2026年11月16日 20:59

                                                                                                                          原创 健康一问 2026-11-16 20:59 北京

                                                                                                                          淋浴椅是“老年人专用”吗?

                                                                                                                          01

                                                                                                                          洗澡时觉得站着累、怕滑倒

                                                                                                                          不妨选一把淋浴椅

                                                                                                                          淋浴椅虽然常被当作适老化用品,但它的适用人群非常广泛。

                                                                                                                          • 孕妇:孕中后期站立洗澡容易腰酸背痛、体力不支,坐着洗更省力安全。

                                                                                                                          • 术后康复者:比如做过髋关节或膝盖手术的人,在恢复期需要长时间坐着洗澡。

                                                                                                                          • 患有特定疾病的人群:如高血压、心脏病、贫血或脑供血不足,长时间站立洗澡容易头晕甚至晕倒。

                                                                                                                          • 普通年轻人:日常淋浴时想坐一会儿,给幼童洗澡,或者崴脚后当临时坐具都很实用。

                                                                                                                          简单来说,只要你在洗澡时觉得站着累、怕滑倒,或者需要借力,都可以使用淋浴椅。

                                                                                                                          02

                                                                                                                          淋浴椅有扶手、靠背

                                                                                                                          不等于安全

                                                                                                                          问题来了,怎么才能挑到安全、好用又划算的淋浴椅?

                                                                                                                          近日,上海市消保委对20款淋浴椅开展比较试验发现,所有样品向前稳定性均符合要求,但3款样品在侧向、向后受力时发生倾翻,其中1款还是自带靠背扶手、看上去安全性更高的款式;另有2款样品经过强度测试后靠背出现变形。

                                                                                                                          专家提醒,扶手、靠背不等于安全,稳固的支撑结构,才是淋浴椅的安全根基。选购淋浴椅时,建议从这三维度入手。

                                                                                                                          1.整体框架形态

                                                                                                                          支脚向外张开的梯形结构,比垂直支脚的结构更稳定。外张的支脚能让重心更居中,受力向四周分散传导,抗侧翻、抗后翻的能力会明显提升。

                                                                                                                          2.主体材质强度

                                                                                                                          铝合金、不锈钢等金属框架的强度远高于纯塑料框架,长期使用也不容易出现支脚弯折、结构松垮的问题。 

                                                                                                                          3.底部防滑设计

                                                                                                                          浴室常年湿滑,椅脚是否防滑直接影响使用安全。合格的淋浴椅会在四个支脚配备防滑垫或防滑吸盘,能有效避免椅身移位打滑。

                                                                                                                          03

                                                                                                                          网购淋浴椅

                                                                                                                          注意看三个细节

                                                                                                                          多数消费者通过线上选购淋浴椅,无法现场试用。挑选时可注意这三处细节。

                                                                                                                          1.产品类别

                                                                                                                          要选择明确标注为“淋浴椅/淋浴辅助器具”的产品,查看商品详情页是否标注对应的国家执行标准号,避开没有明确产品类别的“三无”普通凳子。 

                                                                                                                          2.额定承重参数

                                                                                                                          要根据使用者的体重选择,尽量预留充足的承重余量,不要卡着体重上限进行选购,体重较大的人群更要重点关注这一指标。 

                                                                                                                          3.结构细节

                                                                                                                          可通过商品详情页的背面实拍图观察塑料部件,留意加强筋的密度与布局。加强筋分布密集、设计合理的产品,塑料件的结构强度更有保障。

                                                                                                                          04

                                                                                                                          购买淋浴椅

                                                                                                                          不必盲目追求多功能

                                                                                                                          如今市场上的淋浴椅品类繁多,折叠挂墙式、升降式、带轮移动式等款式层出不穷。附加功能越多,意味着结构节点越多,潜在的不稳定因素也越多,普通家庭无需盲目追求多功能,按需选择即可。

                                                                                                                          1.空间宽裕,优先固定款

                                                                                                                          卫生间空间充足的家庭,可优先选择结构简单的固定式淋浴椅,没有折叠、升降、滚轮等额外结构,整体稳定性最优。

                                                                                                                          2.面积有限,可选折叠款

                                                                                                                          卫生间面积狭小、无法长期放置座椅的家庭,折叠挂墙式更适合,但折叠结构可能会影响稳定性,使用前必须确认座椅完全展开、锁扣完全卡紧,避免因未完全展开引发翻倒。 

                                                                                                                          3.辅助移位,警惕轮式升降款

                                                                                                                          带轮款仅推荐行动不便、需要他人辅助移动的人群使用,家庭使用时容易出现忘记锁死轮刹的情况,反而增加滑动跌倒风险。

                                                                                                                          可升降款则要重点关注最高升降档的重心,通常座椅重心越低稳定性越好,重心升高容易出现侧翻。

                                                                                                                          此外,消费者也应关注产品价格。几十元的低价产品多是普通塑料凳,在结构强度、稳定性检测上都难以达标,安全隐患较大。常规铝合金或不锈钢框架的合格淋浴椅,一百多元属于入门价位,两百元左右的中端产品性价比相对更高。


                                                                                                                          来源:人民日报微信、人民日报健康客户端,受访专家:江南大学设计学院产品设计系副教授 董玉妹,记者:杨林宋

                                                                                                                          本期编辑:石磊、方梓祎

                                                                                                                          图片

                                                                                                                          觉得好看,请点这里↓↓↓

                                                                                                                          阅读原文

                                                                                                                          跳转微信打开

                                                                                                                          长期伴侣重燃性欲的小妙招,竟然是它

                                                                                                                          2026年11月16日 20:50

                                                                                                                          原创 知我心理 2026-11-16 20:50 上海

                                                                                                                          携手拥抱未知,是最好的前戏

                                                                                                                          伴侣间的「性欲消退」,在长期关系中,似乎是一种普遍的趋势。

                                                                                                                          很多人在这个阶段会感到无聊和失望,甚至怀疑自己或者对方是不是不行了、或者不爱了。

                                                                                                                          听起来很悲观。不过,我们也常常会在后台看到一些相恋多年依然「激情满满」的留言。

                                                                                                                          这种情况到底是天赋异禀还是别有缘由?出于好奇,我们略作了一番研究,竟然发现:影响伴侣间性欲的关键因素,是一种叫做「自我扩展」的能力。

                                                                                                                          自我扩展

                                                                                                                          在关系中到底意味着什么?

                                                                                                                          「自我扩展(Self-Expansion)」指的是,人类天生就渴望成长。生而为人,我们有着基本的驱动力去获得新身份、发展新视角、提升技能和获取资源,来拓宽我们的自我意识[1]。

                                                                                                                          而通常,「自我扩展」需要通过关系来实现,尤其是亲密关系[2]。

                                                                                                                          原因很简单:当我们进入一段亲密关系时,对方本身就是一扇通往新世界的大门。对方的爱好、思维方式、甚至语言和饮食习惯,都有可能成为我们自我意识中全新的部分。

                                                                                                                          更重要的是,在健康的亲密关系中,会发生一种被称为 「将他人纳入自我」(Inclusion of Other in the Self, IOS)的认知过程[3]。这意味着,我们不再把伴侣视为一个「外部的人」,而是开始把对方的资源、视角、能力和身份等,在某种程度上当作自己的一部分。

                                                                                                                          比如,当你的伴侣擅长摄影,你会觉得自己也「懂一点摄影」;当你的伴侣有一个荒诞的童年故事,那个故事仿佛也成了你记忆的一部分。这种自我与伴侣的认知重叠,从单独的「我」到「我们」这个整体的转变,正是亲密关系中自我扩展最核心的机制。

                                                                                                                          图片来源:《无耻之徒》

                                                                                                                          「自我扩展」不只是存在于恋爱刚开始时,而是贯穿于亲密关系的整个生命周期[2]:

                                                                                                                          • 关系初期:快速自我扩展,点燃强烈吸引

                                                                                                                          当我们开始一段新关系时,对方可能会向我们介绍新的爱好、朋友以及想法等等。每一件这样的小事,都在快速扩展我们的自我感。

                                                                                                                          这种高强度的自我扩展会带来明显的生理唤醒和积极情绪。我们会感到兴奋、好奇、充满活力。这正是热恋期那种「上头」状态的重要来源——激情,并不仅仅是荷尔蒙的产物,更是成长感的直接体现。

                                                                                                                          • 关系维持:自我拓展放缓、关系倦怠浮现

                                                                                                                          然而,随着双方逐渐适应各自的角色和日常生活,在关系中体验到的自我扩展感往往会随着时间的推移而下降。

                                                                                                                          对方不再有那么多你不知道的故事,你们的生活逐渐形成了固定模式——同样的周末安排、同样的对话节奏...当自我扩展感下降时,那种曾经让人心跳加速的激情,也会自然减退。

                                                                                                                          除非那种「我们在一起成长」的感觉被再一次激活,才会重新带来生理上的唤醒。

                                                                                                                          • 关系解体:自我概念受损、需要时间重建

                                                                                                                          人们的自我概念会因此受损。长期以来,伴侣的一部分已经被纳入了你的自我意识——你们一起建立的回忆、共同的身份认同、甚至对方教会你的那些技能和视角,都会在分离时被撕裂。

                                                                                                                          分手后,人们往往需要相当长的时间来重新定义「我是谁」。那个曾经包含「我们」的自我,需要被重新整合成一个独立的「我」。

                                                                                                                          图片来源:《普通人》

                                                                                                                          自我拓展如何

                                                                                                                          激活了关系中的性欲?

                                                                                                                          原因有四个——

                                                                                                                          激活性欲相关脑区,引发生理性唤醒

                                                                                                                          当我们与伴侣一起经历新奇或有挑战性的体验时,像是攀岩、或是密室逃脱,甚至不需要有性的参与,会自然而然地产生生理上的唤醒:心跳加速、呼吸急促、手心出汗。

                                                                                                                          这种唤醒并不会止步于此,而是会「溢出」到其他方面,包括性唤醒。

                                                                                                                          此时,心理学中的 「唤醒的错误归因」效应就发生了[4]。简单来说,大脑有时会「偷懒」——它分不清心跳加速到底是因为新体验本身,还是因为身边的那个人。于是,它会把我们的部分兴奋感,错误地归因于对方。

                                                                                                                          结果就是,伴侣在我们眼中的性吸引力,被无形中放大了。

                                                                                                                          Ortigue等人的 fMRI 研究更证实了这一点[5],他们发现,自我扩展和性欲的激发,涉及到同样的脑区——一个特定的额-颞-顶叶神经网络,以及一个调节无意识机制的皮层下网络。

                                                                                                                          也就是说,当你们共同体验新鲜事物时,即使当时没有任何亲密接触,大脑中与欲望相关的深层回路也会被直接激活。伴侣对我们的性吸引力,有一部分就源于这种无意识层面的神经激活,且我们甚至没有意识到它正在发生。

                                                                                                                          或许,从某种意义上来说,一起尝试新事物,本身就是一种独特的前戏。

                                                                                                                          图片来源:《去他妈的世界》

                                                                                                                          打破关系中的可预测性,

                                                                                                                          带来一种「他者感」

                                                                                                                          长期关系会带来稳定和安全感,这是大多数人所渴求的。但讽刺的是,这种安心有时却会给情欲泼冷水。稳过头了,就容易「痿」。

                                                                                                                          正如心理治疗师埃丝特·佩雷尔在《亲密陷阱》中所论证的:熟悉滋生安逸,但当我们过于安逸时,我们就失去了能够激发欲望的神秘感[6]。

                                                                                                                          当两个人已经熟到可以一起拉屎放屁、对彼此屁股上的痣都了如指掌时,真的就很难再对对方有什么幻想,更别提探索欲了。

                                                                                                                          但欲望,却需要未知、需要惊喜、需要一种「对方还没有被我完全看透」的感觉。心理学上称之为 「他者感(otherness)」[7]。

                                                                                                                          而自我扩展活动,恰恰可以制造这种感觉。当我们和伴侣一起尝试突破以往界限的新事物时,就给关系引入了不确定性和新奇感[4]。更重要的是,我们能够发现伴侣从未展现过的新的一面,打破「我完全了解你」的固化认知。

                                                                                                                          比如,你们心血来潮去玩密室逃脱,在昏暗的灯光下,你发现那个平时温吞吞的伴侣,竟然开始指挥全局、推理线索、跟NPC讨价还价——陌生、陌生极了,但也性感极了。

                                                                                                                          再比如,你们一起去攀岩,你绑着安全绳挂在半空中,腿直打抖,一向怂包的伴侣在下面不急不慢地喊:「左脚踩那个红色点,对,稳住,我接着你。」你会突然发现,原来他还有这种「冷静控场」的一面。

                                                                                                                          而这点恰到好处的未知,就是重新点燃性欲最好的「药」。

                                                                                                                          图片来源:《生活大爆炸》

                                                                                                                          强化了私人时刻的「自我暴露」,

                                                                                                                          包括脆弱点燃的活力

                                                                                                                          当伴侣双方共同探索新领域,将新观点和体验融入自我认知时,两个人之间的情感亲密感或迅速飙升——你们不再是单独的个体,而是彼此的一部分。

                                                                                                                          因为这些新活动,往往伴随着不确定性,两个人不可避免地都会暴露自己的笨拙、焦虑或无助,在共同面对挑战的过程中,你可能会无意间透露一个深埋心底的恐惧,或者一个难以启齿的秘密。

                                                                                                                          但这种脆弱性的展现,是通往深度亲密的必经之路,如Brené Brown研究所指出的,脆弱感是建立连接的核心[8]。这种高压情境下情不得已、难以控制的「自我暴露」,能瞬间击穿日常生活的琐碎,让亲密感呈指数级增长。

                                                                                                                          当亲密感因为共同拓展而加强时,伴侣间的坦诚感(Authenticity)也会随之提升。研究表明,这种透明度会直接转化为性沟通的意愿[7]。

                                                                                                                          当你们习惯于在日常挑战中交换感受,就更容易在卧室里说出关于性的真实想法,无论它有多么禁忌和羞耻。心理学研究证实,能够坦诚讨论性偏好和幻想的伴侣,往往拥有更高的性满意度和持续的性欲[9]。

                                                                                                                          新奇的共同经历会打破感官的迟钝,让彼此在对方眼中重新变得「鲜活」且「充满诱惑」。

                                                                                                                          图片来源:《亢奋》

                                                                                                                          另外,自我拓展还降低了第三者的吸引力

                                                                                                                          自我扩展还有一个意想不到的效果:ta让你对外界的诱惑「免疫」一些。

                                                                                                                          一项fMRI实验发现,当参与者被唤起自我扩展需求后,比如想象自己与伴侣共同成长时,他们大脑中与「吸引力感知」相关的区域,在面对有性吸引力的异性时,活跃度明显降低[10]。

                                                                                                                          这说明,自我扩展能通过改变大脑的神经反应,来抑制对潜在出轨对象的关注。

                                                                                                                          当我们在关系中获得了足够的自我扩展感,关系本身就会提供满满的「性张力」,外界的诱惑也会变得不那么「诱人」。倘如家里已经是满园春色、那又何必红杏出墙?

                                                                                                                          只有当我们在一段关系中,感到缺乏自我扩展时,才会对「拥有伴侣所不具备优点」的潜在对象记忆更深。毕竟说到底,成长是一种刚需,如果一段关系无法满足它,人们也很难不向外寻求替代。

                                                                                                                          图片来源:《回家的诱惑》

                                                                                                                          请和你的伴侣一起践行

                                                                                                                          「自我拓展实操指南」——

                                                                                                                          或许你会好奇,该怎么和伴侣好好进行一场自我拓展,其实只要满足这几点:

                                                                                                                          1.试试稍带不适感的新事物

                                                                                                                          并非所有「一起做的事」都能产生扩展效果。重复性的日常活动,比如一起看电影、去常去的餐厅,效果就一般般。只有那些包含「新颖性」和「适度挑战」的活动,才能激活自我扩展动机[2]。

                                                                                                                          关键在于「适度」——活动不应过于轻松以至于毫无挑战,也不应过于困难以至于引发挫败或焦虑。这种「恰到好处」的挑战感,才会点燃欲望的火花。

                                                                                                                          具体而言,可以尝试:

                                                                                                                          • 去一个并不熟悉的地方逛逛,不提前做详细攻略,而是说走就走

                                                                                                                          • 在性亲密中分享或实现一个未曾言说的幻想,或者尝试不同于以往的发起方式(具体不展开了)

                                                                                                                          • 参加一门你们俩都没尝试过的体验课,比如陶艺或者攀岩....

                                                                                                                          • 挑选持续性的更大型的活动,而非一次性的,那些需要长期共同投入、有明确目标的活动,往往能产生更深远的扩展效果。

                                                                                                                          图片来源:《绝望的主妇》

                                                                                                                          长时间的共同投入创造了一个独特的心理空间:你们不仅在积累共享的回忆,更在共同构建一个「正在进行时」的身份叙事。

                                                                                                                          当你们一起为一场徒步冒险坚持锻炼、一起学习一门新语言并坚持用这门语言进行日常对话、或者一起完成一个需要长期协作的公益项目时,你们实际上在共同创造一段有方向、有投入、有成长的「故事线」。

                                                                                                                          它将自我扩展的动机从「偶尔为之」转化为「融入日常」。此时,自我扩展感不再依赖于外部的新奇刺激,而是来源于共同的承诺和持续的成长。

                                                                                                                          2.共同拓展的同时,不妨加入一点单独拓展

                                                                                                                          并非所有的扩展都必须以「我们」为单位进行。支持彼此的个性发展,保持一点距离和一些做自己的空间,对维持欲望也非常重要。

                                                                                                                          因此,理想的模型并非「所有扩展都在一起」,而是形成一个动态的循环:

                                                                                                                          • 个人扩展:每个人在关系之外发展自己的兴趣、热情或爱好,获得新鲜的能量和视角

                                                                                                                          • 带入分享:将这些新鲜的体验带回关系中,与伴侣分享,邀请对方进入自己的新世界

                                                                                                                          • 关系扩展:个人扩展带来的能量最终转化为关系的共同财富

                                                                                                                          例如,一个人学习了心理学课程(个人扩展),他将新学到的沟通技巧用于改善与伴侣的互动,并邀请伴侣一起探讨那些让他深受触动的概念(关系扩展)。这个过程既满足了个体保持独立的需求,又不断为关系注入亲密感。

                                                                                                                          图片来源:《最完美的离婚》

                                                                                                                          最后,KY想说,在长期关系中,欲望消退再常见不过,但比重燃兴趣更重要的,其实是关系中成长的停滞甚至是退步。

                                                                                                                          愿每一对伴侣,都能在岁月的长河里牵手挑战全新的事物,不害怕改写过去的关系剧本。当自我扩展发生之时,也是欲望再临之际。

                                                                                                                          今日互动

                                                                                                                          你在关系中有过性欲消退的时候吗?

                                                                                                                          是怎么克服的?

                                                                                                                          References:

                                                                                                                          [1]Mattingly, B. A., & Lewandowski, G. W., Jr. (2014). Broadening horizons: Self-expansion in relational and non-relational contexts. Social and Personality Psychology Compass, 8(1), 30–40.

                                                                                                                          [2]Aron, A., Lewandowski, G. W., Jr., Branand, B., Mashek, D., & Aron, E. N. (2022). Self-expansion motivation and inclusion of others in self: An updated review. Journal of Social and Personal Relationships, 39(12), 3821–3852.

                                                                                                                          [3]Aron, A., & Aron, E. N. (1986). Love and the expansion of self: Understanding attraction and satisfaction. Hemisphere.

                                                                                                                          [4]Lehmiller, J. J. (2026, February 23). The proven secret to long-term passion. Psychology Today. https://www.psychologytoday.com/us/blog/the-myths-of-sex/202602/the-proven-secret-to-long-term-passion

                                                                                                                          [5]Ortigue, S., & Bianchi-Demicheli, F. (2010b). Désir sexuel inconscient: evidences en IRMf et EEG de la théorie de l’auto-expansion aux neurones miroirs [Unconscious sexual desire: fMRI and EEG evidences from self-expansion theory to mirror neurons]. Revue Médicale Suisse, 6(241), 620–622, 624.

                                                                                                                          [6]Perel, E. (2006). Mating in captivity: Unlocking erotic intelligence. HarperCollins.

                                                                                                                          [7]Goss, S. C., Raposo, S., Balzarini, R., Rosen, N. O., Benyamin, V., & Muise, A. (2022). Feeling close and seeing a partner in a new light: How self-expansion is associated with sexual desire. Journal of Social and Personal Relationships, 39(8), 2478–2506.

                                                                                                                          [8]Brown, B. (2012). Daring greatly: How the courage to be vulnerable transforms the way we live, love, parent, and lead. Gotham Books.

                                                                                                                          [9]Dhir, R., & G., V. K. (2021). Relationship between sexual fantasy, sexual communication, personality traits and sexual satisfaction in married individuals. Journal of Psychological Research, 3(3), 44–50.

                                                                                                                          [10]Raposo, S., & Muise, A. (2020). Manipulation of self-expansion alters responses to attractive alternative partners. Frontiers in Psychology, 11, 938.

                                                                                                                          本文关键词:性欲、自我拓展

                                                                                                                          欢迎大家在 KY 账号内搜索你需要的科普,如果没提到,也可以在文章下留言~

                                                                                                                          图片源自网络,侵权请联系

                                                                                                                          搜索文章丨心理测试丨招聘丨转载丨合作 请戳菜单栏

                                                                                                                          作者 / 淼淼

                                                                                                                          合作请联系:bd@knowyourself.cc

                                                                                                                          编辑 / KY主创们

                                                                                                                          我们同时提供专业的心理教练服务

                                                                                                                          欢迎使用知我心理小程序或知我心理APP

                                                                                                                          跳转微信打开

                                                                                                                          ❌