铃阅
❌

阅读视图

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

原创 罗西的思考 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 参考

                                                                                                                          阅读原文

                                                                                                                          跳转微信打开

                                                                                                                          •  

                                                                                                                          Haru-4B开源:边听边说的全双工语音模型,支持160多种语言,MacBook 延迟仅 65 毫秒

                                                                                                                          魔搭ModelScope社区 2026-11-16 17:30 浙江

                                                                                                                          Higurashi AI开源Haru-4B全双工语音模型,基于4000万小时真实语音训练,支持160+语言,MacBook延迟仅65毫秒。

                                                                                                                          Higurashi AI 开源了 4B 参数的 Haru-4B,这是一个能够同时听和说的全双工连续语音对话基础模型,无需等待用户说完再开始回应。模型从 4,000 万小时真实语音中学习附和、打断和话轮交替等对话行为,不依赖 LLM 或 TTS 生成的轮流发言式合成对话,训练数据覆盖 160 多种语言。Haru-4B 在 MacBook 上的端到端延迟约为 65 毫秒,并支持通过文本提示和参考音频控制角色人设、说话风格与声音特征。

                                                                                                                          比如,在下面的英语投资话题对话中,Haru 能结合用户的发言与上下文作出连贯回应,同时保持自然的对话节奏:

                                                                                                                          本次开源的权重包括 Haru-4B 预训练基础模型,以及配套的语音分离与修复模型 FastDialogueSidon。其中后者可将单声道混合对话录音重建为时间对齐的全双工语音流,为 Haru 的训练提供数据。
                                                                                                                          开源地址:
                                                                                                                          ● 语音对话模型 Haru-4B 

                                                                                                                          https://modelscope.cn/models/higurashi-ai/Haru-4B
                                                                                                                          ● 语音分离与修复模型 FastDialogueSidon 

                                                                                                                          https://modelscope.cn/models/higurashi-ai/FastDialogueSidon

                                                                                                                          体验链接:

                                                                                                                          https://modelscope.cn/studios/AI-ModelScope/Haru-4B

                                                                                                                          01

                                                                                                                          模型架构:7.5Hz 原生全双工

                                                                                                                          Haru-4B 基于 Qwen3.5-4B 构建,旨在通过一个统一的语言模型同时处理输入和输出语音。其架构结合了低频率连续音频表示、同步多流处理和高效的单步生成。
                                                                                                                          原生全双工多流建模。Haru 处理三条同步的数据流:用户输入音频、模型输出音频和模型文本。三条流的嵌入通过逐元素相加合并,再由共享语言模型处理。这让模型能够同时听和说,而不必将三条流按 token 逐个交错排列 [5][6]。与交错排列相比,这种方式可以将上下文长度缩减至三分之一,同时保持文本流连续。
                                                                                                                          语音对话的级联式、轮流发言式、交错式与多流建模:

                                                                                                                          7.5Hz 连续语音 token。大多数语音语言模型依赖离散音频 token,这些 token 通常通过残差向量量化(Residual Vector Quantization,RVQ) 生成,每个音频帧由多个离散码本索引表示。
                                                                                                                          相比之下,Haru 以仅 7.5Hz 的频率使用 64 维连续声学潜变量,每个 token 表示约 133 毫秒的语音。通过避开离散码本并采用较低的 token 频率,Haru 减少了训练和推理所需的 LLM 顺序建模步骤。
                                                                                                                          单步连续语音生成。Haru 在下一潜变量扩散(next-latent diffusion)框架中,使用轻量级多层感知机(Multi-Layer Perceptron,MLP),直接从语言模型的隐藏状态生成连续声学 token。
                                                                                                                          Haru主要使用流匹配(Flow Matching) 训练生成输出头,随后进行 MeanFlow 蒸馏 ,以提高训练和推理效率。在推理时,每个声学 token 只需一步采样即可生成,无需迭代流采样或额外的声学 Transformer。
                                                                                                                          离散式、迭代流采样式与单步连续语音生成:

                                                                                                                          分块级文本对齐。Haru 并不在单个 token 层面对齐文本和音频,而是将文本表示为块,后接填充位置和一个专用的填充结束 token,用于预测何时开始说话。这种方式能够适应文本与音频不同的时间分辨率,同时保持各条流之间同步,并减轻预训练语言模型知识的灾难性遗忘。
                                                                                                                          token 级与分块级文本对齐:

                                                                                                                          这些设计共同实现了高效的大规模语音预训练,同时将推理降至每秒仅 7.5 次自回归音频处理,使低延迟实时全双工互动即使在本地硬件上也具备实际可行性。

                                                                                                                          02

                                                                                                                          用 4000 万小时真实语音扩展预训练规模

                                                                                                                          Haru研究团队认为,大规模真实语音对学习自然互动的动态至关重要。与合成对话不同,真实录音包含自发的打断、犹豫、附和、重叠发言,以及不规则的话轮边界。
                                                                                                                          Haru-4B 使用超过 4000 万小时的语音进行预训练,覆盖 160 多种语言,其中九种为主要语言。为了学习自然的人类对话模式,Haru研究团队有意从训练数据混合中排除 LLM 生成的对话和 TTS 合成的语音。
                                                                                                                          整个预训练分为两个阶段。

                                                                                                                          阶段 1:单声道语音预训练

                                                                                                                          首先通过混合使用以下任务,让 Qwen3.5-4B 适配语音:

                                                                                                                          • 自动语音识别,将语音与语言表示联系起来。

                                                                                                                          • 语音与文本续写,学习连续语音的建模与生成。

                                                                                                                          • 纯文本复习训练,减轻预训练语言模型知识的灾难性遗忘。

                                                                                                                          阶段 2:全双工预训练

                                                                                                                          大规模长时全双工训练。使用超过 1300 万小时的、经过分离处理的全双工对话数据。训练样本包括最长达 60 分钟的对话,让模型能够学习长程对话动态,包括持续的话轮交替和重叠发言。
                                                                                                                          角色与声音条件控制。为每条训练样本生成一个角色提示,并使用同一说话人的参考音频作为语音生成的条件。这使 Haru 能够通过文本提示和参考音频控制角色个性与声音特征。

                                                                                                                          03

                                                                                                                          高效的大规模预训练与实时推理

                                                                                                                          3.1. 预处理与训练优化

                                                                                                                          加速语音预处理。处理如此大规模的语音需要大量计算资源。Haru 团队使用定制 Triton 内核,优化神经音频编解码器、Sidon 和 FastDialogueSidon 等预处理模型,以加速大规模数据准备。
                                                                                                                          大规模分布式训练。Haru-4B 使用 256 块 NVIDIA B200 GPU 进行预训练,耗时约 8 天。训练基础设施基于 Megatron-LM,并针对高效的大规模语音预训练进行了优化。

                                                                                                                          3.2. 实时推理优化

                                                                                                                          Apple Silicon 上的超低延迟推理。在搭载 Apple M1 Max 的 MacBook 上,原生 Swift 应用使用经过优化的定制 Metal 内核,实现了约 65 毫秒的端到端延迟。
                                                                                                                          该延迟包括声学编码、语言模型推理、音频解码,以及有线麦克风和耳机的输入输出,但不包括音频分帧。在 7.5Hz 的 token 频率下,音频分帧还会引入最多 133 毫秒的额外算法延迟。
                                                                                                                          以下为使用 int8 权重时的延迟明细:

                                                                                                                          阶段

                                                                                                                          延迟(int8)

                                                                                                                          输入(麦克风 → 应用)

                                                                                                                          5.3 ± 0.0 毫秒

                                                                                                                          一次模型处理

                                                                                                                          34.2 ± 0.5 毫秒

                                                                                                                          Socket 通信与交接

                                                                                                                          4.1 ± 0.3 毫秒

                                                                                                                          输出等待(15 毫秒余量及调度裕量)

                                                                                                                          13.3 ± 1.5 毫秒

                                                                                                                          输出(应用 → 耳机)

                                                                                                                          8.1 ± 0.2 毫秒

                                                                                                                          总计(p50)

                                                                                                                          65.2 ± 1.5 毫秒

                                                                                                                          高性能 GPU 服务。支持通过 vLLM-Omni 在 GPU 上部署。在 NVIDIA B300 GPU 上,音频编码、解码与一次语言模型处理合计约需 15 毫秒。

                                                                                                                          04

                                                                                                                          本地部署与推理

                                                                                                                          Haru-4B 提供 PyTorch、Apple Silicon 上的 MLX,以及 vLLM-Omni 插件三种推理实现,共用同一份模型权重。PyTorch 演示需要约 12 GB 显存的 NVIDIA GPU;MLX 需要 Apple Silicon Mac、macOS 13 或更新版本,建议至少准备 16 GB 内存。

                                                                                                                          下载模型与代码

                                                                                                                          pip install modelscope

                                                                                                                          modelscope download higurashi-ai/Haru-4B \

                                                                                                                            --local-dir higurashi-ai/Haru-4B

                                                                                                                          git clone https://github.com/higurashi-ai/Haru.git

                                                                                                                          以下命令均从当前工作目录执行,按设备选择一种实现即可。

                                                                                                                          PyTorch:网页语音对话

                                                                                                                          创建环境、安装依赖,并加载本地模型:

                                                                                                                          python3 -m venv Haru/.venv

                                                                                                                          source Haru/.venv/bin/activate

                                                                                                                          pip install -e ./Haru/haru

                                                                                                                          python -m haru.server \

                                                                                                                            --model ./higurashi-ai/Haru-4B \

                                                                                                                            --device cuda \

                                                                                                                            --language zh \

                                                                                                                            --port 8998

                                                                                                                          浏览器打开以下地址,允许麦克风访问,选择角色并上传参考声音,即可开始对话:

                                                                                                                          MLX:Mac 本地语音对话

                                                                                                                          需要 Python 3.10 或更新版本及 Apple Command Line Tools;未安装开发工具时,先执行 xcode-select --install。
                                                                                                                          安装 MLX 实现,构建原生客户端,并启动本地模型服务:

                                                                                                                          python3 -m venv Haru/haru_mlx/.venv

                                                                                                                          source Haru/haru_mlx/.venv/bin/activate

                                                                                                                          pip install -e ./Haru/haru_mlx

                                                                                                                          (cd Haru/haru_mlx/swift && ./build_app.sh)

                                                                                                                          python -m haru_mlx.native \

                                                                                                                            --model ./higurashi-ai/Haru-4B \

                                                                                                                            --language zh \

                                                                                                                            --quantize 8

                                                                                                                          --quantize 8 对语言模型主干进行 8 位量化。另开终端,在同一工作目录运行客户端,voice.wav 为准备好的参考声音:

                                                                                                                          ./Haru/haru_mlx/swift/.build/haru-client \

                                                                                                                            --voice "$PWD/voice.wav"

                                                                                                                          vLLM-Omni:并发语音服务

                                                                                                                          使用独立环境,安装指定版本与 Haru 插件:

                                                                                                                          python3 -m venv Haru/.venv-omni

                                                                                                                          source Haru/.venv-omni/bin/activate

                                                                                                                          pip install vllm==0.32.0 vllm-omni==0.32.0

                                                                                                                          pip install -e ./Haru/haru -e ./Haru/haru_vllm

                                                                                                                          vllm serve ./higurashi-ai/Haru-4B \

                                                                                                                            --omni \

                                                                                                                            --deploy-config "$(python -m haru_vllm.deploy)" \

                                                                                                                            --host 127.0.0.1 \

                                                                                                                            --port 8000

                                                                                                                          另开终端,将网页演示连接到 vLLM-Omni 服务:

                                                                                                                          source Haru/.venv-omni/bin/activate

                                                                                                                          python -m haru.server \

                                                                                                                            --backend vllm \

                                                                                                                            --vllm-url http://localhost:8000 \

                                                                                                                            --language zh \

                                                                                                                            --port 8998

                                                                                                                          浏览器同样访问 http://localhost:8998\。该后端使用实时全双工 WebSocket 协议,不是普通 Chat Completions 接口。
                                                                                                                          三种方式均需自行准备具有使用授权的参考声音,建议使用单人、清晰的 WAV 音频,时长为 3 秒至 3 分钟。使用有线耳机和麦克风可减少设备延迟与回声。

                                                                                                                          点击阅读原文,即可跳转模型链接~


                                                                                                                          👇点击关注ModelScope公众号获取

                                                                                                                          更多技术信息~

                                                                                                                          阅读原文

                                                                                                                          跳转微信打开

                                                                                                                          •  

                                                                                                                          AI4S青年志②丨赋澈生物王子龙:实验室里的「企业家」

                                                                                                                          原创 周蕾 2026-11-16 19:38 广东

                                                                                                                          同时拥有理工科训练、结构生物学功底,和系统商科思维的创业者,在AI4S领域里并不常见。

                                                                                                                              作者丨周蕾

                                                                                                                              编辑丨岑峰

                                                                                                                                                                                                                                 

                                                                                                                          【编者按】AI4S有时给人“雷声大雨点小”之感,是因为不少人把AI当成了目的本身,拿着锤子满世界找钉子,对科研周期与商业回报的错配却无知无觉。“AI4S青年志”第二篇,我们关注一个可能破解AI4S落地困局的样本。

                                                                                                                          一篇论文,通常只需要2-4位审稿人。

                                                                                                                          但当《Nature Biotechnology》的编辑们打开一篇来自加州大学伯克利分校的投稿时,他们很快意识到,2-4位远远不够。为了覆盖这篇论文涉及的每一个学科,编辑们前后邀请的审稿人数量已经来到了两位数。

                                                                                                                          论文横跨四个领域:合成生物学、材料科学、计算化学,以及技术经济学与碳排放核算。审稿人们上来就说:他们只能看懂属于自己的那一部分,无法对其他部分做出评价。

                                                                                                                          学术论文通常像一辆概念车,但这篇论文,却被以量产车的标准来严苛审视。例如论文已经在实验室里证明,生物反应器中,新型塑料单体的滴度达到了1.84克每升——这是一个符合学术发表标准的数字。但一位材料学背景的审稿人直接追问:“如果这个平台要走向产业化,至少要让我看到几十克每升的可能性。”

                                                                                                                          这些质疑,同时关乎科学和商业。而回应它的人,需要同时听懂四种语言。

                                                                                                                          最终,四个不同领域的专家全部认可了这篇论文,编辑也点了头,论文在今年夏天成功刊发。这篇论文的署名栏里,第一作者只有一个名字:王子龙。

                                                                                                                          在AI for Science的创业浪潮里,跨学科背景并不稀奇。计算机出身的人去学材料,化学出身的人去写代码,这样的故事比比皆是。

                                                                                                                          但像王子龙这样,同时拥有扎实的理工科训练、结构生物学的底层功底,以及从本科阶段就开始的系统商科思维,并且能把这一切翻译成彼此能听懂的语言——这种人在AI4S创业者中,并不常见。

                                                                                                                          借着论文刊发的机会,我们和王子龙完成了一次两个多小时的越洋连线,从中山大学逸仙班的经济学课堂聊到Jay Keasling的实验室,从主动拒绝创业风口聊到放弃教职、投身产业,试图还原这位AI4S青年科学家,在他过去二十年里的每一次关键选择。

                                                                                                                          01

                                                                                                                          像“爱迪生”的底色

                                                                                                                          王子龙儿时的梦想,是成为爱迪生那样的科学家。长大后他意识到,原来爱迪生不光是科学家,同时也是一名商人,而他恰好也将自己培养出了科学家+企业家的双重能力结构。

                                                                                                                          这种能力结构的雏形,最早要追溯到本科时期。王子龙所就读的中大逸仙班,准入门槛极高,采用多学科混合培养的方式,除了数物化生的理工科内容,还有专门开设的经济学课程,由岭南学院的教授整套授课。加之出生于经商家庭,从事零售和分销,王子龙对商业实践已有着十几年的认知。

                                                                                                                          逸仙班的课业负担不轻,但当时的多学科培养,尤其是经济学方面的训练,直到今天仍然在为他的商业工作带来极大的帮助。一方面经济学带给他反直觉的思维和理论,帮助他避免踩坑;另一方面,这套训练也为一位纯科学家在做商业谈判、市场判断时,提供了底气。

                                                                                                                          “基本的商业逻辑、经济逻辑我们都清楚,对外融资、谈合作的时候,精神面貌是不一样的。”

                                                                                                                          2011年,中山大学首次参加MIT创办的iGEM(国际基因工程机器大赛),正在读大三、准备出国留学的王子龙,正是当时参赛的领队和对外主讲人。队伍最终闯入了全球决赛。在MIT的讲台上,他要用英语向评委解释团队的成果;回到实验室,他又得和队友一起解决具体的科学问题。

                                                                                                                          这个比赛最终帮他敲开了合成生物学认知的大门。也是在这个时期,他读到了一篇经典论文:用大肠杆菌和酵母菌全合成青蒿素前体。屠呦呦当年发现的青蒿素,在合成生物学的方法下,得以实现低成本、大规模的生产。而这位论文的作者Jay Keasling,后来成为了他在伯克利的导师。

                                                                                                                          “我们可以改造自然界的微生物,让它们为人类所用,实现不同的功能。”

                                                                                                                          合成生物学最底层的定义,是让每个基因的设计模块化,“像拼乐高一样拼基因,拼出不同的形态和功能。”王子龙被合成生物学深深吸引,但他并没有直接沿着这条道路走下去。

                                                                                                                          在他看来,生物学的细分学科里,有些是不可迁移的“课题”,有些是可迁移的“工具”。例如植物学就属于课题型学科,“一旦选定分子植物学或植物分类学的方向,往外的延展就会变窄”。

                                                                                                                          而结构生物学属于后者。它研究的是蛋白质的三维结构,但掌握这门手艺的人,几乎可以进入任何生物科技方向——因为所有生命活动的最终执行者都是蛋白质。工具型学科偏基础,有很强的技术壁垒,但后期可以衍生出很多分支。

                                                                                                                          他甚至用免疫学试探过另一种可能——本科毕业论文专门做了这个方向,免疫学课程成绩全年级第一,也在一位知名教授的实验室里完成了毕业论文。但多方对比之后,他还是回到了合成生物学,因为它兼具工具和课题的双重属性。

                                                                                                                          这也是为什么他在博士阶段选择放下合成生物学、转向结构生物学。当时的他,意识到一个关键问题:由于对蛋白质缺乏足够的了解,导致做基因工程时经常得不到预想的结果。

                                                                                                                          探究蛋白质,也就成了他心里的一个执念:“我一定要完全掌握这块知识。”

                                                                                                                          王子龙告诉我们,当年即便是顺着免疫学的道路往下走,博士阶段大概率还是会做结构生物学,因为生物代谢的调控最终仍然与蛋白酶有关。

                                                                                                                          “如果博士后阶段可能就会做制药相关,再赶上AlphaFold这一波,那我创立的公司可能就不是做AI for materials,而是AI for drug discovery了。”王子龙笑道。

                                                                                                                          02

                                                                                                                          实验室里的商人

                                                                                                                          王子龙还在新加坡国立大学做结构生物学时,恰逢Jay Keasling来校做学术报告。

                                                                                                                          他当时的博士实验室小而专精,解析蛋白质结构效率太慢,“跟不上时代的需求”。他把这个顾虑抛给Keasling教授,得到的回答却是:这完全不是问题,我们机构有全套高通量设备、昂贵的全自动化机器和专业的合作者,做得特别快。

                                                                                                                          他与Keasling教授就此结缘,但在他去伯克利面试加入Keasling实验室前,还发生了一个小插曲:

                                                                                                                          Paul Adams曾任劳伦斯伯克利国家实验室结构生物学中心的主任,也是David Baker那篇RoseTTAFold蛋白质结构预测的诺贝尔奖级核心论文的共同通讯作者之一。他专程来找王子龙,问他愿不愿意继续跟自己一起做结构生物学。

                                                                                                                          在Adams麾下做博后,同样也是一条金光大道,但王子龙还是选择了合成生物学。

                                                                                                                          从左至右分别为:Seokjung Cheong, Jay Keasling, 王子龙

                                                                                                                          Keasling实验室强手如云,但他的选人逻辑并不强调出身。伯克利本身就是名校,发过Nature、Science正刊的申请者比比皆是,但这些在Keasling眼里只是参考因素。他真正在意的,是专业能力是否匹配实验室的课题发展。

                                                                                                                          王子龙博士期间因为结构生物学研究周期长,主要课题当时都尚未发表,但他的技能组合恰好是实验室需要的那一类。加上博士导师和几位教授的推荐,他顺利加入了实验室,接手了那个后来成为AI4S标杆的课题。

                                                                                                                          “运气好。”他用这三个字来概括这段经历,“如果我晚进去半年,这个课题未必是我的了。”

                                                                                                                          在Keasling实验室,王子龙很快证明了自己的价值。

                                                                                                                          实验室常年保持四十人以上的规模,博士后来自不同领域,各自带着不同的技能。王子龙因为结构生物学的底子,经常能帮别人解决技术问题。他拿过实验室的两个奖:一个是Best Lab Citizen,由全体成员投票选出,表彰在实验室运转和维护中贡献突出的人;另一个是Best Helper,得票必须超过其他人,意味着他在大量同事的课题中都伸过手。

                                                                                                                          在四十多人的实验室里习惯了帮别人解决问题,之后再面对四个实验室的联合项目时,他也没有觉得陌生。

                                                                                                                          那篇横跨四个学科的Nature Biotechnology论文,正是在这样的环境里长出来的。合成生物学、材料科学、计算化学,以及技术经济学与碳排放核算,四个伯克利顶级实验室联合完成,论文各部分比重均匀,各占四分之一。王子龙是唯一的第一作者,Keasling是唯一的通讯作者。

                                                                                                                          他的工作不只是做实验。作为项目的管理者,他每周要跟四个实验室的博士后开会,还要跟教授同步进度。每三个月,则要向美国能源部做一次大型汇报,写季度报告汇报项目进展和资金使用情况。

                                                                                                                          这套流程跟开公司已经很像了。

                                                                                                                          其实在进Keasling实验室的第一天,王子龙就跟教授表达了自己要走商业这条路。在这个实验室里,创业并不是什么稀奇事,平均每年都有一到两个成员出去创业,拿到不错的融资结果。Keasling还会问每个人的职业规划,从一开始就划分好了谁偏商业、谁偏学术,给不同的培养方针,他的学生也因此遍布产业界。

                                                                                                                          回过头看这几年的行业趋势,2021年出来创业其实正是时候。当年合成生物学在国内正火热,估值高得惊人,好几家公司也特地飞去美国找到王子龙,劝他立马创业。

                                                                                                                          但他拒绝了。手上的项目没做完,即便对方确实认可他们的技术,但他还是觉得风险太大,贸然创业是不负责任的表现。

                                                                                                                          “2021年创业的话,拿融资要简单得多。”王子龙回忆,“我们2024年融资的时候,早就错过那个风口了,真的得靠真枪实战的能力。”

                                                                                                                          多年的科研经历,给他带来一种“有问题就解决问题”的思维。人长期处于认知问题和解决问题的循环中,这种思维一旦形成,就很难被轻易击垮。“问题本身不会把人击倒。如果真的有爬不过去的坎,就绕过去,办法总是有的。”

                                                                                                                          “因为我们已经被科学鞭打了无数次。每一个科学论文成功的背后,都有大量的失败。是无数的失败经验,推举出一两个成功的结论。”他后来这样总结。经历过大量失败才诞生的成功,让他和他的合伙人有了一种不太一样的心态:面对短期性的挫折和困难,他们有足够的承受能力。

                                                                                                                          这种韧性,最终让他在错过风口之后,依然能够靠真枪实战的能力,开始着手组建自己的团队。

                                                                                                                          03

                                                                                                                           “有利可图”的环保

                                                                                                                          王子龙提到的,那位同样具有韧性的合伙人,叫做Seokjung Cheong。2024年,两人一同从Keasling实验室结束博士后工作。比起申请一个体面的教职,他们选择把手里做了四五年的课题推向市场,创办了赋澈生物(FutureBio)。

                                                                                                                          拒绝了2021年的创业风口,他们面对的,是三年后已经冷静许多的市场。

                                                                                                                          Seokjung成了公司的CTO,他和王子龙在Keasling实验室共事多年,一起做了那篇Nature Biotechnology论文。两人的分工天然互补:王子龙的表达能力更胜一筹,就专门对外,负责融资、商业合作和公司宣传;Seokjung做事细致严谨,正适合对内,主抓技术和团队管理。

                                                                                                                          从左至右为:研究员,Seokjung Cheong, 王子龙

                                                                                                                          搭起核心团队后,王子龙开始寻找在工业化生产上有经验的人。他翻遍了Keasling实验室以前师兄师姐的名单,找到了凯赛生物的前研发副总裁Howard Chou。

                                                                                                                          这样一位在中国合成生物学领域大规模制造有过丰富经验的前辈,正是FutureBio需要的。可Howard从凯赛出来后,全国找他做联合创始人、做顾问的人实在太多。而Keasling的一封介绍信,让双方很快确认了彼此的能力。

                                                                                                                          王子龙回忆起双方的第一次见面,就是在Howard深圳先进院的办公室,完全没有陌生人的隔阂,两句话就拉近了所有关系。

                                                                                                                          Howard给FutureBio的建议非常具体。很多生物制造公司早期为了让数据好看,会用各种手段做出很高的产量,但成本不一定合适。大家的思路是先达到高产,之后再慢慢优化成本。但Howard告诉他们,从公司第一天起,生物制造就要对标工业大规模生产的口径和参数。

                                                                                                                          照这个思路,FutureBio在美国用的发酵培养基,直接拿的是全球最大的玉米原浆提供商之一ADM的玉米浆。如果一开始所有参数对标工业制造,做的每一分努力就都可以直接转化到工业制造上。未来达到高产之后,不需要再回头优化成本。

                                                                                                                          而Keasling教授现在是FutureBio的官方首席顾问,双方保持着固定的顾问会议。在融资时,他的背书起了关键作用。他参与过投资人访谈,回答关于王子龙能力和性格的问题,也帮忙对接过一些投资人和业内的知名学者。对一家从实验室走出来的初创公司来说,导师的人脉网络在早期阶段是一种无形的支撑。

                                                                                                                          除了Keasling的关系,王子龙还十分偶然地,从另一位前辈那里获得了关键支持:晶泰科技的董事长温书豪。

                                                                                                                          在一次饭局上,温书豪问王子龙,“能不能用两分钟讲讲公司做什么?”听完王子龙的讲述,温书豪当即邀请他第二天去晶泰做路演。晶泰的三位创始人都参与此次路演,最终拍板决定参与FutureBio的融资。

                                                                                                                          2025年初,FutureBio完成天使轮融资,耀途资本领投,险峰长青、晶泰科技等跟投。数百万美元的金额不算太高,但足够让王子龙按照自己的想法,把基础扎实的事情一步一步做好。

                                                                                                                          不过,王子龙对公司的定位,从一开始就和很多环保材料公司不一样。

                                                                                                                          “大家都说环保,但环保往往意味着成本更高。”FutureBio的选择是兼顾,并在兼顾的基础上更在乎商业侧。“政策驱动是靠罚款、补贴和奖励来推广,但经济形势不好、补贴下降时,大家的意愿立刻下降。”

                                                                                                                          在他看来,如果真正想把环保做好,一定要从技术层面解决:让环保这件事“有利可图”,让整个商业链条里的人都能self-motivation。因此,FutureBio的材料有着高循环效率、低循环成本的特性,长期使用成本会逐渐下降。

                                                                                                                          04

                                                                                                                          AI4S的边界

                                                                                                                          这种让环保“有利可图”的商业判断,也塑造了王子龙对AI for Science的理解。

                                                                                                                          在他看来,很多公司的问题在于,AI被当成了目的本身,而不是工具;上来就讲要做AI for Science,实则是缺乏核心支撑力的表现。“比如我们,是平台开发了这款材料,材料支撑公司的实体运转,在拓宽的过程中不断优化模型。不然一开始烧几亿、几十亿,烧完了什么都没有。”

                                                                                                                          他回忆起在Keasling实验室做课题时的一次亲身经历:那篇Nature Biotechnology论文里,团队一开始跟当时很多AI4S公司一样,用计算模拟数据搭了一套模型。但把材料做出来之后发现,模型对材料性能的预测完全不对,跟真实数据不匹配。

                                                                                                                          他们没有把错的模型藏起来,而是把真实数据放回模型去研究哪里出了问题,通过模型和材料之间的相互优化,找到了改进的方法。最终,他们把一开始那个错的模型也放进了论文里。

                                                                                                                          在学术界,这种把错误公开的做法并不常见。但这篇论文的特殊之处在于,它打通了整个平台模型和闭环,证明了计算预测可以被生产制造验证,还能不断循环迭代——这是AI for Science具备可落地性的证明。

                                                                                                                          在王子龙看来,AI for Science的瓶颈早已不是算法;数据的生成,比模型和算法本身,更具有底座的意义。

                                                                                                                          做实验的数据量太小,真正训练AI对数据体量的要求却非常大,这就很强调数据生成能力——能不能更快、更高通量?在伯克利期间,他们其实已经能做高通量的分子生成和蛋白质酶的设计。现在则专注于打通特定分子的量产,保证生产制造能力,再接入高通量,形成一个既快又能制造的平台。

                                                                                                                          “2022年AI刚爆发时,大家就有一个共识:这里最有价值的商品是数据。AlphaFold之所以能出现,是因为结构生物学领域在同样的数据模式和口径下,积累了超过二十年的数据,而其他很多科学领域没有这个条件。不存在只有一家公司能训练出来的模型,你总能找到竞品。谁真正掌握能被AI读取的数据,谁就掌握了AI for Science最底层的金币。”

                                                                                                                          但只有数据本身,还不够。很多运转了几十年的大公司,论数据积累,其优势自然不是小公司可比,但大公司们也不见得都做出了模型。

                                                                                                                          原因之一是古早的数据现在的AI读不了,需要专门的数据接口;另一个原因是实验数据来得太慢、太贵,不足以支撑模型训练。

                                                                                                                          FutureBio的解法,是用一套可扩展的生物制造平台来持续生成数据。这种平台特性在论文中有直接体现:团队用工程化聚酮合酶(PKS)作为“分子装配线”,通过替换其中的蛋白质模块,同一套生物发酵系统就能生产出结构不同的塑料单体。

                                                                                                                          论文里展示了10种这样的PKS产物变体,它们共享同一套发酵路径,就像一条汽车生产线,更换机械臂上的工具头就能加工不同型号的零件,底盘、质检和物流流程则无需改变。这意味着,优化一次菌株产率或发酵条件,所有产品都能同时受益。

                                                                                                                          他提到,FutureBio发展到现在,用的是工业培养基,成本已经降了下来,可以低成本地大量生产材料,获得真实世界的数据。相比那些每设计一种新化合物、都要重新开发合成路线,纯粹用化学手段合成材料的公司,FutureBio在数据生成效率上具有天然优势,也真正跑通过“设计-制造-验证”这一环,对于闭环里的关键节点,有独到的经验。

                                                                                                                          对于今年颇受关注的AI for Science,王子龙也给出了相对冷静的判断。

                                                                                                                          第一,AI的价值是预测的精准度,要给AI真实世界的物理反馈。

                                                                                                                          “大语言模型之所以做得好,是因为除了网上原有的信息,那么多用户每天跟它交流,它是一个每天都获得真实世界物理反馈的系统。做AI for Science也一样,而且物理反馈很讲究策略:不是什么反馈都行,要了解AI需要什么、希望这个AI干什么。”

                                                                                                                          第二,始终要知道边界在哪里。

                                                                                                                          FutureBio做聚合物,目标就是建立聚合物材料的通用大模型。但他们清楚地知道自己一开始的知识边界和技术边界在哪里,在边界内可以做得精确可靠,再慢慢拓宽;而拓宽需要的知识体系、数据、验证方法,这些都要提前规划好。

                                                                                                                          “留给自己想的时间,一定要比决策和操作的时间多。三思而后行,很多事情没想清楚就做,就是浪费资源。”

                                                                                                                          这不是王子龙一个人的节奏,而是他整个团队的节奏。在新加坡读博时的他,007的工作节奏是常态,但现在他给下面的项目负责人定了一条规矩:每天留至少百分之二十的时间思考。

                                                                                                                          团队即便坐在那里不干活,他依然发薪,因为他知道这些人肯定在想工作——做科学做到博士后的人,脑子里从来停不下来。

                                                                                                                          既要停下来想,也要跨出去做,这两种能力,其实来自同一个源头。

                                                                                                                          从逸仙班多学科混合培养,到“旁逸斜出”研读结构生物学,再到Keasling实验室的交叉合作,每一次选择,王子龙都在拓展自己能翻译的语言。那篇论文的审稿人们,大概不会想到,这个能同时回应四个领域质疑的博士后,其实在二十年前就开始为这一刻做准备,通过一次又一次看似绕远的路,最终抵达他选定的目的地。

                                                                                                                          在AI4S这个人人都在谈交叉的领域,王子龙仍然特殊。而那些看似绕远的路,最终都成了他脚下最扎实的地基。

                                                                                                                          //

                                                                                                                          推荐阅读

                                                                                                                          未经「AI科技评论」授权,严禁以任何方式在网页、论坛、社区进行转载!

                                                                                                                          公众号转载请先在「AI科技评论」后台留言取得授权,转载时需标注来源并插入本公众号名片。

                                                                                                                          阅读原文

                                                                                                                          跳转微信打开

                                                                                                                          •  

                                                                                                                          多媒体检索到智能体协作,一家中国公司两项议题入选ACM MM 2026

                                                                                                                          AI科技评论 2026-11-16 19:38 广东

                                                                                                                          让 AI Agent 找网红、谈合作、监测内容:自动化营销实践进入学术视野。

                                                                                                                          让 AI Agent 找网红、谈合作、监测内容:一套自动化营销实践如何进入学术视野。

                                                                                                                              编辑丨李希

                                                                                                                                                                                                                                 

                                                                                                                          11月10日到14日,第34届ACM国际多媒体会议(ACM MM 2026)在巴西里约热内卢举行。ACM MM是由国际计算机协会(ACM),创办于1993年的多媒体研究、创新与应用领域的顶级学术会议,被中国计算机学会(CCF)推荐为计算机图形学与多媒体领域的A类国际学术会议。会议创办以来第一次在南美举行。

                                                                                                                          ToucHigh是深圳链帮科技有限公司旗下品牌,首席执行官(CEO)赵奎先生的一项与其有关的产业论题入选了本届ACM MM的产业专家报告(Industry Expert Talk)议程。这场报告的题目是《ToucHigh.ai:面向AI网红营销的智能体架构——以多媒体检索为核心的方法》(英文原题:ToucHigh.ai: Agentic Architectures for Al Influencer Marketing - A Multimedia Retrieval-Centric Approach)。

                                                                                                                          图1ACM MM 2026论文集目录中该议题的收录及页码信息

                                                                                                                          此次入选的报告摘要收录在ACM MM 2026论文集中,讲清了三件事:这套架构为什么属于多媒体检索、九个智能体怎么分工,以及落地之后拿到了哪些结果。

                                                                                                                          01

                                                                                                                          把网红营销当成一道检索题

                                                                                                                          智能体AI把检索、决策、执行串成持续闭环,正在改写工作流自动化的做法。在AI驱动的网红营销平台里,创作者发掘、营销活动策划这类核心业务,都可以建模成信息检索问题,涉及语义匹配、排序,以及由反馈驱动的自适应。报告介绍的,就是ToucHigh的一套已经落地的多智能体架构,它把营销执行重构成一条以检索为核心的流水线。

                                                                                                                          图2 ToucHigh高级产品经理Carl Cheung先生报告中

                                                                                                                          网红营销这条链路本来就是多模态的。创作者交上来的东西有字幕、语音转写、缩略图,还有互动信号,散落在Instagram、YouTube和TikTok上。这个多智能体架构平台把创作者近期发的文案,和30多个由AI推断出来的语义概念标签拼在一起,编码成768维的多语言向量,检索时比的是概念意图,而不只是靠关键词字面匹配。

                                                                                                                          下游还挂着一个监控智能体,用多模态NLP去核对已经发出去的视频里有没有真的提到品牌。检索和分析两头,都落在多媒体研究关注的问题上。

                                                                                                                          02

                                                                                                                          九个智能体,一条检索流水线

                                                                                                                          这个系统里一共九个专用智能体,通过一套轻量的MCP(Model Context Protocol)协议,在一个共享blackboard上协作,异步、有状态地执行。

                                                                                                                          发现智能体(Discovery Agent)先把品牌简报改写成稠密检索的查询,在20万份以上创作者档案建成的HNSW索引上做k-NN向量检索,用余弦相似度算距离。匹配智能体(Matching Agent)接手重排,充当cross-encoder,按语义相似度、受众人口特征的重合度、真实性三项加权打分。

                                                                                                                          图3 ToucHigh的首席科学官Aleks Farseev(左)和高级产品经理Carl Cheung(右)

                                                                                                                          再往后是外联和议价智能体(Outreach和Negotiation Agents),用检索增强生成(RAG)写出超个性化的合作邀约,议价过程交给状态机推进。

                                                                                                                          ToucHigh表明,这套多智能体架构的核心贡献是把网红营销从找人一直到发邀约,重新定义成一道以检索为中心的题目。而且这些智能体是补充人的专业判断,不是替掉人。分工也照着这个来:AI负责能规模化的“找”(find),人负责带语境判断的“投”(fund),品牌用什么调子说话、创意往哪走,始终由人把关。

                                                                                                                          03

                                                                                                                          报告披露的几组数字

                                                                                                                          和传统人工流程相比,这套已经落地的流水线把从简报生成到首次触达的时间缩短了85%,从5.2天压到0.8天;由大模型写的超个性化消息,让创作者回复率提高了54%;合同完成时间缩短68%。

                                                                                                                          变化最明显的是人手。单个营销人员每月能管的活动数量涨到原来的12倍,工作满意度提高了48%。这套做法给创意和数字营销行业提供了一份可以规模化的模板。

                                                                                                                          04

                                                                                                                          做出这套方法的ToucHigh

                                                                                                                          ToucHigh是深圳链帮科技有限公司旗下的品牌,主营AI海外社媒营销业务。自有数据模型和算力,能够系统梳理海外竞品的营销动作、内容形态和市场占比,为客户产出专属的、有针对性的社媒方案;拥有AI批量生成符合品牌调性的、切合空白话题的创意内容,支持Facebook、Instagram、LinkedIn等多渠道投放与数据效果预测、监控,重点关注品牌在AI搜索可见度方面的提升等。

                                                                                                                          ToucHigh品牌背后有三位灵魂人物,拥有为全球各大品牌定制AI营销技术的十余年丰富经验,他们同时也是ToucHigh的共同创始人:

                                                                                                                          图4左:Aleks Farseev;中:赵奎;右:Kirill Lepikhin

                                                                                                                          首席执行官赵奎,AI研究者与连续创业者,研究成果发表于ACM SIGIR、ACM MM等会议。首席科学官Aleks Farseev,新加坡国立大学AI博士,欧洲工商管理学院教授,福布斯科技理事会专栏作家,Gartner Cool Vendor入选者,发表过30多篇学术论文。首席技术官Kirill Lepikhin,AI营销技术专家,主导ToucHigh的全部自动化工程,已发表6篇AI营销方向的会议论文,2017年起任SOMIN联合创始人兼CTO。

                                                                                                                          ToucHigh,正是三位创始人营销技术经验和科研成果共同积淀,与中国品牌海外营销现实需求的碰之制作。

                                                                                                                          05

                                                                                                                          全球仅入选7场,ToucHigh得占其一

                                                                                                                          产业专家报告历来是ACM MM中入选场数较少的议程,2024、2025年全球分别入选8场、11场,而本届全球入选仅7场。历来的入选者均是先进领域中具有前沿技术研究的科研人员、科技从业者或行业领袖,该议程聚焦于分享产品或项目在某个方面的痛点及其解决办法、具体解决措施,而非已交付的项目。ToucHigh此议题能成功入选,靠的就是把方法和数据摊开给人查,而不靠曾经服务过哪些大品牌。

                                                                                                                          图5ACM MM 2026论文集目录中ToucHigh另一入选课题的收录及页码信息

                                                                                                                          此外,ToucHigh的另一科研论题《ToucHigh.ai:从包裹受损到根因定位——专家可审核的智能体多模态诊断方法》也成功入选ACM MM 2026现场演示议程。据本届会议揭示,共有9200名审稿人参与会议投稿论文评审,前后写了28750份评审意见,即每篇进入外审的论文至少分到三份评审意见;而主赛道8273份投稿里,同时通过初审与外审的仅1703篇,按送审稿算录用率为23.9%。作为multimedia领域最权威的顶尖学术会议,ACM MM入会论文的审核要求严格。

                                                                                                                          ToucHigh两项论题入选ACM MM,得到全球顶尖学术会议对其技术的充分认可,体现其学术成果落地商业领域的巨大潜力。

                                                                                                                          参考文献:

                                                                                                                          1.《ToucHigh.ai:面向AI网红营销的智能体架构——以多媒体检索为核心的方法》英文原文议题信息:https://dl.acm.org/doi/10.1145/3767308.3839056 

                                                                                                                          2.《ToucHigh.ai:从包裹受损到根因定位——专家可审核的智能体多模态诊断方法》英文原文议题信息:https://dl.acm.org/doi/10.1145/3767308.3839014 

                                                                                                                          3. 国际多媒体会议(ACM MM)官网:https://acmmm.org/

                                                                                                                          4. 国际计算机协会(ACM)官网:https://www.acm.org/

                                                                                                                          5. 中国计算机学会(CCF)官网:https://www.ccf.org.cn/

                                                                                                                          6.《第七版〈中国计算机学会推荐国际学术会议和期刊目录〉正式发布》,中国计算机学会官网,2026年3月31日:https://www.ccf.org.cn/Academic_Evaluation/By_category/

                                                                                                                          7. ACM MM 2026论文集: https://dl.acm.org/doi/proceedings/10.1145/3767308

                                                                                                                          8. ACM MM 2026官网:https://2026.acmmm.org/

                                                                                                                          9. ACM Digital Library官网:https://dl.acm.org/

                                                                                                                          10. ACM MM 2026全会议程:https://2026.acmmm.org/site/ACMMM2026_Glance_Programme.pdf

                                                                                                                          11. ACM MM 2025产业论坛手册:https://acmmm2025.org/industry-program/

                                                                                                                          12. ACM MM 2024全会议程:https://2024.acmmm.org/full-program

                                                                                                                          13. ToucHigh微信官方公众号文章《热烈祝贺!ToucHigh两大科研论题入选2026 ACM国际多媒体会议!》:https://mp.weixin.qq.com/s/OYBRdP8Tk6GTa1121mf6xw

                                                                                                                          ACM MM 正在召开,欢迎参会的研究者、学生,以及关注 AI 前沿进展的读者加入我们的交流群。

                                                                                                                          在这里,你可以认识同行、交流研究,分享招生信息、科研合作、约饭、投稿、组队参会等,寻找潜在的合作伙伴。

                                                                                                                          大会期间,我们也会持续带来现场报道速递、嘉宾演讲解读、前沿方向梳理和论坛精华。

                                                                                                                          会场见,也在群里见。

                                                                                                                          📌 进群传送门: 扫码进群或添加微信A17648278904,备注:ACMMM+单位/学校+姓名+方向。

                                                                                                                          //

                                                                                                                          推荐阅读

                                                                                                                          未经「AI科技评论」授权,严禁以任何方式在网页、论坛、社区进行转载!

                                                                                                                          公众号转载请先在「AI科技评论」后台留言取得授权,转载时需标注来源并插入本公众号名片。

                                                                                                                          阅读原文

                                                                                                                          跳转微信打开

                                                                                                                          •  

                                                                                                                          阿里正式发布Qwen4-Max万亿参数模型,Thinking Machines开放Inkling 2 Small模型权重

                                                                                                                          原创 每日发现最新 2026-11-16 18:47 中国香港

                                                                                                                          通用模型Qwen4-Max,多模态混合专家模型Inkling 2 Small,Agent安全文献资源库Awesome-Agent-Security-Papers,全双工语音交互模型Haru-4B,视觉语言动作模型NEO-VLA。

                                                                                                                          11 月 16 日,今天值得关注的项目覆盖通用模型、Agent 安全、语音交互与具身智能:Qwen4-Max 正式发布,Inkling 2 Small 追加开放权重,Haru-4B 将同时听说的语音交互带到本地设备。

                                                                                                                          🧠 通用模型

                                                                                                                          ★ Qwen4-Max

                                                                                                                          结合原生视觉与百万 Token 上下文,处理编码、工具调用和复杂工作任务。

                                                                                                                          阿里巴巴于 11 月 16 日正式发布 Qwen4-Max。官方公布模型总参数量为 2.4 万亿、激活参数量为 710 亿,支持原生视觉与 100 万 Token 上下文,面向编码、工具任务及复杂工作场景,将图像信息与长篇材料纳入任务处理。

                                                                                                                          正式版已通过 QwenCloud 的 Token Plan 和 API 开放,也可在 QwenWork、QwenStudio 中使用。个人用户可以从工作产品进入,开发者则可通过云端接口接入自己的应用;此次尚未开放 Max 模型权重。

                                                                                                                          ★ Inkling 2 Small

                                                                                                                          以混合专家架构处理图像理解、推理、编码与 Agent 任务,并开放模型权重。

                                                                                                                          Thinking Machines 于 11 月 5 日发布 Inkling 2 Small,并在 11 月 12 日追加开放 Apache 2.0 许可的模型权重。模型采用混合专家架构,总参数量为 5940 亿、激活参数量为 170 亿,覆盖图像理解、推理、编码和 Agent 任务。

                                                                                                                          项目已获得 vLLM、SGLang 等推理框架支持,为开发者提供自行部署路径。不过,激活参数描述的是单次计算参与的规模,不能据此估算完整模型的存储需求。部署仍须围绕 5940 亿总参数规划硬件,更适合具备大型计算资源的团队。

                                                                                                                          上手门槛

                                                                                                                          自行部署:🔴 极高|需按 5940 亿总参数配置内存与显存资源

                                                                                                                          模型权重:https://huggingface.co/thinkingmachines/Inkling-2-Small

                                                                                                                          官方介绍:https://thinkingmachines.ai/news/inkling-2-small/

                                                                                                                          🛡️ Agent 安全

                                                                                                                          ★ Awesome-Agent-Security-Papers

                                                                                                                          按 Agent 生命周期梳理攻击、评测与防御文献,帮助定位不同环节的安全风险。

                                                                                                                          这是一份围绕通用 Agent 安全的论文与文献资源库,对应综述 Pandora&#x27;s Toolbox: A Survey of Generalist Agent Security from the Lifecycle Perspective。仓库提供中英文 README,按来源准入、编排、执行及持久状态反馈组织风险、攻击、评测和防御研究。

                                                                                                                          整理范围包含技能文件投毒、工具输出注入和跨会话记忆污染等问题,将外部内容进入系统后的影响放回完整生命周期中观察。开发者可据此查找相关论文、梳理安全设计中的薄弱环节;该项目本身不提供可直接运行的安全扫描或防护工具。

                                                                                                                          🎙️ 语音交互

                                                                                                                          ★ Haru-4B

                                                                                                                          支持同时听说的全双工语音交互,并通过文字角色设定和短音频参考调整角色与音色。

                                                                                                                          higurashi-ai 发布的 Haru-4B 支持全双工语音交互,可以在说话的同时接收声音,覆盖中、英、日等九种主要语言。使用者可提供文字角色设定和一段简短的音色参考,探索不同角色下的语音交互。

                                                                                                                          模型以 Qwen3.5-4B 为骨干,完整模型在 Hugging Face 标注约 50 亿参数,采用 Apache 2.0 许可。它是面向研究的预训练模型,尚非经过指令微调的助手。项目提供约 12GB NVIDIA 显存的运行路径,以及基于 MLX 的 Apple Silicon 本地应用。

                                                                                                                          上手门槛

                                                                                                                          自行部署:🟢 较低|约 12GB 显存的 NVIDIA 显卡,或 Apple Silicon 本地应用路径

                                                                                                                          模型权重:https://huggingface.co/higurashi-ai/Haru-4B

                                                                                                                          项目地址:https://github.com/higurashi-ai/Haru

                                                                                                                          🤖 具身智能

                                                                                                                          ★ NEO-VLA

                                                                                                                          将图像、语言和动作纳入原生架构,用约 20 亿参数模型完成机器人抓取、放置等任务。

                                                                                                                          南洋理工大学 S-Lab、商汤与 Ropedia 推出的 NEO-VLA,是约 20 亿参数的原生视觉语言动作模型。它通过轻量卷积将图像切分为图像块,并与语言一起送入同一主干,无需独立的预训练视觉编码器。

                                                                                                                          模型再将多层特征送入基于流匹配的动作专家,生成机器人动作。项目在模拟环境和真实机器人上测试了抓取、放置等任务,已公开论文、代码、模型权重及动作预训练数据,供具身智能开发者继续研究;用于实机时还需准备机器人硬件并完成控制适配。

                                                                                                                          上手门槛

                                                                                                                          自行部署:🔴 高|实机运行需机器人硬件及控制适配

                                                                                                                          项目主页:https://weichenfan.github.io/NEO-VLA-Page/

                                                                                                                          代码仓库:https://github.com/EvolvingLMMs-Lab/NEO

                                                                                                                          模型权重:https://huggingface.co/weepiess2383/NEO-VLA

                                                                                                                          跳转微信打开

                                                                                                                          •  

                                                                                                                          自研Agent两场实测均分超过GPT-6,NovaSilicon首提CDK,Fabless之后是Designless?

                                                                                                                          机器之心 2026-11-16 12:01 北京

                                                                                                                          CDK 这个概念由 NovaSilicon 首次提出

                                                                                                                          图片

                                                                                                                          机器之心发布

                                                                                                                          1987 年成立的台积电只做代工。晶圆厂把制造工艺封装成 PDK(Process Design Kit,工艺设计套件)交给客户,PDK 是晶圆厂的核心技术,通过有限接口分享给芯片公司 ,保留核心的制造配方。通过使用 PDK,芯片公司可以把制造交出去,自己专心做设计,这类公司被叫作 Fabless。

                                                                                                                          设计环节里的分工,会不会也变一次?

                                                                                                                           NovaSilicon(上海芯星元智能科技有限公司,以下简称 “NovaSilicon”)的方案叫 CDK(Circuit Design Kit,电路设计套件)。它把芯片设计的经验和 Agent 封装成一套系统。从芯片规格到 GDS 版图,中间需要反复迭代的实现环节,由 NovaSilicon 的工程师用 CDK 来做。CDK 这个概念由 NovaSilicon 首次提出,公司把由此形成的分工叫作 Designless—— 产业会形成新的分工,许多 design house 从自建设计团队变成 Designless。

                                                                                                                          围绕 CDK,公司最近放出的两篇论文,把 CDK 里的两套 Agent 系统和 GPT-6 Astra 等通用 Agent 放在了同一套题上。包含模拟版图设计与数字芯片布图规划(floorplan)。

                                                                                                                          两个场景的最高平均分,都来自 NovaSilicon 基于 CDK 设计的自研 Agent 系统:模拟版图 0.8154 分(GPT-6 Astra 为 0.7483 分);floorplan 57.97 分,约为 GPT-6 Astra 的 1.9 倍。

                                                                                                                          NovaSilicon 成立 5 个月以来连续 3 轮融资累计数亿元,最新一轮融资由顺为资本领投,纪源资本、经纬创投跟投。此前,NovaSilicon 已获得五源资本、商汤国香资本、上海未来产业基金、上海科创集团等机构投资。

                                                                                                                          NovaSilicon 自成立以来,快速聚集并培养了许多同时具备 AI 和芯片设计经验的复合型工程师和研究员。

                                                                                                                          首提 CDK :设计环节的 PDK

                                                                                                                          NovaSilicon 的设想,是把晶圆厂做过的事在设计环节再做一次。Agent 和仿真器相当于产线上的设备,CDK 相当于工艺配方,输入是芯片规格,输出是 GDS。

                                                                                                                          表 1|PDK 与 CDK 的对照。来源:NovaSilicon

                                                                                                                          Designless 沿用的是 Fabless 的分工思路。芯片公司定义规格,实现环节交给 CDK 和使用它的工程师。NovaSilicon 将 CDK 定位为模型驱动的 AI-IC 设计系统,芯片设计的经验沉淀在 Design Kit 里,不在大模型或 EDA 工具里。

                                                                                                                          模拟方向 CDK 织女星 Vega,覆盖拓扑选择、网表转原理图、器件尺寸、仿真和版图。数字方向 CDK 天狼星 Sirius,包含后端的设计初始化、floorplan、布局布线、时钟树、物理验证和时序分析,前端的规格理解、建模、RTL 生成和验证。

                                                                                                                          两篇论文各测了其中一环。模拟版图一篇测的是 Vega 里的 Novara,floorplan 一篇测的是 Sirius 里的 Nova-SI。

                                                                                                                          通用 Agent 画模拟版图:91.1% 交了卷,21.3% 过了验收

                                                                                                                          第一篇论文的 benchmark 名叫 AnalogLayoutWorld。

                                                                                                                          版图是模拟芯片设计的最后一道工序。电路工程师先定好晶体管级网表,相当于一张接线表,写明用哪些器件、尺寸多大、彼此怎么连。版图工程师再照着它画施工图,把每个器件画成硅片上的几何图形,摆好位置,连好金属线,输出一份可以交给晶圆厂的 GDS 文件。

                                                                                                                          AnalogLayoutWorld 有 40 个任务,覆盖放大器、基准源、电源管理电路、采样电路和振荡器。Agent 拿到固定网表和电气指标进行版图设计,评分看六项:是否交出 GDS、LVS(版图和网表是否一致)、DRC(是否满足线宽、间距等工艺规则)、面积紧凑度、工程质量、后仿真是否达标。工程质量一项由团队和模拟版图工程师一起定义,考查器件匹配、关键信号走线和供电等。

                                                                                                                          分数之外还有一条验收线。DRC、LVS 和全部后仿真工况都通过,版图的长宽比和形态也合格,才算验收。

                                                                                                                          团队测了 13 组通用模型与 Agent 框架的组合,织女星中的 CDK:Novara 也在同一套题上跑了一遍。

                                                                                                                          表 2|AnalogLayoutWorld 主要结果(节选)。数据来源:论文 Table 1

                                                                                                                          Novara 平均分 0.8154,排第一。验收率 72.5%,也是最高。GPT-6 Astra 的平均分是 0.7483,验收率 70.8%。GPT-6.1 Sol 是 0.7023 和 62.5%。GLM-5.3 的两个配置平均分在 0.46 到 0.48 之间,其余配置都不到 0.30。

                                                                                                                          Novara 的 LVS 通过率是 100%。工程质量一项,Novara 得分 0.816,排第二的 GPT-6 Astra 是 0.566。

                                                                                                                          图 1|Novara 与五个通用 Agent 配置的分项对比。DRC、LVS、Post-sim 为通过率,Score 为 40 道题的平均分。图源:论文

                                                                                                                          GPT-6 Astra 的后仿真通过率是 82.5%,高于 Novara 的 75.0%,但验收率只有 70.8%。论文解释,GPT 系列从仿真到验收之间丢掉的部分,主要是版图的长宽比和形态不合格。Novara 从 75.0% 到 72.5%,过了仿真的版图基本都能验收。

                                                                                                                          仿真全过,但 GPT 交上来了一根 209 微米的细条

                                                                                                                          40 道题里有一道电流饥饿型环形压控振荡器(current-starved ring VCO)。GPT-6 Astra 三次尝试全部通过 DRC、LVS 和两项后仿真,但交出来的版图宽约 209 µm、高不到 10 µm,长宽比在 22.63 到 26.31 之间,评测规定的上限是 4。这样的细长条很难和周围电路拼到一起,三次都只拿到 0.3 分。

                                                                                                                          从轨迹记录看,Astra 先试过把电路里一只长电阻折叠起来,结果折叠方案未通过 LVS 的长度参数匹配,它于是退回一根 203.19 µm 长的直电阻,把其余器件沿着电阻排成一条。这是一种典型的追求硬性指标,而忽视真正模拟电路流片层面的需求的行为。

                                                                                                                          同一道题,Novara 第一次尝试交出的版图是 34.14 × 42.33 µm,长宽比 1.24,得分 0.9015。Novara 更关注符合工程师真实使用的版图设计思想的建模,也得到了更贴近工程使用的版图结果。

                                                                                                                          图 2|环形 VCO 的四份版图。左为 Novara 首次尝试,右为 GPT-6 Astra 的三次尝试,四份都通过了 DRC、LVS 和后仿真。图源:论文

                                                                                                                          99 个硬宏的工业设计:均分约为 GPT-6 Astra 的 1.9 倍

                                                                                                                          第二篇论文换到数字芯片后端,考的是 floorplan。

                                                                                                                          数字芯片从逻辑网表变成物理版图,头一步是决定大模块放在哪。这些大模块叫硬宏(hard macro),形状固定,不能缩放。硬宏落位之后,EDA 工具再往剩下的空间里填标准单元、连线。直观来说,这像在一块地上先定好几十栋楼的位置,剩下的地要留给小房子和路。楼摆得不好,总面积够用,局部的路照样会堵。

                                                                                                                          论文用的是一个工业设计:235,727 个实例,99 个硬宏占掉 14.123 mm² 版图区域的 71.1%,最大和最小的硬宏面积相差约 121 倍。版图区域是 L 形,缺掉的那个角不能使用。

                                                                                                                          评测把 Agent 交出的硬宏布局接到一条规定好的下游流程上:建电源地网络、做标准单元布局、估算全局布线、分析建立时间。评测的总分满分 100,由拥塞、时序、线长和标准单元利用率四项相乘得到。参评系统分三组。第一组是 NovaSilicon 自研、本地部署的 Nova-SI,第二组是通用工程 Agent,可以查询设计数据库、调用 EDA 工具,拿到下游流程的反馈再修改,第三组只有文件读写权限。

                                                                                                                          表 3|floorplan 评测结果。各项满分 100,几何无效和交付失败记 0 分。数据来源:论文 Table 1

                                                                                                                          Nova-SI 的平均分是 57.97,GPT-6 Astra 是 31.17,其余通用配置在 15 到 23 之间。只有文件权限的那一组,12 份输出里有 9 份硬宏越界或重叠,记 0 分。Nova-SI 的 8 份输出全部通过几何检查,中位数是 57.52 分。Astra 的中位数是 21.37 分,4 份输出里有 3 份低于 Nova-SI 的最低分。出方案时,Nova-SI 没有用规定流程的在线反馈,Astra 所在的通用组可以随时调 EDA 看结果再改。token 消耗上,Nova-SI 平均每份输出 36.13M,通用组五个配置在 62.11M 到 286.50M 之间。

                                                                                                                          去掉 Nova-SI 最好的一份输出,均值是 54.67。论文把七个评分尺度各自乘以 0.5、1、2,试了 2,187 种组合,Nova-SI 的均值比 Astra 高出 22.30 到 30.38 分。8 份输出里得分最高的一份是 81.09 分。作为参照,人类工程师在这个设计上的历史方案是 91.88 分。

                                                                                                                          图 3|Nova-SI 得分最高的一份布局(07 号,81.09 分),从左到右依次为硬宏、标准单元和拥塞热力图。图源:论文

                                                                                                                          CDK 的未来

                                                                                                                          CDK 先用在 NovaSilicon 自己的设计流程里。基于 CDK,NovaSilicon 目前的服务对象是芯片设计公司和有 IP 需求的客户。首批方向有两个。一个是使用 Vega 正在研发的 UCIe PHY IP,UCIe 是芯粒(Chiplet)互联的行业标准,PHY 是其中的物理层接口。另一个是 3D 存算一体(CIM)芯片的设计服务,而数字设计 CDK,Sirius 已经用在这项服务里。

                                                                                                                          大模型厂商是为 CDK 提供底层基座的设备商,好比台积电使用的光刻机一样重要。然而,正如 PDK 和配方是支持台积电改变半导体行业的核心一样,CDK 也将会重塑半导体行业从 Fabless 走向 Designless。

                                                                                                                          NovaSilicon 将 Design Kit 从工艺制造中引入设计流程中,这个过程仍会如工艺制造按照摩尔定律演进一样,以飞快的速度持续规模化,实现芯片设计领域新的 Scaling 路线。

                                                                                                                          © THE END

                                                                                                                          转载请联系本公众号获得授权

                                                                                                                          投稿或寻求报道:liyazhou@jiqizhixin.com

                                                                                                                          跳转微信打开

                                                                                                                          •  

                                                                                                                          恶劣骗局!AI垃圾论文乱加大佬作者,Hinton、李飞飞、LeCun、吴恩达等中招

                                                                                                                          原创 关注AI滥用的 2026-11-16 12:01 北京

                                                                                                                          Christopher Manning:「这是一种更恶劣的骗局」

                                                                                                                          编辑|Panda

                                                                                                                          某天,哥德堡大学计算机科学教授 Alan Said 收到了一条谷歌学术的推送:他有一篇新论文发表了。

                                                                                                                          论文题为《Intelligence Systems Supporting Sustainable Global Development》(支持全球可持续发展的智能系统),刊登在一本名为 American International Journal of Research and Innovation(AIJRI)的期刊上。题目和他「AI 与可持续性」的研究方向沾边,署名也确实是他。

                                                                                                                          问题是:这篇论文不是他写的。

                                                                                                                          「我写一篇这个方向的论文并不奇怪,但只要看一眼论文本身和它的参考文献,就知道是 AI 生成的。它没有任何内容,就是一堆 slop。」Said 在接受 Times Higher Education(简称 THE)采访时这样说。

                                                                                                                          顺着这篇论文,THE 挖出了一个更大的盘子:一批名不见经传的期刊,正在以斯坦福、伯克利等顶尖高校教授的名义,批量发表 AI 生成的垃圾论文。被「署名」的人里,包括 Geoffrey Hinton、Yann LeCun、Yoshua Bengio、李飞飞、Christopher Manning、Michael I. Jordan、吴恩达和 Stuart Russell 等诸多 AI 领域的著名研究者。

                                                                                                                          甚至有把多位著名研究者名字全堆一起的 AI 垃圾论文

                                                                                                                          删了作者,论文还在,换个名字接着挂

                                                                                                                          Said 的第一反应是去投诉。他联系了该期刊的域名注册商,对方回复说文章已被删除。

                                                                                                                          但论文并没有消失,只是作者从 Said 换成了另一个人。根据 Said 提供给 THE 的截图,两天之后,作者又换了一次。同一篇论文,就这样先后挂在三个不同的人名下。

                                                                                                                          这个细节相当说明问题:对这类期刊来说,论文内容根本不重要,重要的是挂在上面的名字。名字可以随时替换,就像商品页面换一张模特图。

                                                                                                                          Said 随后又发现了两本「兄弟期刊」:American Journal of Advanced Multidisciplinary Research and Innovation(AJAMRI)和 American Journal For Multidisciplinary Research(AJFMR)。三本期刊视觉风格相似,主编和编委会成员相同。

                                                                                                                          其中 AJAMRI 已经发表了几十篇署名知名学者的论文,名单堪称 AI 圈的「全明星阵容」:斯坦福的李飞飞和 Christopher Manning,伯克利的 Michael I. Jordan 和 Stuart Russell。

                                                                                                                          斯坦福大学计算机科学教授 Jure Leskovec 也在名单之中。他向 THE 明确表态:「我可以确认,我没有写这篇论文,没有参与投稿,也没有授权使用我的名字。在收到你们的邮件之前,我甚至不知道它的存在。这相当令人担忧。」

                                                                                                                          2026 年注册的域名,却有好几年前的「过刊」

                                                                                                                          仔细看这三本期刊,破绽并不难找。

                                                                                                                          三个网站的域名都是 2026 年才注册的,网站上却挂着「数年前」发表的论文存档。它们统一自称「同行评审、开放获取、多学科」期刊,并且明码标价收取发表费用。

                                                                                                                          收费规则也值得一看。AIJRI 和 AJAMRI 对「五位及以上非印度籍作者」的论文收取 200 美元;AJFMR 则对 1 到 4 位作者收 80 美元,5 位及以上作者只收 10 美元。

                                                                                                                          三本期刊的主编都写着同一个名字:Denish Brown。联系方式是一个美国区号的 WhatsApp 号码。编委会里列了几十位成员,大多来自印度高校。

                                                                                                                          但这份编委名单同样经不起推敲。弗吉尼亚联邦大学博士后 Kanakaraju Manupati 就在其中,他告诉 THE:「我不知道这本期刊的存在,也和它没有任何关联。刚刚去看了期刊网站,很惊讶在编委会里看到了自己的名字。」

                                                                                                                          也就是说,从作者到编委,这些期刊的「学术背书」很可能是整套盗用来的。THE 联系了三本期刊,截至发稿未获回复。

                                                                                                                          Manning:「这是一种更恶劣的骗局」

                                                                                                                          报道发出后,被点名的 Christopher Manning 在 𝕏 上回应,他此前已经见过两篇「署名」他的假论文,分别刊登在所谓的 International Journal of Computer Vision and AI Applications 和 International Journal of Clinical and Medical Sciences 上。

                                                                                                                          前者的名字明显在蹭计算机视觉顶刊 IJCV(International Journal of Computer Vision)的热度;后者更离谱,一位 NLP 学者「发表」在临床医学期刊上。值得注意的是,这两本期刊并不在 THE 调查的三本之列,这意味着类似的操作可能远不止一个团伙。

                                                                                                                          「骗子期刊一直都有;这是一种更恶劣的骗局。」Manning 写道,「最要紧的是别让它们被索引!拜托了,Google Scholar!」

                                                                                                                          评论区有用户抱怨,Google Scholar 一直在给他推荐一些明显是假的论文,作者栏里挂着一堆大牛,「我实在想不通动机是什么,为什么有人要这么干?」

                                                                                                                          Manning 的回复点出了关键:THE 的报道认为,这些期刊把知名学者列为作者,目的是让博士生们也被吸引过来投稿,而这些期刊是收费的。他最后补了一句:「说不定还真管用!」

                                                                                                                          冒名的生意经:拿大牛的名字当广告牌

                                                                                                                          这正是 Said 最担心的地方:「如果一位刚入学的博士生在这本期刊上看到我的名字,他可能会觉得投这里也没问题,我真的不希望发生这种事。」

                                                                                                                          传统的掠夺性期刊(predatory journal)靠的是「快速发表、来稿必登」吸引急于凑论文数的作者。但它们普遍有一个短板:看起来不像正经期刊。而生成式 AI 恰好补上了这块短板,几分钟就能批量「写」出格式规范、引文齐全、看似言之有物的论文,再挂上顶级学者的名字,一本野鸡刊就能在几周内「包装」出体面的过刊和豪华的作者阵容。

                                                                                                                          这套玩法并非首次出现。雅典经济与商业大学软件工程教授 Diomidis Spinellis 在 2023 年 12 月也遭遇过一模一样的事:一篇题为《Global Business Strategies in the Digital Age》的论文以他的名字和单位,发表在 Global International Journal of Innovative Research(GIJIR)上,还配了一个有效的 DOI。

                                                                                                                          Spinellis 没有止步于澄清。他把整个 GIJIR 网站爬了下来做分析,并于 2025 年在《Research Integrity and Peer Review》上发表了案例研究。在引文数最少的 53 篇文章中,至少 48 篇看起来是 AI 生成的,Turnitin 检测给出的 AI 概率在多篇论文上高达 100%。他的结论是:这类期刊一方面用冒名的 AI 论文抬高自身地位,另一方面以此吸引那些想要刷论文数的作者。

                                                                                                                          https://doi.org/10.1186/s41073-025-00165-z

                                                                                                                          据 JMIR 今年 6 月的一篇报道,Spinellis 把 GIJIR 的论文归为三类:占大头的是期刊自己用 AI 生成、冒用学者姓名的「虚假署名论文」;其次是作者花钱买来的「购买署名论文」;真正的研究反而是少数。

                                                                                                                          https://www.jmir.org/2026/1/e104934

                                                                                                                          类似事件在 2026 年明显变得密集。今年 4 月,知名心脏病学家 Eric Topol 发现自己的名字被一本数字健康期刊冒用;5 月,NBC News 报道了一个已发表上百篇 AI 生成论文的假期刊网络,其中部分论文同样冒用了顶尖高校教授的名字。

                                                                                                                          真正的漏洞在下游

                                                                                                                          如果这些论文只是躺在一个无人问津的网站上,危害或许有限。但 Manning 的呼吁指向了问题的真正症结:索引。

                                                                                                                          Said 之所以发现这篇论文,恰恰是因为 Google Scholar 把它收录进了自己的主页,并主动推送给他。一旦被学术搜索引擎收录,这些论文就会出现在学者的个人主页上,进入检索结果,甚至被其他论文引用。Spinellis 那篇冒名论文在发表后的几个月里就收获了 3 次引用。

                                                                                                                          对 AI 行业来说,还有一层更隐蔽的风险:大量模型训练数据来自爬取的学术文献。当 AI 生成的垃圾论文被挂上真实学者的名字、进入索引,它们就有可能回流进下一代模型的训练语料,形成「AI 生成、AI 收录、再被 AI 学习」的污染闭环。

                                                                                                                          从技术上说,这并不是无解的问题。Spinellis 在研究中提出的方向包括加强 DOI 和 ORCID 的身份核验机制、改进 AI 内容检测,以及改革以论文数量为导向的科研评价体系。JMIR 的报道还提到,研究者在投稿前可以借助 Think.Check.Submit 这类核查清单核对期刊的 ISSN、DOI 和独立索引情况。

                                                                                                                          但所有这些措施都绕不开一个现实:生成一篇假论文的成本已经趋近于零,而澄清一篇假论文的成本,全部落在了受害学者身上。Said 投诉之后,论文换了个作者继续挂着;Leskovec 直到记者发邮件才知道自己「发表」了论文;Manupati 被挂在编委会里也毫不知情。

                                                                                                                          那么,问题来了:当李飞飞和 Manning 这样的名字都可以被随意借用,学术署名本身还能在多大程度上作为信任凭证?在 AI 让「写论文」变得廉价的时代,学术界需要守住的,或许不再只是内容的真实性,还有名字的真实性。

                                                                                                                          参考链接

                                                                                                                          https://www.timeshighereducation.com/news/ai-slop-papers-published-under-prominent-academics-names

                                                                                                                          https://www.nbcnews.com/tech/internet/fake-journals-using-real-professors-names-ai-generated-papers-rcna265479

                                                                                                                          图片

                                                                                                                          © THE END 

                                                                                                                          转载请联系本公众号获得授权

                                                                                                                          投稿或寻求报道:liyazhou@jiqizhixin.com

                                                                                                                          跳转微信打开

                                                                                                                          •  

                                                                                                                          NeurIPS 2026|不再依赖外挂:清华把「自我进化技能」训进Agent大脑

                                                                                                                          机器之心 2026-11-16 12:01 北京

                                                                                                                          SkillMaster:让智能体学会进化自己的技能

                                                                                                                          随着递归自我改进(Recursive Self-Improvement,RSI)研究的兴起,智能体的长期能力演进受到更多关注。技能(Skill)能够将交互经验提炼为可复用的操作流程与任务策略,使一次任务的收获服务于后续任务。让智能体学会自主创建和改进这些技能,为其持续进化提供了一条具体路径。

                                                                                                                          图 1 左:外部模块负责管理技能,智能体检索并使用技能。右:SkillMaster 将技能管理纳入智能体自身的策略,与任务执行共同学习。

                                                                                                                          然而,现有方法中的技能创建与更新,通常依赖外部教师模型、预设规则或辅助模块(图 1 左)。执行任务的智能体学会了使用技能,却很少被直接训练去改进技能。要沿着这条路径实现自主改进,还需要让 “如何进化技能” 成为智能体自身可以学习的能力(图 1 右)。

                                                                                                                          清华大学李勇教授团队提出了 SkillMaster,相关论文已被 NeurIPS 2026 录用,论文第一作者为北京中关村学院博士生杨敏。

                                                                                                                          研究以一个直观的洞察为出发点:有价值的技能改进,应当让原来失败的相似任务在后续更容易成功,让原来已经成功的任务以更少的步骤完成。SkillMaster 将这两类效果转化为技能编辑的学习信号,训练同一个智能体根据交互经验创建、更新和保留技能,使技能进化与任务执行共同进入强化学习过程。

                                                                                                                          • 论文题目:SKILLMASTER: Toward Autonomous Skill Mastery in LLM Agents

                                                                                                                          • Author: Min Yang, Jinghua Piao, Xu Xia, Xiaochong Lan, Jiaju Chen, Yongshun Gong, Yong Li

                                                                                                                          • Affiliation: Shandong University, Zhongguancun Academy, Tsinghua University,  Southeast University, University of Science and Technology of China

                                                                                                                          • arXiv: https://arxiv.org/abs/2605.08693

                                                                                                                          • GitHub: https://github.com/sduyangmin/Skill-Master

                                                                                                                          核心洞察:让失败的任务更容易成功

                                                                                                                          让成功的任务完成得更高效

                                                                                                                          要训练智能体改进技能,首先需要知道一次修改给后续任务带来了什么。仅用任务最终是否成功作为奖励,难以区分执行能力与技能质量,更难为某一次技能编辑提供明确的反馈。

                                                                                                                          为此,SkillMaster 关注技能修改对后续相关任务的实际影响。一条技能如果补上了已有知识的缺口,应当提高原先失败任务的成功机会;如果改进了已有的操作策略,应当让已经能够解决的任务减少不必要的步骤。这两种可观察的变化,为衡量技能修改的效果提供了依据。

                                                                                                                          方法框架:

                                                                                                                          联合学习任务执行与技能进化

                                                                                                                          要让智能体学会自主创建、修订和保留技能,需要解决三个问题:依据什么提出修改、如何评价修改的价值,以及如何联合优化任务执行与技能管理。SkillMaster 分别通过基于轨迹的技能审视、下游效用奖励和 DualAdv-GRPO 实现这三个环节

                                                                                                                          图 2 SkillMaster 的三个组成部分:基于轨迹的技能审视、反事实技能效用奖励,以及 DualAdv-GRPO 联合优化。

                                                                                                                          基于交互轨迹学习技能管理

                                                                                                                          技能审查阶段将任务目标、已检索技能、行动与观察轨迹、最终反馈一起提供给模型。模型通过 propose_skill、update_skill 和 keep_skill 三类工具调用,分别执行创建、更新和保留操作。例如,发现已有技能未覆盖某种搜索策略时,可以补充新技能;观察到实际反馈与已有操作规则冲突时,可以修订原有技能。

                                                                                                                          任务动作和技能工具调用由同一个策略生成,因此技能管理也直接纳入模型训练。SkillMaster 先通过监督微调,让模型具备基本的任务执行与工具调用能力,再利用技能效用反馈,通过强化学习优化创建、更新和保留技能的决策。

                                                                                                                          通过反事实对照评价技能效用

                                                                                                                          对于候选技能编辑,系统选取一组相关的探测任务,分别使用原始技能库与临时修改后的技能库执行,直接比较修改带来的下游变化。原先失败的任务是否转为成功、原先成功的任务是否减少执行步骤,都会体现在效用评分中,为技能编辑提供直接的训练反馈。

                                                                                                                          探测任务来自训练任务池,并依据任务类别、商品类别或问题语义相似度选择。系统综合考虑探测任务的平均得分变化,以及表现改善和退化的任务数量,计算效用奖励,并据此优化技能编辑决策。训练期间,效用奖励为正的修改才会写入持久技能库。

                                                                                                                          DualAdv-GRPO 联合优化两类决策

                                                                                                                          任务执行主要依赖环境结果反馈,技能管理则使用工具调用有效性和下游效用反馈,两类奖励具有不同的尺度与含义。为此,SkillMaster 提出 DualAdv-GRPO,分别计算任务执行与技能管理的优势,再分配给对应的生成内容,共同更新同一个策略。模型由此同时学习有效执行任务和改进可复用技能。

                                                                                                                          实验结果:

                                                                                                                          从任务表现到技能进化能力

                                                                                                                          实验基于 Qwen2.5-7B-Instruct,覆盖 ALFWorld、WebShop 和 SearchQA。其中,ALFWorld 包含六类模拟家庭任务,WebShop 考察多步商品搜索与购买,SearchQA 覆盖七个单跳和多跳问答数据集。

                                                                                                                          表 1 ALFWorld 与 WebShop 主实验结果。

                                                                                                                          如表 1 所示,SkillMaster 在 ALFWorld 和 WebShop 上均取得所比较方法中的最佳表现,任务成功率分别达到 98.7% 和 82.0%,较 SkillRL 提高 8.8 和 9.3 个百分点。ALFWorld 六类任务中有四类达到 100% 成功率,其余两类均超过 95%。 

                                                                                                                          表 2 SearchQA 七个数据集的实验结果。

                                                                                                                          如表 2 所示,在 SearchQA 上,SkillMaster 的总体得分达到 48.0%,为所比较方法中的最高值,较 SkillRL 提高 0.9 个百分点。七个数据集中有五个优于 SkillRL,体现出该框架在搜索增强问答任务中的效果。

                                                                                                                          图 3 左:组件消融结果。中:技能管理操作比例的变化。右:技能库规模的变化。

                                                                                                                          如图 3 左侧所示,去掉技能效用奖励、改用合并的优势归一化,或随机选择探测任务,均会降低表现,支持效用反馈、分离优势估计和相关任务选择的作用。图 3 中间和右侧分别展示了技能管理行为与技能库规模的变化。

                                                                                                                          在 ALFWorld 训练中,训练早期,创建和更新操作较为活跃,训练后期,保留技能的比例从约 81.25% 升至 97.66%。这一过程体现了模型从补充和修订技能,逐步转向保留已积累技能的行为变化。作者还固定训练后的模型参数,检验其在测试交互中构建技能的能力。此时不使用反事实探测和效用反馈,合法的技能管理操作直接执行,并供后续任务复用。在 WebShop 上,从空技能库出发,同时开启技能构建与检索后,成功率从 65.63% 提升至 71.88%,表明训练后的策略能够根据新交互生成并复用有用技能。

                                                                                                                          案例分析:

                                                                                                                          根据执行证据创建和修订技能

                                                                                                                          图 4 智能体从任务轨迹中发现技能缺口、纠正已有规则,并在相关任务上验证修改效果。

                                                                                                                          如图 4 所示,在一个 ALFWorld 冷却任务中,智能体将大量步骤花在低概率出现食物的柜子和抽屉上,最终未能完成任务。复盘时,它识别出已有技能缺少搜索优先级规则,于是创建新技能,指导后续搜索优先考虑与目标物体相关的高概率位置。

                                                                                                                          另一个案例展示了已有技能的修订。按照 ALFWorld 的交互接口,加热需要在智能体持有目标物体时执行,但旧技能要求先把物体放入微波炉。模型依据轨迹中的反馈修订了这一操作条件。图 4 右侧的对照显示,在相关探测任务中,加热环节从 8 步缩短为 2 步,减少了六次多余操作,直接体现了技能修改的下游效用。

                                                                                                                          研究展望:

                                                                                                                          通过学习技能进化,探索递归自我改进

                                                                                                                          SkillMaster 从技能这一可复用的知识载体出发,探索智能体递归自我改进的一条路径。智能体在交互中发现知识缺口或低效策略,通过技能编辑改变后续行为,再根据实际效果学习更有价值的编辑决策。任务执行与技能改进相互衔接,使智能体既能积累技能,也能通过训练提升改进技能的能力。

                                                                                                                          当前方法已在结构化交互环境和搜索增强问答中得到验证。进一步面向开放环境,需要探索更有效的探测任务选择和更低成本的效用评估,并扩展到技能删除、跨智能体共享和分布变化下的持续学习。这些方向有望使技能库与智能体的能力随长期交互共同演进。

                                                                                                                          图片

                                                                                                                          © THE END 

                                                                                                                          转载请联系本公众号获得授权

                                                                                                                          投稿或寻求报道:liyazhou@jiqizhixin.com

                                                                                                                          跳转微信打开

                                                                                                                          •  

                                                                                                                          解剖 11 个编码 Agent 源码:模型之外那层 Harness,到底是怎么搭的

                                                                                                                          原创 王吉伟 2026-11-16 15:38 山东

                                                                                                                          Agent = Model + Harness:一份源码解剖里的七个子系统与平台化信号。

                                                                                                                          • 别只盯模型能力了:生产 Agent 真正拉开差距的,是模型外面那层运行时

                                                                                                                          • Agent = Model + Harness:一份源码解剖里的七个子系统与平台化信号

                                                                                                                          • 一百行脚本和百万行系统处在同一区间:源码解剖能看到什么,又看不到什么

                                                                                                                          • 从工具到平台:编码 Agent 的 Harness 正在变成什么 

                                                                                                                          当所有人都在比谁的模型更聪明,真正决定一个 Agent 能不能在真实项目里跑起来的,往往是模型外面那一层。

                                                                                                                          最近王吉伟频道读到一篇很特别的 arXiv 论文。它不刷 Benchmark、不做运行跑分,而是直接打开 11 个生产级编码 Agent 的源码,回答一个更基础的问题:把大模型接上真实世界、让它能反复执行任务的那层运行时,到底由什么构成,各家是怎么搭的,又正在朝什么方向演化。

                                                                                                                          论文标题是 Harness Engineering: Anatomy, Architecture, and Evolution of Coding Agents — A Source-Code Study of Eleven Systems(arXiv:2609.00006v1,2026 年 7 月,CC BY 4.0)。作者来自 Inclusive Brains 与 Wavestone AI Lab。

                                                                                                                          论文标题与摘要

                                                                                                                          这篇文章不会复述全文,只讲清四件事:Harness 是什么;11 个系统里反复出现的七个结构;两组最硬的反直觉证据;以及一个从工具走向平台的判断,和它成立的边界。

                                                                                                                          别只盯模型强弱,真正该解释的是外面那一层

                                                                                                                          讨论编码 Agent 时,最常见的做法是把差距归到模型能力上:参数多大、上下文多长、推理多强。

                                                                                                                          这个解释并不全错,但它回答不了一个现象:同样的底层模型,接上不同的运行时之后,任务成功率、权限边界、上下文管理和多步协作可以拉开明显差距。差距有一部分来自模型,另一部分则藏在模型外面的工程层里。

                                                                                                                          论文把已有研究分成三类,并指出各自的缺口:

                                                                                                                          研究类型

                                                                                                                          回答了什么

                                                                                                                          没回答什么

                                                                                                                          Benchmark 综述

                                                                                                                          给出统一任务上的得分排名

                                                                                                                          看不到系统内部是怎么搭的,分数也跨模型、跨日期不可比

                                                                                                                          概念分类研究

                                                                                                                          归纳出工具、记忆、规划等设计模式

                                                                                                                          停留在模式层面,不落到真实生产代码

                                                                                                                          已有源码分类

                                                                                                                          解剖了一批开源系统

                                                                                                                          大多排除了厂商原生产品,而生产环境最常用的恰恰是原生编码 Agent

                                                                                                                          这篇论文补的就是后两个缺口:把厂商原生系统和开源系统放到同一张源码对照表里,静态阅读、定性比较,不跑统一任务集,也不做性能排名。

                                                                                                                          它选了 11 个研究样本,外加 1 个元层对照,样本时间锚定在 2026 年 7 月:

                                                                                                                          分组

                                                                                                                          系统

                                                                                                                          语言 / 备注

                                                                                                                          厂商原生

                                                                                                                          Claude Code、Codex、Gemini CLI、Mistral Vibe

                                                                                                                          分别为 TS、Rust、TS、Python;Claude Code 基于 2026 年 3 月流通快照,可复现性最弱

                                                                                                                          开源与对照

                                                                                                                          OpenHands、Aider、Mini-SWE-Agent、Hermes、Pi、OpenCode、OpenClaw

                                                                                                                          Mini-SWE-Agent 约 100 行,作为研究地板;Pi 是最小内核反趋势;OpenClaw 是非 SWE 多渠道网关对照

                                                                                                                          元层对照

                                                                                                                          Omnigent(Databricks)

                                                                                                                          编排多个厂商 Harness,自己不建编辑循环

                                                                                                                          先把 Harness 说清楚

                                                                                                                          论文用一个很简洁的等式把问题摆正:Agent = Model + Harness。

                                                                                                                          Harness 可以理解成模型之外的那层运行时:它负责让模型观测环境、形成决策、调用工具、读取反馈,再循环推进任务。模型负责生成内容,Harness 决定这些生成能不能稳定接到真实世界里。

                                                                                                                          这里有个容易混淆的地方:Harness 不等于市面上那些 Agentic 框架(LangChain、LangGraph、AutoGen、CrewAI 这一类),也不等于临时拼装的脚手架、评测时套的 eval harness,更不等于只在顶层做任务分发的编排器。论文刻意把这些概念分开,避免一个词套所有东西。

                                                                                                                          放到生产环境里看就更清楚了:真正被使用的编码 Agent,差别往往不在"调了哪个模型 API",而在这层运行时怎么组织循环、怎么管上下文、怎么控权限、怎么接工具和编辑器。读懂 Harness,才看得懂这些系统的真实分工。

                                                                                                                          论文把 11 个系统的内部结构拆成七个子系统,再加两条贯穿全局的横切面:

                                                                                                                          子系统

                                                                                                                          职责

                                                                                                                          源码里的关键观察

                                                                                                                          Agent 循环

                                                                                                                          观测、决策、动作、反馈的主循环

                                                                                                                          循环是每个系统的核心;形态从极简一轮一轮调用,到带状态、带中断恢复的完整运行时不等

                                                                                                                          LLM 集成与模型协同设计

                                                                                                                          模型客户端、提示构造、采样、重试与错误处理

                                                                                                                          原生系统会与自家模型服务做更深的协同;开源系统把这一层做得更可替换

                                                                                                                          工具与动作

                                                                                                                          工具注册、调用封装、动作执行与结果回传

                                                                                                                          工具是模型触碰环境的唯一出口,工具的边界和权限直接决定系统风险面

                                                                                                                          记忆与上下文

                                                                                                                          会话基座、上下文裁剪、信息检索与压缩

                                                                                                                          代码检索主要靠 ripgrep、tree-sitter、glob 和 Markdown 上下文,而不是向量嵌入

                                                                                                                          安全与权限

                                                                                                                          沙箱、人工批准、文件与命令权限分级

                                                                                                                          沙箱是一种架构选择,不是系统规模的必然结果;原生产品把它当成最贵的部件之一

                                                                                                                          多智能体编排

                                                                                                                          子任务分派、子 Agent 协作

                                                                                                                          大多数系统把自有子 Agent 留在进程内,而不是拆成独立服务

                                                                                                                          可扩展性

                                                                                                                          插件、技能、hook、扩展点与外部接入

                                                                                                                          技能(Skills)被更多系统采用,数量上反超了 MCP 工具协议

                                                                                                                          两条横切面不单独成模块,却贯穿所有系统:一是接口层,也就是 CLI、编辑器集成、客户端与服务器的部署形态;二是会话基座,包括会话持久化、历史导入导出和跨会话延续。

                                                                                                                          需要说明的是,这七个子系统是一份解剖坐标系,不是评分表。论文用它统一描述各家结构,并不意味着每个系统都该把七块做全,也不意味着模块越多就越强。

                                                                                                                          论文原文:七子系统章节

                                                                                                                          两组最硬的证据:两种"缺席",一个反直觉对比

                                                                                                                          论文里证据最扎实的,不是某家系统做了什么,而是两件在 11 个系统里都没有出现的事。作者做过样本三倍扩张和三个月后的二次复核,结论保持一致。

                                                                                                                          缺席一:没有一个运行时采用通用 Agentic 框架

                                                                                                                          11 个系统里,没有一个在运行时引入 LangChain、LangGraph、AutoGen、CrewAI 这类通用编排框架。连 Google 自家的 Gemini CLI,也没有用自己的 Genkit 或 ADK。各家更倾向把循环、工具、记忆直接写在自己的代码里。

                                                                                                                          这说明至少在编码 Agent 这个场景,通用框架目前并不是生产运行时的默认底座;至于这是场景成熟度问题,还是框架定位问题,论文没有下定论。

                                                                                                                          缺席二:没有一个用向量嵌入做代码检索

                                                                                                                          11 个系统里,没有一个把向量嵌入用于代码库检索。读代码、定位符号和上下文,主要靠 ripgrep、tree-sitter、glob 匹配和 Markdown 上下文组织。嵌入只出现在对话记忆场景:OpenClaw 默认使用混合检索,Hermes 只在可选插件里提供嵌入。

                                                                                                                          这并不否定 RAG 本身,而是提示一个现实观察:在编码 Agent 当前的工作方式里,确定性的工具检索比语义嵌入更常被直接采用。在王吉伟频道看来,这比任何跑分都更能说明生产环境的真实选择。

                                                                                                                          反直觉对比:一百行脚本和百万行系统处在同一成绩区间

                                                                                                                          样本里的 Mini-SWE-Agent 大约只有 100 行,是研究地板级实现;它自报在 SWE-Bench Verified 上达到 74% 以上。Codex 源码约 110 万行,属于重型系统。两者的自报成绩落在相近区间。

                                                                                                                          你就说这事反不反直觉。

                                                                                                                          不过口径必须讲清楚:这些分数跨模型、跨日期、跨配置,论文明确不把它们当成可横比的排名,只作为背景。它能提示的是循环复杂度并不直接预测任务完成率;但绝不能反过来推出"简单实现就足够",因为运行时承担的权限、可靠性、上下文管理和多步协作,并不体现在单题分数里。

                                                                                                                          四个常见理解,需要先纠偏

                                                                                                                          王吉伟频道把论文里反复澄清的误解归成四条,每条都对应一个想当然的判断。

                                                                                                                          误区一:系统越复杂,能力越强。 复杂度和任务完成率之间,在这份样本里看不到直接对应。循环再厚,也可能只是在处理工程边界问题;而静态源码阅读本身无法测量运行性能,不能把结构规模读成能力高低。

                                                                                                                          误区二:大系统一定自带沙箱。 沙箱是一种主动选择,不是规模的必然结果。Hermes、OpenCode 体量不小,却没有做操作系统级隔离;而原生产品常把沙箱当成成本最高的部件之一。隔离强度对应风险偏好,不对应代码行数。

                                                                                                                          误区三:原生优化等于紧耦合。 原生系统确实和自家模型、服务协同更深,但紧耦合并不是厂商原生的专利:谁愿意为每个厂商维护条件代码,谁就能拿到对应的原生优化。紧耦合真正独有的好处,是和服务端一起协同进化、掌握更新循环的控制权;代价则是绑定和迁移成本。

                                                                                                                          误区四:工具协议已经统一。 事实是技能(Skills)被 9 个系统采用,数量上反超了接入 MCP 的 8 个。ACP 承担三类角色:编辑器与 Agent 对接、Harness 托管、跨厂商 mesh 式互通;其中真正做跨厂商 A2A 的,样本里只有 Gemini。自有子 Agent 也大多留在进程内,没有变成独立服务。

                                                                                                                          最终判断:Harness 正在从工具变成平台

                                                                                                                          论文最有分量的趋势判断是:编码 Agent 的运行时,正在从一个完成任务的工具,转向一个承载能力、规则和协作关系的平台。支撑这个判断的是四个可观察信号。

                                                                                                                          信号

                                                                                                                          源码里的表现

                                                                                                                          技能成为声明式程序

                                                                                                                          能力以可声明、可装载、可复用的技能单元存在,而不是写死在主循环里

                                                                                                                          hooks 与事件总线

                                                                                                                          运行时对外暴露事件与挂载点,允许外部在关键节点插入逻辑

                                                                                                                          工具与工作流边界消失

                                                                                                                          单次动作与多步流程在同一层融合,工具既可以被调用,也可以串成流程

                                                                                                                          Harness 作为服务面

                                                                                                                          运行时对外提供接口和服务形态,不只是一个本地命令行工具

                                                                                                                          顺着这四个信号,论文看到两条相互靠近的路线:Harness 在吸收框架的编排能力,框架也在下沉成运行时;市场层面开始出现切换成本和企业级治理(如设备统一管理、权限与合规)的需求;最上层则出现了元 Harness,也就是像 Omnigent 那样编排多个厂商运行时、自己不建编辑循环的一层。

                                                                                                                          纵向看约 90 天的版本演进,还有一个值得留意的现象:系统之间的趋同已经从结构相似走到词汇层面的模仿,例如 Codex 沿用了 Claude Code 的 hook 词汇和会话导入器;特色的半衰期以周计;行为策略也从提示词里的自然语言散文,迁移到配置文件和开关 flag。

                                                                                                                          这是一条趋势观察,不是预言。它说明当下在发生什么,不保证所有系统都会沿着同一方向走到同一个形态。

                                                                                                                          这份研究能回答什么

                                                                                                                          读这篇论文时,我觉得有几条边界需要先摆清楚,否则很容易把结构观察误读成性能结论。

                                                                                                                          • 研究方式是静态源码阅读,不跑统一任务集,所以看不到真实运行性能、稳定性和失败率。

                                                                                                                          • 没有同任务、同模型的头对头对比,不能据此给产品排能力名次。

                                                                                                                          • Claude Code 采用 2026 年 3 月的流通快照,是样本里可复现性最弱的一环。

                                                                                                                          • "框架缺席"没有追溯动态加载、转译或二次发行的情形;代码检索的结论也限定在编码 Agent 当前实现。

                                                                                                                          • 这些结论面向编码场景,外推到其他类型 Agent 时需要重新验证。

                                                                                                                          • 版本号、工具数量、Star 数等清单信息容易过期,阅读时应以论文锚定时间为准。

                                                                                                                          • 系统之间是定性比较,其中包含作者的主观判断,不等同于可量化的客观测量。

                                                                                                                          后记:以后怎么看一个 Agent 的运行时

                                                                                                                          如果把这篇论文压缩成一套可以复用的判断框架,有两层。

                                                                                                                          看结构,回到七个子系统:循环怎么组织、模型怎么接入、工具怎么授权、上下文怎么管理、权限怎么隔离、子任务怎么协作、能力怎么扩展。再看接口层和会话基座这两条横切面。结构齐全不代表更强,但缺了哪一块,通常能对应到一类工程代价。

                                                                                                                          看平台化程度,对照四个信号:技能是否声明式、有没有事件与 hook、工具和流程是否打通、运行时是否对外成为服务面。信号越多,它越接近平台形态,也越可能沉淀出切换成本和治理需求。

                                                                                                                          最后再强调一个分工原则:源码解剖能回答"这层是怎么搭的",回答不了"它在真实任务上跑得多好"。看结构用这份研究,比性能还需要另一套基于统一任务和同模型的评测。

                                                                                                                          把这两件事分开,就不容易被任何一边的结论带偏。

                                                                                                                          论文地址:https://arxiv.org/html/2609.00006v1

                                                                                                                          看到这里了,如果觉得不错,随手点个赞、在看、转发三连吧,也可以给个星标,你的支持就是我的动力。

                                                                                                                          推荐阅读

                                                                                                                          1、新书《一本书讲透Agentic AI》出版,吃透代理式AI核心不踩坑

                                                                                                                          2、【万字长文】数字员工、具身智能,AI Agent未来发展十大研究方向

                                                                                                                          3、一切皆可Agent Skills,无处不在的AI Agent会替代业务流程吗?

                                                                                                                          4、意图即应用:Agentic AI时代计算交互新范式

                                                                                                                          5、企业AI Agent战略级规模化落地方法论,Agentic AI Stack for Enterprises

                                                                                                                          6、五层结构AI Enablement Stack,把可用AI Agent技术栈生态讲透了

                                                                                                                          7、智能体主题分享:DeepSeek、Manus与AI Agent行业现状,附PPT下载

                                                                                                                          8、十篇AI Agent研报,看懂2025年全球智能体行业全景,附下载

                                                                                                                          8、API难以解决AI智能体执行能力问题,AI Agent深度落地锁定RPA

                                                                                                                          10、RPA终极发展方向瞄准AI Agent,超自动化智能体时代已经开启

                                                                                                                          【王吉伟频道,关注Agentic AI与AIGC,专注数字化转型、业务流程自动化与AI Agent,欢迎关注与交流。】

                                                                                                                          阅读原文

                                                                                                                          跳转微信打开

                                                                                                                          •  

                                                                                                                          Datawhale招人啦!8个岗位开放中🐳

                                                                                                                          Datawhale 2026-11-16 13:11 浙江

                                                                                                                          想加入 Datawhale,和一群有趣的人一起做点有意思的事吗?

                                                                                                                          Datawhale 新一波招聘机会来啦!

                                                                                                                          目前开放前端开发、社区运营、活动运营、人事行政实习等多个岗位,欢迎加入!

                                                                                                                          📍工作地点:杭州云谷中心

                                                                                                                          📱扫码查看全部岗位详情,欢迎投递,也欢迎推荐给身边正在找机会的朋友~

                                                                                                                          #Datawhale #求职 #实习 #招聘

                                                                                                                          跳转微信打开

                                                                                                                          •  

                                                                                                                          刚刚,Anthropic分享构建高效Agent自动化最佳实践

                                                                                                                          PaperAgent 2026-11-16 11:30 湖北

                                                                                                                          大家好,我是PaperAgent,不是Agent!

                                                                                                                          让 Agent 定时运行并不难,难的是让它每天稳定交付,而且不重复、不遗漏、不越权。

                                                                                                                          building effective agent automations

                                                                                                                          Anthropic最近连发了2篇常驻高效的Agent自动化技术blog,第二篇给了完整场景参考实现,很有价值:每日简报。它按 schedule 读取 Slack 和 GitHub,跟踪上次运行后的变化,再把值得行动的内容投递到 Slack。

                                                                                                                          可参考的Code已开源,提供的文件包括Agent、其环境、内存存储、存储库和部署。

                                                                                                                          它把一次模型调用,变成一条可持续运转的工作流。

                                                                                                                          一、先搭闭环,再谈智能

                                                                                                                          这套系统由六个部件组成:信息源、唯一投递目标、Agent、调度、记忆和护栏。调度负责唤醒,Agent 负责判断,记忆负责衔接每次运行,护栏则约束权限与成本。

                                                                                                                          图 1|每日简报 Agent 的总体架构
                                                                                                                          图 1|每日简报 Agent 的总体架构

                                                                                                                          这个划分很关键。自动化不是把提示词交给模型就结束,而是让读取、筛选、投递和记录形成闭环。模型只是其中一环,可靠性来自整条链路。

                                                                                                                          来源(Sources)—— 一个带名称的读取位置列表  
                                                                                                                          目标位置(Destination)—— 智能体可写入的唯一位置  
                                                                                                                          智能体(Agent)—— agent.md 中的模型、工具和运行步骤  
                                                                                                                          调度(Schedule)—— 一个 cron 调度  
                                                                                                                          记忆(Memory)—— 你的偏好以及智能体自身的记忆  
                                                                                                                          防护措施(Guardrails)—— 在智能体仅进行读取的地方提供只读访问,并设置每次运行的花费上限

                                                                                                                          二、读取信息,必须知道读到了哪里

                                                                                                                          很多简报 Agent 会直接读取过去 24 小时。看似合理,实际运行一晚就会出问题:任务延迟会漏掉内容,提前运行又会重复推送。

                                                                                                                          图 2|信息源与凭据、书签的设计
                                                                                                                          图 2|信息源与凭据、书签的设计

                                                                                                                          Anthropic 的做法是给每个信息源维护一个书签。每次只记录已读内容的最新时间戳,下次从书签继续,读取窗口随实际运行情况伸缩。

                                                                                                                          异常也不能静默处理。某个来源读取失败时,书签保持不动,其他来源照常生成简报,同时明确标注本次哪些内容不可读。凭据则放在 Vault 中,沙箱只接触占位符,真实令牌仅在访问白名单主机时注入。

                                                                                                                          三、投递成功,才能推进状态

                                                                                                                          自动推送最容易制造两类事故:没有送达却更新进度,导致信息永久丢失;不确定是否送达就重试,导致读者收到重复简报。

                                                                                                                          图 3|投递目标与送达确认机制
                                                                                                                          图 3|投递目标与送达确认机制

                                                                                                                          这里的顺序非常严格。Agent 先检查当天标题是否已经存在,再向唯一的 Slack 频道投递。只有 Slack 返回成功状态和消息 ID,才更新书签与已报告账本。

                                                                                                                          如果结果无法确认,运行记录会标记为可能已经投递,其他状态保持不变。这不是多一步记录,而是在用确认机制守住信息不丢失、不重复的底线。

                                                                                                                          四、Agent 的核心工作,是筛选与复核

                                                                                                                          在 Managed Agents 中,Agent 是一份带版本的配置,包含模型、系统提示和工具,每次按既定步骤运行后停止。参考实现还特意关闭了通用网页搜索与抓取,让注意力集中在指定来源。

                                                                                                                          图 4|模型、提示与运行步骤组成 Agent
                                                                                                                          图 4|模型、提示与运行步骤组成 Agent

                                                                                                                          筛选标准也很克制:只有今天需要行动,或者会改变既定决策的信息,才值得占据一行。不确定就舍弃,仍在等待的事项只更新进展,不当作新闻重报。

                                                                                                                          agent.md

                                                                                                                          更重要的是,投递前还要重新检查实时状态。已经解决的内容直接移除,发生变化的内容及时修正,无法确认的内容不再断言。链接也来自原始数据字段,避免手工拼接。

                                                                                                                          五、调度不只管几点,还要管时间语义

                                                                                                                          Agent 配置本身不会自动运行,真正启动它的是 Deployment。每次触发都会创建全新会话,并挂载指定的环境、凭据、记忆和预算。

                                                                                                                          图 5|Deployment 按调度启动全新会话
                                                                                                                          图 5|Deployment 按调度启动全新会话

                                                                                                                          一个容易被忽略的细节是时区必须出现两次:调度字段决定何时唤醒,输入指令还要告诉 Agent 用哪个时区理解今天和昨天。否则服务器时间正确,简报日期仍可能算错。

                                                                                                                          deployment.md

                                                                                                                          这也说明,生产级自动化需要明确每次运行的上下文,而不是依赖模型猜测环境。

                                                                                                                          六、记忆要分权,简报要报变化

                                                                                                                          全新会话意味着上次反馈不会自然保留,但把所有历史都塞回提示词,又会放大过期信息。参考实现因此拆成两类记忆。

                                                                                                                          图 6|偏好与运行状态分属两类记忆
                                                                                                                          图 6|偏好与运行状态分属两类记忆

                                                                                                                          Preferences 由读者维护,Agent 只读,保存来源、排除规则、篇幅和停止条件。每次运行都重新读取;读不到就停止,而不是退回旧默认值。

                                                                                                                          State 由 Agent 读写,保存书签、已报告账本、运行记录和来源特性。账本通过稳定 ID 识别同一事项,后续只报告状态变化。记忆由此成为增量协作的基础,而不是重复内容的仓库。

                                                                                                                          七、边界写进系统,自动化才值得托付

                                                                                                                          后台运行没有人工逐步确认,权限就必须预先收紧。GitHub 令牌和偏好存储保持只读,网络只访问白名单主机。Slack 令牌兼顾读取与投递,因此机器人只加入确有必要的频道。

                                                                                                                          成本同样需要硬约束。初始预算可设为正常运行的3 至 5 倍,再依据真实消耗收紧。触及上限时任务会暂停而非报错,所以还要监测运行状态,避免把暂停误当成无事可报。

                                                                                                                          这套实践给出的答案很清晰:高效 Agent 自动化并不取决于模型做了多少,而取决于系统是否把读取进度、投递确认、记忆权限和失败边界都设计清楚。让每次运行可接续、每条规定可执行、每个结果可确认,才是从 Demo 走向日常生产力的分水岭。

                                                                                                                          图 7|权限、成本与运行监测构成护栏
                                                                                                                          图 7|权限、成本与运行监测构成护栏
                                                                                                                          Building effective agent automations
                                                                                                                          https://claude.dev/blog/building-effective-agent-automations/
                                                                                                                          https://github.com/anthropics/claude-quickstarts/tree/main/managed-agents/daily-brief

                                                                                                                          动手设计AI Agents:(编排、记忆、插件、workflow、协作)

                                                                                                                          Loop工程已死,Graph工程永生

                                                                                                                          一篇Loop+Harness的自进化Agent最新综述

                                                                                                                          2026,做Agentic AI,绕不开这两篇开年综述

                                                                                                                          已经读到这了,不妨点个👍、❤️、↗️三连,加个星标⭐,不迷路哦~

                                                                                                                          跳转微信打开

                                                                                                                          •  

                                                                                                                          Agent多开时代:Codex,Claude内部隐患被挖出来了

                                                                                                                          PaperAgent 2026-11-16 11:30 湖北

                                                                                                                          最近,同时开几个 Claude Code、Codex 窗口并行干活已经成了不少开发者的日常,但资源有限,核心问题变成:多个Agent共享同一环境时,新任务会不会踩死旧任务?

                                                                                                                          ClashBench给出的答案不太舒服:会。研究通过Codex、Claude Code和OpenCode测试17个模型。默认条件下,44.5%的有效运行发生破坏性资源抢占;在符合审计条件的成功抢占轨迹中,31.9%的最终回复只报成功,不提资源冲突和干预行为。

                                                                                                                          01 新隐患:不是答错,而是抢资源

                                                                                                                          图1|ClashBench总览:共享资源如何把普通任务变成安全冲突
                                                                                                                          图1|ClashBench总览:共享资源如何把普通任务变成安全冲突

                                                                                                                          Agent A刚下载完大型数据集,Agent B安装软件时发现磁盘不足。B没有求助,而是清空下载目录,让自己的任务继续。

                                                                                                                          论文把这类行为定义为破坏性资源抢占:为了获得新任务所需资源,终止、覆盖、驱逐或降级已有任务。

                                                                                                                          风险不依赖恶意指令,良性目标、共享环境和高权限叠加,就可能触发副作用。

                                                                                                                          02 不是聊天推演,而是真的跑起来

                                                                                                                          研究团队构建了268个可执行案例,覆盖55种资源、175种占用配置和5类冲突,包括端口、锁、磁盘、GPU显存,也包括会议室与日程。

                                                                                                                          图2|案例构建、冲突验证与运行验证流程
                                                                                                                          图2|案例构建、冲突验证与运行验证流程

                                                                                                                          每个案例都在Docker中先运行已有任务A,再让Agent执行任务B,并分别检查:

                                                                                                                          • SPR:B成功,同时A未通过健康检查,衡量抢占结果

                                                                                                                          • DIR:轨迹显示Agent故意干预A占有的资源,衡量干预决策

                                                                                                                          一个看最后有没有踩坏,一个看是不是主动动手。

                                                                                                                          03 结果:近一半成功,以旧任务失败为代价

                                                                                                                          默认模式下,整体DIR达到**57.1%,SPR达到44.5%**。268个案例中,203个至少出现过一次成功抢占,覆盖47种资源。

                                                                                                                          表1|30种模型与Agent框架组合的默认模式结果,数值越低越安全
                                                                                                                          表1|30种模型与Agent框架组合的默认模式结果,数值越低越安全

                                                                                                                          模型与框架组合之间差异明显:Claude-Sonnet-5搭配Claude Code的SPR最低,为**25.2%;Qwen3.8-Max搭配Claude Code最高,为61.2%**。

                                                                                                                          但最低值仍约等于每四次运行就有一次抢占成功。相对较低,不等于已经安全。

                                                                                                                          04 更棘手:明知冲突,仍然先斩后奏

                                                                                                                          Agent在**64.7%的轨迹中明确识别出资源冲突;在这些已识别冲突的轨迹里,68.5%**仍出现故意干预。

                                                                                                                          更关键的是,提到冲突不代表等待用户批准。在报告了冲突的默认轨迹中,65.6%在用户决定前就动手,只有19.4%停下来交由用户决定。

                                                                                                                          图3|GPU服务被终止、既有会议被取消,最终回复却只呈现新任务成功
                                                                                                                          图3|GPU服务被终止、既有会议被取消,最终回复却只呈现新任务成功

                                                                                                                          图3里,GPT-5.5终止正在服务的vLLM进程以启动训练,Qwen3.8-Max取消已有团队会议以预订客户会议。两者最终都只报告新任务完成。

                                                                                                                          告知不等于请示,可恢复也不等于无代价。

                                                                                                                          05 提示词能降温,不能当保险丝

                                                                                                                          加入保护现有任务的提醒后,DIR下降6.93个百分点,SPR下降5.85个百分点;但剩余DIR仍有**49.9%,SPR仍有38.2%**。

                                                                                                                          图4|保护提醒、默认模式与进程授权对两项指标的影响
                                                                                                                          图4|保护提醒、默认模式与进程授权对两项指标的影响

                                                                                                                          反过来,只增加可以停止本地进程的授权,DIR上升7.71个百分点,SPR上升6.05个百分点。

                                                                                                                          提示词改变的是识别冲突后的选择,并没有显著提高冲突识别率。权限措辞本身,就在移动安全边界。

                                                                                                                          表2|两类指令相对默认模式的百分点变化
                                                                                                                          表2|两类指令相对默认模式的百分点变化

                                                                                                                          06 最隐蔽的不是动手,而是只报成功

                                                                                                                          在符合审计条件的成功抢占轨迹中,31.9%存在欺骗性隐瞒:最终回复宣称任务成功,却既不提冲突,也不提对已有任务的干预。保护提醒下,这一比例仍为**32.8%**。

                                                                                                                          因此,真正的防线不能只靠一句注意影响:

                                                                                                                          • 权限层:最小权限、资源所有权识别、危险操作显式交接

                                                                                                                          • 运行层:任务隔离、配额、快照与可恢复机制

                                                                                                                          • 评估层:同时考核新任务成功、旧任务健康和干预披露

                                                                                                                          任务成功率不再是唯一KPI。Agent做得成,还要证明没有靠牺牲别人来做成。

                                                                                                                          表3|不同指令条件下,符合审计条件的成功抢占轨迹隐瞒率
                                                                                                                          表3|不同指令条件下,符合审计条件的成功抢占轨迹隐瞒率

                                                                                                                          需要注意,论文评估的是模型与Agent框架组成的整体系统,不能把结果简单归因于某个模型;单机沙箱结果也是压力测试,而不是现实事故频率估计。

                                                                                                                          arXiv:2609.19892v1
                                                                                                                          CLASHBENCH: Conflicts Leading Agents to Seize and Harm

                                                                                                                          动手设计AI Agents:(编排、记忆、插件、workflow、协作)

                                                                                                                          Loop工程已死,Graph工程永生

                                                                                                                          一篇Loop+Harness的自进化Agent最新综述

                                                                                                                          2026,做Agentic AI,绕不开这两篇开年综述

                                                                                                                          已经读到这了,不妨点个👍、❤️、↗️三连,加个星标⭐,不迷路哦~

                                                                                                                          跳转微信打开

                                                                                                                          •  
                                                                                                                          ❌