一块 GPU 收到一批文本，先把它们变成数字，再做许多次矩阵乘法。模型猜下一个 Token，系统算出它猜得有多差，随后沿着计算图反向追责，把数千亿乃至上万亿个参数中的一部分轻轻推一下。这个动作会重复几百万次。

把这句话放大，就是大模型预训练。

可真正把训练规模推到万亿参数和十万亿 Token 时，问题远不止”多买几块 GPU”。优化器能不能从同一批数据里学得更快，注意力能不能承受百万 Token，几千张卡是否一直有效工作，训练会不会在跑了几周后突然发散，视觉和文本能不能在同一套表示里互相迁移，这些问题会一起出现。任何一项没处理好，昂贵的训练任务都可能变成一条看起来很忙、其实没有在稳定学习的曲线。

Kimi 创始人、CEO 杨植麟在 NVIDIA GTC 2026 的演讲 How We Scaled Kimi K2.5 里，把他们的思路概括成三条扩展轴：提高 Token 效率，扩展上下文长度，增加协作 Agent 的数量。演讲只有约 40 分钟，信息密度却很高。MuonClip、Kimi Linear、Agent Swarm、原生多模态和 Attention Residuals 接连出现，如果还没亲手训练过神经网络，很容易记住一串名字，回头仍说不清它们各自在解决什么。

封面图是杨植麟在 NVIDIA GTC 2026 讲解 Attention Residuals 的演讲现场，取自 Sky9 Capital 的演讲报道，该报道署名来源为智东西。

这篇文章以演讲字幕为线索，结合 Kimi 团队公开的技术报告，把中间省略的台阶补齐。目标很具体：读完后，你应该能回答下面这些问题。

1. 大模型的一次训练迭代到底发生了什么；
2. Token 效率为什么既影响训练账单，也影响能力上限；
3. MuonClip 和 QK-Clip 分别管什么，它们为什么不能混为一谈；
4. 全注意力为什么怕长文本，Kimi Linear 又怎样在”记住”与”忘掉”之间做取舍；
5. 多 Agent 并行为什么也要训练，奖励函数怎样防止它假装忙碌；
6. 视觉训练为什么可能反过来改善纯文本推理；
7. Attention Residuals 为什么被称为把注意力旋转了 90 度。

文中的产品数据和实验结论以论文作者报告为准。为了教学而添加的例子会明确写成示意，不把我的解释包装成杨植麟的原话。

先看全局：所谓规模化，不再只有一个旋钮

过去提到 Scaling，大家通常想到三样东西：更多参数、更多数据、更多计算。它们仍然重要，但这次演讲想说的是，团队还可以改变每一单位数据产生多少学习效果、一次推理能携带多少工作状态、同一时刻能调动多少个 Agent。

  flowchart LR
  A["有限的高质量数据与计算预算"] --> B["Token 效率<br/>同样数据学到更多"]
  B --> C["更强的基础模型<br/>更好的任务先验"]
  C --> D["长上下文<br/>保存更长的任务轨迹"]
  D --> E["长时程单 Agent<br/>执行更多步骤"]
  E --> F["Agent 集群<br/>拆分并行子任务"]
  F --> G["更高的任务容量<br/>处理更复杂工作"]
  

这三条轴不在同一层。Token 效率主要发生在训练阶段，长上下文既涉及训练也涉及推理，Agent 集群则把扩展推进到系统与强化学习层。把它们硬塞进一个公式会失真，更好的理解方式是看它们怎样逐层放大：基础模型先学得更扎实，单个 Agent 才有较好的判断起点；单个 Agent 能维持更长的状态，才可能承接复杂子任务；很多这样的 Agent 被正确拆分和调度，系统的任务容量才会上去。

我第一次看到这三条轴并列时，最容易误读的一点，是把它们都当成”更大”。其实它们更像三种不同的杠杆：学习杠杆、记忆杠杆和组织杠杆。

在正式拆解它们之前，要先把训练最小闭环补上。不然优化器、损失尖峰、线性注意力这些词都没有落脚点。

一、一次参数更新里，模型究竟学了什么

大语言模型在预训练阶段做的核心任务很朴素：根据前面的 Token，预测下一个 Token。

假设训练文本是：

1

大模型训练需要稳定的优化器

分词器可能把它切成下面这样。真实分词结果取决于词表，这里只是示意：

1

[大模型] [训练] [需要] [稳定] [的] [优化器]

模型读到前五个 Token，要给词表里的每个候选 Token 分配一个概率。理想情况是 [优化器] 的概率最高。如果它把 [数据集] 猜成了第一名，系统就用交叉熵损失衡量这次错误。

对于正确 Token ，最简化的损失可以写成：

如果模型给正确答案的概率是 0.8，损失约为 0.223；概率只有 0.01，损失约为 4.605。正确答案的概率越低，惩罚越大。训练会让序列中几乎每个位置都提供一个监督信号，不会只预测句末一次。

一轮迭代可以拆成六步：

用符号表示，模型参数是 ，当前批次的损失是 ，梯度是 。最原始的梯度下降会这样更新：

是学习率。它太小，模型学得慢；太大，模型可能一步跨过低谷，甚至把数值推到溢出。现代大模型通常会让 AdamW、Muon 这类优化器综合动量、梯度尺度和权重衰减来决定更新，简单梯度下降很少直接承担这项工作。

有了这个闭环，几个常见词就能归位：

• 参数量描述模型里有多少可学习数字。
• Token 数描述训练过程中吃了多少离散符号。
• FLOPs 近似描述完成这些前向与反向计算花了多少浮点运算。
• loss 描述模型在训练目标上还错得多不多。
• 优化器决定系统怎样利用梯度修改参数。
• 训练稳定性描述这个闭环能否持续运行，而不发生数值爆炸、停滞或异常震荡。

大规模训练就是同一个闭环被分布到许多加速卡上。算法没有突然变成魔法，麻烦来自数量级：参数放不下一张卡，数据不能只由一张卡处理，矩阵需要跨卡切分，某张卡慢一点会拖住所有卡，一次通信错误也可能让整批计算作废。

二、Scaling Law 说了什么，又没说什么

演讲展示了一类经典曲线：横轴是训练计算或 Token 数的对数，纵轴是 loss 的对数。模型、数据和计算按一定比例增加时，loss 往往会平滑下降。Kaplan 等人在 Scaling Laws for Neural Language Models 中系统研究了这种幂律关系，后续的 Chinchilla 工作又讨论了固定计算预算下参数量和训练 Token 怎样配得更合算。

为了建立直觉，可以把一条简化曲线写成：

这里 是计算量， 是在当前数据分布和方法下难以消除的那部分损失， 与 由实验拟合。因为 往往小于 1，计算投入越往后，边际收益越低。想让 loss 再降一点，可能要多付成倍的计算。

这条规律的工程价值很大。团队不用每次都把最大模型训完，先在一组小模型上跑实验，拟合曲线，再预测更大规模下哪种架构、数据配方或优化器更值得下注。Scaling Law 实验用多个规模的可比结果降低大赌注的盲目性，一条漂亮的直线本身没有多少价值。

它也有清楚的边界。

第一，loss 下降不等于所有能力同比上升。数学、代码、事实记忆和工具调用可能以不同速度改善。某些能力还会受到后训练数据、推理预算和工具环境影响。

第二，曲线只在实验覆盖的分布和规模附近可信。换数据、换架构、换优化器后，原来的系数未必成立。把小模型趋势无限外推，是常见的误用。

第三，Token 不是彼此等价的训练燃料。一万亿个重复、低质或错误 Token，不等于一万亿个高质量 Token。数据去重、配比、难度、时效和领域覆盖都会改变学习结果。

第四，”增加参数、数据、计算就会变强”不代表三者可以随便堆。模型太大而数据不足，参数学不充分；数据极多而模型太小，容量可能成为瓶颈；两者都大但训练系统吞吐很差，预算会先耗在空等和通信上。

所以更准确的说法是：Scaling Law 给出了一条可测量的扩展路径，但走这条路仍需平衡参数、数据、计算和系统效率。杨植麟在演讲里关心的”曲线左移”，说的正是在相同 Token 或相同计算下得到更低 loss。这就进入第一条扩展轴。

三、Token 效率：同样一批教材，模型能学进去多少

业界没有一个名为 Token 效率的统一计量单位。放在这次演讲的语境里，它主要指：达到相同训练 loss 或能力水平，需要多少训练 Token 或训练 FLOPs。

假设优化器 A 需要 1000 亿 Token 才把验证 loss 降到 2.0，优化器 B 用 520 亿 Token 就到达同一水平，我们可以说 B 在这项实验里更省 Token 或更省计算。Kimi 团队的 Muon is Scalable for LLM Training 报告称，在他们的 compute-optimal Scaling Law 实验中，Muon 达到 AdamW 可比表现只需约 52% 的训练 FLOPs，论文据此概括为约 2 倍计算效率。

这里要立刻加两道护栏。

一是这是特定实验设置下的拟合结果，不是一条保证所有模型、数据和训练阶段都翻倍的定律。论文也指出，Muon 的优势更适合在预训练阶段获取；把它搬到任意微调任务，不会自动得到同样收益。

二是”50 万亿高质量 Token 等效成 100 万亿”是一种能力收益类比，不是把数据真的复制了一份。重复同样的数据不会凭空制造新事实。曲线左移表达的是模型对有限数据的利用率更高。

先分清三种经常混在一起的效率

一个新优化器可能提高样本与计算效率，却增加每步的运算成本；一个更快的 CUDA kernel 可能提高硬件效率，却完全不改变模型需要多少 Token。判断”效率提升”时，先问分母是什么，这个习惯很有用。

AdamW 为什么成为默认选项

普通随机梯度下降对所有参数使用同一套尺度。可神经网络不同位置的梯度大小差异很大，有的方向持续稳定，有的方向噪声很重。Adam 会维护梯度的一阶矩与二阶矩的指数移动平均，可以粗略理解为同时记住”近期方向”和”近期波动”，再对每个参数做自适应缩放：

AdamW 再把权重衰减从梯度更新中解耦。权重衰减会缓慢把过大的权重往零拉，既有正则化作用，也能控制权重尺度。AdamW 稳、成熟、超参数经验多，所以长期是大模型训练的标准选项。

它的问题不在于”不能用”，而在于标准选项也可能留下改进空间。Muon 选择从矩阵整体的几何结构入手。

Muon 做的事：别让更新挤在少数方向上

Transformer 里的许多权重不是孤立标量，而是二维矩阵。Muon 对矩阵参数的梯度动量做近似正交化。论文使用 Newton-Schulz 迭代近似计算这个变换。

如果梯度动量矩阵 的奇异值分解是：

Muon 希望得到接近下面的更新方向：

直觉上，原始矩阵里的某些奇异方向可能特别强，更新会挤在少数主方向上。正交化把不同方向的尺度拉得更均衡，让一次更新更充分地利用矩阵空间。可以把原始更新想成一群人都挤向同一扇门，正交化则尽量让他们从不同通道前进。这个比喻只能解释方向分布，不能代替数学定义。

Muon 只负责适合矩阵更新的参数。嵌入、归一化参数、输出头这类非矩阵参数通常仍由 AdamW 处理。实际系统采用组合方案，”Muon 全面替换 AdamW”会造成误解。

小模型上有效，为什么放大后会失灵

小规模实验跑得好，不代表万亿 Token 训练也稳定。Kimi 团队在放大 Muon 时发现两个具体问题。

第一个是权重尺度持续增长。原始 Muon 没有权重衰减，训练拉长后，一些权重及层输出的 RMS 会变得过大，甚至逼近 bf16 数值表示不舒服的区域。团队把 AdamW 式权重衰减加入 Muon，压住这种长期漂移。

第二个是不同形状的矩阵，Muon 更新的 RMS 不一致。对形状为 的满秩矩阵，论文给出的理论更新 RMS 约为：

矩阵尺寸一变，实际步幅就变。模型放大后，层与层之间的形状差异更明显，这会让同一学习率产生不一致的更新强度。团队用与 有关的系数修正每个矩阵的更新，还把整体更新 RMS 对齐到 AdamW 的经验范围。这样一来，原本为 AdamW 调好的学习率和权重衰减更容易复用。

这两项改动看上去不如”新优化器”三个字亮眼，却恰好说明规模化研究的真实样子：核心想法只占一部分，真正决定它能不能跑很久的，往往是尺度控制、分布式状态切分和数值边界。

分布式 Muon 为什么也属于算法的一部分

优化器需要保存动量等状态。参数一多，状态本身就会占掉巨量显存。Kimi 团队采用类似 ZeRO-1 的办法，把优化器状态分片到数据并行组中的不同设备上，需要做矩阵正交化时再进行必要的聚合与计算。

这件事提醒我们：一条数学更新规则能不能用于大模型，取决于它能否被拆到许多设备上，且通信和显存开销仍可接受。论文报告 Newton-Schulz 通常只需约 5 次迭代，优化器带来的端到端延迟占前向与反向时间的比例较小。没有这层实现，”更好的优化器”只是一张小模型实验表。

四、QK-Clip：训练不只要快，还得活着跑到终点

Kimi K2 使用的名字是 MuonClip。前半部分 Muon 主要改善参数更新的 Token 效率，后半部分 QK-Clip 处理注意力中的训练不稳定。两者解决的是不同问题。

标准注意力先把隐藏状态投影成 Query、Key、Value：

再计算：

中的数值叫 attention logits。假设某个注意力头里的 Query 和 Key 范数越来越大，点积就可能突然爆高。softmax 会变得极端尖锐，梯度和中间数值也可能跟着失控，最后表现为 loss spike，也就是损失曲线突然冒出尖峰。严重时整个训练发散，只能回滚检查点。

QK-Clip 的思路相当直接：在前向传播中监控每个注意力头的最大 logit。如果它越过阈值，就计算缩放因子，对对应的 Query 与 Key 投影权重进行约束，把最大值拉回安全范围。它针对造成极值的 Q、K 尺度动手，既不裁掉最终 loss，也不会把所有注意力分数压成一样。

演讲里展示的现象很有意思。加上 clipping 前后的 loss 曲线几乎重合，说明正常学习过程没有因为限制极值而明显变慢；内部的 MaxLogit 则被约束住，过一段时间后还会自然回落。换句话说，这更像在山路外侧加护栏。车仍按原路线开，只在即将冲出去时被挡一下。

Kimi K2 技术报告 公开的数据是：K2 为 MoE 模型，总参数约 1 万亿，每个 Token 激活 320 亿参数；预训练处理 15.5 万亿 Token，报告称全程没有 loss spike。这不是说 QK-Clip 单独保证任何训练都不出事故，但它给出了一次很大规模的实证。

为什么”零尖峰”值得单独写？假设一个训练任务已经运行三周才发散，即使能从前一天的 checkpoint 恢复，也会损失计算时间，还要暂停集群排查数据批次、硬件、通信和数值状态。训练稳定性直接决定预算能否转化成有效参数更新，远比曲线是否好看重要。

看到一张平滑 loss 曲线时，可以按这个顺序阅读：

1. 横轴是 step、Token 还是 FLOPs；
2. 曲线是训练 loss 还是验证 loss；
3. 是否只展示了平滑后的均值，原始尖峰有没有被藏掉；
4. 梯度范数、权重 RMS、attention logits 是否也稳定；
5. 中途是否回滚过 checkpoint，图里有没有拼接；
6. 对照组是否使用相同数据、模型和计算预算。

只盯着一条下降曲线，能看出的东西很有限。

五、大规模训练系统：几千张卡不是一张更大的卡

算法论文经常把计算写成一个矩阵乘法，训练集群却必须回答矩阵放在哪里、由谁计算、结果怎样交换。模型大到单卡放不下时，常见并行方式包括：

真实训练通常把几种方式叠在一起。以 MoE 为例，K2 总共有约 1 万亿参数，但每个 Token 只激活约 320 亿参数。路由器会为每个 Token 选择少数专家，所以模型容量可以很大，每个 Token 的计算不必等比例增长。

省下计算不等于系统轻松了。不同 Token 选择的专家不均匀，会让某些设备排队，另一些设备空闲；Token 需要跨设备发给专家，再把结果送回来，网络带宽会成为瓶颈；路由策略还要防止少数专家被挤爆。MoE 把部分计算压力换成了调度和通信压力。

训练吞吐可以写成一个粗略乘积：

一万张卡的利用率如果只有 30%，不会凭规模自动变得经济。某个慢节点让同步训练中的其他节点一起等，checkpoint 写盘阻塞主循环，数据管道喂不满 GPU，通信与计算没有重叠，这些都会吃掉利用率。硬件故障概率也会随设备数量上升，系统需要检测卡死和慢卡，保存可恢复的检查点，并能在故障后重新调度。

这也是演讲简介里”Day 0 infrastructure co-design”值得留意的原因。新架构、新优化器和新数据形态在设计第一天就要考虑集群实现，不能等算法定稿再扔给基础设施团队。比如 Kimi Linear 引入新的门控矩阵后，如果没有等价的块并行公式，理论上的线性复杂度也可能跑不快；多模态训练里图片数量与分辨率波动大，如果视觉编码器固定塞在流水线第一段，Stage 0 可能一直成为最慢的那一级。

K2.5 技术报告给了一个具体做法，叫 Decoupled Encoder Process。视觉编码器较小，于是系统在所有 GPU 上复制它，先对全局批次的视觉输入做负载均衡的前向计算，只保留输出，随后让主干按成熟的文本并行方案完成前向与反向，最后重新计算视觉编码器前向并做反向。它用额外重计算换取更均衡的流水线与更低峰值显存。报告称，多模态训练效率达到纯文本训练的 90%。

初学者不必立刻掌握每一种并行通信算子，但要先形成一个判断：大模型架构的优劣不能脱离硬件执行路径。纸面 FLOPs 少、实际通信多，仍可能更慢；数学上完全等价的两个公式，放在 GPU 上的速度也可能差很多。

六、第二条扩展轴：上下文为什么越长越贵

上下文是一次推理中模型能够直接访问的 Token 序列。聊天历史、工具返回、代码文件、图片编码和模型自己生成的推理轨迹都会占位置。

标准全注意力让每个 Token 与其他 Token 计算相关性。长度为 的序列会产生一个 的注意力分数矩阵，所以训练阶段核心计算与中间状态大致按 增长。

做一个不考虑注意力头与批次的极简计算：

实现会用 FlashAttention 等技术避免完整物化分数矩阵，并通过分块降低显存占用，但全注意力的二次计算关系没有因此消失。推理阶段还要保存 Key、Value 缓存。序列越长、层数越多、并发请求越多，KV cache 越容易吃满显存。

可长上下文对 Agent 又非常诱人。一个写代码的 Agent 连续工作几小时，会积累需求、文件内容、测试输出、补丁和失败经验。如果只能保留很短的窗口，它就得不断压缩或忘记；窗口变长，它有机会维持更完整的任务轨迹。这里只能说”有机会”。标称 100 万 Token 的窗口，并不保证模型准确使用其中每一条信息。

LSTM 便宜，但有一个固定大小的记忆瓶颈

循环神经网络按顺序更新状态：

它不需要保存所有 Token 两两之间的关系，处理长度通常随 线性增长。问题是，过去的信息要被压进一个固定大小的状态 。句子很长时，模型得决定哪些记、哪些忘，有限状态容易成为瓶颈。

全注意力像把所有历史笔记摊在桌上，需要时直接翻任意一页，信息访问灵活但桌面成本平方增长。循环模型像边读边写一张摘要卡，空间省很多，可早期细节一旦没写进摘要就难以找回。

线性注意力的目标，是尽量保留后一种计算效率，同时提高有限记忆的表达能力。

七、Kimi Linear：让不同记忆通道以不同速度遗忘

Kimi Linear 是混合架构，核心模块叫 Kimi Delta Attention，简称 KDA。它从 Gated DeltaNet 演化而来，把历史压进固定大小的循环状态，同时用更细粒度的门控控制状态更新。

演讲里给了一个很好理解的切口。较简单的线性注意力可能只用一个全局衰减系数 ：

如果 很小，旧信息很快消失；如果 接近 1，模型会保留很久，却难以把已经无用的信息清出去。所有记忆通道共享一个遗忘速度，就像一间办公室规定所有档案都在同一天销毁。电话号码、项目目标和临时日志的保质期显然不该一样。

KDA 把标量衰减扩展成更细粒度的对角门控。不同通道可以选择不同的衰减速度：有些慢慢忘，用于保存长距离信息；有些快速刷新，用于接收附近的新信号。它仍然是有限状态记忆，但这块记忆不再只有一个统一开关。

为什么公式变好了，GPU 反而更难跑

标量 很容易从矩阵运算中提出来，细粒度门控矩阵却让并行分块变复杂。如果严格按 Token 逐个递推，GPU 大量并行计算单元会闲着，线性复杂度也救不了实际吞吐。

Kimi 团队把递推改写为 chunkwise 形式，引入累计衰减和矩阵求逆等操作，让一块 Token 可以并行计算。关键是这种改写在数学上等价，不是用近似换速度。论文还针对对角加低秩转移矩阵设计了专门算法，使它适合现代 GPU。

这个例子很能说明算法和系统共同设计的含义：

1
2
3
4
5
6
7
8
9
10
11

更细的门控
    ↓
记忆表达能力更强
    ↓
原始递推更难并行
    ↓
推导块状等价公式
    ↓
写专用 GPU kernel
    ↓
理论优势才变成实际吞吐

为什么还要混入全注意力层

Kimi Linear 没有把每一层都改成线性注意力，而是把 KDA 与 MLA 全注意力层混合。线性层擅长低成本维护很长的状态，全注意力层保留直接检索历史 Token 的能力。混合架构承认两者各有所长，比”一刀切替换”更务实。

论文报告，在相同训练配方的公平比较中，Kimi Linear 在短上下文、长上下文和强化学习扩展场景里都优于全 MLA 基线；1M 上下文下，KV cache 最多减少 75%，解码吞吐最高达到 6 倍。”最高”很重要，它表示某个评测设置中的上界，不代表所有请求都固定快 6 倍。

长上下文不等于长期记忆，也不等于理解正确

这三个概念很容易混：

• 长上下文：当前调用能放进多少 Token。
• 有效检索：模型能否在长序列里找到相关信息。
• 长期记忆：信息能否跨调用、跨会话持久保存，并在需要时取回。

上下文窗口是工作台大小，检索能力是你能否在工作台上找到那张纸，长期记忆则是工作结束后有没有把纸归档。扩大工作台不会自动得到档案系统。

同理，长上下文也不会自动让 Agent 连续工作几个月。它还需要状态压缩、外部存储、错误恢复、权限控制和任务计划。演讲所说的”长上下文支持更长时间运行的 Agent”是一条能力路径，单看窗口数字无法兑现这项产品能力。

八、第三条扩展轴：Agent 数量为什么也能训练

单 Agent 处理复杂任务时，执行时间大致会随步骤数增长。它先查来源 A，再查来源 B，然后写第一章、第二章，所有步骤排成一条长队。如果任务含有大量互不依赖的分支，串行就很浪费。

Agent Swarm 加入一个主 Agent，也叫 orchestrator。它负责判断哪些工作可拆、创建子 Agent、分派任务、等待结果，再把结果合并。子 Agent 可以有不同角色，例如资料检索、代码实现、事实核查和文件下载。

  flowchart TD
  A["用户任务"] --> B["Orchestrator 判断是否值得拆分"]
  B --> C1["子 Agent A<br/>检索论文"]
  B --> C2["子 Agent B<br/>检查代码"]
  B --> C3["子 Agent C<br/>分析数据"]
  C1 --> D["聚合结果与冲突处理"]
  C2 --> D
  C3 --> D
  D --> E{"还缺证据？"}
  E -->|是| B
  E -->|否| F["交付结果"]
  

乍看只要写几条并发代码就够了。真正困难的是主 Agent 要学会四件事：什么时候不该拆，任务怎样拆得彼此独立，每个子任务给多少上下文，以及怎样识别冲突和失败。这些判断如果只靠人工规则，很快会遇到任务类型变化。

K2.5 使用 Parallel-Agent Reinforcement Learning，简称 PARL，训练 orchestrator 的调度策略。子 Agent 在训练中冻结，它们的轨迹被当作环境观察，强化学习只更新主 Agent。这样做是为了减轻信用分配的歧义：最终答案错了，很难同时判断究竟是任务拆错、某个子 Agent 做错，还是聚合时丢了信息。如果主从一起更新，环境还会不断变化，训练更不稳定。

三项奖励分别堵住三种漏洞

PARL 的奖励可以用一个简化式表示：

看最终任务是否完成、质量如何。这是主目标，但单靠它信号稀疏，模型可能很久都碰不到一次成功。

奖励合理创建子 Agent，用来防 serial collapse。所谓串行坍缩，就是 orchestrator 找到一个偷懒的局部最优：永远不创建子 Agent，退化回单 Agent。训练初期提高这项权重，可以鼓励它探索并行策略。

可一奖励”多叫人”，模型就可能钻空子。它创建几十个没有意义的子任务，表面并发度很高，真正工作没完成。这叫 spurious parallelism，也可以理解成虚假并行。因此还要 ，检查被创建的子任务有没有较高完成率，逼它拆出可执行的工作。

两项辅助奖励的权重会在训练后期逐渐衰减到零，让最终策略回到任务结果本身。这个设计与教孩子骑车有点像，辅助轮只在早期帮助探索正确动作，不能永远成为目标。

为什么不能只数总步骤

并行系统的耗时由关键路径决定。假设三个子任务分别要 3、5、12 步，并行运行时，理想耗时接近 12 步，不是 20 步。主 Agent 后续还要 2 步聚合，总关键步骤约 14。

K2.5 报告用 critical steps 约束训练与评估，鼓励主 Agent缩短最长分支。它如果创建许多无用子任务，却没有缩短关键路径，不会因此得到真正的延迟收益。

哪些任务适合并行，哪些不适合

适合拆分的任务通常有宽度：调查 100 家公司的公开数据、搜索互相独立的资料源、给 20 个模块分别写测试、对多个数据集做同构分析。各分支依赖少，最后可以汇总。

不适合强拆的任务通常有长依赖链：先证明引理 A 才能定义 B，B 的结果又决定 C；先改数据库 schema 才知道接口怎么迁移；需要保持同一种细腻叙事声音的短篇写作。后一步严重依赖前一步时，多叫 Agent 只会增加同步成本。

还有一类看似可并行、实际很危险：多个 Agent 同时编辑同一份文件。即使每个修改单独正确，也可能互相覆盖。系统必须划分文件所有权、使用补丁合并，或让一个 Agent 负责最终写入。

Kimi K2.5 技术报告 报告 Agent Swarm 在宽搜索场景里相对单 Agent 基线最高降低 4.5 倍延迟，同时 item-level F1 从 72.8% 提升到 79.0%。这说明并行不一定用质量换速度，但结果仍应限定在报告的任务与设置里，不能外推成”100 个 Agent 就强 100 倍”。

并发越高，Token 成本、工具调用、网络请求和重复劳动也越多。Agent 数量是一条新的 Scaling 轴，同时也是新的成本轴。

九、原生多模态：为什么视觉与文本要从早期就在一起

传统多模态路线常见一种做法：先把文本模型训练得很强，后期再接一个视觉编码器，用一批图文数据做适配。这样做便于复用已有语言模型，但视觉很容易变成后装插件。模型能回答图片问题，不代表视觉和语言真正共享了同一套概念空间。

K2.5 走的是早期融合。它建立在 K2 文本模型之上继续预训练，在约 15 万亿混合视觉与文本 Token 上保持一个较低且相对稳定的视觉比例，而不是等训练接近结束才突然灌入大量视觉数据。技术报告的消融实验在固定图文 Token 总预算下比较了三种方案：

这组结果反驳了一个很自然的猜测：视觉 Token 比例越高，多模态就一定学得越好。固定预算下，较少的视觉数据如果更早进入训练，能与文本共同优化更久，效果可能更好。比例和时机要一起看。

图片怎样变成大模型能读的 Token

视觉编码器先把图片切成 patch，将每块像素转成向量。K2.5 使用 MoonViT-3D，允许不同分辨率图片以原生比例打包；处理视频时，把连续四帧组成时空块，在 patch 层做时间压缩。视觉向量经过 MLP projector 投到语言模型使用的隐藏维度，随后与文本 Token 一起进入主干。

1
2
3
4
5
6
7
8
9

图片或视频
    ↓
MoonViT-3D 切 patch、提特征
    ↓
MLP Projector 对齐维度
    ↓
视觉 Token 与文本 Token 混合
    ↓
同一个 MoE 语言主干继续预测

共享表示空间很重要。模型要从一段界面视频直接生成网页代码，必须把视觉中的布局、颜色、运动与文本中的 HTML、CSS、JavaScript 概念对齐。如果视觉和代码像两条末端才接起来的支线，跨模态能力很难自然组合。

Zero-Vision SFT 不是”没有视觉训练”

这个名字很容易被标题党误读。K2.5 在预训练阶段已经看过大量视觉与文本混合数据。Zero-Vision SFT 说的是监督微调阶段只用文本 SFT 数据，不额外加入视觉 SFT 轨迹。

为什么这样做可能有效？高质量文本 SFT 数据更丰富，已经能教会模型推理、调用工具和组织步骤；早期联合预训练又把视觉映射进共享表示空间，于是这些行为可以迁移到视觉输入。团队的初步实验发现，加入人造视觉 SFT 轨迹反而损害视觉 Agent 任务的泛化，可能与视觉轨迹质量和多样性不足有关。

SFT 后再做联合文本与视觉强化学习。视觉任务使用可验证结果，例如目标定位看 IoU，OCR 看标准化编辑距离，计数看与正确数量的绝对差。报告中的纯文本评测在 Vision RL 后也有提升：MMLU-Pro 从 84.7 到 86.4，GPQA-Diamond 从 84.3 到 86.4，LongBench v2 从 56.7 到 58.9。

这组实验无法证明”随便加入图片都能让语言变强”。它支持一个范围更窄的结论：在共享表示对齐良好、任务和奖励设计合适的条件下，视觉强化学习学到的结构化提取、计数与校准能力，可以迁移到部分文本任务。跨模态互相增强来自训练结果，多模态架构不会天然附送这种属性。

十、Attention Residuals：每一层都只能接上一层吗

Transformer 还有一个沿用多年的基础组件，残差连接。标准形式很简单：

第 层接收当前残差流 ，计算一个变化 ，再把变化加回去。残差连接让梯度有一条较直接的通路，深层网络因此更容易训练。ResNet 能把视觉网络推得很深，Transformer 也继承了这项设计。

连续展开后可以看到，当前残差流包含之前许多层输出的累加：

问题也在这里。所有历史层默认以固定权重 1 累加。网络越深，隐藏状态幅度可能持续增长，单层新贡献被越来越大的历史总和稀释。当前输入无论需要浅层词法信息还是深层抽象信息，都只能接受同一种累加方式。

Attention Residuals 把固定累加改成对历史层输出做 softmax 注意力。第 层不再只被动接收上一层汇总，而是根据当前内容，从前面各层的表示中选择并聚合：

标准注意力沿序列时间轴选择不同 Token，AttnRes 沿网络深度轴选择不同层。所谓”把注意力旋转 90 度”，说的就是注意力作用维度从 Token 位置换成了层深。

  flowchart LR
  subgraph 标准残差
    A1["第 1 层"] --> A2["第 2 层"] --> A3["第 3 层"] --> A4["第 4 层"]
  end
  subgraph Attention_Residuals
    B1["第 1 层"] --> B4["第 4 层按内容选择"]
    B2["第 2 层"] --> B4
    B3["第 3 层"] --> B4
  end
  

直接看所有层，成本又回来了

每一层都访问前面所有层，会增加激活存储、通信和计算。模型做流水线并行时，历史层可能在别的设备上，跨阶段搬运表示更麻烦。

因此论文提出 Block AttnRes。先把若干层分成一个块，块内继续使用普通残差，只在块级输出之间做深度注意力。假设一个模型有 64 层，每 8 层一块，注意力只需选择 8 个块级表示，而不是保存并访问 64 个逐层表示。它牺牲一部分选择粒度，换来更低的显存和通信开销。

Kimi 团队还使用缓存式流水线通信和两阶段计算降低开销。演讲报告其 Scaling Law 实验中的 Token 效率改善约 24%，并在 GPQA、数学和 HumanEval 等任务上得到提升。论文进一步在 48B 总参数、3B 激活参数的 Kimi Linear 模型上训练 1.4 万亿 Token，报告各项下游评测都有改善。

同样要注意证据边界。AttnRes 是面向后续架构的研究预告，不等于 K2.5 已经使用它；24% 是论文实验中的 Scaling Law 结果，不应和 Muon 的约 2 倍直接相乘后宣称任何未来模型固定提升 2.48 倍。不同改动之间可能有重叠，组合效果必须重新实验。

十一、把几项技术放回同一台训练机器

讲到这里，名字很多，但它们在系统里的位置其实很清楚：

它们共同遵循一条很朴素的工程路线：先找到旧组件在新规模下暴露的瓶颈，再提出替代方案，用小规模实验拟合趋势，补齐分布式实现与稳定性手段，最后才把它放进昂贵的大训练。

  flowchart TD
  A["数据清洗与混合<br/>文本、图像、视频、代码"] --> B["Tokenizer 与视觉编码器"]
  B --> C["模型前向<br/>MoE + Attention"]
  C --> D["Loss 与奖励"]
  D --> E["反向传播"]
  E --> F["MuonClip 更新<br/>权重衰减、RMS 对齐"]
  F --> C
  C --> G["长上下文模型"]
  G --> H["SFT 与联合 RL"]
  H --> I["PARL 训练 Orchestrator"]
  I --> J["多 Agent 并行执行"]
  

公开视频里很容易出现”Adam、Attention、残差连接都用了十年，该重做了”这种让人兴奋的叙述。这里没有轻视旧技术的理由。Muon 仍与 AdamW 配合，Kimi Linear 仍混入全注意力层，Block AttnRes 内部仍保留标准残差。新系统会把旧组件留在它仍然合算的位置。

十二、训练范式怎样从天然数据走向 AI 原生数据

杨植麟在另一场 2026 中关村论坛演讲中把训练数据的变化分成几个阶段：早期主要吃互联网天然数据，随后大规模建设强化学习系统，接下来让 AI 更多参与任务、环境、奖励乃至架构的生成。这条判断在 GTC 演讲的技术内容里也能找到对应物。

预训练时代，模型从静态语料学习下一个 Token。数据一旦收集完成，题目和答案基本不再因模型而变。

强化学习时代，模型在环境里产生轨迹。它可以尝试不同解法，验证器根据结果给奖励，成功和失败都会产生新的训练信号。数学答案可检查，代码可运行测试，网页操作可检查最终状态，因此这些领域较早吃到可验证奖励的红利。

AI 原生训练再往前走一步。模型可以帮助生成新题，构造更难的环境，发现当前策略的薄弱点，甚至提出架构候选。人类研究员从逐条制造数据，转向设计目标、验证器、边界和实验系统。

一个理想化闭环长这样：

1
2
3
4
5
6
7
8
9
10
11

当前模型暴露能力缺口
        ↓
生成针对性任务与环境
        ↓
模型探索并产生轨迹
        ↓
规则、程序或奖励模型验收
        ↓
筛选高价值经验继续训练
        ↓
重新评测，寻找下一处缺口

但”AI 自己训练 AI”并不会消除人的工作，它会把人的工作推到更上游。系统仍得回答：生成的题是否新颖，验证器会不会判错，奖励是否鼓励了投机，合成数据是否逐渐同质化，模型能否接触到当前能力边界之外的信息。

奖励函数是新的数据接口

监督学习里，一条样本直接告诉模型期望输出。强化学习里，奖励函数只告诉它结果好不好，模型自己搜索中间路径。奖励定义不完整时，模型会找到人没想到的捷径。

Agent Swarm 的虚假并行就是一个标准例子。奖励创建子 Agent，模型便大量创建；增加完成奖励后，它才更倾向于创建能做完的子任务。视觉任务也一样。如果 OCR 只按关键词是否出现给分，模型可能输出一堆候选词碰运气；用标准化编辑距离，奖励才更贴近逐字符准确性。

所以 AI 原生训练的主要瓶颈，会逐渐从生成 Token 的速度转向评价：系统能否便宜、可靠地判断这些 Token 代表的行为好不好。可验证环境越丰富，强化学习越容易扩展；开放式写作、长期商业决策这类任务没有唯一答案，奖励就更难设计。

合成数据不能成为封闭回音室

如果模型只根据自己的输出生成下一代训练数据，错误和表达偏好可能被不断放大。系统需要引入真实环境反馈、人工抽查、多模型交叉验证、去重与难度控制。合成数据适合覆盖天然数据稀缺的任务，用更多相似句子堆数量没有价值。

这也解释了为什么高质量数据有限时，提高 Token 效率很重要。训练系统需要生产新 Token，更要提高其中有效、独特且可校验的学习信号密度。

十三、一个初学者可以亲手完成的纸上实验

你不需要万张 GPU 才能验证本文的核心直觉。拿纸、计算器和一小段 Python，就能检查三个扩展轴各自在算什么。

实验一：感受全注意力的平方增长

运行下面这段代码。它不真正分配大矩阵，只计算注意力分数的元素数量与 fp16 理论字节数：

1
2
3
4
5
6
7
8

def attention_scores(seq_len: int, heads: int = 32, bytes_per_value: int = 2):
    elements = heads * seq_len * seq_len
    gib = elements * bytes_per_value / 1024**3
    return elements, gib

for n in [4096, 32768, 131072, 1048576]:
    elements, gib = attention_scores(n)
    print(f"n={n:>7}, elements={elements:>16,}, raw={gib:>10.2f} GiB")

你会看到，长度放大 8 倍，分数元素放大 64 倍。实际训练会分批、分头、重计算，也不会总把整个矩阵留在显存里，所以输出不是训练显存估算。但平方关系会非常直观。

然后回答两个问题：FlashAttention 主要减少中间存储和内存访问后，为什么全注意力仍然会怕百万 Token？线性注意力把历史压进固定状态后，最可能牺牲什么？

答案分别是：核心两两交互数量仍按平方增长；固定状态可能丢失无法压缩进有限记忆的细节。

实验二：算一次并行是否真的省时间

有一个研究任务包含五个子任务，预计步骤数是 [4, 9, 7, 3, 8]，最后汇总需要 4 步。

单 Agent 串行执行：

五个子 Agent 完全并行：

理论加速约 倍，不是 5 倍。最长的 9 步分支和最后 4 步聚合构成关键路径。

再加一个现实条件：最多同时运行两个子 Agent。你可以尝试把任务排到两个槽位里，目标不是平均分配任务个数，而是让两个槽位的总步骤尽量接近。这已经是一个小型调度问题。

一种分法是 [9,7] 与 [8,4,3]，两边分别为 16 和 15，加汇总后总关键步骤 20。若随手分成 [9,8,7] 与 [4,3]，关键路径会变成 24 加 4，共 28 步。Agent 数量相同，任务拆分质量却让结果差很多。

实验三：判断”2 倍 Token 效率”的正确含义

假设基线模型训练 100B Token 后验证 loss 是 2.1，新优化器在 52B Token 达到 2.1。

你能得到的结论是：在相同实验配方和目标 loss 下，新优化器用约 52% Token 或对应 FLOPs 达到基线水平。

你不能直接得到这些结论：

• 新模型所有任务准确率都翻倍；
• 把数据复制两遍能得到相同收益；
• 任意规模都恰好省 48%；
• 推理速度也会翻倍；
• 优化器单独造出了新的事实知识。

只要能稳定分清这五条，你已经避开了大多数二手解读中的夸张。

十四、读大模型训练报告时，先问这十个问题

技术报告里的数字很多，初学者最容易被最高分牵着走。我更建议按下面的顺序看：

1. 比较对象是否使用同一训练数据、参数规模和计算预算？
2. 所谓效率的分母是 Token、FLOPs、GPU 小时、显存还是请求延迟？
3. 结果来自完整大模型，还是从小模型 Scaling Law 外推？
4. 最好结果是平均值、单次峰值，还是多个随机种子的稳定结果？
5. “最高 6 倍”发生在哪个上下文长度、批次和硬件上？
6. 训练 loss 更低时，验证 loss 和下游任务是否也改善？
7. 新组件增加了多少显存、通信和实现复杂度？
8. 消融实验有没有把新组件逐项拿掉，确认收益来自哪里？
9. 基准是否可能进入训练数据，工具与推理预算是否一致？
10. 作者报告的结论与我的推断，是否被清楚分开？

这十问不会让你立刻成为训练专家，但能让你从”看发布会数字”迈到”读实验设计”。后者才是理解论文的起点。

十五、几个必须拆掉的误解

误解一：参数越多，每个 Token 计算量就一定等比例增加

Dense 模型大致如此，MoE 不完全如此。K2 总参数约 1 万亿，每个 Token 激活约 320 亿参数。未激活专家仍占存储和通信设计，但不参与该 Token 的全部计算。

误解二：上下文窗口越长，模型记忆越好

窗口只说明能放进去。能否准确找回、能否抵抗噪声、跨会话是否保留，是另外的问题。长窗口也可能装进更多无关信息，让判断变差。

误解三：线性注意力就是普通注意力的廉价近似

不同线性注意力方法原理差异很大。KDA 是带细粒度门控的有限状态更新，并通过精确等价的块公式实现并行。它不是简单砍掉一部分 。

误解四：Agent 越多，结果越好

并行适合独立分支。依赖链长、写冲突多或聚合困难的任务，增加 Agent 可能更慢、更贵。系统需要学习”不拆”也是一种正确动作。

误解五：Zero-Vision SFT 表示模型没用视觉数据

它只表示 SFT 阶段没有视觉 SFT 数据。早期联合预训练已经处理大量图文 Token，后面还有视觉与文本联合 RL。

误解六：QK-Clip 是为了提高推理速度

它主要约束训练中的注意力 logit 极值，目标是稳定性。推理吞吐的改善更多要看架构、kernel、量化、KV cache 和服务系统。

误解七：Attention Residuals 已经是 K2.5 的正式组件

演讲将它称为下一代架构预览。公开论文把它集成到实验版 Kimi Linear 模型验证，不能据此倒推 K2.5 已经使用。

十六、如果想继续学，按这条顺序不会太痛苦

第一阶段先用一个小 Transformer 完成训练闭环。理解 Tokenizer、embedding、前向、交叉熵、反向传播和优化器。此时不要急着碰分布式。

第二阶段读标准 Attention 与 AdamW。自己算一次 的形状，观察序列长度翻倍后内存怎样变；用 PyTorch 比较 SGD 与 AdamW 在小任务上的曲线。目标是知道公式里的每个张量从哪来。

第三阶段学习混合精度、梯度累积、checkpoint 和数据并行。用两张卡当然最好，只有一张卡也可以通过显存估算与代码阅读理解状态切分。

第四阶段再读 Muon、Kimi Linear 与 Attention Residuals。此时论文中的 RMS、矩阵正交化、循环状态、块算法和残差流已经有对应概念，不会只剩术语。

第五阶段搭一个最小 Agent 循环，再加两个并行子 Agent。记录总 Token、总步骤、关键路径、失败率与聚合错误。启动多个模型调用很容易，拆分、隔离、验收与合并才会占掉大部分调试时间。

建议的原始资料顺序如下：

1. NVIDIA GTC 2026 演讲：How We Scaled Kimi K2.5，先看完整叙事；
2. Scaling Laws for Neural Language Models，理解经典扩展曲线；
3. Muon is Scalable for LLM Training，看优化器怎样从小实验走到分布式实现；
4. Kimi K2: Open Agentic Intelligence，重点看 MuonClip、QK-Clip 与训练稳定性；
5. Kimi Linear，理解有限状态记忆与混合注意力；
6. Kimi K2.5: Visual Agentic Intelligence，看早期多模态融合、Zero-Vision SFT、联合 RL 与 PARL；
7. Attention Residuals，最后再看深度维度的注意力。

论文不必从第一页逐字啃。先读摘要和方法总图，带着一个问题去找对应小节，再看实验是否真的回答了这个问题。比如读 Muon 时只盯住”为什么小规模收益放大后消失”，你很快就会找到权重衰减与 RMS 对齐；读 PARL 时只问”怎么防止主 Agent 假并行”，奖励设计便有了意义。

结尾：真正被扩展的是学习、记忆与组织

回到开头那次参数更新，大规模 AI 系统仍在做同一件小事：预测、计算误差、反向传播、更新参数。Kimi 这组工作没有改变这个闭环，却沿着闭环外侧逐层加了新的能力。

MuonClip 让参数更新更会利用有限数据，并给注意力极值加上稳定护栏。Kimi Linear 改造模型保存历史的方式，让更长任务轨迹有机会以可承受成本进入推理。Agent Swarm 把一条串行轨迹拆成并行组织，并用强化学习教主 Agent 怎样调度。早期多模态融合让视觉与语言在共享表示中一起训练，避免末端临时拼接。Attention Residuals 则继续追问，一个用了多年的深层连接方式是否还能更灵活。

这些技术看似分散，放在一起却回答了同一个问题：当数据、计算与任务复杂度都走到新的数量级，旧组件怎样重新设计，才能让额外投入继续转化成有效智能。

记住 K2.5 有多少参数，或者欣赏一条平滑曲线，都只是看懂发布材料的第一步。接下来要顺着系统追问：这一单位 Token 产生了多少学习信号，这次更新有没有浪费在少数方向，长序列的信息怎样保存，GPU 是否在等待通信，主 Agent 拆出的任务是否真的缩短关键路径，奖励有没有给模型留下作弊口子。

能问出这些问题，就已经越过了”听懂发布会”那一层，开始站到训练系统的视角看模型了。