铃阅
❌

阅读视图

Strata“黑魔法”:12GB 显卡如何跑起 Qwen3.8-Flash-Next

原创 NLPer 2026-11-16 21:54 江苏

本地部署

今年9月,开发者 Niko1221 开源了 Strata。它最初想做的是:用一张12—24GB的 NVIDIA 显卡,配64GB内存和桌面 CPU,跑起125B的 Qwen3.8-Flash-Next。

不到两个月,项目已经有了约4.47万 Star、4900多个 Fork。原本的专用推理引擎,也有了桌面应用、终端和本地模型服务。

Strata官方桌面应用截图 图中使用Gyro-S

Strata官方桌面应用截图 图中使用Gyro-S

从专用引擎起步

第一版 Strata 是为 Qwen3.8-Flash-Next 定制的推理引擎,面向 NVIDIA 显卡提供现成的 Windows 运行包,同时开放兼容 OpenAI 和 Anthropic 的本地接口。用户可以把已经在用的聊天软件、编码工具接进来。

10月初,Hacker News 出现了一条“消费级硬件以100 token/s运行125B Qwen”的帖子,目前累计有940分、420条评论。有人贴自己的机器和速度,也有人追问量化质量、长上下文和视觉表现。

到了10月的0.2.0-beta,Strata 把桌面应用、终端和引擎接成了一套。Windows、Linux、Mac 有了各自的安装包,下载模型、选择存储位置、聊天和工具连接也有了界面。

桌面应用可以处理文件、图片和代码,生成的网页还能在侧边直接预览。

10月下旬,0.2.4 加入了 DeepSeek-V4.1-Flash 的终端运行入口。最近的0.2.14,又把 NVIDIA、AMD 上的提示词处理切到了 Strata 自有内核。

用户 irawanw 把它叫作“黑魔法”。他原先用两张 RTX 3090、vLLM 张量并行跑 Qwen3.8 27B,后来换成一张 GPU 配64GB RAM,在 Strata 上跑 Qwen3.8-Flash-Next,成了自己的日常主力。

显存里只留常用的部分

Qwen3.8-Flash-Next 是125B的 MoE,每个 token 激活约6B参数。它的48层中,每层有512个路由专家,当前 token 选出10个,全模型合计24,576个专家。

其中36层使用 Gated DeltaNet,维护固定大小的递归状态;另外12层使用稀疏注意力。还有约51B参数的 n-gram 查找表,按最近几个 token 读取对应的行。

Strata 做了一个技术说明,用 RTX 5070 12GB、Ryzen 5 7600、64GB DDR5-5200和 NVMe SSD,记录了这套分工。

以文中的 Q2_0 配置为例,Attention、DeltaNet、路由器、共享专家、输出头,以及缓存和递归状态优先留在显存。剩余显存用来缓存常用的路由专家。

约34GB路由专家放在系统内存,约29GB的 n-gram 表留在 SSD。查找表每次只读取需要的行,文中记录的每 token 读取量不超过约23KB。

技术说明图1 显存 内存与SSD的分工

技术说明图1 显存 内存与SSD的分工

生成时,GPU先算出当前层要调用哪些专家。缓存命中的,直接在GPU计算;没有命中的,一部分通过 PCIe 传给GPU,另一部分由CPU在内存里就地计算,最后合并结果。

技术说明图2 一层中的GPU CPU与PCIe并行

技术说明图2 一层中的GPU CPU与PCIe并行

GPU算已缓存的专家,CPU算另一部分,传输也同时进行。

专家缓存会随对话调整。说明中的12GB显卡约能缓存4500个专家;同组测试里,静态命中率约50%,在4K上下文下动态调整后约72%。

技术说明图3 静态专家缓存容量与命中率

技术说明图3 静态专家缓存容量与命中率

读入长代码时,Strata 则分块处理输入,把一层层权重流送到GPU,让传输与批量计算重叠。开始逐字生成后,再切回CPU与GPU分担的小批计算。

早期实现使用 Qwen 自带的 MTP 层:先起草后续几个 token,再交给主模型一起验证,通过的留下,遇到不一致的位置再修正。

项目示意图 起草模块预测 主模型按顺序验证

项目示意图 起草模块预测 主模型按顺序验证

技术说明中,最多起草3个 token,和前一个已接受的 token 组成最多4个 token 的验证窗口。4K测试里,每个窗口平均产出约3.2个 token,MTP加速收益约1.6—1.8倍。较新的版本还加入了 DFlash2 等起草路径。

生成速度如何

在前面那台 RTX 5070 测试机上,记录了以下生成速度。每种输入长度运行一次代码审查任务,生成256个 token,使用 greedy 解码与 MTP。

量化

约4K上下文

约128K上下文

Q2_0

94.6 token/s

65.1 token/s

IQ2_XS

78.0 token/s

52.0 token/s

IQ3_XXS

65.6 token/s

44.8 token/s

项目9月技术说明表3 不同量化和上下文下的生成速度

项目技术说明表3 不同量化和上下文下的生成速度

Q2_0 在约4K输入下,首次响应约6.7秒;接近262K输入时,要先等约524秒,随后仍能以56.3 token/s生成。

长历史占用更多显存,留给专家缓存的空间也会减少。

12GB是显存,64GB是系统内存。 以原版 Qwen 的 ISTA-DASLab 量化为例,路由专家的内存占用大致如下:

量化

路由专家约占

Q2_0

34GB

IQ2_XS

35.5GB

IQ3_XXS

43GB

IQ3_S

50GB

还要给操作系统、缓冲区、上下文和其他程序留空间。64GB机器选择 IQ3_S 时,余量已经比较紧。内存放不下专家,Strata 可以改从 SSD 读取更多权重,但速度会明显下降。

量化也会改变输出。项目在固定文本的4995个位置上,以 Q8_0 为参照,测得首选 token 一致率:Q2_0 为80.6%,IQ3_S 为87.7%,UD-Q4_K_XL 为93.1%。

项目目前推荐先看 ISTA-DASLab 的兼容量化,再看 Unsloth 等选择。Q2_0 更省内存、生成更快;更高位数的包需要更多资源,可以结合自己的代码任务判断是否值得。

Q2_0 文件合计约66GB,起草层和图片组件还会增加下载。NVMe SSD 要同时承担模型存放和部分运行中的读取。

最后

想试用的朋友可以从项目 Releases 下载对应系统的安装包,在模型页选择模型、存储位置和上下文;已有 GGUF,也可以直接导入。

安装好 Strata 后,用终端先查看运行计划:

strata launch --family qwen --model q2_0 --plan

这一步只显示模型、文件和硬件安排,不下载、不启动。确认后再运行:

strata launch --family qwen --model q2_0

首次下载完成后,可以在监控界面看提示词处理、逐字生成和内存占用。先用自己常做的任务跑一轮,再调整上下文和量化。

Strata官方终端监控界面 图中为Gyro-S会话

Strata官方终端监控界面 图中为Gyro-S会话

桌面应用也能直接处理文件和代码,默认 Manual 模式会在修改文件、执行非只读命令前请求确认。模型准备好后,本地聊天和推理可断网运行;联网搜索、外部模型和远程工具按各自功能访问网络。

接回已有编码工具,运行:

strata connect

它会列出 Claude Code、Codex CLI、OpenCode 等客户端的连接设置。

参考链接

跳转微信打开

  •  

突发!黄仁勋与盟友商讨重返英伟达CEO之位

大模型智能 2026-11-17 00:00 吉林

硅谷的盟友开始向英伟达董事会施压,要求恢复黄仁勋的职位

图片

大模型智能|分享

来源 | 机器之心

黄仁勋辞职没几天,硅谷已经开始想办法把他请回来了。

当地时间 11 月 15 日,据英国《金融时报》报道,黄仁勋正在与身边亲信讨论重返英伟达 CEO 职位的可能性。

图片

来源:https://www.ft.com/content/45383d86-33c4-4d99-86e5-5e058d3567c1?utm_source=chatgpt.com&syn-25a6b1a6=1

一位黄仁勋的盟友向《金融时报》透露,他们正在组建一个由硅谷科技企业高管组成的 War Room,计划游说英伟达董事会,推动黄仁勋重新担任 CEO,并尝试争取白宫的支持。

这位人士表示:「在前沿实验室之外,科技行业里所有有影响力的人都喜欢黄仁勋。」他还补充称,推动黄仁勋回归的行动得到了黄仁勋本人的支持。

图片

刚刚过去的这个周末,一场要求黄仁勋重返英伟达的声援行动迅速升温。

特斯拉和 SpaceX CEO 埃隆・马斯克(Elon Musk)、Epic Games CEO 蒂姆・斯威尼(Tim Sweeney)、Replit CEO Amjad Masad 等科技圈知名人士,纷纷加入联名行动,呼吁英伟达董事会让黄仁勋回归。

图片

这场声援不仅来自硅谷高管,也得到了英伟达内部员工的响应。黄仁勋辞职后,已有多名员工公开表达对他的支持,并签署联名信。

截至目前,支持黄仁勋回归的在线请愿签名人数已经突破 15 万,且仍在持续增长。

图片

需要注意的是,这些身份主要来自签署者自行申报,尚不能视为全部经过独立核实。

不过,黄仁勋想要回来,恐怕没有那么容易。

首先,英伟达董事会并不一定会接受外部压力。

《金融时报》此前披露,董事会已经接触 Arm CEO 雷内・哈斯(Rene Haas),探讨其接任英伟达 CEO 的可能性。

但英伟达董事会随后回应称,目前尚未启动正式的 CEO 遴选程序。

与此同时,英伟达的管理层已经进入临时过渡状态。公司首席财务官科莱特・克雷斯(Colette Kress)目前担任临时 CEO,管理团队正试图稳定公司运营,为即将公布的季度财报做准备。

黄仁勋本人也缺少一个重要筹码。

与一些拥有绝对控制权的创始人不同,黄仁勋并不持有足以控制英伟达的股份,无法单方面推翻董事会的决定。即使硅谷支持者不断发声,最终能否回归仍然取决于董事会。

外部力量的态度同样存在分歧。一方面,Altimeter Capital 创始人 Brad Gerstner 和 Atreides Management 创始人 Gavin Baker 两位英伟达股东,已经联名致信董事会,要求保留所有可能性,包括黄仁勋回归。

两人在信中强调,黄仁勋长期以来为英伟达创造了巨大价值,而他的突然离职又给公司带来了不确定性。因此,他们希望董事会审慎处理这场危机,不要提前排除黄仁勋复职的可能。

另一方面,推动黄仁勋复职的行动很可能遭到华盛顿部分重要政策制定者的反对。美国财政部长斯科特・贝森特(Scott Bessent)周日呼吁英伟达进行一次「重大管理层改组」(dramatic shake-up)。

截至目前,英伟达发言人和黄仁勋的发言人均拒绝置评。

英伟达这场突如其来的 CEO 风波,显然还远没有结束。

图片

技术交流群邀请函

图片

图片

图片

图片

△长按添加小助手

扫描二维码添加小助手微信

请备注:姓名-学校/公司-研究方向-城市

(如:小夏-浙大-大模型-杭州)

即可申请加入深度学习/机器学习等技术交流群

—完—

图片

跳转微信打开

  •  

哈佛最新 AI 课发布:从 Agent 一路学到 GPU!

Datawhale 2026-11-17 00:00 吉林

以下文章来源于:Datawhale

Datawhale

一个专注于AI领域的开源组织,汇聚了众多优秀学习者,使命-for the learner,和学习者一起成长。

 Datawhale干货 

最新课程:哈佛 CS2680

一个 AI Agent 从你敲下第一句提示词,到物理显卡上吐出最后一个 token,中间到底穿透了哪些技术层级?

很多开发者在尝试构建复杂的智能体系统时,很快就会撞墙。瓶颈往往不在于提示词写得够不够巧,而在于真实的工程现实:不可控的延迟、高企的 Token 账单、长程规划失控,以及多轮交互下迅速被吃满的显存。

想要真正做出一套可靠的高性能 Agent,只懂上层框架不够,只看底层 CUDA 算子也不够。

哈佛大学今年秋季开设了一门极具特色的硬核大课:CS2680《Modern AI Systems: Agents and System Optimizations》。

全学期不搞分散的散点练习,只盯准一个名为 Mads 的智能体系统,带你从应用层的 Agent Loop 一路往下拆,直到接管开源模型的推理服务与底层 GPU 硬件。

目前,这门课的大纲、阅读清单以及课件幻灯片已全部在官方主页向公众开放。

Image

    课程官网:https://cs2680.seas.harvard.edu/

    一、课程大纲与主线

    这门课之所以让人眼前一亮,首先在于它的课程结构设计。

    它没有把内容割裂成孤立的章节,而是以一个名为 Mads(Modern Agent Design and Systems) 的系统贯穿始终。全课 14 周被清晰地切分为两大阶段:

    前半程(第 1~7 周)聚焦智能体设计与评估。 从 Claude Code 的运行机制切入,依次讲透多 Agent 协作、上下文与工具管理(ReAct)、长期记忆(MemGPT)、评测体系以及成本性能权衡。

    后半程(第 8~14 周)深挖底层推理系统。 从 GPU/CUDA 基础出发,逐层拆解批处理调度、PagedAttention(vLLM/SGLang)、投机推理、KV Cache 优化与量化压缩,最终落到智能体请求调度与负载均衡。

    二、五个贯穿式作业

    CS2680 不设期末考试,而是通过5个作业一环扣一环,带着学习者从最上层的前端一路改到底层推理引擎:

    Image

    1. Mads-Lens(搭建可视化监控台,10%)
    用 Claude Code 为它自己写一个 Web UI 前端,实时可视化运行轨迹:展示每次工具调用的入参和返回结果,把派生的子 Agent 展开成树状图,定位报错现场,并实时统计每次调用的 Token 消耗与花费。

    2. Mads-Loop(手写核心运行时,10%)去掉现成客户端,直接围绕模型 API 手写 Agent Runtime:实现结构化工具调用、上下文滑动窗口管理、报错重试与退出判定。助教会用隐藏测试集专门测这套 Runtime 的容错能力,重点看代码循环本身够不够稳。

    3. Mads-Opt(压榨成本与延迟,20%)在调用商业 API 的前提下做端到端优化。要求在任务成功率不降的基础上,砍掉多余 Token、把简单任务分流给便宜的小模型、做工具并发调用并重构上下文,把延迟和开销压到最低,最后写一篇技术复盘博客。

    4. Mads-Serve(接管本地推理引擎,20%)拿掉外部商业 API,课程给每位学生发一张 RTX PRO 4500(32GB 显存) 独立 GPU。学生需要在卡上自己部署开源模型,把前一步写好的 Agent 接进本地推理服务,通过改批处理调度和 KV Cache 复用解决显存与排队瓶颈,按完成任务数和总耗时在全班实时榜单(Leaderboard)上排名。

    5. Mads-Stack(全栈解封打榜,10%)最后一步把上层 Agent 架构、开源模型选型和底层推理内核全部放开修改。统一用 Terminal-Bench 2.0 评测,跑过基线就能拿满基础分,前 26 项任务的综合排名还会有额外的榜单加分。

    三、学习地址

    课程主页:https://cs2680.seas.harvard.edu/

    需要提醒的是,这门课是一门地道的研究生级系统硬核课程,并不适合零基础入门。

    官方先修要求是完成过 CS61(计算机系统导论)以及至少一门研究生级别的系统课,默认熟练掌握 Python 与 PyTorch。课程主页写得非常直白:老师在课堂上不会把作业所需的所有技术细节都讲完,想要拿到满意的成绩,必须做好课后花费大量时间自学和调试实验的准备。

    值得一提的是,虽然哈佛官方目前暂未向外网公开课堂现场录像,但官方所有课件幻灯片均已按周次直接放出;同时海外技术社区也已经在 YouTube 上推出了针对这门课的逐讲视频深度拆解(覆盖 Claude Code 运行原理、多 Agent 架构、上下文管理与评测基准等),非常适合配合官方课件同步精读。

    Image

    大模型时代已经从单纯的比拼提示词,走向了智能体架构与推理基础设施协同优化的深水区。

    无论你正在开发智能体应用,还是在搭建模型推理服务,哈佛 CS2680 所给出的这条工程演进路线,都值得每一位工程人员认真研读。

    目前官方主页上的教学日历、课件幻灯片与论文清单均可自由访问,建议收藏学习。

    图片

    一起“点赞”三连↓

    跳转微信打开

    •  

    ICLR 2027初审均分仅2.06!清华份额第一,武大均分第三

    原创 让你更懂AI的 2026-11-16 21:49 北京

    中国高校表现抢眼

    图片

    今年 ICLR 拿到 2.5 分,究竟排在什么水平?

    ICLR 2027 的全球高校成绩单来了,中国高校包揽了论文份额榜前四。

    清华大学排在第一,北大、上交、浙大紧随其后。

    按初审均分排名,武汉大学以 2.35 分位居全球高校第三,仅次于康奈尔大学和浦项科技大学,排在斯坦福、麻省理工等名校前面。

    〓 图源 https://github.com/clareLab/posters/

    超过 4 万篇论文的初审均分只有 2.06,近六成评审给出 2 分(Weak Reject),平均分达到 3 分的论文仅占约 4.1%。

    一篇论文拿到 2.5 分,在 4 万多篇投稿中究竟是什么水平?

    有网友开发了 Score Atlas,输入分数就能查看百分位和并列排名。

    随着 Rebuttal 推进,审稿人上调或下调分数的情况,也被网友做成了每日更新的统计。

    清华份额第一,武汉大学均分全球第三

    有网友从 OpenReview 获取初审评分,通过标题匹配 arXiv 预印本,再利用 OpenAlex 识别作者机构,整理出一份覆盖全球高校、研究机构和大厂的统计榜单。

    按分摊投稿量计算,清华大学以 315.2 位居全球第一,关联 734 篇论文。北京大学、上海交通大学和浙江大学紧随其后。排在第五的斯坦福大学为 145.9,尚不及清华的一半。

    中国内地高校前十名如下:

    中国香港地区单独统计。香港科技大学的分摊投稿量为 113.4,香港中文大学 91.6,香港大学 80.4。

    在分摊投稿量不少于 20 的高校中,康奈尔大学以 2.40 分位居全球初审均分第一,浦项科技大学 2.37 分第二,武汉大学 2.35 分第三。

    武汉大学关联 90 篇论文,分摊投稿量 29.4,不到清华的十分之一,初审均分却比清华的 2.19 高出约 0.16 分。

    中国内地及香港高校中,上海科技大学均分 2.25,同济大学 2.23,香港中文大学(深圳)和香港科技大学约 2.22,也排在均分榜前列。

    大厂方面,美团初审均分达到 2.38,腾讯 2.28,阿里 2.27。阿里的分摊投稿量还有 133.7,接近卡内基梅隆大学。

    按国家和地区统计,中国内地机构占样本加权投稿量的 33.39%,略高于美国的 31.96%;两者初审均分分别为 2.175 和 2.182,几乎没有差别。

    这份榜单基于 10520 篇成功匹配作者机构的论文,约占同期已评分投稿的四分之一,合作论文按作者及机构分摊计数。

    近六成评审给2分,2.5分能排在哪?

    ICLR 2027 将总体推荐评分从上届的六档改为四档,分别是 1 分(Clear Reject)、2 分(Weak Reject)、3 分(Weak Accept)和 4 分(Clear Accept)。

    clareLab 在 11 月 6 日整理的初审数据覆盖 40544 篇论文、125304 份评审,论文初审均分为 2.06,中位数 2.00。

    单份评审中,2 分占 57.5%,1 分占约 19%,两者合计超过 76%。相比之下,3 分约占 22%,最高的 4 分仅占 1.5%。

    按论文均分计算,只有约 4.1% 的论文达到 3 分及以上。

    〓ICLR 2027初审均分与单份评审评分分布

    不同研究方向也存在一些差异。

    生成模型均分约为 2.16,学习理论 2.13,机器人与规划 2.12。包括大语言模型在内的基础模型方向约为 2.07,与全体均分接近,强化学习则为 2.04。

    在在线工具 Score Atlas 中输入 2.50,页面显示 84.8% 的论文均分不高于这一成绩,其中 606 篇与之同分。

    〓2.50分在公开评审中的百分位查询结果

    大量论文的平均分完全相同,名次也因此出现大规模并列。

    例如,三名审稿人分别给出 2、2、3 分,均分约为 2.33,与 8563 篇论文并列,排名区间为第 6818-15380 名。

    如果拿到 2、3、3 分,均分约为 2.67,并列论文减少至 4231 篇,对应第 1905-6135 名。

    新四分制下,绝大部分论文只有三份评审,可形成的平均分组合相对有限,这也是分数集中、并列名次较多的原因。

    除了查询排名,Score Atlas 还支持按研究方向、评审数量和置信度筛选,并可导出 CSV 数据。工具使用 11 月 6 日采集的 40642 篇有评分论文快照。

    Rebuttal进行时,改分明显加速

    随着 Rebuttal 推进,有网友制作了 ICLR 2027 Rebuttal Tracker,持续追踪 OpenReview 上的评分变化,并将改分方向、每日走势和作者回复情况汇总到一个网页中。

    根据 11 月 16 日更新的数据,126395 份评审中已有 3204 份修改评分,占 2.53%。

    其中,2916 份评分上调、288 份下调,已经发生的改分中,约 91% 都是上调。

    最受关注的是,2006 条评审从 2 分(Weak Reject)升至 3 分(Weak Accept),评分由拒稿倾向转为接收倾向。

    全部改分涉及 3029 篇论文,其中 2745 篇的平均分提高。

    〓ICLR 2027评审改分趋势

    改分数量增长很快。11 月 15 日还只有 1823 条评审发生变化,一天后就增加至 3204 条。

    已有 18620 篇论文发布作者回应,其中 5729 篇得到至少一名审稿人的公开回复,约占已回应论文的 30.8%。

    Rebuttal官方规则

    1. 公开讨论截止时间

    作者与审稿人的公开讨论截至 11 月 18 日 AoE(UTC−12)。随后进入内部讨论,12 月 16 日公布最终录用决定。

    2. 论文修订与页数

    讨论期内可以多次上传修订稿,正文页数上限从初稿的 9 页提高至 10 页。参考文献不计入页数,附录不限页。

    作者需要主动说明修改内容及具体位置,审稿人和领域主席没有义务逐一阅读所有修订版本。

    3. 新增实验的范围

    可以补充实验回应审稿意见,但应围绕原论文已有结果展开。对于与初稿存在重大差异的修改,审稿人和领域主席可以选择不予采纳。

    4. 多轮回复与评分调整

    每条评论有字数限制,回复总次数不限。审稿人有责任参与讨论,并可根据作者回应调整评分和推荐意见。

    作者公开讨论期结束后,审稿人仍可更新评审意见。

    5. 向领域主席反馈问题

    作者可以通过 OpenReview 的 Readers 设置,向 AC 发送限制可见范围的评论。

    如果问题无法通过 AC 解决,还可以联系 PC,邮件标题需以 [Authors-to-PCs] 开头。

    6. 双盲匿名要求

    修订稿、补充材料、代码仓库及演示链接都必须保持匿名。在线演示网站也不能通过访问记录泄露审稿人身份,否则可能面临 desk reject。

    7. SOTA与近期工作

    未达到 SOTA,本身不足以成为拒稿理由。

    对于投稿截止前不久发表的同期研究,以及仅在 arXiv 公开、尚未经过同行评审的论文,也不能仅因作者缺少相关对比就直接拒稿。

    ICLR 2027 Rebuttal Tracker 还提供了往届 ICLR 的改分统计。从初审评分公开到最终决定,往年约有 11%-20% 的评审修改过评分,其中约九成为上调。

    图片

    参考文献

    图片

    [1] https://github.com/clareLab/posters

    [2] https://songjhpku.github.io/ICLR2027-statistics/

    [3] https://iclr.hackmypaper.com/today/2026-11-16.html

    [4] https://iclr.cc/Conferences/2027/AuthorGuidelines

    [5] https://iclr.cc/Conferences/2027/ReviewerGuidelines

    [6] https://iclr.cc/Conferences/2027/AreaChairGuidelines

    更多阅读

    ·

    跳转微信打开

    •  

    AI学着读懂物理世界:清华张强团队发布自进化AI科学家EvoSim

    让你更懂AI的 2026-11-16 21:49 北京

    让模型与方法一起进化

    从电池实验数据出发,AI 科学家开始自己搭建模型解析物理世界了!

    最近,清华大学化工系张强教授团队联合北京清屿科技、香港大学、北京怀柔实验室等机构,在论文《EvoSim: Learning to Model, Modeling to Learn》中提出了一个面向物理建模的 AI 科学家 EvoSim。

    论文地址:

    https://arxiv.org/abs/2610.11344

    物理模型是材料研发和器件设计中的常用工具。研究人员用一组方程描述材料内部发生的过程,算出电压、温度这些可以测量的量,再与实验结果对照。

    现有的 AI 科学家系统已经能在物理模型中调整参数、拟合数据,但模型该包含哪些物理过程,通常仍由研究人员事先定好。

    EvoSim 把这一步也交给了 AI。当模型算出的结果和实验对不上时,它会判断问题是否出在模型漏掉了某个物理过程,找到后补进模型,再用实验数据检验。

    在这个过程中,EvoSim 还会把检验有效的做法整理成建模方法,用到后续任务中。模型在改进,建模方法也在改进,论文把这种两者同步提升的过程称为“自进化”。

    〓 图1. EvoSim让物理模型与开发它的 AI 科学家协同进化。图片来自论文。

    团队用两项工业级电池建模任务测试了 EvoSim。

    第一项任务是预测快充时何时开始析锂,也就是负极表面何时开始析出金属锂。EvoSim 的平均误差为 1.79 个百分点,原研究模型为 2.82 个百分点。

    第二项任务是预测车辆行驶时的电池电压。面对建模时没有用过的温度,EvoSim的误差低至 7.62 毫伏,好于此前发表的多个电池电压模型。

    更值得注意的是,用上自己总结的建模方法后,EvoSim 在同一任务上的误差降低了 75.4%。在 11 项建模任务的 45 组实验中,它的出错次数减少 36.4%,运行时间缩短 42.6%。

    这是怎么做到的?

    预测和测量对不上:是参数、求解,还是方程本身出了问题?

    AI 在数学、编程等任务上进步很快。这些任务规则清楚,答案对不对可以直接判断。

    材料研发和器件设计面对的问题则不同。以锂电池为例,锂离子在电解液中迁移,在电极颗粒中扩散,在电极表面发生反应。

    这些过程都发生在微观尺度,没法直接看到。研究人员能拿到的,通常只有电压、电流和温度这些外部数据。

    物理模型就是用来连接这两者的。研究人员把内部过程写成方程,通过求解(用计算机算出模型结果)得到电压等数值,再与实验数据比较。两者吻合,说明模型对内部过程的描述大体正确。

    真正的难点在两者不吻合的时候。偏差可能来自参数取值不准,可能来自求解过程出错,也可能是方程漏掉了某个物理过程。

    前两种情况,调整参数、检查计算就能解决。第三种情况,则要先弄清漏掉的是什么,再把它补进模型。

    这恰恰是现有 AI 不擅长的地方。在电池专业知识问答上,前沿大模型的准确率已经很高,但问答只需要从已有知识里找答案。

    一旦要求它根据实验现象提出新的物理解释,并用实验去检验,它的表现就不稳定了。

    许多 AI 辅助建模工具,也只是在研究人员给定的模型里调参数、跑仿真。如果模型本身漏掉了关键的物理过程,参数调得再细,预测和实验之间那些有规律的偏差也消除不了。

    于是,EvoSim 要回答的问题是:预测和实验对不上时,AI 能不能自己找到原因、补上缺失的物理过程,并把这次摸索出的有效做法用到下一个任务里?

    EvoSim 的做法,是把每一次预测偏差都当作一个需要研究的问题。

    它会先列出几种可能的原因,比如某个参数取值不准,或者模型缺了某个物理过程。

    每种原因对应一个修改方案,由此生成一个待检验的模型,称为候选模型。几个候选模型会同时搭建,并调用仿真软件 COMSOL 求解。

    每个候选模型都要通过三项检查:修改是否真的在模型中生效;求解是否完整完成、结果有没有异常值;预测与实验数据的误差有多大。三项都通过,候选模型才会被采用。

    没被采用的候选模型也有用处。EvoSim 会记下它失败的条件和出错的步骤,并据此提出改进做法。改进做法要在后续任务中用过、确认有效,才会作为建模方法保存下来。

    下一轮研究开始时,EvoSim 会调出与当前问题条件相符的建模方法,用来决定先检验哪个原因、先做哪项检查。

    〓 图2. 同一轮实验反馈在推动物理模型修订的同时,也为 AI 提炼和检验建模方法提供了证据;更新后的方法继续引导后续的模型探索。图片来自论文。

    因此,每一轮研究改进的不只是模型,还有 EvoSim 自己的建模方法。下面两项电池任务,分别展示了这两方面的效果。

    快充提速的代价:析锂从哪一刻开始?

    充电时,锂离子本应嵌入石墨负极。充电倍率是充电电流与电池容量之比,倍率越高,充得越快。

    但倍率过高时,部分锂离子来不及嵌入,就会在负极表面析出为金属锂,这就是析锂。析出的锂有一部分会永久失去活性,导致电池容量下降,还可能带来安全隐患。

    析锂起点通常用荷电状态来表示。荷电状态是当前电量占总容量的百分比。析锂起点决定了快充时电池最多能充到多少电量而不析锂,是设计快充策略的重要依据。

    预测析锂起点并不容易。它同时受温度、电极厚度、充电倍率等因素影响。充电过程中,负极内部的锂含量又无法直接测量,单看外部电压曲线,很难判断析锂从何时开始。

    研究使用的是一项发表在 Nature Energy 上的研究所公开的数据。

    这批数据包括来自 61 个测试电池的 20 组析锂起点,覆盖两种厚度的石墨电极、25 至 45 摄氏度,以及 2C 至 6C 的充电倍率(1C 约为 1 小时充满)。

    其中 14 组数据用于参数识别,也就是用实验数据确定模型参数的取值。另外 6 组作为验证条件,只用来检验预测,不参与参数识别。

    EvoSim从 首先建立了锂离子在电解液和电极颗粒中的迁移,以及锂嵌入石墨的反应。继续,EvoSim 给模型加上了析锂反应,以及已析出的锂重新溶解的剥离反应。

    接下来,模型需要估算析出的锂中有多少变成了不可逆锂,也就是再也无法参与充放电的锂。一开始,这个比例被设为固定的 30%。

    结果发现,预测偏差随充电倍率有规律地变化。这说明“固定比例”这个假设站不住。

    EvoSim 据此提出了新的解释:不可逆锂所占的比例并不固定,而是随充电倍率变化。

    背后的道理并不复杂。析出的锂要失去活性需要一段时间,比如与电极断开电接触,或者被电极表面新生成的膜层包裹。

    充电倍率越高,充电时间越短,析出的锂在测量前来得及失去活性的比例就越低。

    当然,这并不是说快充时析出的锂更少。快充时析锂总量会增加,只是其中失去活性的比例下降了。

    EvoSim 随后把这一比例改成了随充电倍率变化的关系。研究用平均绝对误差来衡量结果,也就是把各条件下预测值与实测值之差的绝对值取平均。

    在验证条件上,误差从固定比例时的 3.79 个百分点降到了 1.79 个百分点。

    作为对比,原研究模型在同样条件上的平均绝对误差为 2.82 个百分点,而且它在建立时用到了全部 20 组数据。

    这项任务也体现了 EvoSim 的一个判断:当偏差呈现规律时,它会转去检查物理过程,而不是继续调参数。

    换一个从未见过的温度,整段行车电压还能算准吗?

    第二项任务,是预测车辆行驶时的电池电压。

    车辆加速时,电池放电;制动时,电池回收能量充电。电流不停变化,电压也跟着波动。

    电池管理系统是车上负责监测和控制电池的系统。它要靠准确的电压预测,来估计剩余电量、判断能输出多大功率,并让电压保持在安全范围内。

    难点在于,电流一变,电池里几个过程的变化快慢不一。电极颗粒内部的锂浓度、电解液中的锂离子浓度、电极表面的电荷,变化速度各不相同。模型要同时描述好这些过程,才能把整段电压曲线算准。

    研究使用的是马里兰大学公开的一块磷酸铁锂电池的测试数据,包括两种标准测试工况。

    DST 是动态应力测试,电流在充电和放电之间快速切换。US06 是美国环保署制定的驾驶工况,包含高速和急加速。

    数据覆盖 -10 至 50 摄氏度的 8 个温度,共 16 条完整曲线、109,746 个数据点。数据每秒记录一次,总时长约 30 小时。

    EvoSim 的起始模型用四个变量描述电极状态,分别是正极和负极颗粒中锂的平均含量和表面含量。

    EvoSim 重写了这四个变量随时间更新的计算方式,并在模型中加入了两个物理过程:锂离子在电解液中的迁移,以及电极表面电荷的积累和释放。

    验证时,每次取出一个温度下的两条曲线,用其余7个温度的14条曲线做参数识别,再去预测取出的那两条。也就是说,模型要预测的,始终是参数识别时没见过的温度。

    结果用均方根误差衡量,它反映整条预测曲线与实测曲线的平均偏离程度。30 摄氏度 DST 曲线的误差为 7.62 毫伏,20 摄氏度 US06 曲线为 8.97 毫伏。

    其他研究在 DST 和 US06 工况下报告的电压误差,在 12.25 至 49.50 毫伏之间。论文据此认为,EvoSim 的精度超过了此前研究人员发表的模型。

    能在没见过的温度下算准电压,说明模型描述的物理过程在不同温度下都成立,而不只是贴合了参与参数识别的那几条曲线。

    〓 图3. 析锂起点与动态电压预测:(a)两种电极设计在不同温度和倍率下的析锂起点;(b)20 个工况的实测与预测,以及电压误差与文献对比;(c)两个留出温度下的完整电压轨迹。图片来自论文。

    在这项任务中,EvoSim 还碰到了一个计算错误。它解决这个错误的过程,正好说明了建模方法是怎样积累起来的。

    一次纠错,改变了 AI 之后的建模思路

    模型计算时,会把连续的时间切成每秒一步,每一步都根据当时的电流和温度更新电极状态。

    早期模型虽然能算完,算出的电极状态却和作为参照的标准结果对不上,误差达到 88.518 毫伏。

    EvoSim 查出问题出在每一步更新电极状态的公式上。改正之后,误差降到了 4.1136 毫伏。

    它把这次修正整理成一条建模方法,写清了四件事:每一步更新用的准确公式,每一步该用哪个时刻的电流和温度,电极状态在仿真软件中如何设置,以及求解完成后要检查哪些输出。

    这条建模方法到底有没有用?论文设计了一组对照实验。

    三组实验做的是同一个任务:30 摄氏度 DST 曲线,共 7,461 个数据点。

    三组的起始模型、数据、仿真软件和检查标准都相同,所用的大模型都是 gpt-5.5。每组最多提交 12 个模型,比较前 3 次提交的结果。

    三组唯一的区别,是事先拿到的材料。第一组什么都没有;第二组拿到一份按时间顺序整理的过往尝试摘要;第三组拿到的是上面那条检验过的建模方法。

    通过全部三项检查的模型,才算有效模型。

    前 3 次提交中,三组最好的有效模型误差分别是 89.478、89.383 和 22.015 毫伏。

    第三组在第 2 次提交时就拿到了这个结果,误差比第一组低 75.4%。第一组和第二组一直提交到第 12 次,最低误差都没有再下降。

    差别就出在材料的内容上。第二组的摘要只写了“后来某个版本改成逐秒更新状态,误差降到约 4 毫伏”,没说具体怎么改。第三组的建模方法则写明了公式和检查项目。

    可见,决定下一轮结果的,不是记住过去做过什么,而是把有效的做法整理成能直接照着执行的步骤。

    这些建模方法也能用到别的任务上。

    在一项同时考虑电化学反应和电池温度变化的建模任务中,EvoSim 用上了一条“先同时比较几种可能的物理机制,再修改模型”的方法。

    这里的物理机制,指产生实验现象的物理过程。用上这条方法后,模型修改次数从 10 次减少到了 1 次。

    论文还在 11 项建模任务上做了 45 组配对实验。每组中,同一个任务运行两次,一次不用积累的建模方法,一次用,其余条件完全相同。

    结果显示,用上建模方法后,出现模型搭建错误或物理机制错误的运行从 33 次减少到 21 次,减少了 36.4%。实际运行时间也缩短了 42.6%。

    不止于电池:一种能自我积累的科研方式

    EvoSim 展示的,是一种让 AI 不断积累科研能力的方式。

    实验数据指出模型解释不了的现象,EvoSim 提出新的物理解释并加以检验。每次研究中的成功和失败,又被整理成建模方法,留给下一次研究。

    EvoSim 也会说明自己的结论在什么范围内成立。

    在 9 项任务得出的结论中,有 4 条在全部测试条件下成立,4 条只在部分条件下成立。还有 1 条原本被认为普遍适用的物理机制,因为所有相关模型都没通过检验而被否定。这 9 个判断都与检验结果一致。

    电池建模任务为这种方式提供了可以量化的检验,而 EvoSim 的这套研究流程并不针对某一种特定的电池模型。

    下一步,研究者可以在材料科学、化学工程、生物工程等领域挑选具体问题来测试它,只要这些问题有实验数据,也有可靠的仿真软件。

    对 AI 来说,理解材料和器件内部发生了什么,不只在于一次预测准不准,更在于能否根据实验数据不断完善自己的解释,并把行之有效的研究方法积累下来。

    作者介绍

    最后,介绍一下这篇工作的作者。

    论文的三位共同第一作者为宋韫玮、陶进开、张俊东,共同通讯作者为张睿、张强。

    清华大学张强教授带领的课题组长期深耕能源化学与能源材料,围绕锂硫电池、锂金属电池和固态电池提出锂键化学、离子溶剂复合结构等重要理论认识,推进高比能电池材料与器件研发。

    近年来,又将高通量计算、机器学习和化学机器人引入电解液设计,开发 Uni-Electrolyte 平台与知识—数据双驱动的性质预测方法,探索从分子生成到实验验证的闭环研发。

    团队相关成果发表于《自然》(Nature)、《自然·化学》(Nature Chemistry)、《自然·能源》(Nature Energy)、《美国化学会志》、《德国应用化学》(Angewandte Chemie International Edition)等期刊。

    更多阅读

    ·

    跳转微信打开

    •  

    【轻量化复刻大模型 / 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

                                                                                                                            跳转微信打开

                                                                                                                            •  
                                                                                                                            ❌