DeepSeek-V4 技术报告精读

在一百万 token 的上下文下，DeepSeek-V4-Pro 每生成一个 token 的推理 FLOPs 只有 V3.2 的 27%，KV cache 只有 10%；小一号的 V4-Flash 分别是 10% 和 7%。这是 DeepSeek 2026 年 4 月随 V4 预览版发布的 58 页技术报告《DeepSeek-V4: Towards Highly Efficient Million-Token Context Intelligence》（arXiv 2606.19348）开篇给的数字，报告的主线就是让一百万 token 的上下文变得便宜到可以日常使用。

为什么做得到？答案大部分在注意力里：V4 几乎把 V3 的注意力推倒重来，换成 CSA + HCA 混合注意力。此外它换了残差连接（mHC），换了优化器（Muon），又在训练、推理、后训练三套基础设施上做了一大堆配套工作。

1. 全景：V4 相对 V3 / V3.2 改了什么

V4 有两个型号，都是 MoE（Mixture-of-Experts，混合专家）模型，都原生支持 1M（\(2^{20}=1{,}048{,}576\)）token 上下文：

• DeepSeek-V4-Pro：总参数 1.6T，每个 token 激活 49B，预训练 33T token；
• DeepSeek-V4-Flash：总参数 284B，激活 13B，预训练 32T token。

每个模型又有三档「推理强度」：Non-think、Think High、Think Max。报告里最常出现的 V4-Pro-Max 就是 Pro 在 Think Max 档。

开头那几个效率数字都能从超参数直接算出来，第 4 节有一个计算器。

和 V3、V3.2 逐项对比：

2. 先复习基线：MLA、DeepSeekMoE、MTP、DSA

V4 的每个新部件都是在这四样东西上改出来的。记号：\(d\) 是隐藏维度，\(\mathbf h_t\in\mathbb R^d\) 是第 \(t\) 个 token 进入某层时的隐藏状态，\(n_h\) 是注意力头数。

2.1 MLA：把 KV 压成一个潜向量

标准多头注意力（MHA）在每层为每个 token 缓存 \(n_h\) 个 key 和 \(n_h\) 个 value。以 V3 的尺寸（\(n_h=128\)，每头 128 维）算，每 token 每层要存 \(2\times128\times128=32768\) 个数。解码时每生成一个 token 都要把整个 KV cache 从显存读一遍，所以 cache 越大越慢、能并发的请求越少。

MLA（Multi-head Latent Attention，V2 提出、V3 沿用）的做法是：只缓存一个低维潜向量，需要时再「解压」出各头的 K、V：

RoPE（旋转位置编码）和这种低秩分解不兼容（旋转矩阵夹在中间，没法把 \(W^{UK}\) 吸收进别的矩阵），所以 MLA 另开一条 64 维的「解耦 RoPE」通道：\(\mathbf k^R_t=\mathrm{RoPE}(W^{KR}\mathbf h_t)\in\mathbb R^{64}\)，所有头共享。query 也先压到 \(d_c'=1536\) 维再升回来。于是每 token 每层只需缓存 \(512+64=576\) 个数，是 MHA 的 1/57。

还有一个关键技巧叫矩阵吸收：注意力分数 \(\mathbf q_i^\top\mathbf k^C_{s,i}=\mathbf q_i^\top W^{UK}_i\mathbf c^{KV}_s=(W^{UK\top}_i\mathbf q_i)^\top\mathbf c^{KV}_s\)。把 \(W^{UK}_i\) 并进 query 一侧之后，每个头的 query 直接在 512 维潜空间里和缓存的 \(\mathbf c^{KV}\) 做内积；同理 \(W^{UV}_i\) 可以并进输出投影。解码时 MLA 因此等价于一个 MQA（Multi-Query Attention，所有头共享同一份 K/V）：128 个 query 头，key 是 576 维 \([\mathbf c^{KV};\mathbf k^R]\)，value 是 512 维 \(\mathbf c^{KV}\)。V3.2 报告把这叫 MLA 的「MQA 模式」。记住这一点，V4 的注意力就是把它变成了模型的「原生形式」。

2.2 DeepSeekMoE 与无辅助损失的负载均衡

MoE 层把一个大 FFN 拆成很多小专家，每个 token 只走其中几个。DeepSeekMoE 的两个特点是：专家切得细（V3 每个专家中间维度只有 2048），以及有始终激活的共享专家。V3 的一层 MoE 可以写成：

其中 \(\mathbf e_i\) 是第 \(i\) 个专家的「质心」向量，\(s_{i,t}\) 是亲和度分数。选专家时用 \(s_{i,t}+b_i\) 排序取 top-\(K_r\)，但门控权重 \(g_{i,t}\) 只用 \(s_{i,t}\)，并在选中的 \(K_r\) 个里归一化。偏置 \(b_i\) 不参与梯度：每步之后，过载的专家 \(b_i\) 减 \(\gamma\)，欠载的加 \(\gamma\)，这就是无辅助损失的负载均衡（auxiliary-loss-free）。V3 另外加了一个权重很小的序列级均衡损失，防止单条序列内部极端不均。V3 还限制每个 token 最多发往 4 个节点，以控制跨节点通信。

2.3 MTP：多预测一个 token

MTP（Multi-Token Prediction）在主干之后串一个小模块：把主干第 \(i\) 个位置的最终表示和第 \(i+1\) 个 token 的嵌入拼起来，过一个 Transformer 块，再用共享的输出头预测第 \(i+2\) 个 token。训练时它是一个附加损失（加权 \(\lambda\)），让表示更「往前看」；推理时可以拿来做投机解码。V3 用深度 1，V4 的 MTP 配置与 V3 完全相同。具体实现上，MTP 块的输入是 \(\mathbf x=W_e\,\mathrm{RMSNorm}(\mathrm{Emb})+W_h\,\mathrm{RMSNorm}(\mathbf h)\)，等价于先拼接再投影。

2.4 DSA：用一个便宜的打分器挑 token

V3.2 引入了 DSA（DeepSeek Sparse Attention）。它的出发点是：一个 query 真正需要关注的历史 token 往往很少。DSA 用一个轻量的 lightning indexer 给每个历史 token 打分：

其中 indexer 的头数 \(H^I=64\)、维度 128，可以全程用 FP8 算；然后只取分数最高的 top-\(k\)（V3.2 是 2048）个 token 的 KV 做真正的注意力。这样核心注意力从 \(O(L^2)\) 降到 \(O(Lk)\)。但 indexer 本身仍要扫过全部历史 token，是 \(O(L^2)\) 的，只是常数小。

V3.2 的 indexer 是这样训出来的：先冻结主模型、保持稠密注意力，用 KL 散度把 indexer 的分布 \(\mathrm{Softmax}(I_{t,:})\) 拉向主注意力在所有头上求和、L1 归一化后的分布（1000 步，共 2.1B token）；再打开稀疏选择，所有参数一起训（943.7B token），indexer 只在选中的集合上继续对齐，且它的输入从计算图中 detach，只受自己的 KL 损失驱动。

3. 混合注意力：CSA 与 HCA

V4 设计了两种注意力层，交替堆叠：

• CSA（Compressed Sparse Attention，压缩稀疏注意力）：先把每 \(m=4\) 个 token 的 KV 压成 1 个条目，再在压缩后的条目上做 DSA，只挑 top-\(k\) 个参加注意力；
• HCA（Heavily Compressed Attention，重度压缩注意力）：把每 \(m'=128\) 个 token 压成 1 个条目，压完之后条目已经很少，直接做稠密注意力，不再挑选。

两者都额外带一个 128 token 的滑动窗口分支，用来看最近的、尚未凑满一个压缩块的 token。

3.1 Token 级压缩器

设一段输入隐藏状态 \(H\in\mathbb R^{n\times d}\)，\(n\) 是序列长度，\(c\) 是注意力的头维度（V4 里 \(c=512\)）。CSA 的压缩器先算两套「原始 KV」和两套「压缩权重」：

于是 \(C^a,C^b,Z^a,Z^b\in\mathbb R^{n\times c}\)。第 \(i\) 个压缩条目由「本块」的 \(m\) 个 \(C^a\) 和「上一块」的 \(m\) 个 \(C^b\) 共 \(2m\) 个向量加权得到：

有几个细节值得停下来看：

• softmax 是逐通道的。\(Z\) 和 \(C\) 形状相同（每个 token 每个通道都有一个权重），softmax 沿「这 \(2m\) 个 token」的方向做，\(c\) 个通道各自归一化。所以这是一个可学习的、逐通道的加权池化，不是简单平均。
• \(B^a,B^b\in\mathbb R^{m\times c}\) 是可学习的位置偏置：块内第几个位置天然更重要，可以由它表达。
• 重叠。条目 \(i\) 用到上一块的 \(C^b\)，条目 \(i-1\) 用到同一块的 \(C^a\)，所以相邻条目覆盖的 token 有一半重叠，每个条目「看」的是 \(2m=8\) 个 token，但条目数仍是 \(n/m\)。\(i=0\) 时上一块不存在，\(Z^b\) 填 \(-\infty\)、\(C^b\) 填 0。只有压缩率为 4 的压缩器（CSA 的主 KV 和 indexer）才用重叠窗口。

HCA 的压缩器更简单：只有一套 \(C=HW^{KV}\)、\(Z=HW^{Z}\)，不重叠，每 \(m'=128\) 个 token 做一次逐通道 softmax 加权求和（位置偏置 \(B\in\mathbb R^{m'\times c}\)），条目数 \(n/m'\)。

压缩之后，每个条目还要做一次 RMSNorm，在最后 64 维上施加 RoPE（位置取该块第一个 token 的位置 \(mi\)），再把非 RoPE 的 448 维量化成 FP8 存进 cache。注意：只有凑满 \(m\) 个 token 才会产生一个新条目；没凑满的尾巴 token 要先放在缓冲区里（8.5 节的「state cache」）。

3.2 CSA：在压缩条目上做 DSA

有了 \(n/m\) 个压缩条目，CSA 接下来用 lightning indexer 挑选。indexer 有自己的一套压缩器（同样的重叠压缩，但头维度是 \(c_I=128\)），得到压缩的 indexer key \(K^{\text{IComp}}\in\mathbb R^{\frac nm\times c_I}\)。query 一侧走低秩路径：

形式和 V3.2 一模一样，区别只是打分对象从「每个 token」变成了「每个压缩块」，候选数少了 4 倍。然后取 top-\(k\)：

V4-Flash 取 \(k=512\)，V4-Pro 取 \(k=1024\)，都比 V3.2 的 2048 小。每个压缩条目代表 4 个 token，所以 Pro 每层实际「覆盖」约 4096 个 token 的信息，而 V3.2 是 2048 个 token。

注意 query 的低秩潜向量 \(\mathbf c^Q_t\) 由主注意力和 indexer 共享。indexer 的 query 和 key 在量化到 FP4 之前还要做一次 Hadamard 旋转：正交变换不改变内积，却能把少数离群维度的能量摊到所有维度上，量化误差因此更小。

3.3 Shared-KV MQA 与分组输出投影

挑出来的压缩条目直接同时充当 key 和 value，所有 query 头共享（MQA）：

和 2.1 节对照：MLA 在 MQA 模式下，key 是 576 维 \([\mathbf c^{KV};\mathbf k^R]\)，value 是其中 512 维的 \(\mathbf c^{KV}\)；V4 直接把它统一成一个 512 维向量（最后 64 维带 RoPE），K 和 V 用同一个，也不再有 \(W^{UK},W^{UV}\) 这层「先压后解」的分解。换句话说，V4 把「吸收后的 MLA」直接当成了模型本来的样子。

代价是输出变宽了：每头输出 512 维，Pro 有 128 个头，拼起来 \(cn_h=65536\) 维，直接投影回 \(d=7168\) 要一个 \(65536\times7168\) 的矩阵（4.7 亿参数，每 token 每层 9.4 亿 FLOPs）。V4 因此用了分组输出投影：把 \(n_h\) 个头分成 \(g\) 组，每组 \(\frac{n_h}{g}\) 个头的输出（\(c\frac{n_h}{g}\) 维）先各自投影到 \(d_g\) 维，拼成 \(gd_g\) 维后再投影到 \(d\)：

算一下 Pro（\(g=16,\ d_g=1024\)）：第一级 16 个 \(4096\times1024\) 矩阵，共 67.1M 参数；第二级 \(16384\times7168\)，117.4M；合计 184.5M，是直接投影的 39%。Flash（\(g=8\)）：33.6M + 33.6M = 67.1M，是直接投影（\(32768\times4096\)）的一半。这其实就是把一个大矩阵换成「块对角 + 稠密」的低秩结构。

3.4 HCA：压得更狠，但不挑

HCA 和 CSA 共用 query 路径、shared-KV MQA、分组输出投影，区别只在压缩：128 个 token 压成 1 个条目、不重叠、没有 indexer，query 对所有已完成的压缩条目做稠密注意力。1M 上下文时也只有 8192 个条目，是 V3.2 每层 top-k（2048 个 token）的 4 倍，远小于 1M。

为什么要两种层交替？报告没有为此做消融，只说这种混合结构显著改善了长上下文效率。从结构上看，两者是分工：HCA 以极低成本给每一层提供「全局但模糊」的视图，CSA 提供「按需取回、分辨率 4 倍」的细节，滑窗分支补最近的精确信息。

3.5 其他细节

Query 与 KV 条目的 RMSNorm。在核心注意力之前，对每个 query 头和唯一的那个 KV 头各做一次 RMSNorm。这样 \(\mathbf q\cdot\mathbf k\) 的量级被锁住，注意力 logit 不会爆炸。正因为有这一步，V4 用 Muon 时不需要 Kimi K2 的 QK-Clip（第 7 节）。

部分 RoPE + 输出的反向旋转。每个 query 和 KV 条目只在最后 64 维施加 RoPE。问题来了：K 和 V 是同一个向量，于是 value 也带着绝对位置 \(s\) 的旋转。设 \(R(\theta_s)\) 是位置 \(s\) 的旋转矩阵，注意力输出的 RoPE 部分是

V4 的处理是在输出上再乘一次位置 \(-t\) 的旋转：\(R(-\theta_t)\mathbf o^{\text{rope}}_t=\sum_s p_{t,s}R(\theta_{s-t})\mathbf x_s\)。旋转矩阵满足 \(R(a)R(b)=R(a+b)\)，所以每个条目对输出的贡献只依赖相对距离 \(s-t\)。实现上就是对输出的最后 64 维再调用一次 apply_rotary_emb(..., inverse=True)。

滑动窗口分支。压缩条目只有在整块凑满后才可见（严格因果），所以 query 看不到自己所在块里的其他 token；而最近的 token 往往最相关。因此 CSA 和 HCA 都额外接入最近 \(n_{\text{win}}=128\) 个未压缩的 KV（同样是 512 维 shared-KV），和压缩条目放在同一个 softmax 里。

Attention sink。每个头有一个可学习的 logit \(z'_h\)，加到 softmax 的分母上：

这样一个头的注意力权重之和可以小于 1，甚至接近 0，头可以选择「这次什么都不看」。在稀疏和压缩注意力里这很有用：被选中的条目不一定真的相关，强行归一到 1 会引入噪声。

层的排布。Flash 共 43 层：前两层只用滑动窗口注意力（SWA），之后 CSA 与 HCA 交替；Pro 共 61 层：前两层用 HCA，之后交替。合起来，Pro 是 30 个 CSA 层 + 31 个 HCA 层，Flash 是 21 个 CSA + 20 个 HCA + 2 个 SWA；MTP 层的压缩率为 0，即只用滑窗。

位置编码的配置。RoPE 底数 10000，带压缩的层用 compress_rope_theta = 160000 并开 YaRN（factor 16，原始长度 65536）；纯 SWA 层不开 YaRN。

4. 一百万 token 到底省了多少：KV cache 与 FLOPs

报告 2.3.4 节列了四个效率来源：

1. 混合精度存储 KV：RoPE 的 64 维用 BF16，其余 448 维用 FP8，比纯 BF16 小将近一半；
2. indexer 用 FP4 计算：indexer 的 QK 路径在 FP4 下缓存、读取和相乘（这是后训练 QAT 的结果，见 10.6 节）；
3. 更小的 top-k：512 / 1024 而不是 2048，对中短文本也更省；
4. 最重要的：压缩 + 混合本身。

报告给出的对照是：以「BF16、GQA8、头维度 128」这种常见配置为基线，V4 在 1M 上下文时的 KV cache 约为基线的 2%。报告图 1 还画了 V3.2 / V4-Pro / V4-Flash 的累计 KV cache 和单 token FLOPs 随长度变化的曲线，在 1M 处标注 KV 小 9.5×（Pro）和 13.7×（Flash），FLOPs 低 3.7×（Pro）和 9.8×（Flash）。

这些曲线可以从超参数直接算出来。把每生成一个 token 的开销拆成四项（\(n\) 是当前上下文长度；「层」是主干层，不含 MTP）：

报告用「等效 FP8 FLOPs」计量，但没有给出折算方式。最自然的折算是按张量核心吞吐：同样一次乘加，BF16 的耗时是 FP8 的 2 倍，FP4 是一半，所以 FP8 计 1、BF16 计 2、FP4 计 0.5。按这套账，1M 处 KV 比值是 9.5×（Pro）和 13.6×（Flash），FLOPs 比值是 3.8× 和 10.1×；V4-Pro 的 FLOPs 是 V3.2 的 26.5%、KV 是 10.6%，Flash 是 9.9% 和 7.4%；以 61 层 GQA8 BF16 为基线，Pro 的 KV 是 1.98%。这些和报告给出的数字（9.5×、13.7×、3.7×、9.8×、27%、10%、2%）只差几个百分点，说明 V4 的长上下文开销基本就是由上表这几项决定的。

拖一拖能看到几件事：

• V3.2 的 FLOPs 在长上下文里几乎全被 indexer 吃掉：1M 时 indexer 约 1.05 TFLOPs，线性层只有 74 GFLOPs。这正是 CSA 先压缩再 index 的动机：候选数少 4 倍、只有一半左右的层带 indexer，原始 FLOPs 降到约 1/8，再算上 FP4 折算约为 1/16。
• V4-Pro 的核心注意力里，HCA 层反而是大头：1M 时每个 HCA 层要对 8192 个条目做 128 头的稠密注意力，而 CSA 层只看 1024 + 128 个条目。
• 短上下文（4K）下 V4-Pro 的 FLOPs 和 V3.2 相近，因为激活参数更多（49B vs 37B）。V4 的优势几乎完全体现在长度上。
• KV cache 的比值在 32K 以上基本是常数：V4 每 token 每层的平均开销是 \(\frac{30\times160+31\times4.5}{61}\approx 81\) 字节（Pro），V3.2 是 768 字节。

5. mHC：流形约束的超连接

5.1 从残差到超连接（HC）

普通残差连接是 \(\mathbf x_{l+1}=\mathbf x_l+F_l(\mathbf x_l)\)：只有一条宽度为 \(d\) 的「残差流」。超连接（Hyper-Connections，HC）把残差流加宽成 \(n_{hc}\) 条：残差状态是一个矩阵 \(X_l\in\mathbb R^{n_{hc}\times d}\)，用三个小映射连接子层：

• \(A_l\)（输入映射）：把 \(n_{hc}\) 条流加权合成一个 \(d\) 维向量，喂给子层 \(F_l\)（注意力或 MoE）；
• \(C_l\)（输出映射）：把子层的 \(d\) 维输出按权重写回各条流；
• \(B_l\)（残差变换）：各条流之间互相混合。

子层本身的输入输出仍是 \(d\) 维，所以内部结构不用改。HC 相当于提供了一条和隐藏维度解耦的扩展轴：\(n_{hc}=4\) 时残差流宽了 4 倍，但额外计算只是几个 \(4\times4\) 的混合。普通残差就是 \(n_{hc}=1,\ A=B=C=1\) 的特例。

问题是：深层堆叠时信号经过的是 \(\prod_l B_l\)。只要 \(B_l\) 的谱范数稍大于 1，乘上上百层就会爆炸；稍小于 1 就会消失。报告说 HC 在层数多时会频繁出现数值不稳定，难以扩展。

5.2 把 B 约束成双随机矩阵

mHC（DeepSeek 2025 年底的论文，arXiv 2512.24880）的核心是把 \(B_l\) 限制在双随机矩阵集合（Birkhoff 多面体）上：

即非负、每行和每列都等于 1。它有两条好性质：

1. 谱范数 \(\le1\)。Birkhoff–von Neumann 定理说双随机矩阵是置换矩阵的凸组合 \(M=\sum_k\lambda_kP_k\)（\(\lambda_k\ge0,\sum\lambda_k=1\)），而置换矩阵是正交的，\(\|P_k\|_2=1\)，由三角不等式 \(\|M\|_2\le\sum_k\lambda_k=1\)。也就是说残差变换是「非扩张」的，前向和反向都不会放大。
2. 对乘法封闭。两个双随机矩阵的乘积仍是双随机的（行和：\(M_1M_2\mathbf1=M_1\mathbf1=\mathbf1\)），所以堆多少层，\(\prod_lB_l\) 都还在 \(\mathcal M\) 里，范数仍 \(\le1\)。

同时 \(A_l\) 和 \(C_l\) 也被约束为非负且有界（用 sigmoid），避免不同流之间的信号互相抵消。

5.3 动态参数化与 Sinkhorn 投影

三个映射的参数是「动态 + 静态」两部分：先把 \(X_l\) 展平并归一化 \(\hat X_l=\mathrm{RMSNorm}(\mathrm{vec}(X_l))\in\mathbb R^{1\times n_{hc}d}\)，再线性生成原始参数：

其中 \(W^{\text{pre}},W^{\text{post}}\in\mathbb R^{n_{hc}d\times n_{hc}}\)，\(W^{\text{res}}\in\mathbb R^{n_{hc}d\times n_{hc}^2}\)，\(S\) 是静态偏置，\(\alpha\) 是初始化为小值的门控标量。然后施加约束：

Sinkhorn–Knopp 迭代：从 \(M^{(0)}=\exp(\tilde B_l)\)（保证正）出发，交替做列归一化和行归一化 \(M^{(t)}=\mathcal T_r(\mathcal T_c(M^{(t-1)}))\)，迭代 \(t_{\max}=20\) 次。对正矩阵这个过程收敛到一个双随机矩阵。

形状账（Pro，\(d=7168,\ n_{hc}=4\)）：三组 \(W\) 合在一起是 \(4d\times(4+4+16)=28672\times24\)，每个子层一份（注意力前一份、MoE 前一份），每层 1.38M 参数，61 层约 84M，相对 1.6T 可以忽略。8.4 节会提到的「mHC 里输出维度只有 24 的矩阵乘」就是它。模型入口把嵌入复制成 4 份，出口用一个只有 sigmoid 权重的 \(A\) 把 4 路合成 1 路再接输出头。

工程上 mHC 并不免费：残差流宽了 4 倍，激活显存和流水线阶段之间的通信量都变大。报告用融合 kernel、选择性重计算、调整 DualPipe 的 1F1B 重叠三招把墙钟开销压到流水线阶段的 6.7%（见 8.3 节）。

6. MoE 的小改动与参数账

V4 的 MoE 仍是 DeepSeekMoE，报告列了这些改动：

• 打分函数从 Sigmoid 换成 Sqrt(Softplus)：\(s_{i,t}=\sqrt{\log(1+e^{\mathbf u_t^\top\mathbf e_i})}\)。Sigmoid 会在 1 处饱和，而 \(\sqrt{\mathrm{softplus}(x)}\) 在 \(x\) 大时像 \(\sqrt x\) 一样继续增长，在 \(x\) 很负时像 \(e^{x/2}\) 一样趋于 0。报告没有解释这个改动的动机。选中专家的分数在 top-k 内归一化后，再乘一个 route_scale（Pro 2.5，Flash 1.5）。
• 无辅助损失均衡 + 轻微的序列级均衡损失，与 V3 一样；偏置更新速度 0.001，均衡损失权重 0.0001。
• 取消路由目标节点数的限制（V3 是最多 4 个节点），改为重新设计并行策略来维持训练效率，见 8.1 节的 MegaMoE。
• 前几层的稠密 FFN 换成 Hash 路由的 MoE。V3 前 3 层是稠密 FFN；V4 所有层都是 MoE，但前 3 层的专家由 token id 经过预先定义的哈希决定（实现上是一张 tid2eid[vocab, 6] 的固定表），不由隐藏状态决定。门控权重仍然由打分函数计算。
• 激活专家数从 8 降到 6，但单个专家更大（Pro 的专家中间维度 3072）。每 token 计算 1 个共享 + 6 个路由专家。
• SwiGLU clamping：线性分支截断到 \([-10,10]\)，门控分支上界截断到 10（见 9.4 节）。

按 config 把参数逐项数一遍：注意力（含 query 低秩、KV 投影、两级输出投影、压缩器、indexer）、mHC、门控、专家、嵌入和输出头。Flash 主干 284.3B、激活 13.3B（不含嵌入表），Pro 主干 1573B、激活 48.9B，正好是报告的 284B/13B 和 1.6T/49B（1573B 取整为 1.6T）。MTP 模块另有 6.6B（Flash）和 25.8B（Pro），与主干共享嵌入和输出头。

7. Muon 优化器

7.1 为什么要「正交化」更新

对一个权重矩阵 \(W\in\mathbb R^{n\times m}\)，SGD/Adam 的更新方向通常是低秩、病态的：少数几个奇异方向占了绝大部分能量。Muon 的想法是：取动量矩阵 \(M=U\Sigma V^\top\)，把它替换成 \(UV^\top\)，即保留方向、把所有奇异值拉成 1。这样每个奇异方向都得到同样大小的更新，相当于在谱范数意义下做最速下降。直接算 SVD 太贵，于是用 Newton–Schulz 迭代近似。

先归一化 \(M_0=M/\|M\|_F\)（保证最大奇异值 \(\le1\)），再迭代

因为 \(M=U\Sigma V^\top\) 时 \((MM^\top)^jM=U\Sigma^{2j+1}V^\top\)，这个迭代对每个奇异值独立地作用一个奇多项式 \(f(\sigma)=a\sigma+b\sigma^3+c\sigma^5\)，奇异向量不变。我们要的就是让 \(f\) 迭代若干次后把 \((0,1]\) 里的所有值都推到 1 附近。

7.2 V4 的混合 Newton–Schulz

V4 共做 10 次迭代，分两个阶段：

• 前 8 次用 \((a,b,c)=(3.4445,-4.7750,2.0315)\)：原点处斜率 3.44，小奇异值每步放大约 3.4 倍，收敛快，但不会精确停在 1，而是在约 0.7～1.13 之间来回振荡；
• 后 2 次用 \((a,b,c)=(2,-1.5,0.5)\)：这个多项式满足 \(f(1)=1\) 且 \(f'(1)=a+3b+5c=0\)，在 1 附近二次收敛，把奇异值「钉」在 1 上。

7.3 完整算法与其他配置

报告的算法 1，对每个逻辑上独立的权重矩阵 \(W\in\mathbb R^{n\times m}\)：

• \(\mu M_t+G_t\) 是 Nesterov 动量；\(\mu=0.95\)，权重衰减 \(\lambda=0.1\)。
• RMS 重标定：正交矩阵 \(O'\) 有 \(\min(n,m)\) 个为 1 的奇异值，\(\|O'\|_F^2=\min(n,m)\)，所以每个元素的均方根是 \(1/\sqrt{\max(n,m)}\)。乘 \(\sqrt{\max(n,m)}\) 把 RMS 变成 1，再乘 \(\gamma=0.18\)，让 Muon 的更新幅度和 AdamW 的典型更新 RMS 对齐，从而直接沿用 AdamW 的学习率等超参（这一做法来自 Moonshot 的 Moonlight 工作）。
• 仍用 AdamW 的部分：嵌入、输出头、mHC 的静态偏置和门控因子、所有 RMSNorm 权重。AdamW 超参 \(\beta_1=0.9,\beta_2=0.95,\varepsilon=10^{-20}\)，权重衰减 0.1。
• 不用 QK-Clip：Kimi K2 用 Muon 时遇到注意力 logit 爆炸，靠 QK-Clip 截断；V4 的注意力结构允许直接对 query 和 KV 条目做 RMSNorm（3.5 节），logit 本来就不会爆。

8. 训练与推理基础设施

这部分来自报告第 3 节和第 5.2 节。具体的并行度（TP/PP/EP/DP 各多少）报告没有公开。

8.1 细粒度专家并行：把通信藏进计算

专家并行（EP）把不同专家放在不同 GPU 上，每层 MoE 要做两次 all-to-all：Dispatch（把 token 发给专家所在的卡）和 Combine（把结果收回来）。一层 MoE 因此分成四个阶段：Dispatch（通信）、Linear-1（gate/up 投影，计算）、Linear-2（down 投影，计算）、Combine（通信）。DeepSeek 的 profiling 发现单层里通信总时间小于计算总时间，所以只要排得好，通信可以完全藏住。

• 朴素做法：四个阶段串行。
• Comet（字节的工作）：Dispatch 与 Linear-1 重叠、Linear-2 与 Combine 重叠，在 V4-Flash 的配置下理论加速 1.42×。
• V4 的做法：把专家切成若干 wave（每波一小部分专家）。一个 wave 的 token 一到齐就开算，不等其他专家；稳态下「当前 wave 的计算」「下一 wave 的 token 传输」「已完成专家的结果回传」三件事同时进行。理论加速 1.92×。

实测：在 NVIDIA GPU 和华为昇腾 NPU 上都验证过，相对强的非融合基线，一般推理负载加速 1.50～1.73×，RL rollout、高速 agent 服务这类延迟敏感场景最高 1.96×。CUDA 版的「mega-kernel」以 MegaMoE 的名字开源在 DeepGEMM 里。

报告由此给硬件厂商提了几条建议，第一条就是上面计算器里的那个比值：通信能否完全藏住取决于「算力/带宽」比 \(C/B\) 而不是带宽本身。对 V4-Pro，每个 token-专家对需要 \(6hd\) FLOPs、传输 \(3h\) 字节，条件化简为 \(C/B\le2d=6144\) FLOPs/字节，即每 1 GB/s 带宽足以藏住 6.1 TFLOP/s 算力的通信；超过这个平衡点后继续堆带宽收益递减。另外三条：极端融合让算力、显存、网络同时满载，功耗墙会成为瓶颈，需要更多功耗余量；Dispatch 用的是「拉」（每张卡主动读远端激活）而不是「推」，因为细粒度推送的通知延迟太高，希望硬件提供更低延迟的跨卡信号；建议把 SwiGLU 换成不含指数和除法的逐元素激活函数，减少 GEMM 之后的处理开销。

8.2 用 TileLang 写算子

V4 的结构如果用 PyTorch 原生算子拼，会有几百个细碎的 ATen 算子。DeepSeek 用 TileLang（一种写 GPU kernel 的领域专用语言）写了一批融合 kernel 替换掉其中绝大部分，开源推理代码里的 FP4/FP8 GEMM、稀疏注意力、Sinkhorn 都是 TileLang 写的。报告提到三项对 TileLang 本身的改进：

• Host Codegen：kernel 越快，CPU 端 Python 里的参数检查等固定开销占比越高。他们在 IR 层面同时生成设备 kernel 和一个轻量的宿主端启动器（基于 TVM-FFI），把类型、形状、步长检查都挪进生成的宿主代码，每次调用的 CPU 开销从几十到几百微秒降到 1 微秒以下。
• Z3 SMT 求解器辅助的整数分析：布局推断、内存冲突检测、边界分析都要判断整数表达式的性质。把 TileLang 的整数表达式翻译成 Z3 的无量词非线性整数算术（QF_NIA），能处理可变形状下的向量化等难题，编译时间只多几秒。
• 数值精度与逐位可复现：默认关闭 fast-math，近似函数（T.__exp 等）需要显式选用；提供带显式舍入模式的 IEEE 内建函数；代数化简规则与 NVCC 对齐，可以用布局注解固定累加顺序，从而和手写 CUDA 参考实现逐位一致。

8.3 训练框架

Muon 与 ZeRO 的冲突。ZeRO 把优化器状态按元素切分到多个数据并行 rank 上，这对 AdamW 这种逐元素优化器很自然；但 Muon 要对整个矩阵做 Newton–Schulz，需要完整的梯度矩阵。V4 的混合方案：

• 稠密参数：限制 ZeRO 的最大并行度，用背包算法把整个矩阵分配给各 rank，使负载大致均衡；各 rank 的 bucket 填充到最大 bucket 的大小以便做 reduce-scatter，每个 rank 不超过 5 个矩阵，填充开销通常低于 10%。数据并行规模超过 ZeRO 上限时，多出来的组冗余地计算 Muon 更新，用计算换显存。
• MoE 参数：专家数量多，每个专家独立优化。把所有层所有专家的 down 投影展平，再接 up 和 gate，填充到能被各 rank 整除且不切断任何一个矩阵，不限制 ZeRO 并行度。
• 同一 rank 上相邻且形状相同的矩阵自动合并，批量执行 Newton–Schulz。Newton–Schulz 在 BF16 矩阵乘下仍然稳定，于是 MoE 梯度在数据并行同步前用随机舍入量化到 BF16，通信量减半；为避免低精度加法累积误差，不用树形或环形 reduce-scatter，而是先 all-to-all 交换，再在每个 rank 上用 FP32 本地求和。

mHC 的开销控制。融合 kernel（训练与推理各一套）；选择性重计算：层间的大多数隐藏状态和所有归一化后的层输入都重算，计算密集的操作不重算；调整 DualPipe 的 1F1B 重叠，容纳更大的流水线通信并让部分 mHC 操作并发。合起来 mHC 的墙钟开销只占重叠后 1F1B 流水线阶段的 6.7%。

压缩注意力下的上下文并行（CP）。CP 把序列切成连续的段，每个 rank 持有 \(s\) 个 token。压缩注意力带来两个麻烦：训练样本是多条序列拼起来的，每条序列独立压缩、尾部不足 \(m\) 个的 token 丢弃，所以各 rank 的压缩长度不一定是 \(s/m\)；而且一个压缩块可能跨在两个 rank 的边界上。V4 用两阶段通信解决：

1. rank \(i\) 把最后 \(m\) 个未压缩的 KV 发给 rank \(i+1\)；rank \(i+1\) 把它们和本地 \(s\) 个 KV 一起压缩，产生固定长度 \(s/m+1\) 个条目（含若干填充）。
2. all-gather 收集所有 rank 的压缩条目，再用一个融合的 select-and-pad 算子整理成总长 \(\text{cp\_size}\cdot s/m\) 的完整序列，填充放在末尾。

对 HCA 和 CSA 的 indexer，每个 query 可见的压缩条目范围按规则预先算好；对 CSA 的稀疏注意力，top-k 选择器直接给出可见条目的下标。

张量级激活 checkpoint。常规的激活 checkpoint 以模块为单位决定保存还是重算，粒度太粗；手写整层的前向和反向又失去了自动微分的便利。V4 的框架让开发者只写前向、给个别张量打「需要重算」的标注；框架用 TorchFX 追踪完整计算图，对每个标注张量反向遍历找出重算它所需的最小子图，插到对应梯度计算之前。重算时直接释放原张量显存、复用重算结果的存储指针，没有额外拷贝；由于追踪时能看到底层存储指针，共享存储的张量（如 reshape 前后）会自动去重。与手写实现相比没有额外开销。

8.4 批不变与确定性 kernel

V4 要求预训练、后训练和推理三条管线之间逐位对齐。两个概念：

• 批不变（batch invariance）：一个 token 的输出与它在 batch 里的位置、batch 里还有什么无关，逐位相同。
• 确定性（determinism）：同样的输入多次运行结果逐位相同。

难点和解法：

• 注意力解码：为了批不变不能用 split-KV（把一条序列的注意力拆到多个 SM 上），否则累加顺序随 batch 变化；但不拆会有严重的 wave quantization（最后一波 SM 吃不满）。解法是双 kernel：第一个 kernel 一条序列一个 SM，处理满载的波；第二个 kernel 专门处理最后不满的那一波，一条序列用多个 SM，但精心设计累加路径与第一个完全相同，并用 thread-block cluster 的分布式共享内存在 SM 间高速交换数据。开销可以忽略。
• 矩阵乘：cuBLAS 做不到批不变，于是全面换成 DeepGEMM；小 batch 常用的 split-k 也不批不变，因此大多数场景放弃 split-k，再用一系列优化把性能追平甚至超过 split-k。
• 稀疏注意力反向：KV 的梯度原本用 atomicAdd 累加，浮点加法不满足结合律，结果不确定。改为每个 SM 一个独立累加缓冲区，最后做一次确定性的全局求和。
• MoE 反向：多个 rank 的 SM 同时往接收方同一缓冲区写数据时，协商写入位置会引入不确定性。用 rank 内的 token 顺序预处理加 rank 间缓冲区隔离解决。
• mHC 里输出维度 24 的矩阵乘：小 batch 时不得不用 split-k，于是让每个分片单独输出，再由后续 kernel 做确定性归约。

这件事在后训练里尤其值钱：10.7 节的 rollout 服务会说到，有了批不变和确定性，「中断后用同一个随机种子重新生成」在数学上就是正确的。

8.5 推理：异构 KV cache 的布局

V4 一个模型里有好几种 KV：CSA 的主 KV（每 4 token 一个，512 维）、CSA 的 indexer KV（每 4 token 一个，128 维）、HCA 的 KV（每 128 token 一个）、滑窗 KV（每层最近 128 个），还有「没凑满一个压缩块」的尾巴 token 及其隐藏状态。不同层的 cache 大小、更新规则、淘汰策略都不同，打破了 PagedAttention 的基本假设。报告把障碍归成两条：滑窗等不同的缓存策略；高性能注意力 kernel 的对齐要求。对应地：

• State cache：把滑窗 KV 和未压缩的尾巴 token 看成一种「状态」（像状态空间模型一样，只依赖当前位置，大小固定）。预分配一个固定大小的池子，每个请求分一块。
• 经典 KV cache：存压缩后的 CSA/HCA 条目，按块分页。每块覆盖 \(\mathrm{lcm}(m,m')\) 个原始 token，产生 \(k_1=\mathrm{lcm}(m,m')/m\) 个 CSA 条目和 \(k_2=\mathrm{lcm}(m,m')/m'\) 个 HCA 条目。代入 \(m=4,m'=128\)：每块 128 token，含 32 个 CSA 条目、1 个 HCA 条目。借助能处理「每块条目数可变」的稀疏注意力 kernel，块大小可以是 \(\mathrm{lcm}(m,m')\) 的任意倍数，并可填充对齐 cache line。

8.6 磁盘 KV cache

为了让共享前缀的请求不再重复 prefill，V4 把 KV 存到磁盘。CSA/HCA 的压缩条目全部落盘，命中前缀时读取到最后一个完整压缩块为止，尾部不完整块里的 token 需要重算（未压缩的 KV 不落盘）。滑窗 KV 不压缩且每层都有，体积约是压缩条目的 8 倍，报告给了三种策略：

• 全量缓存：存所有 token 的滑窗 KV，命中时只读前缀最后 \(n_{\text{win}}\) 个 token 的即可，零重算；但写多读少，对 SSD 不友好。
• 周期 checkpoint：每 \(p\) 个 token 存一次「最后 \(n_{\text{win}}\) 个 token 的滑窗 KV」，命中时加载最近的 checkpoint 再重算尾巴；\(p\) 可调，在存储和计算之间折中。
• 不缓存：完全重算。第 \(l\) 层某 token 的滑窗 KV 只依赖第 \(l-1\) 层最近 \(n_{\text{win}}\) 个 token，所以 \(L\) 层模型只需重算最后 \(n_{\text{win}}\cdot L\) 个 token（借助已缓存的 CSA/HCA 条目）。以 Pro 为例是 \(128\times61=7808\) 个 token，与前缀总长度无关。

9. 预训练：数据、超参与稳定性

9.1 数据

• 在 V3 的预训练数据之上继续改进，总量超过 32T token，包含数学、代码、网页、长文档等。
• 网页数据过滤掉批量自动生成和模板化的内容，降低模型崩溃（model collapse）的风险。
• 数学和代码仍是核心；在 mid-training 阶段加入 agentic 数据增强代码能力。
• 更大的多语言语料，覆盖不同文化的长尾知识。
• 特别重视长文档：优先收集科学论文、技术报告等有独特学术价值的材料。
• 分词器沿用 V3（词表 128K，精确值 129280），只新增了几个构造上下文用的特殊 token；沿用 V3 的 token-splitting 和 FIM（Fill-in-Middle）策略；按来源打包文档以尽量减少截断；与 V3 不同，预训练使用样本级注意力掩码（同一个打包序列里的不同文档互相看不到）。

9.2 超参数总表

V4 两个型号的完整超参数，V3.2 一列作为对照。

顺带一提：75.5M 恰好是 \(18432\times4096\)，94.4M 是 \(23040\times4096\)，即以 4K 序列计的整数个样本；Flash 在 75.5M 的 batch 下 32T token 大约对应 42 万步量级（前期 batch 更小，实际步数更多）。

9.3 训练日程

• Batch size 调度：和 V3 一样从小 batch 逐渐增大，到 75.5M（Flash）/ 94.4M（Pro）后保持。
• 长度扩展：从 4K 开始，逐步扩到 16K、64K、1M。预训练结束时模型已经原生支持 1M。
• 稀疏注意力的引入：Flash 先用稠密注意力训练前 1T token，在序列长度到 64K 时引入稀疏注意力并保持到最后；引入时先用一个短阶段预热 CSA 里的 lightning indexer，再进入稀疏训练。Pro 的稠密阶段更长，引入方式相同（两阶段）。这里的「稠密」是指 CSA 不做 top-k（对全部压缩条目做注意力）还是连压缩都不做，以及 indexer 预热用什么损失，报告没有公开；V3.2 的做法见 2.4 节。

9.4 训练不稳定与两个「土办法」

训练万亿参数的 MoE 时，V4 遇到了明显的不稳定，回滚只能暂时恢复、不能防止 loss spike 再次出现。他们的经验观察是：spike 总是和 MoE 层里的离群值（outlier）绑在一起，而路由机制本身似乎会加剧离群值的出现——离群值影响路由，路由又放大离群值。于是从两头下手：打断路由造成的恶性循环，以及直接压住异常值。

Anticipatory Routing（预见式路由）。第 \(t\) 步用当前参数 \(\theta_t\) 计算特征，但路由下标用历史参数 \(\theta_{t-\Delta t}\) 计算。实现上，在第 \(t-\Delta t\) 步就预取第 \(t\) 步的数据，「提前」算好路由下标缓存起来——这正是名字的由来，也避免了加载两份参数。预计算只需要一次前向，通过精心编排流水线和 EP 通信的重叠，额外墙钟开销约 20%。更进一步，它不是一直开着：系统自动检测 loss spike，检测到时短暂回滚并打开预见式路由，跑一段时间后切回正常训练，所以总开销可以忽略，也不损害模型性能。

SwiGLU Clamping。把 SwiGLU 的线性分支截断到 \([-10,10]\)，门控分支上界截断到 10（即 up.clamp(-10, 10)，gate.clamp(max=10)，然后 \(\mathrm{SiLU}(\text{gate})\odot\text{up}\)）。这个做法来自 gpt-oss。Flash 和 Pro 全程都开着，报告说它能有效消除离群值、帮助稳定，且不损害性能。

这两个技巧为什么有效，目前还没有完整的理论解释。

9.5 基座模型评测

报告表 1，三者在同一内部框架、同一设置下评测（差距不超过 0.3 视为持平）：

最显眼的是知识类：Simple-QA verified 从 28.3 到 55.2，FACTS Parametric 从 27.1 到 62.6，几乎翻倍——总参数从 671B 涨到 1.6T，能记住的东西多了。Flash 用 13B 激活就在多数项上超过 37B 激活的 V3.2，但 BigCodeBench、MATH 这类推理密集项反而低于 V3.2，激活参数少的代价在这里。

10. 后训练：专家 RL + 多教师在线蒸馏

10.1 流程

V4 的后训练大体沿用 V3.2，但有一个关键替换：V3.2 最后的混合 RL 阶段（把推理、agent、人类对齐放进同一个 RL）被整个换成了在线策略蒸馏（On-Policy Distillation，OPD）。流程分两步：

1. 培养专家：对每个目标领域（数学、代码、agent、指令遵循……），从基座出发先做该领域的 SFT，再用 GRPO 做 RL，奖励按该领域的成功标准设计。得到一组各自擅长一个领域的专家模型。
2. 合并：训练一个统一的学生模型，在它自己生成的轨迹上，按 token 最小化它与各专家之间的反向 KL。报告说这一步用了十多个教师。

10.2 专家阶段的 GRPO

RL 用的是 GRPO，超参与 R1、V3.2 保持接近。它的目标函数如下（V3.2 的版本）。对问题 \(q\)，从旧策略采样一组 \(G\) 个回答 \(\{o_i\}\)，目标是

其中 \(r_{i,t}=\pi_\theta(o_{i,t}\mid q,o_{i,\lt t})/\pi_{\mathrm{old}}(o_{i,t}\mid q,o_{i,\lt t})\) 是重要性比；优势用组内相对奖励 \(\hat A_{i,t}=R_i-\mathrm{mean}(R_1,\dots,R_G)\)，不需要价值网络。V3.2 在此之上加了四个稳定 RL 的做法：

• 无偏 KL 估计：样本来自 \(\pi_{\mathrm{old}}\) 而不是 \(\pi_\theta\)，所以给 K3 估计器乘上重要性比 \(\frac{\pi_\theta}{\pi_{\mathrm{old}}}\big(\frac{\pi_{\mathrm{ref}}}{\pi_\theta}-\log\frac{\pi_{\mathrm{ref}}}{\pi_\theta}-1\big)\)，使梯度无偏；某些领域（如数学）KL 罚项可以很弱甚至去掉。
• 离策略序列掩码 \(M_{i,t}\)：如果一条回答优势为负，且旧策略与当前策略在这条序列上的平均对数比超过阈值 \(\delta\)，就整条掩掉——偏离太远的负样本容易误导优化。
• Keep Routing：训练时强制使用采样时推理框架给出的专家路由，避免同一输入在训练和推理里走不同专家。
• Keep Sampling Mask：采样时用了 top-p/top-k 截断，就把截断掩码保留下来用在 \(\pi_\theta\) 上，让两边的动作空间一致。

10.3 推理强度、奖励模型与对话格式

三档推理强度。同一个模型支持 Non-think、Think High、Think Max。它们来自不同 RL 配置训出来的专家：每档用不同的长度惩罚和上下文窗口，输出的推理长度因此不同。格式上，Non-think 直接输出 </think> 加回答；High 输出 <think> 推理 </think> 加总结；Max 在此之外还在 system prompt 开头注入一段指令，大意是「推理强度拉满、不许走捷径：彻底分解问题、找根因，对所有路径、边界情况和对抗情形压力测试，把每个中间步骤、考虑过的备选方案和被否定的假设都写出来」。评测时三档的上下文窗口分别是 8K、128K、384K。

生成式奖励模型（GRM）。容易验证的任务用规则或测试用例；难以验证的任务，传统做法是 RLHF 训一个标量奖励模型。V4 不再用标量奖励模型，而是准备带评分细则（rubric）的 RL 数据，用生成式奖励模型给轨迹打分。关键是对 GRM 本身也做 RL，而且 actor 自己就充当 GRM，评判能力和生成能力一起优化。报告说这样只需要少量多样的人工标注就能获得稳健的打分。

工具调用格式。新格式用一个特殊 token |DSML| 加 XML 风格的标签：<|DSML|tool_calls> 包住若干 <|DSML|invoke name="…">，每个参数用 <|DSML|parameter name="…" string="true|false"> 标出——字符串参数原样写、string="true"，其他类型写 JSON、string="false"。报告说 XML 格式比 JSON 嵌套更少出现转义错误，减少了工具调用失败。

交错思考（interleaved thinking）。V3.2 的策略是：工具调用轮次之间保留推理内容，但一来新的用户消息就清掉之前所有推理。V4 借着 1M 上下文改成：在有工具调用的场景，推理内容在整段对话里全部保留，跨用户消息也不清；在普通对话场景仍沿用旧策略，新用户消息到来时丢弃之前的推理。用用户消息模拟工具交互的 agent 框架（如 Terminus）触发不了前一条路径，报告仍建议它们用 non-think 模式。

Quick Instruction。聊天产品在生成回答前要做一堆辅助判断（要不要搜索、意图识别、生成搜索词……），通常交给另一个小模型，但小模型不能复用主模型已算好的 KV cache，要重新 prefill。V4 的做法是在输入序列末尾直接追加专用的特殊 token，每个对应一个辅助任务，复用已有 KV cache，而且像生成搜索词、判断权威性需求、判断领域这些任务可以并行。报告列了 <|action|>（是否需要搜索）、<|title|>（生成对话标题）、<|query|>（生成搜索词）、<|authority|>（对来源权威性的需求）、<|domain|>（领域）、<|extracted_url|> + <|read_url|>（某个 URL 是否要抓取阅读）。好处是降低首 token 延迟，也省掉维护一个额外小模型的工程成本。

10.4 多教师 OPD

给定 \(N\) 个专家 \(\{\pi_{E_1},\dots,\pi_{E_N}\}\)，OPD 的目标是

\(w_i\) 是各专家的权重，通常按重要性定。这里有两个要点。

一，反向 KL、在线采样。\(\mathbb D_{\mathrm{KL}}(\pi_\theta\|\pi_E)=\mathbb E_{y\sim\pi_\theta}[\log\pi_\theta(y)-\log\pi_E(y)]\) 的期望在学生分布下取，所以轨迹必须由学生自己生成（on-policy）。这和普通 SFT 式蒸馏（在教师生成的数据上做前向 KL / 交叉熵）不同：学生在自己会走到的状态上被纠正，不会出现训练时没见过的分布偏移。反向 KL 还有「寻模」的性质：学生倾向于集中在教师概率高的区域，而不是去覆盖教师的全部分布。在实际训练中，学生遇到数学题时，主要是数学专家的 KL 在起作用；遇到代码题时则是代码专家——不同专家的能力在 logits 层面汇总到一套参数里，绕开了权重合并或混合 RL 常见的性能退化。

二，全词表 KL 而不是单 token 估计。以前的工作通常把每个位置的 KL 简化为只看采样到的那个 token，再复用 RL 框架：把 \(\mathrm{sg}\big[\log\frac{\pi_E(y_t\mid x,y_{\lt t})}{\pi_\theta(y_t\mid x,y_{\lt t})}\big]\) 当作每个 token 的优势，代入策略梯度。这很省资源，但梯度方差大、训练不稳。V4 改为在每个位置对整个词表精确计算 KL。对学生 logits \(\mathbf z\) 求导很干净（记 \(p=\pi_\theta,\ q=\pi_E\)，\(\ell_v=\log p_v-\log q_v\)，\(\mathrm{KL}_t=\sum_vp_v\ell_v\)）：

推导：\(\partial p_u/\partial z_v=p_u(\delta_{uv}-p_v)\)，所以 \(\partial\mathrm{KL}_t/\partial z_v=\sum_up_u(\delta_{uv}-p_v)(\ell_u+1)=p_v(\ell_v+1)-p_v(\mathrm{KL}_t+1)\)。每个位置的梯度都是一个确定的 129280 维向量，不再依赖采到哪个 token，方差自然小得多（前缀仍是学生采样来的，这部分随机性还在）。

10.5 让全词表 OPD 跑得动

十几个教师、每个可能上万亿参数、词表 12.9 万，直接把所有教师的 logits 存下来是不可能的。V4 的做法：

• 教师权重放在集中式分布式存储里，前向时按需加载，用类似 ZeRO 的参数分片减轻 I/O 和内存压力；
• 前向时只缓存教师最后一层隐藏状态，训练时再取出来过一遍对应教师的输出头，现场重建完整 logits。按 Pro 的尺寸，一个位置的隐藏状态是 7168 维，logits 是 129280 维，存储少约 18 倍，重算只多一个矩阵乘；
• 按教师编号给训练样本排序，保证每个 mini-batch 里每个教师的输出头只加载一次、显存里同一时刻最多一个教师头；所有加载/卸载在后台异步进行；
• 教师与学生 logits 之间的精确 KL 用专门的 TileLang kernel 计算，避免动态显存分配。

10.6 FP4 量化感知训练（QAT）

后训练阶段引入 QAT，让模型（包括教师和参考模型）适应量化带来的精度损失。量化格式是 MXFP4：每 32 个元素一组，共享一个 8 位的 2 的幂次缩放因子（E8M0），每个元素是 4 位 E2M1 浮点，能表示 \(\pm\{0,0.5,1,1.5,2,3,4,6\}\)。作用在两处：

1. MoE 专家权重：显存的主要占用者。Pro 主干有约 1.55T 个路由专家参数（\(61\times384\times3\times7168\times3072\)），FP8 存要约 1.55 TB，MXFP4（每元素 4 bit，加上每 32 个元素一个 8 bit 的 scale，平均 4.25 bit）约 0.82 TB。
2. CSA indexer 的 QK 路径：QK 激活在 FP4 下缓存、读取、相乘，加速长上下文下的打分。同时把索引分数 \(I_{:,:}\) 从 FP32 量化到 BF16，top-k 选择器提速 2 倍，KV 条目的召回率保持 99.7%。

专家权重的 QAT 流程：优化器维护 FP32 主权重，前向时先量化到 FP4，再反量化到 FP8 参与计算。这一步反量化是无损的：E4M3 比 E2M1 多 2 个指数位、动态范围大得多，只要每个 FP8 量化块（128×128）里各个 FP4 子块（1×32）的 scale 之比不超过某个阈值，细粒度的 scale 信息就能被 FP8 的指数范围完全吸收；他们验证了当前权重满足这个条件。于是整个 QAT 可以完全复用现有的 FP8 训练框架。反向时，梯度对前向用的那份 FP8 权重计算，直接传回 FP32 主权重——等价于对量化操作使用直通估计器（STE），也省掉了对转置权重重新量化。

在推理和 RL rollout 阶段（不需要反向），直接使用真正的 FP4 权重，而不是模拟量化。这保证采样时的模型行为与线上部署完全一致，同时真正减少了显存读取和占用。indexer 的 QK 路径同样处理。

10.7 Rollout 服务、百万 token RL 与沙箱

可抢占、容错的 rollout。集群有全局抢占式调度器，任何任务随时可能被抢占，硬件故障也很常见。V4 给每个生成请求维护一个 token 粒度的预写日志（WAL）：每生成一个 token 就追加进去。被抢占时暂停推理引擎、保存未完成请求的 KV cache；恢复时用 WAL 和 KV cache 接着解码；即使遇到致命硬件错误，也能用 WAL 里的 token 重新 prefill 重建 KV cache。

报告特别指出：把未完成的请求从头重新生成在数学上是错的，会引入长度偏差。原因是短回答更可能在中断前就生成完，长回答更可能被打断；如果被打断的统统重来，最终收集到的样本会系统性地偏短。如果推理栈是批不变且确定的（8.4 节），用相同随机种子重新生成也是正确的，但要多花一遍解码，远不如 WAL 高效。

百万 token 的 RL/OPD。把 rollout 数据拆成轻量的元数据和重量的逐 token 字段。分发时先加载全部元数据做全局 shuffle 和打包布局计算；逐 token 字段通过共享内存数据加载器加载（节点内不重复），在 mini-batch 粒度用完即释放；设备上同时存放几个 mini-batch 由负载动态决定。

DSec 沙箱。为 agent 的训练和评测，DeepSeek 做了一个生产级沙箱平台 DeepSeek Elastic Compute（DSec）：三个 Rust 组件（API 网关 Apiserver、每台机器上的代理 Edge、集群监控 Watcher），用自定义 RPC 互连，构建在 3FS 分布式文件系统上，单集群管理数十万个并发沙箱。设计要点：

• 一套 Python SDK 背后四种执行载体：Function Call（预热容器池，无冷启动）、Container（兼容 Docker，EROFS 按需加载镜像）、microVM（Firecracker，VM 级隔离）、fullVM（QEMU，任意操作系统），切换只改一个参数；
• 分层存储快速加载镜像：容器的基础镜像和提交作为 3FS 上只读的 EROFS 层挂成 overlay 的下层，元数据放本地盘，数据块按需从 3FS 拉取；microVM 用 overlaybd 格式，只读基础层在 3FS 上共享，写入落本地写时复制层，快照可链式叠加，毫秒级恢复；
• 高密度：减少虚拟化环境里重复的页缓存、做内存回收以安全超分；缓解容器运行时的自旋锁竞争，降低单沙箱 CPU 开销；
• 轨迹日志：为每个沙箱维护全局有序的命令与结果日志，用于训练任务被抢占后的快进恢复（重放已完成命令的缓存结果，避免非幂等操作被重复执行）、细粒度溯源和确定性重放。

11. 评测结果

11.1 设置

• 知识与推理：温度 1.0，Non-think / High / Max 的上下文窗口为 8K / 128K / 384K。数学题用「逐步推理并把答案放进 \boxed{}」的模板；Pro-Max 做数学时换成要求给出严格证明的模板。
• Codeforces 是内部基准：14 场 Div.1 比赛共 114 题（2025 年 5 月到 11 月）。每题生成 32 个候选，每次随机无放回抽 10 个排成提交顺序，用专家构造的测试判定；解出的题按「同样失败次数下解出该题的人类选手得分中位数」计分，换算成排名和 rating，取所有抽样与排列下的期望，再对 14 场取平均。
• 形式化数学：Lean v4.28.0-rc1 下的 agent 设置，可用编译器和语义 tactic 搜索，最多 500 次工具调用；另有一个更重的流程，先生成自然语言解答并自我验证筛选，再作为指导交给形式化 agent 证明。两种设置都要求严格验证器 Comparator 通过。
• 代码 agent（SWE 系列、Terminal-Bench）：内部框架，只提供 bash 和文件编辑两个工具，最多 500 步、512K 上下文。搜索 agent（BrowseComp、HLE w/ tools）：内部框架，网页搜索 + Python，同样 500 步、512K；BrowseComp 沿用 V3.2 的「discard-all」上下文管理。
• 1M 上下文：OpenAI MRCR 和 CorpusQA。Claude Opus 4.6 和 Gemini 3.1 Pro 由他们重新统一配置评测；GPT-5.4 因 API 大量无响应没有评。K2.6 和 GLM-5.1 的部分格子因 API 太忙而空缺。

11.2 与闭源/开源模型对比（报告表 6）

报告的总结是：知识上 SimpleQA-Verified 比其他开源模型高出约 20 个点，但仍落后 Gemini-3.1-Pro；推理上超过所有开源模型，略逊于 GPT-5.4 和 Gemini-3.1-Pro，自评落后前沿闭源模型约 3～6 个月；Codeforces 3206 分，报告说在人类选手中排第 23；agent 上与 K2.6、GLM-5.1 相当、落后闭源；MRCR 1M 超过 Gemini-3.1-Pro、不及 Opus 4.6。另外，在 Terminal-Bench 2.0 的 Verified 子集上 V4-Pro 约 72.0。

11.3 两个尺寸、三档强度（报告表 7）

几个规律：Flash 和 Pro 的差距主要在知识（SimpleQA-Verified 34.1 vs 57.9）和难的 agent 任务（Terminal Bench 56.9 vs 67.9）；给足思考预算后，推理题上 Flash-Max 和 Pro-Max 差距不大（HMMT 94.8 vs 95.2）。报告图 9 显示 MRCR 8-needle 在 128K 以内很稳，超过 128K 后开始下降。报告图 10 还显示，在 HLE 上 V4-Pro 达到同样分数所用的 token 比 V3.2 少。

形式化数学（报告图 8）：在 Putnam-2025 的「重算力、形式与非形式混合」设置下，V4 拿到满分 120/120；在 Putnam-200 Pass@8 的轻量设置下也超过 Seed-Prover 等此前的系统。

11.4 真实任务

• 中文写作：功能性写作对 Gemini-3.1-Pro 的总胜率 62.7% vs 34.1%；创意写作在指令遵循上胜率 60.0%、写作质量上 77.5%；但在最难的复杂指令与多轮写作上，Claude Opus 4.5 以 52.0% vs 45.9% 领先。
• 搜索：网页/App 的 non-think 模式用检索增强（RAG），thinking 模式用 agentic 搜索。V4-Pro 对 V3.2 的 RAG 搜索问答，总计 28.1% 胜、10.4% 负、61.5% 平；agentic 搜索对 RAG 是 61.7% 胜、18.3% 负，平均工具调用 16.2 次，prefill 13649 vs 10453 token，输出 1526 vs 1308 token，只贵一点。
• 白领任务：30 个中文专业任务（13 个行业），人工盲评，V4-Pro-Max 对 Opus-4.6-Max 的不输率 63%；强在任务完成度和内容质量，弱在格式约束遵循、长文压缩成短摘要和幻灯片视觉设计。
• 代码 agent：从 50 多位内部工程师收集约 200 个真实研发任务，筛出 30 个。通过率：Haiku 4.5 13%、Sonnet 4.5 47%、V4-Pro-Max 67%、Opus 4.5 70%、Opus 4.5 Thinking 73%、Opus 4.6 Thinking 80%。对 85 位内部用户的调查：52% 认为可以作为默认主力代码模型，39% 倾向于是，不到 9% 认为不行。

12. 小结与我的看法

从 V3/V3.2 出发，V4 改动的全部清单：

1. 注意力：MLA 的潜向量 → 512 维 shared-KV（K=V）MQA；在序列维度上压缩（CSA 4 倍重叠压缩、HCA 128 倍）；DSA 从选 token 变成选压缩块，top-k 变小；加滑窗分支、attention sink、Q/KV RMSNorm、部分 RoPE + 输出反旋转、分组输出投影。
2. 残差：mHC，4 路残差流 + Sinkhorn 投影到双随机矩阵。
3. MoE：√softplus 打分，前 3 层 Hash 路由，去掉节点限制，激活 6 个更大的专家，SwiGLU clamp。
4. 优化：Muon（混合 Newton–Schulz、RMS 0.18、Nesterov），不需要 QK-Clip；预见式路由处理 loss spike。
5. 系统：wave 化的 MegaMoE；TileLang；批不变 + 确定性 kernel；Muon 的混合 ZeRO；压缩注意力的两阶段 CP；张量级重计算；异构 KV cache 和磁盘缓存。
6. 后训练：专家 SFT + GRPO → 多教师全词表 OPD；GRM 由 actor 自己担任并被 RL；三档推理强度；DSML 工具格式；跨轮保留推理；Quick Instruction；FP4 QAT；WAL rollout；DSec 沙箱。

几点看法：

• 最核心的思路是「先压缩、再稀疏」。V3.2 证明了「用便宜的打分器挑选」可行，但 indexer 仍是 \(O(n)\) 每 token；V4 先在序列维度上做可学习的池化，让打分对象少一个数量级，然后再挑。把 DSA 的成本从 \(n\) 降到 \(n/4\)，再配上 FP4，是能在 1M 上省下来的关键。
• shared-KV、512 维头、分组输出投影这一组设计，本质上是承认「解码时的 MLA 就是 MQA」，把它变成原生结构，省掉 \(W^{UK}/W^{UV}\) 的分解；代价转移到了输出投影上，再用分组低秩补回来。
• 报告自己在结论里也承认架构「相对复杂」：为了降低风险保留了很多初步验证过的组件和技巧，未来要做更系统的研究，把架构精简到最本质的部分。Anticipatory Routing 和 SwiGLU clamp 的原理也还没弄清。这份报告里几乎没有消融实验，很多设计（比如 CSA/HCA 的交替比例、√softplus）只给结论不给对比，读的时候要记住这一点。
• 工程部分的分量不亚于架构：确定性和批不变被当成一等公民，直接服务于 RL 的正确性（WAL 那段关于长度偏差的论证很值得记住）。

报告提到的未来方向：进一步精简架构、研究训练稳定性的基础问题、在 MoE 和稀疏注意力之外探索新的稀疏维度（比如更稀疏的嵌入模块）、低延迟架构、长程多轮 agent 任务、多模态，以及更好的数据构造与合成。

13. 参考与延伸阅读

• DeepSeek-AI. DeepSeek-V4: Towards Highly Efficient Million-Token Context Intelligence, arXiv 2606.19348, 2026。架构在 §2（§2.1 继承部分、§2.2 mHC、§2.3 CSA/HCA、§2.4 Muon），基础设施在 §3，预训练在 §4，后训练与评测在 §5。
• 模型卡、config 与推理代码（层排布、RoPE 配置、Hadamard 旋转、量化等实现细节见这里）：huggingface.co/deepseek-ai/DeepSeek-V4-Pro（inference/）、DeepSeek-V4-Flash。
• DeepSeek-AI. DeepSeek-V3.2: Pushing the Frontier of Open Large Language Models, 2025（DSA §2.1，GRPO 的改进 §3.1）。
• DeepSeek-AI. DeepSeek-V3 Technical Report, 2024（MLA、DeepSeekMoE、无辅助损失均衡、MTP）；DeepSeek-V2（MLA 的提出）。
• Z. Xie et al. mHC: Manifold-Constrained Hyper-Connections, 2026；D. Zhu et al. Hyper-Connections, ICLR 2025。
• K. Jordan et al. Muon: An optimizer for hidden layers in neural networks, 2024；J. Liu et al. Muon is Scalable for LLM Training, 2025。
• Y. Gu et al. MiniLLM, ICLR 2024；K. Lu and Thinking Machines Lab, On-Policy Distillation, 2025。
• MegaMoE：DeepGEMM PR #304；TileLang（Wang et al., ICLR 2026）；B. D. Rouhani et al. Microscaling Data Formats for Deep Learning, 2023（MXFP4）。