第0章 起步：读这篇论文之前，你需要的全部基础

这一章不属于论文。它是一块地基。读完它，你会拥有读懂后面十五章所需的每一个概念——不是「听说过」，而是「能用自己的话讲清楚，并且算得出来」。如果你已经知道什么是注意力机制和 KV 缓存，可以跳到第1章；但我建议你至少做一遍本章末尾的自测，看看是不是真的知道。

0.1 先给你一个方向感：这篇论文在讲什么

Kimi K3 是月之暗面（Moonshot AI）在 2026 年 7 月发布的一个大语言模型，同时公开了模型权重。这份 47 页的技术报告讲的是：他们怎么把它造出来的。

造一个这种规模的模型，大致要回答四类问题，而这份报告的结构正好对应这四类：

1. 模型长什么样（第 2 节，本站第 3–6 章）——里面有哪些零件，为什么这么摆。
2. 怎么把知识灌进去（第 3 节，本站第 7 章）——用什么数据、训多久、怎么定超参数。
3. 怎么让它学会做事（第 4 节，本站第 8–9 章）——从「会说话」到「会干活」，靠的是后训练和强化学习。
4. 怎么让这一切在真实机器上跑得动（第 5 节，本站第 10–11 章）——2.8 万亿个参数装不进任何一张显卡，这本身就是个大工程。

剩下的是第 6 节的评测（本站第 12 章）、第 7 节的案例（第 13 章）和附录里的几个证明（第 14 章）。

0.2 语言模型到底在做什么：猜下一个词

这件事说出来会让人失望，但它是真的：大语言模型做的唯一一件事，是根据前面的文字，猜下一个字最可能是什么。

比如给它「中华人民共和」，它会给出一个概率分布：

然后按这个分布抽一个字出来，接在后面，变成「中华人民共和国」，再拿这个新的句子去猜下下一个字。如此反复，就「写」出了一整段话。

下一 token 预测（Next-Token Prediction, NTP）：上面这个「看前文、猜下一个」的任务。整篇论文里所有的预训练，做的都是这一件事。

0.3 token：模型眼里的「字」

上一节我说「猜下一个字」，那是简化。模型实际处理的单位叫 token，中文常译作「词元」。

token 不是字，也不是词，而是一种介于两者之间的、由统计方法切出来的片段。比如英文 unhappiness 可能被切成 un + happi + ness 三个 token；中文里常见字通常一个字就是一个 token，生僻字可能被拆成两三个。

词表（vocabulary）：所有可能 token 的清单。Kimi K3 的词表大小是 160K（16 万个），这个数字你在表 1 里会看到。

所以更准确的说法是：模型看到的是一串编号（比如 [3612, 8829, 174, ...]），它要预测的是下一个编号，从 16 万个候选里挑。

0.4 向量：把 token 变成一串数

计算机不能直接对「编号 3612」做数学。所以第一步是把每个 token 变成一串数字，叫做向量。

向量（vector）：一串有顺序的数，比如 (0.3, −1.2, 0.8)。这串数有多长，就叫它的维度。

Kimi K3 用 7168 维的向量表示一个 token。也就是说，「猫」这个字在模型内部是 7168 个小数组成的一串。

0.5 矩阵乘法：神经网络里唯一真正重的运算

这一节是全章最重要的一节。如果你只学一个数学工具，学这个。

矩阵（matrix）：把数排成一个长方形的表格。一个 3 × 2 的矩阵有 3 行 2 列。

矩阵乘以向量是这样算的：把向量竖着放在矩阵右边，矩阵的每一行与这个向量逐个相乘再求和，得到结果向量的一个分量。

注意形状：一个 3×2 的矩阵乘一个 2 维向量，得到一个 3 维向量。矩阵把向量从一个维度搬到了另一个维度，同时把信息重新混合了一遍。

0.6 一层神经网络 = 矩阵乘法 + 掰弯

如果只有矩阵乘法，会出问题：连续做很多次矩阵乘法，效果等同于只做一次（两个矩阵可以先乘起来变成一个矩阵）。那么叠 93 层就毫无意义。

所以每做完一次矩阵乘法，要插进一个非线性函数——一个不能被矩阵乘法模拟的、把直线掰弯的操作。

激活函数（activation function）：那个负责「掰弯」的函数。常见的有：

第5章的主角 SiTU-GLU 就是在 Swish 的基础上改造出来的，你到那时会需要这张表。

0.7 softmax：把任意一串数变成一组概率

模型算出 16 万个候选 token 的「分数」之后，怎么变成概率？分数可能是负的，加起来也不等于 1。

softmax 解决这个问题，两步：

1. 对每个数取指数 e^x（结果一定是正数，而且大的数被放大得更厉害）
2. 除以所有指数的总和（这样加起来正好是 1）

动手算一遍：三个候选的分数是 (2, 1, 0)。

0.8 注意力：让每个 token 自己去「查资料」

现在到了最关键的机制。注意力（attention）回答的问题是：处理「它」这个词时，模型怎么知道「它」指的是前面哪个东西？

答案是：让「它」主动去前面查一遍，看谁跟自己最相关，就多读谁的信息。具体分三步。

查询、键、值（Query, Key, Value，简称 Q、K、V）：每个 token 用三个不同的矩阵，从自己的向量里造出三个新向量。Q 是「我要找什么」，K 是「我是什么，供别人搜」，V 是「如果你选中我，我给你什么内容」。

0.9 注意力的代价：为什么长文本这么贵

注意力的代价来自一个简单的事实：序列里每个 token 都要跟前面所有 token 打一次分。

如果序列有 n 个 token，打分次数大约是 n²/2。这叫平方复杂度。

从 1000 涨到 100 万，长度涨 1000 倍，计算量涨一百万倍。这就是为什么「100 万 token 上下文」在工程上是件大事。

还有第二个代价，而且往往更要命。

KV 缓存（KV cache）：生成文字时，模型是一个 token 一个 token 往外吐的。每吐一个新 token，它都要回头查之前所有 token 的 K 和 V。为了不重复计算，就把算过的 K 和 V 全都存在显存里——这就是 KV 缓存。

0.10 残差连接：给信息修一条高速公路

网络很深（K3 有 93 层）时会出现一个问题：信息在层层传递中被反复揉搓，原始内容丢失，而且训练时的梯度信号传不回前面的层。

残差连接（residual connection）的做法极其简单：让每一层的输出等于「这一层算出来的东西」加上「这一层的输入」。

0.11 归一化：不让数字失控

深层网络里数值容易越滚越大或越滚越小。归一化（normalization）就是每隔一段把一组数拉回到一个标准尺度。

RMSNorm（Root Mean Square Normalization）：先算这组数的「均方根」（每个数平方、求平均、开根号），再让每个数都除以它。结果是这组数的整体大小被拉到 1 附近，但相互之间的比例关系不变。

论文里 RMSNorm 出现过至少五次，每次都是同一个动机：某个地方的数值尺度可能失控，先归一化再往下走。你在第4章（防止某一层主导注意力权重）、第5章（防止专家聚合后的尺度乱跳）都会见到它。

0.12 MoE：一个巨大的专家团，每次只请几个

常规神经网络里，每个 token 都要经过全部参数。参数越多，算得越慢。这让「模型变大」和「推理变贵」死死绑在一起。

混合专家（Mixture-of-Experts, MoE）解开了这个绑定：

1. 把一层里的前馈网络复制成很多份，每份叫一个专家（expert）。K3 有 896 个。
2. 加一个小小的路由器（router），它看一眼当前 token，给 896 个专家各打一个分。
3. 只把分数最高的几个专家叫来干活。K3 每个 token 只激活 16 个。

0.13 三个必须分清的量：总参数、激活参数、FLOPs

0.14 训练与推理：两种完全不同的活

训练（training）：给模型看海量文本，让它猜下一个 token，猜错了就微调所有参数让它下次猜得准一点。这个「根据错误反过来调参数」的过程叫反向传播（backpropagation），它需要把前向过程中的中间结果（叫激活值，activations）都保存下来——这是训练时显存爆炸的主因，第10章会详谈。

推理（inference）：模型训练好了，参数冻结，只用来生成文字。推理又分两个阶段：

• 预填充（prefill）：把你输入的整段提示一口气读进去。这一步所有 token 可以并行处理，算力吃满，是「计算受限」的。
• 解码（decode）：一个一个往外吐字。这一步必须串行（要先吐出第 5 个字才能吐第 6 个），每吐一个字都要把整个模型的权重过一遍，所以是「带宽受限」的。

0.15 三段人生：预训练、后训练、强化学习

强化学习（Reinforcement Learning, RL）：模型自己尝试完成一个任务（比如「修好这个 bug」），产生一整条行动轨迹；然后有个奖励函数给这条轨迹打分；模型据此调整参数，让高分行为更容易发生。

智能体（agent）：能自主使用工具、多步执行任务的模型。工具调用（tool call）指模型输出一段结构化的请求（比如「运行这段 Python」），外部系统执行后把结果送回来作为新的输入。一次任务里模型可能这样来回几百次，这叫长时程（long-horizon）。

0.16 GPU：为什么显存和带宽经常比算力更要命

训练和运行大模型全靠 GPU（图形处理器）。你需要知道三个数，以及它们之间的紧张关系。

还有一组必须知道的名词——当一张卡装不下时，就要把模型切开放到多张卡上，这叫并行：

0.17 100 万 token 的上下文，到底是什么概念

上下文窗口（context window）：模型一次能「看见」的最大 token 数。超出的部分它就完全不知道了。

K3 是 100 万 token。给你一点尺度感：

而 K3 的前一代 K2 只有 128K（12.8 万）。表 1 里那个「8×」就是这么来的。

0.18 符号速查表

下面这些符号会在后面十五章反复出现。现在不需要背，但读到卡壳时回来查。

第1章 全景：这篇论文在主张什么，以及知识地图

在钻进任何细节之前，你需要一张地图。这一章做三件事：说清这篇论文想解决什么问题、把它的十六个知识点排成一张依赖图、给你一条推荐的行进路线。读完这一章，你后面每读到一个新概念，都能知道它挂在哪根枝上。

1.1 论文开篇的那个论断：缩放有两条轴，开源界只走了一条

论文的第一段做了一件很聪明的事：它先给整个领域画了一个坐标系，然后指出坐标系里有一块空地，而 K3 就是要去占这块空地。

第一条轴：部署前的算力。 在大语言模型发展的大部分时间里，「缩放」意味着在部署之前投入更多算力——训更大的模型、喂更多的数据。这是 2020 年那批缩放定律论文奠定的路线。

第二条轴：测试时的算力。 推理模型的兴起确立了第二条轴：让模型在回答问题的时候多花算力。论文点名了几条支线：OpenAI 的 o 系列用强化学习扩展测试时推理；Anthropic 的扩展思考让模型分配自适应的思考预算并把思考与工具调用交错；DeepSeek-R1 和 Kimi K1.5 表明大规模强化学习能从强预训练模型中引出复杂的推理行为；Kimi K2.5 Agent Swarm 则把测试时缩放从「顺序推理」扩展到「并行的智能体协同」。

1.2 摘要拆解：每一个短语对应哪一节

下面这张表是本站最实用的一张。摘要里的每个短语，都能在论文里找到一整节来展开。你也可以把它当作全站的导航。

1.3 知识地图：谁依赖谁

下面这张图是整篇论文的骨架。箭头 A → B 读作「要理解 B，先得理解 A」。

1.4 架构总纲：把信息流往三个方向撑开

论文第 2 节开头给了一个非常清晰的组织原则，值得单独拎出来记住。K3 的架构设计沿三个互补的维度扩展信息流：

1.5 论文的四条贡献，以及它们的证据强度

论文在引言末尾自己列了四条贡献。这里逐条列出，同时标注证据强度——这是训练「批判性阅读」的第一次练习。

1.6 推荐的行进路线

十六章不必按顺序读完。下面是三条路线，按你的目标挑一条。

第2章 Kimi Delta Attention：把无限增长的记忆压成一块固定大小的黑板

这是全站最核心也最难的一章。KDA 是 K3 架构的地基——93 层里有 69 层是它，第10章的内核与并行、第11章的前缀缓存，全都是在为它擦屁股。这一章我们会从「记忆该怎么建模」这个最朴素的问题出发，一步步走到论文的式 1 到式 6。请慢一点读，每个小节末尾的题都做。

2.1 出发点：注意力的诅咒，和一个被放弃的老方案

第0章讲过注意力的两个代价：计算量随长度平方增长，KV 缓存随长度线性增长且永不缩小。在 100 万 token 的尺度上，第二个代价尤其致命——你算过那道题，光是一份缓存就能吃掉一张顶级显卡三成的显存。

但在注意力发明之前，序列建模用的是另一套方案：循环神经网络（RNN）。它的做法是从左到右读，把读过的一切压缩进一个固定大小的状态里。

RNN 的固定状态有一个无可替代的优点：不管序列多长，内存都不变。但它当年被抛弃，是因为两个致命伤：

• 记忆被冲淡：状态就那么大，读到第 1000 个词时，第 1 个词的信息早被后来的内容挤掉了。
• 不能并行：必须先算完第 999 步才能算第 1000 步。而 GPU 的全部威力都建立在「同时算很多东西」上。

线性注意力（linear attention）：一类把 softmax 去掉、从而可以改写成「固定大小状态 + 递推更新」的注意力变体。KDA 属于这一类，它是 Kimi Linear 那篇工作的延续。第0章的 softmax 那一节你算过：softmax 里的指数让每个 query 必须亲自和每个 key 打分，无法提前汇总。去掉 softmax，汇总就成为可能——这是整个线性注意力家族的数学起点。

2.2 状态是一块黑板：怎么「写」和「读」

先把 KDA 的状态 S 想象成一块黑板。它是一个矩阵，形状是 d_k × d_v——第0章讲过，矩阵就是一个数字表格。

怎么往黑板上写一个「键 → 值」的配对？ 答案是外积：

第0章提过，一个竖向量乘一个横向量得到一个矩阵。kv^⊤ 就是这么一个矩阵——它可以理解为「在 k 指向的那个方向上，刻下 v 这个内容」。

怎么从黑板上读？ 用查询向量去乘它：

为什么这样能读出来？做一次代数就明白了。假设黑板上只写过一对 (k, v)，那么：

注意 k^⊤q 是一个数（两个向量的点积，也就是它们的相似度）。所以读出来的是「v 乘以一个相似度」。

2.3 delta 规则：写之前先擦

朴素写入 S ← S + kv^⊤ 有个明显的毛病：如果同一个键被写了两次，两个值会叠在一起。

假设「首都」这个键先被写成「北京」，后来上下文变了要改成「东京」。朴素写入的结果是黑板上同时有「北京」和「东京」，读出来是两者的混合——一团糨糊。这正是 RNN 「记忆被冲淡」的数学本质。

delta 规则的想法很直接：写新的之前，先把这个键上原有的内容擦掉。

关键在那个 (I − β_tk_tk_t^⊤)。它长得吓人，但意思很简单。让我们看看它作用在旧状态上会发生什么。

2.4 加上遗忘：式 1 的完整形态

delta 规则解决了「同一个键被反复覆盖」的问题。但还有一个问题它解决不了：那些再也用不到的旧信息，怎么慢慢淡出？

比如你读一篇长文档，第一章的细节到第十章基本就不需要了。delta 规则只会在「同一个键被重写」时才擦，从没被重写的旧内容会永远占着黑板。

解法是加一个遗忘门：每走一步，就让整块黑板按一定比例淡化一点。这就得到了论文的式 1：

2.5 式 2：这些 q、k、v、α、β 是从哪来的

式 1 里的每个量都要从 token 向量 x_t 算出来。论文式 2 给了具体做法（h 是头的编号）：

2.6 分块并行形式：让串行的东西跑在 GPU 上

现在面对 RNN 的第二个致命伤：式 1 是严格串行的。S_t 依赖 S_t−1，一百万个 token 就要一百万步，GPU 完全用不上。

解法叫分块并行形式（chunkwise parallel form），思路是一个漂亮的折中：

要写出这个形式，先需要一个记号。论文式 3 定义累积衰减：

有了它，再加上一个叫 UT 变换的技巧产出的 U_[t] 和 W_[t]，定义伪值项 Ṽ_[t] := U_[t] − W_[t]S_[t]，块内所有输出就可以并行算出来：

这条式子不需要你能自己推出来（论文自己也把完整推导推给了 Kimi Linear 那篇），但你需要读懂它在说什么：

2.7 下界衰减：一个溢出问题如何改写了数学

这一节是全章最精彩的地方，因为它展示了一件在论文里很少被讲得这么透的事：硬件的数值精度限制，可以反过来决定模型的数学形式。

问题：那个除法会爆炸

回看式 4 里的 K_[t] / Γ_[t]^1→C——键要除以累积衰减。

而 Γ 是一串 (0,1) 之间的数连乘。连乘会发生什么？

BF16：训练大模型最常用的数字格式，每个数占 2 字节。它能表示的最大值约为 3.4 × 10³⁸。超过就变成「无穷大」，计算全毁。

论文原文的说法是：「因为 Γ 是一串 (0,1) 中保留因子的乘积，这个倒数可以无界增长，在有限精度下溢出。」

前代的解法，以及它留下的疙瘩

Kimi Linear（KDA 的前身）用两招控制这个数值范围：

1. 在对数空间计算相对衰减——连乘变成连加，动态范围大幅压缩。
2. 把每个块再划分成 16 个 token 的次级小片（tile）——只在小片内部算相对衰减，跨小片的部分另外处理。

这两招之后，非对角的小片可以直接用稠密矩阵乘法在 Tensor Core 上算。但对角线上的小片不行——论文原话是：对角小片「仍然需要显式的位置对计算，这仍是块内的主要瓶颈」。

Tensor Core：现代 GPU 里专门做矩阵乘法的硬件单元，比通用计算单元快好几倍。但它只吃「标准的稠密矩阵乘法」这一种形式。任何需要「逐个位置对单独处理」的计算都用不上它，只能退回慢得多的通用路径。

K3 的解法：换掉衰减函数本身

这里是关键的思维转折。前人的思路是「数会爆炸，那我想办法在计算上绕开」。K3 的思路是「数会爆炸，那我从一开始就不让它爆炸」。

回忆 2.5 节留下的悬念：从衰减 logit z 到保留因子 α 的映射被推迟了。现在揭晓这个映射：

对比一下前代的做法。Kimi Linear（以及 GDN、Mamba-2）用的是负 softplus 映射：

差别只有一个字：值域。前代是 (−∞, 0)，K3 是 (−5, 0)。前代无下界，K3 有下界。这就是「下界衰减」（lower-bounded decay）这个名字的来源。

为什么 −5 这个数字刚刚好

论文给出的推理链条非常干净，值得完整走一遍：

2.8 满秩输出门：最后一道闸

式 1 算出的 ō_t 还不是这一层的最终输出。KDA 在它后面加了一道门：

第3章 Gated MLA 与混合注意力：两种记忆的分工

一句话导语：K3 不把「注意力」当成一种东西，而是让两种机制分工——KDA 负责顺着句子往下记、天然带先后顺序，Gated MLA 负责回头在全篇里随便翻、不受位置约束。这一章讲清它们按什么比例混、各自补什么、以及为什么 MLA 层可以干脆不要位置编码。

3.1 先看地图：K3 把信息流往三个方向撑开

先把最基础的事情说清楚。一个语言模型拿到一段话，会先把它切成一个个 token(token，可以粗略理解成「词或词的一部分」)，每个 token 变成一串数字。K3 里这串数字有 7,168 个（论文表 1 的 Hidden Dimension）。之后模型做的事情，翻来覆去就一件：让这些数字互相看一看、混一混。所谓「设计架构」，说白了就是决定谁跟谁混、怎么混、混几次。

论文 §2 开篇给的框架是：混合可以发生在三个互不相同的方向上，K3 沿这三个方向分别做了扩展。

第一个方向是序列长度，即 token 之间怎么混。K3 的做法叫混合注意力(Hybrid Attention)：每个 block 里放 3 个 KDA 层加 1 个 Gated MLA 层，论文说这样「为长上下文的 token 混合提供了高效机制，同时保留了有选择性的高容量注意力」。第二个方向是网络深度，即层与层之间怎么混：注意力残差(Attention Residuals, AttnRes) 让每个模块能从词嵌入、当前块、以及之前的块里「挑着取」，而不是只能沿一条残差链均匀累加——这是第4章的内容。第三个方向是模型宽度，即同一个 token 内部 7,168 个通道之间怎么混：每个注意力层后面跟一个 Stable LatentMoE 层做稀疏的通道混合，每个 token 只激活 896 个路由专家里的 16 个。

3.2 三个 KDA 配一个 Gated MLA：比例，和末尾补的那一层

论文 §2.1 给的分工写得很明确：KDA 层提供位置敏感、近因感知(position-sensitive and recency-aware)的混合，MLA 层提供不受限的全局内容交互(unrestricted global content interaction)。翻成人话：KDA 管「最近发生了什么，按顺序记着」；MLA 管「整篇文章里跟我现在这个词最相关的是哪几个，不管它在多远」。

混合注意力（Hybrid Attention）：K3 的做法是逐层混合(layerwise hybrid)——不是在同一层里把两种机制拼起来，而是整层整层地交替。每个 block 里放 3 个 KDA 层，后面跟 1 个 Gated MLA 层，比例 3:1，这个模式在整个骨干里重复。此外，骨干末尾额外放一个 Gated MLA 层，确保最后一层总是执行全局注意力。

3.3 MLA：把一个 token 的键值压成一个小向量

多头潜注意力（Multi-head Latent Attention, MLA）：由 DeepSeek-V2 提出。它的想法是：既然缓存太大，那就别缓存 K 和 V 本身，改成缓存一个能重建出它们的小东西。具体做法是把每个 token 的键值表示压进一个低维潜向量(latent vector)：

推理时只缓存 c_t。真正要算注意力的时候，再用学到的上投影(learned up-projections)把 c_t 重建成各个头的内容键和值。论文的原话是：这个分解「在保留全局 token 到 token 注意力的同时，减少了 KV 缓存的足迹」。Kimi K2 和 K2.5 都用了 MLA，K3 把它保留在周期性出现的全局注意力层里。

代价出在哪？至少三处。第一是计算换存储：每次算注意力都要多做一次上投影，把小向量重新撑回大矩阵，省下的显存是用额外乘法换的，论文没讨论这部分开销有多大。第二是表达力受限：所有头的键和值都必须从同一个低维 c_t 里长出来，压得越狠，不同头拿到的信息越接近；论文没有量化这一损失。第三是复杂度没变：注意力「每个 token 看所有前面 token」的平方级计算量，MLA 一点没减少。

3.4 NoPE：位置这件事，交给谁管

无位置编码（No Position Encoding, NoPE）：和 Kimi K2、K2.5 不同，K3 沿用 Kimi Linear 的混合设计，对所有 MLA 层采用 NoPE——它们的查询和键上不施加任何显式位置编码。

敢这么干的理由，论文写得很直白：夹在中间的 KDA 层本身就是位置敏感、近因感知的（它按顺序一步步更新状态，把顺序换掉结果就变了），而 MLA 层负责提供不受限的全局内容交互。也就是说，位置信息在进入 MLA 层之前，已经被 KDA 层写进隐藏向量里了；MLA 层不需要再被单独告知一遍，它可以专心做「按内容找相关」这件事。

还有第二个好处，纯工程但很实在：论文指出，这种分工避免了在扩展上下文长度时去改位置编码的参数，比如重调 RoPE 的频率基，或者套用 YaRN 这类插值方法。K3 的训练上下文从 K2 的 128K 一路推到 1M（表 1，8 倍），如果位置编码是显式的，每一次扩长都要重新调参、重新验证；NoPE 直接把这个环节从流程里删掉了。

3.5 输出门：让每个 token 自己决定听多少（式 7）

K3 给 MLA 加了一个输入相关、逐通道、满秩的输出门。记 ō_t 为位置 t 上未经门控的 MLA 输出，门控后的输出是：

唯一需要额外解释的词是满秩。W_g 把 7,168 维的 x_t 映射成一个同样长的门向量。如果这个映射是低秩的——比如先压到 32 维再撑回去——那么无论输入是什么，所有可能的门向量都被困在一个 32 维子空间里，很多通道只能被绑在一起开关。满秩则意味着门向量原则上可以指向 7,168 维空间里的任何方向，每条通道可以独立开关。论文的说法是：这个门让每个 token 去调制它从全局注意力读到的通道；W_g 满秩这一点与 K3 里 KDA 的新参数化保持一致。

3.6 把注意力输出留在 FP32，以及被逼出来的内核重设计

K3 的处理是：训练时把注意力输出保持在 FP32，采用文献 [98] 的方法纠正这个有偏舍入误差。这听起来只是「多用点精度」，但它在 GPU 上引发了一连串连锁反应，论文把这条链完整写了出来，值得跟着走一遍。

tile（分块）与片上占用：GPU 算大矩阵时不会一次搬进整个矩阵，而是切成小块（tile），一块块搬进共享内存(shared memory)里算。共享内存是紧挨着计算单元的一小块存储，快得多也小得多，寸土寸金。

把输出从 16 位改成 32 位，意味着输出 tile 的片上占用直接翻倍。共享内存就那么大，有东西变胖就得有东西让位。论文的解法是重新设计训练内核：让变胖的输出 tile 去和 KV 暂存缓冲区(KV staging buffers，从显存往片上搬 K、V 时的中转区)重叠，而不是像原来那样和 query tile 重叠。腾出来的共享内存用于更深的 KV 流水线——同时在途的 K、V 块更多，搬运和计算叠得更好，计算单元等待更少。论文的结论是：这样反而换来更高的训练吞吐。

3.7 对账时间：69 + 24 = 93，可 69 ÷ 24 = 2.875

现在把论文表 1 里跟本章相关的几行拉出来，做一次真正的核对。这一节的目的不是记住数字，而是练一件事：拿到一张表，能不能从里面把架构反推出来。

第4章 Attention Residuals：让「深度」也用上注意力

一句话导语：Transformer 当年用注意力取代了 RNN 沿时间的顺序传递，AttnRes 把同一套方法论搬到深度上——让第 40 层不必顺着残差链一路继承，而是像挑选 token 一样，从所有先前层里挑着取。这一章讲清这个类比为什么成立、在哪失效，以及为什么它最后必须被「块化」才养得起。

4.1 灵魂所在：把「时间上的老问题」搬到「深度」上

这个类比是本章的灵魂。RNN(Recurrent Neural Network，循环神经网络)处理句子是从左到右一个词一个词读，每读一个就更新一次隐藏状态；到第 100 个词时，前面 99 个词的信息全都挤在那一个状态里，想调用第 3 个词的细节只能希望它还没被冲掉。序列建模领域怎么解决的？Transformer 用注意力取代了循环：每个位置不再只能看「上一步传下来的状态」，而是用数据相关的权重直接访问所有先前位置，需要谁就给谁高权重。

把这段话里的「位置」全部换成「层」，就是 AttnRes 的全部想法。论文写得非常直接：AttnRes 把同样的方法论用到深度上——每一层从所有先前层里有选择地检索表示，而不是均匀地累加它们。

4.2 全注意力残差：伪查询、键值和 softmax 核（式 8、式 9）

要把注意力搬到深度上，得先回答三个问题：谁来当查询？谁来当键和值？权重怎么算？论文逐个给了答案。

伪查询（pseudo-query）：对每一层 l，定义一个该层专属的、可学习的查询向量 q_l = w_l ∈ ℝ^d。请特别注意「pseudo（伪）」这个字的含义：在普通注意力里，查询是由当前输入算出来的（q = W_qx）；而这里的 q_l 不依赖任何输入，它就是这一层自己的一组参数，训练完之后固定不变。

键和值则来自各层的输出，两者取同一个东西：

i = 0 这一项要单独拿出来说：它把词嵌入也放进了可检索的源里。这意味着无论网络多深，任何一层都有一条直达最原始输入的通道，永远不必担心原始信息在中途被磨没了。这个细节在下一节的块化里会被专门保留。

接下来是权重。论文用的是 softmax 核 φ(q, k) = exp(q^⊤ RMSNorm(k))，其中 RMSNorm 的作用是防止那些输出幅值大的层主导权重。然后归一化：

最后是代价。论文分得很清楚：网络深度是适中的（L < 100），所以这个完整形式的 O(L²d) 算术开销是负担得起的；真正的实际开销是 O(Ld) 的显存——要把所有层的输出一直留着——以及在流水线并行下的跨阶段通信。

4.3 Block AttnRes：把 93 层切成几个块（式 10）

做法分三步。第一步，把 L 层切成 N 个块，每块 S = L/N 层。第二步，块内不再保留每层的输出，而是把它们求和规约成单个块表示：

第三步，跨块才做全注意力，而且只对 N 个块级表示做。具体到块 n 里的第 i 层，值矩阵是：

为什么两种情况写法不一样？关键在于「当前块内已经完成了几层」。如果我是块内第 1 层，这个块里在我之前一层都没有，部分和是空的，没有 b_n⁰ 可放（放零向量只会白占一个注意力名额、白分走一份权重）。从第 2 层起，我前面已有 i−1 层的输出，把它们的部分和挂进清单，就能读到「同块内刚刚发生的事」。注意这带来一个不对称：块内的近期信息只以「部分和」这一整团的形式出现，无法拆开、单独给块内第 1 层和第 2 层不同的权重。这正是块化付出的代价。

最后，论文说最终的输出层聚合全部 N 个块表示——也就是说，模型最顶端仍然能一次性看到所有块级摘要。

4.4 块化换来了什么：显存、通信，以及推理时的状态

论文把收益列成三条，值得逐条对着看。

第一条，显存和通信从 O(Ld) 降到 O(Nd)。这是块化的初衷。用 K3 的数字感受一下（以下为我们的量级估算，论文未给出这些数字）：不块化时每 token 要留 93 × 7,168 ≈ 66.7 万个数（BF16 约 1.3 MB）；块化后只需留 9 个源 × 7,168 ≈ 6.45 万个数（约 129 KB），大约降到十分之一。流水线并行下跨阶段要传的东西同样按这个比例缩小。

第二条，块结构限定了推理时的状态大小。用完整形式的话，走到第 93 层时手里必须攥着 92 份历史层输出；块化之后永远只有至多 N+1 份。状态有了上界，显存规划才做得出来。

第三条，更好地合并两路结果。论文说，块结构使得并行算出的块间结果可以通过 online softmax 与顺序累加的块内部分和更好地合并，显著降低推理时间开销。拆开看：块间的 b₀, …, b_n−1 是已经定型的，可以一次性批量算完；块内的部分和却是边走边长的，每过一层就变一次。两路时间特性完全不同，分开算再合并才划算。

online softmax（在线 softmax）：softmax 的分母是所有打分之和，朴素写法必须先把全部打分算完才能归一化。online softmax 则边算边归一化：一路维护「目前见过的最大值」和「目前累计的和」，来一批新分数就按比例修正已有结果。它的价值是让两批分别算出的部分结果能正确合并，不必等齐——正好对上「块间批量并行 + 块内顺序更新」这个模式。

4.5 对账：93 层是怎么切成 8 块的

论文给的实证结论是：N ≈ 8 在各种模型规模上都能恢复大部分收益（引用 [57]）。K3 据此做的划分，原文是这么写的：把它的层划分成 8 个块、块大小为 12 层，产生一个不完整的末块，算上词嵌入层共 9 个块。

这句话读快了会出事，必须自己算一遍。

4.6 后面还会再见到它：训练时的 checkpointing 与推理时的两阶段内核

AttnRes 的开销不只是「显存里多存几份东西」，它同时牵动训练系统和推理系统的实现。论文在后面的系统章节给了两个配套优化，本章先埋线头，第10、11章会展开。

训练这边：块表示在块的边界层生成一次，之后被块内所有层共享、常驻 GPU；而且整个 AttnRes 计算被 checkpointing（重计算：反向时不保存中间结果，临时再算一遍）整个包住，所以每一层为反向保存的激活与标准残差架构完全相同——也就是说，引入 AttnRes 不会让训练显存额外膨胀。流水线并行下则采用基于缓存的流水线通信，只增量传输新生成的块。

推理这边：Block AttnRes 采用两阶段调度——一次批量的块间遍历，每个块只读一次缓存的块表示；之后每层通过 online softmax 合并把块内部分和折进来。这正是 4.4 节第三条收益的工程落地形式。

第5章 Stable LatentMoE：把「宽度」做稀疏，而不炸掉

一句话导语：这一章回答「怎么把一层里的小网络从 384 个扩到 896 个、还不让训练崩掉」——K3 用三件事做到：把专家搬进一个更窄的潜空间、在上投影前插一个 RMSNorm、给激活值装两道软限位，再用一个不需要学习率的分位数规则把 896 个专家的负载摆平。

5.1 先搞懂 MoE：为什么「参数多」可以不等于「算得慢」

先把舞台搭好。一个 Transformer 层里有两件事：注意力负责让不同的词互相看一眼（前面几章讲过），前馈网络(Feed-Forward Network, FFN) 负责让每个词各自再想一想。

前馈网络（Feed-Forward Network, FFN）：一个只作用在单个 token 上的小网络。它拿到这个 token 的 d 维向量，先用一个矩阵把它升到一个更宽的隐藏维 h，做一次非线性变换，再用另一个矩阵压回 d 维。它不看别的 token，纯粹是「就这一个向量做一次加工」。

混合专家（Mixture-of-Experts, MoE）：不把 FFN 做成一个大的，而是做成很多个小的（每个叫一个专家），再配一个路由器(router)。路由器给每个 token 打分，只挑分数最高的 k 个专家真正跑一遍，其余的专家这一次完全不参与计算。

这就把参数量和计算量解耦了。假设有 n 个专家、每个 token 只用 k 个：参数量正比于 n，每 token 计算量只正比于 k。n 可以往上堆，k 保持不动。模型「知道的东西」变多了，但每个 token 走的路没变长。

稀疏度（sparsity）：论文里指专家总数除以每 token 激活的专家数，n/k。这个数越大，说明每个 token 用掉的专家占比越小，模型越「稀疏」。

K3 的具体数字（论文 Table 1）：路由专家 n = 896 个，每 token 激活 k = 16 个，另外还有 N_s = 2 个共享专家(shared experts)——共享专家不参与挑选，每个 token 都必过，负责那些「谁都用得上」的通用变换。这个「共享 + 路由」的组织方式论文说是沿用 DeepSeekMoE 的做法。

5.2 LatentMoE：把「模型宽度」和「专家宽度」拆成两件事

专家池扩大听起来只是「多存点参数」，但它有一笔隐藏的账。常规 MoE 里，每个被选中的专家拿到的是完整的 d 维 token 表示。在大规模训练里，专家分散在不同的显卡上，token 要通过网络被送到选中的专家那儿去（这一步叫 dispatch），算完再送回来。选了 k 个专家，就要送 k 份。论文的原话是：通信量和专家权重的流量都随路由重数(routing multiplicity)增长。k 从 8 涨到 16，这两笔账就直接翻倍。

LatentMoE：把「整个模型有多宽」和「路由专家有多宽」当成两个可以分别设定的数。共享专家保留全宽通路（d 维进、d 维出）做通用变换；专门化的路由专家则在一个宽度只有 ℓ 的紧凑潜空间(compact latent space) 里工作。

具体做法：先用一个下投影矩阵 W^↓ 把 token 从 d 维压到 ℓ 维，得到 z = W^↓x；被送去 dispatch 的是 z，不是 x。所有路由专家都是 ℓ → ℓ 的小网络。等专家算完、加权汇总成一个 ℓ 维向量之后，再用一个上投影矩阵 W^↑ 送回 d 维，和共享分支相加。

5.3 钥匙：极端稀疏放大的两个失效模式

这一节是全章的钥匙。前面两节讲的都是「怎么把规模做上去」，这一节讲「做上去之后什么东西会坏」。论文的措辞很直白：这种极端稀疏放大了原始设计的两个失效模式。后面 2.3.1、2.3.2、2.3.3 三个小节，就是针对这两个失效模式的三个对策。先记住这个对应关系，后面每一节读起来都会有方向。

失效模式一：路由分支的激活值爆炸

看图 5-1 的下面那条路：W^↓ → 一个带门控的多分支专家前馈网络 → W^↑。论文说这把它们「串成了一条近乎四次连续矩阵乘法的链条」，并称这个结构是病态的(ill-conditioned)；再叠加 2.8 万亿参数的规模，结果就是路由分支内部的激活值爆炸。

失效模式二：近 10³ 个专家的负载摆不平

第二个问题和数值无关，和「分工」有关。路由器要在 896 个专家之间分配 token。如果分配严重不均——有的专家被一整批 token 挤爆，有的一个 token 都没分到——训练就会出问题。论文的说法是：平衡将近 10³ 个专家的负载，已经超出了现有免辅助损失偏置更新还能良好工作的范围。

为什么不均衡有害，论文给了两条理由（在 2.3.3 里）：一是拖慢专家并行训练——专家分散在不同显卡上，一步的耗时由最忙的那张卡决定，别的卡只能干等；二是可能让部分专家训练不足——长期分不到 token 的专家梯度稀少，学不出东西，最后变成一堆死参数，白占显存。

5.4 式 11 与 Normalized LatentMoE：一个 RMSNorm 放在哪里的学问

现在把一层 Stable LatentMoE 的完整前向写下来。论文式 11 分两行：第一行算路由分支的汇总，第二行把两个分支合起来。

先把式子读顺：第一行说「把 x 压进潜空间，送给 16 个选中的专家，各自算完之后按权重 p_i 加权求和，得到 u」；第二行说「共享专家直接吃全宽的 x，它们的输出相加，再加上 u 归一化之后送回全宽的结果」。

整个 2.3.1 节讲的就是式 11 第二行里那个 RMSNorm。论文说：原始的 LatentMoE 是直接把 W^↑ 作用在 u 上的，而 u 的尺度会随着「选中了哪些专家」和「路由权重怎么分布」而变化。K3 在专家聚合和上投影之间插了一个 RMSNorm，降低路由分支对尺度变化的敏感度，然后才和全宽的共享分支相加。

5.5 SiTU-GLU：给两个乘性因子各装一道软限位

第二个数值对策治的是专家内部。要理解它，得先看清楚现在通用的激活函数问题出在哪。

门控线性单元（Gated Linear Unit, GLU）：把输入分别过两个矩阵，得到「门分支」和「上分支」两个向量，然后逐元素相乘（记作 ⊙）。原始 GLU 的门分支是 Sigmoid(W_gx)，上分支是 W_ux。「门」的作用是：sigmoid 的输出在 0 和 1 之间，等于给上分支的每个通道配一个 0~1 的开关，决定这个通道的信息放多少过去。

SwiGLU：把 GLU 的 sigmoid 门换成 Swish，即 Swish(x) = x·Sigmoid(x)。论文说它在 Transformer 里表现很好，后来被大模型广泛采用——但也明说「对它为什么有效的完整解释仍然是开放问题」。K2 用的就是 SwiGLU。

K3 的答案是一个光滑封顶(smooth cap) 函数：

把它同时作用在 Swish 门的线性因子上（即 xσ(x) 里的那个 x，注意 sigmoid 那一半不动）和上分支上，就得到 Sigmoid Tanh Unit GLU(SiTU-GLU)：

论文对 SiTU-GLU 的总结是：缩放后的 tanh 在原点附近近似线性、在大幅值处有界，因此 SiTU-GLU 既保留了 SwiGLU 的局部响应，又控制住了乘积里的两个因子。Figure 4 画的就是这三条曲线在同一个区间 x ∈ [−10, 100] 上的对比：SiTU-GLU（红线）在原点附近紧贴 SwiGLU，在大的正输入处逼近 100 这条界，而 SwiGLU 一路往上冲、没有上界。

5.6 Quantile Balancing：把偏置直接设成「对得上目标负载的那个分位数」

这是本章最难的一节，也是 K3 这一部分最有意思的想法。慢慢来。

问题：过热的专家和饿死的专家

路由器是学出来的，没有任何东西天生保证它把 token 均匀地分给 896 个专家。实际发生的是：少数几个专家变成「热门」，一批 token 全往那里挤；另一批专家几乎没人光顾，论文 Figure 5(a) 里用更深的圆表示过热的专家（overheated），用淡化的圆表示利用不足的专家，用虚线圆表示濒死的专家（dying experts，一个 token 都没分到）。

论文给的两条危害前面提过，这里再落实一下：拖慢专家并行训练——专家分布在不同显卡上，一步的墙钟时间由负载最重的那张卡决定；可能让部分专家训练不足——饿死的专家几乎收不到梯度，训练完还是初始化时的样子。

K3 的路由框架：免辅助损失的偏置

怎么让路由变均匀？一个老办法是加辅助损失：在训练目标里额外加一项「惩罚不均衡」的损失。但这样做会污染主目标——模型为了均衡而牺牲语言建模效果。K3 明确说自己用的是免辅助损失路由(auxiliary-loss-free routing)：不加损失项，而是给每个专家配一个偏置 b_j，只加在用于 Top-k 选择的那个分数上。

老办法的困境：一个调不好的步长

原来的免辅助损失方法用一条定步长符号更新规则：

读法：如果专家 j 的负载低于平均，sign 为 +1，就给它的偏置加 γ，下一步更容易被选中；反之减 γ。注意 sign 把「差多少」这个信息全丢了——差 1 个 token 和差 1000 个 token，动作完全一样，都是挪 γ。

论文指出这里的困境：γ 在「适应太慢」和「震荡」之间权衡。γ 小了，负载偏离目标之后要很多步才能纠回来；γ 大了，会冲过头，然后往回冲，来回震荡。而 LatentMoE 把每层路由专家池扩到 896 个之后，这个权衡更难做了——专家越多，每个专家的负载统计噪声越大（平均只有 mk/896 个 token），也就越容易把噪声当成信号乱挪。

QB 的核心：把偏置设成一个分位数

分位数（quantile）：把一堆数从小到大排好，「q 分位数」就是排在 q 这个比例位置上的那个数。比如 100 个数的 0.9 分位数，就是排序后第 90 个数——有 90% 的数不超过它，10% 的数超过它。中位数就是 0.5 分位数。

分位数均衡（Quantile Balancing, QB）：论文的定义是「把每个专家的偏置设成与它的目标负载相匹配的那个路由分数分位数」。注意这里没有步长、没有学习率——它是一个直接赋值，不是一次挪动。

先把符号摆清楚。考虑一个训练批次：m 个 token，n 个专家，Top-k 选择。总共要发出 mk 个「token→专家」的分配。均分到 n 个专家头上，每个专家的目标负载是

第一步的巧妙：从 Top-(k+1) 里白捡一个门槛

QB 只用一次前向传播就推出下一步的偏置。第一个动作是：把路由时的 Top-k 换成对有偏分数 s_i + b^(t) 的 Top-(k+1)。

取出来的 k+1 个数里：前 k 个就是实际走的路由（和原来一模一样），第 (k+1) 个是一个门槛 α_i^(t)——它的含义是：一个专家要想挤进 token i 的 Top-k，它的有偏分数必须超过这个值。

第二步：固定门槛，反解偏置

现在把所有 token 的门槛 α_i^(t) 钉住不动，只问一件事：给专家 j 换一个候选偏置 b̂_j，它会收到几个 token？答案是数一数有多少个 token 的分数越过了门槛：

把条件挪一挪：s_i,j + b̂_j > α_i 等价于 s_i,j − α_i > −b̂_j。左边是间隔，右边是一个阈值。于是这个计数就变成了「有多少个间隔超过了阈值 −b̂_j」。

这个计数关于阈值 −b̂_j 是单调递减的：阈值越高，能越过的间隔越少（阈值定到 +∞，一个都过不去；定到 −∞，全都过得去）。单调 ⇒ 想让计数等于任何一个目标值，都有唯一的阈值可以做到（在无并列的假设下）。这就是「解方程」而不是「挪一步」的数学依据。

令计数 = q，解是什么？把专家 j 这一列的 m 个间隔从大到小排好，要让恰好 q 个严格超过阈值，阈值就得落在第 (q+1) 大的间隔上——这样前 q 个严格超过它，第 (q+1) 个正好等于它（不算超过），后面的都小于它。所以

换句话说：阈值 −b̂_j^(t+1) 就等于「专家 j 这一列 m 个间隔里第 (q+1) 大的那个」。

最后一步换个说法。「m 个数里第 (q+1) 大」，用分位数怎么表达？有 q 个数在它上面，占比 q/m；而我们在前面验证过 q/m = k/n。所以它下面的占比是 1 − k/n，也就是这批间隔的 (1−k/n) 分位数。写成论文的式 14：

把论文 Figure 5 的例子完整走一遍

论文 Figure 5 用 m=8 个 token、n=4 个专家、k=1 演示了一遍 QB：初始负载是严重不均的 (4, 3, 1, 0)——E₁ 过热，E₄ 是一个 token 都没有的濒死专家；目标负载 q = 8×1/4 = 2；QB 一步之后变成 (2, 2, 2, 2)。

论文没有给出具体的分数数值，下面这组数是我们自己构造的一个满足论文全部条件的算例（m、n、k、初始负载、目标负载、最终负载都与论文一致）。建议拿纸笔跟着算一遍，这一节的所有概念都会在这个表格里落地。设当前偏置 b^(t) = 0（初始状态）。

注意 k=1 时 Top-(k+1) 就是 Top-2，所以门槛 α_i 就是每行的第二高分。第二步，把每个分数减去它所在行的门槛，得到间隔：

怎么读最后两行：以 E₁ 那一列为例，8 个间隔排序后是 0.36, 0.32, 0.06, 0.05, 0.00, 0.00, 0.00, −0.29。q=2，所以取第 q+1 = 3 大的那个，是 0.06。取负得 b̂₁ = −0.06。验算：严格大于 0.06 的间隔恰好有 2 个（0.36 和 0.32）——正是目标负载。四列都可以这样验一遍。E₃ 和 E₄ 这两个冷门专家拿到的是正偏置（+0.10），E₁ 和 E₂ 这两个热门专家拿到负偏置，方向完全符合直觉。

（论文式 14 第二行还要减去均值：mean(b̂) = (−0.06−0.03+0.10+0.10)/4 = 0.0275，减完得 b = (−0.0875, −0.0575, +0.0725, +0.0725)。前面说过这一步不改变任何 Top-k 结果，所以下面直接用 b̂ 验证。）

第三步，用新偏置重新路由：把表 5-4 的每一列各自加上 b̂_j，再取每行最大。例如 t₄ 这一行变成 E₁: 0.74−0.06 = 0.68、E₂: 0.40−0.03 = 0.37、E₃: 0.34+0.10 = 0.44、E₄: 0.68+0.10 = 0.78 —— t₄ 从 E₁ 改投 E₄。全部八行算完：

最终负载 (2, 2, 2, 2)。只动了三条边，四个专家全部达到目标负载，而且没有任何一步用到学习率或步长——每个偏置都是从一次前向传播的统计里直接解出来的。

5.7 直方图估计：真实规模下这个分位数根本收不齐

表 5-4 那个 8×4 的例子里，求分位数就是「把 8 个数排个序，取第 3 大」。真实训练里做不到。

论文把困难说得很清楚：式 14 里的分位数是对整个全局批次算的，这些间隔的数量以百万计，而且分散在各个 rank 和各个梯度累积步上——同一个专家的间隔，一部分在第 3 号卡上、一部分在第 47 号卡上、一部分要等到这一步的第 8 次累积才产生。要精确求分位数，就得把它们全都收集到一处再排序。论文的判断是：训练时这不可行。

直方图（histogram）：把数值范围切成若干个箱（bin），只记录「落在每个箱里的数有多少个」，不保留每个数具体是多少。比如把 [−1, 1] 切成 200 个箱，每个箱宽 0.01，那么 100 万个数就被压缩成 200 个计数。

QB 的做法是：给每个专家维护一个它自己的间隔直方图。每张卡各自统计自己那部分 token 产生的箱计数，然后一次 all-reduce 把各 rank 的箱计数加起来，再从汇总后的计数里把分位数恢复出来（从最大的箱往下累加，加到超过目标个数为止，那个箱的位置就是分位数）。

论文明确说：这个直方图估计器就是实践中真正使用的方法（「This histogram estimator is the method we use in practice」）——式 14 里那个精确的 quantile 是理想化的写法。更详细的描述和它的误差界，论文放在附录 D，见第14章。

第6章 原生视觉与 Per-Head Muon

一句话导语：这一章回答两个问题——为什么 K3 敢把视觉编码器从零开始训（而不是像几乎所有人那样拿一个 SigLIP 来打底），以及为什么要把优化器的正交化操作细到「每个注意力头单独做一次」。

6.1 原生多模态：让「看」和「写」活在同一条 token 流里

先说不用它会怎样。今天绝大多数「能看图的大模型」是这么拼出来的：先有一个只会读文字的语言模型，训好了；再有一个只会看图的视觉模型，也训好了；然后加一个小小的转接头，再花一个专门的阶段把两边「对齐」，让视觉模型输出的东西能被语言模型读懂。这个事后补的阶段，论文叫事后模态对齐(post-hoc modality-alignment stage)。

原生多模态（natively multimodal）：论文对 K3 的原话是，文本、图像和视频由同一个共享骨干在同一个上下文里处理，没有事后的模态对齐阶段。

差别听上去只是流程顺序，实际影响的是信息的宽度。想象模型正在做一件很典型的事：写一段网页代码，把它渲染出来，看看效果，再回去改代码。在拼接式的方案里，「看」这一步是由另一个模型完成的，它必须把看到的东西压缩成一段文字描述，再交回给语言模型——按钮偏了三个像素、某个渐变的方向反了、第七帧的动画抖了一下，这些细节能不能活着穿过那段文字描述，全看运气。论文把这种交接叫跨模型交接(cross-model hand-off)，而 K3 的设计目标就是彻底没有这一步。

在 K3 里，渲染出来的结果和产生它的代码活在同一个 token 流里。模型写代码、检查截图或视频帧、再迭代改视觉产物（用户界面、图形、视频），全程不换模型。论文明确说，这就是第 1 节里那种「长时程、视觉在环」(long-horizon, vision-in-the-loop)行为的架构基础。

6.2 MoonViT-V2：把视觉编码器完全从零训起来

这是 K3 相对 Kimi K2.5 的一个关键改变，论文用斜体强调了它：K3 的视觉编码器 MoonViT-V2 是完全从零、用下一 token 预测训练的。

下一 token 预测（next-token prediction, NTP）：就是语言模型那个最朴素的训练目标——给你前面的内容，猜下一个 token 是什么。这里的新意是，连视觉编码器的参数也由这个目标来训。

论文给的主要理由是训练稳定性。把一个预训练好的编码器接到大语言模型上做联合优化，会不稳：SigLIP 初始化的 MoonViT-3D 表现出持续更高的梯度范数，而且频繁尖峰；而从零训练的 MoonViT-V2 全程稳定。这就是 Figure 6 那张图在说的事——横轴是训练步数（7k 到 30k），纵轴是视觉塔的梯度范数，蓝线（SigLIP 初始化）整体更高、尖刺更多，红线（从零）压得又低又平；右边还放大了 14k–16k 这一小段，让你看清即使在「看起来都还好」的区间里，蓝线的抖动也明显更大。

梯度范数（gradient norm）：把这一步所有梯度当成一个超长向量，量一下它的长度。它大致告诉你「模型这一步想改多狠」。持续偏高说明训练一直在被大幅拉扯，突然的尖峰则往往是灾难性更新的前兆——真炸起来会让损失曲线飞掉，几千步的算力就白烧了。在千亿、万亿参数这个尺度上，一次崩溃的代价高到没人想赌。

还有第二个理由，关于表示被谁塑造。用 NTP 训练，编码器的表示是直接被语言建模目标塑造的；而对比损失塑造出来的表示，论文的说法是偏好全局语义、忽略细粒度的文字和结构线索。用大白话讲：对比预训练只要能把「这是一张猫的照片」和文字对上就得分了，它没有动力去精确记住猫身上第几根胡须、界面上按钮里那行小字写的什么、表格的第三列和第四列是怎么对齐的。而 K3 要干的活恰恰是看截图改代码、读 CAD 图纸、认 OCR，全是细粒度文字和结构。

论文的结论是：MoonViT-V2 在视觉评测上追平了 SigLIP 初始化的基线，说明对比预训练作为多模态语言模型的初始化不是必需的。

6.3 MoonViT-V2 的架构：27 层、无偏置、时空分解、pixel-shuffle

整条视觉通路很短，一句话就能说完：图像先由 MoonViT-V2 编码，再由一个轻量 MLP 投影器(lightweight MLP projector)映射进大语言模型。这个整体设计沿用了 Kimi K2.5 的视觉通路。

MoonViT-V2 本身是一个 27 层的视觉 Transformer，大约 0.4B 参数（第7章的 Table 1 里给的精确数字是 401M）。0.4B 是 4 亿个数——听着不小，但把它放在 K3 总共 2.78 万亿参数旁边，占比大约万分之一点四，视觉编码器在整个模型里其实是很薄的一层皮。它采用 RMSNorm，并且去掉了线性投影和注意力投影里的所有偏置项。论文明说，这个设计是为了进一步稳定从零训练——注意这和上一节是同一条主线：既然选择了从零训练这条更难走的路，架构上就要处处减少可能出问题的自由度。