DeepSeek-V4：Towards Highly Efficient Million-Token Context Intelligence
文章目录
- DeepSeek-V4：迈向高效的百万 Token 上下文智能
- 1. 引言
- 2. 架构
- [ \tilde{A}_l
- [ \tilde{B}_l
- [ \tilde{C}_l
- [ [ S^a_{mi:m(i+1)-1}; S^b_{m(i-1):mi-1} ]
- [ C_i^{\mathrm{Comp}}
- [ [ q^I_{t,1}; q^I_{t,2}; \ldots ; q^I_{t,n_h^I} ]
- q^I_t
- [ [ w^I_{t,1}; w^I_{t,2}; \ldots ; w^I_{t,n_h^I} ]
- w^I_t
- [ I_{t,s}
- [ C_t^{\mathrm{SprsComp}}
- [ [ q_{t,1}; q_{t,2}; \ldots ; q_{t,n_h} ]
- q_t
- [ o_{t,i}
- [ [o_{t,1}; o_{t,2}; \ldots ; o_{t,n_h}]
- [ S_{m'i:m'(i+1)-1}
- [ C_i^{\mathrm{Comp}}
- [ [ q_{t,1}; q_{t,2}; \ldots ; q_{t,n_h} ]
- q_t
- [ o_{t,i}
- [ s_{h,i,j}
- [ M_k
- 3. 通用基础设施
以下为标题、摘要和 Introduction 部分的忠实翻译；括号内引用已保留原文不翻译。
DeepSeek-V4：迈向高效的百万 Token 上下文智能
DeepSeek-AI
research@deepseek.com
摘要
我们发布 DeepSeek-V4 系列的预览版本，其中包括两个强大的专家混合（Mixture-of-Experts, MoE）语言模型——DeepSeek-V4-Pro，拥有 1.6T 参数（49B 激活），以及 DeepSeek-V4-Flash，拥有 284B 参数（13B 激活）——二者均支持一百万 token 的上下文长度。DeepSeek-V4 系列在架构和优化方面融入了若干关键升级：（1）一种结合压缩稀疏注意力（Compressed Sparse Attention, CSA）和重压缩注意力（Heavily Compressed Attention, HCA）的混合注意力架构，用于提升长上下文效率；（2）流形约束超连接（Manifold-Constrained Hyper-Connections, mHC），用于增强传统残差连接；（3）Muon 优化器，用于更快收敛并提高训练稳定性。我们在超过 32T 个多样且高质量的 token 上对两个模型进行预训练，随后通过一套全面的后训练流程解锁并进一步增强其能力。DeepSeek-V4-Pro-Max，即 DeepSeek-V4-Pro 的最大推理努力模式，重新定义了开放模型的最先进水平，在核心任务上超越了其前代模型。同时，DeepSeek-V4 系列在长上下文场景中具有很高效率。在一百万 token 上下文设置下，与 DeepSeek-V3.2 相比，DeepSeek-V4-Pro 仅需要 27% 的单 token 推理 FLOPs 和 10% 的 KV cache。这使我们能够常规支持一百万 token 上下文，从而让长时程任务以及进一步的测试时扩展更加可行。模型检查点可在 https://huggingface.co/collections/deepseek-ai/deepseek-v4 获取。
图 1｜ 左：DeepSeek-V4-Pro-Max 及其对照模型的基准测试表现。右：DeepSeek-V4 系列与 DeepSeek-V3.2 的推理 FLOPs 和 KV cache 大小。
1. 引言
推理模型（DeepSeek-AI, 2025; OpenAI, 2024c）的出现确立了一种新的测试时扩展范式，推动大语言模型（Large Language Models, LLMs）取得显著性能提升。然而，这种扩展范式从根本上受到原始注意力机制（Vaswani et al., 2017）二次计算复杂度的限制，这为超长上下文和推理过程造成了难以承受的瓶颈。与此同时，从复杂的智能体工作流到大规模跨文档分析，长时程场景和任务的出现，也使得对超长上下文的高效支持成为未来进展的关键。尽管近期的开源工作（Bai et al., 2025a; DeepSeek-AI, 2024; MiniMax, 2025; Qwen, 2025）推动了通用能力的发展，但处理超长序列时的这一核心架构低效问题仍然是一个关键阻碍，限制了从测试时扩展中获得进一步收益，也妨碍了对长时程场景和任务的进一步探索。
为了突破超长上下文中的效率壁垒，我们开发了 DeepSeek-V4 系列，包括 DeepSeek-V4-Pro 的预览版本，拥有 1.6T 参数（49B 激活），以及 DeepSeek-V4-Flash，拥有 284B 参数（13B 激活）。通过架构创新，DeepSeek-V4 系列在处理超长序列的计算效率方面实现了巨大跃升。这一突破使其能够高效支持一百万 token 的上下文长度，为下一代 LLM 开启了百万长度上下文的新时代。我们相信，高效处理超长序列的能力将解锁测试时扩展的下一前沿，为深入研究长时程任务铺平道路，并为探索在线学习等未来范式奠定必要基础。
与 DeepSeek-V3 架构（DeepSeek-AI, 2024）相比，DeepSeek-V4 系列保留了 DeepSeekMoE 框架（Dai et al., 2024）和多 Token 预测（Multi-Token Prediction, MTP）策略，同时在架构和优化方面引入了若干关键创新。为了提升长上下文效率，我们设计了一种结合压缩稀疏注意力（Compressed Sparse Attention, CSA）和重压缩注意力（Heavily Compressed Attention, HCA）的混合注意力机制。CSA 沿序列维度压缩 KV cache，然后执行 DeepSeek Sparse Attention（DSA）（DeepSeek-AI, 2025），而 HCA 则对 KV cache 进行更激进的压缩，但保持稠密注意力。为了增强建模能力，我们引入了流形约束超连接（Manifold-Constrained Hyper-Connections, mHC）（Xie et al., 2026），用于升级传统残差连接。此外，我们将 Muon（Jordan et al., 2024; Liu et al., 2025）优化器引入 DeepSeek-V4 系列的训练，从而带来更快收敛和更好的训练稳定性。
为了支持 DeepSeek-V4 系列的高效训练和推理，以及提升开发效率，我们引入了若干基础设施优化。首先，我们为 MoE 模块设计并实现了一个单一融合 kernel，能够充分重叠计算、通信和内存访问。其次，我们采用 TileLang（Wang et al., 2026），这是一种领域专用语言（Domain-Specific Language, DSL），用于平衡开发效率和运行时效率。第三，我们提供高效的 batch-invariant 和确定性 kernel 库，以确保训练和推理中的逐位可复现性。第四，我们对 MoE 专家权重和索引器 QK 路径引入 FP4 量化感知训练，以减少内存和计算。第五，对于训练框架，我们通过张量级 checkpointing 扩展自动求导框架，以实现细粒度重计算控制；并通过用于 Muon 优化器的混合 ZeRO 策略、借助重计算和融合 kernel 实现的高性价比 mHC 实现，以及用于管理压缩注意力的两阶段上下文并行，来提升训练效率。最后，对于推理框架，我们设计了一种异构 KV cache 结构，并结合磁盘存储策略，以实现高效的共享前缀复用。
通过采用混合 CSA 和 HCA，并结合计算和存储方面的精度优化，DeepSeek-V4 系列相比 DeepSeek-V3.2 显著降低了推理 FLOPs，并大幅减少了 KV cache 大小，尤其是在长上下文设置中。图 1 右侧展示了 DeepSeek-V3.2 和 DeepSeek-V4 系列估算的单 token 推理 FLOPs 与累积 KV cache 大小。在 1M-token 上下文场景中，即便是激活参数数量更多的 DeepSeek-V4-Pro，相对于 DeepSeek-V3.2，也仅达到 27% 的单 token FLOPs（以等效 FP8 FLOPs 计）和 10% 的 KV cache 大小。此外，DeepSeek-V4-Flash 凭借其更少的激活参数数量，将效率进一步推高：在 1M-token 上下文设置下，相比 DeepSeek-V3.2，它仅达到 10% 的单 token FLOPs 和 7% 的 KV cache 大小。此外，对于 DeepSeek-V4 系列，路由专家参数使用 FP4 精度。虽然在现有硬件上，FP4 × FP8 操作的峰值 FLOPs 目前与 FP8 × FP8 相同，但从理论上说，在未来硬件上其实现效率可以提高 1/3，这将进一步增强 DeepSeek-V4 系列的效率。
在预训练期间，我们分别在 32T token 上训练 DeepSeek-V4-Flash，在 33T token 上训练 DeepSeek-V4-Pro。预训练后，这两个模型都能够原生且高效地支持 1M 长度上下文。在我们的内部评估中，DeepSeek-V4-Flash-Base 凭借其参数效率更高的设计，已经在多数基准测试中超过 DeepSeek-V3.2-Base。DeepSeek-V4-Pro-Base 进一步扩大了这一优势，在 DeepSeek 基座模型中树立了新的性能标准，在推理、编码、长上下文和世界知识任务上实现了全面领先。
DeepSeek-V4 系列的后训练流程采用一种两阶段范式：首先独立培养特定领域专家，随后通过在线策略蒸馏（on-policy distillation）（Lu and Lab, 2025）进行统一模型整合。最初，对于每个目标领域——例如数学、编码、智能体和指令遵循——都会独立训练一个单独的专家模型。基座模型首先在高质量、特定领域的数据上进行监督微调（Supervised Fine-Tuning, SFT），以建立基础能力。随后，使用组相对策略优化（Group Relative Policy Optimization, GRPO）（DeepSeek-AI, 2025）进行强化学习（Reinforcement Learning, RL），并由针对特定成功标准定制的奖励模型引导，进一步优化模型以产生符合领域目标的行为。这一阶段产生了一组多样化的专门专家，每个专家都在各自领域表现出色。最后，为了整合这些不同的能力，我们通过在线策略蒸馏训练一个单一统一模型，其中统一模型作为学生，通过教师模型学习优化反向 KL 损失。
核心评估结果总结
知识： 在广泛世界知识评估中，DeepSeek-V4-Pro-Max，即 DeepSeek-V4-Pro 的最大推理努力模式，在 SimpleQA（OpenAI, 2024d）和 Chinese-SimpleQA（He et al., 2024）基准测试上显著优于领先的开源模型。关于教育知识——通过 MMLU-Pro（Wang et al., 2024b）、HLE（Phan et al., 2025）和 GPQA（Rein et al., 2023）评估——DeepSeek-V4-Pro-Max 相较开源对照模型显示出小幅领先。尽管 DeepSeek-V4-Pro-Max 在这些基于知识的评估中仍落后于领先的专有模型 Gemini-3.1-Pro，但已经显著缩小了差距。
推理： 通过扩展推理 token，DeepSeek-V4-Pro-Max 在标准推理基准测试上表现优于 GPT-5.2 和 Gemini-3.0-Pro。尽管如此，其性能仍略低于 GPT-5.4 和 Gemini-3.1-Pro，这表明其发展轨迹大约落后于最先进前沿模型 3 到 6 个月。此外，DeepSeek-V4-Flash-Max 的性能与 GPT-5.2 和 Gemini-3.0-Pro 相当，使其成为复杂推理任务中极具成本效益的架构。
智能体： 在公开基准测试上，DeepSeek-V4-Pro-Max 与领先的开源模型（如 Kimi-K2.6 和 GLM-5.1）相当，但略逊于前沿闭源模型。在我们的内部评估中，DeepSeek-V4-Pro-Max 优于 Claude Sonnet 4.5，并接近 Opus 4.5 的水平。
长上下文： DeepSeek-V4-Pro-Max 在具有 1 百万 token 上下文窗口的合成和真实使用场景中取得了强劲结果，在学术基准测试上甚至超过 Gemini-3.1-Pro。
DeepSeek-V4-Pro 与 DeepSeek-V4-Flash： 由于参数规模较小，DeepSeek-V4-Flash-Max 在知识评估中的表现较低。然而，当分配更大的思考预算时，它在推理任务上取得了可比结果。在智能体评估中，尽管 DeepSeek-V4-Flash-Max 在若干基准测试上达到了与 DeepSeek-V4-Pro-Max 相匹配的性能，但在更复杂、更高难度的任务上仍落后于其更大的对照模型。
下面是 Architecture（第 2 节） 的忠实翻译；括号内引用已保留原文不翻译。公式尽量按原样还原，并在公式下方附上简短解释，方便理解。
2. 架构
总体而言，DeepSeek-V4 系列保留了 Transformer（Vaswani et al., 2017）架构和多 Token 预测（Multi-Token Prediction, MTP）模块（DeepSeek-AI, 2024; Gloeckle et al., 2024），同时相较于 DeepSeek-V3 引入了几项关键升级：（1）首先，我们引入流形约束超连接（Manifold-Constrained Hyper-Connections, mHC）（Xie et al., 2026），以增强传统残差连接；（2）其次，我们设计了一种混合注意力架构，通过压缩稀疏注意力（Compressed Sparse Attention）和重压缩注意力（Heavily Compressed Attention）显著提升长上下文效率；（3）第三，我们采用 Muon（Jordan et al., 2024; Liu et al., 2025）作为优化器。对于专家混合（Mixture-of-Experts, MoE）组件，我们仍采用 DeepSeekMoE（Dai et al., 2024）架构，仅相较 DeepSeek-V3 做了少量调整。多 Token 预测（MTP）（DeepSeek-AI, 2024; Gloeckle et al., 2024; Li et al., 2024; Qi et al., 2020）的配置与 DeepSeek-V3 完全相同。所有其他未特别说明的细节均遵循 DeepSeek-V3（DeepSeek-AI, 2024）中建立的设置。图 2 展示了 DeepSeek-V4 的整体架构，细节将在下文描述。
图 2｜ DeepSeek-V4 系列的整体架构。我们在注意力层使用混合 CSA（Compressed Sparse Attention）和 HCA（Heavily Compressed Attention），在前馈层使用 DeepSeekMoE，并用 mHC 增强传统残差连接。
2.1 继承自 DeepSeek-V3 的设计
专家混合。 与之前的 DeepSeek 系列模型（DeepSeek-AI, 2024; DeepSeek-AI, 2024）一样，DeepSeek-V4 系列也在前馈网络（Feed-Forward Networks, FFNs）中采用 DeepSeekMoE 范式（Dai et al., 2024），其中设置了细粒度路由专家和共享专家。与 DeepSeek-V3 不同的是，我们将用于计算亲和度分数的激活函数从 Sigmoid(·) 改为 Sqrt(Softplus(·))。对于负载均衡，我们也采用无辅助损失策略（DeepSeek-AI, 2024; Wang et al., 2024a），并辅以一个轻量的序列级均衡损失，以防止单个序列内部出现极端不均衡。对于 DeepSeek-V4，我们移除了路由目标节点数量的约束，并仔细重新设计了并行策略，以维持训练效率。此外，与 DeepSeek-V3 相比，我们将最初若干个 Transformer block 中的稠密 FFN 层替换为采用 Hash routing（Roller et al., 2021）的 MoE 层。Hash routing 策略根据输入 token ID 相关的预定义哈希函数来确定每个 token 的目标专家。
多 Token 预测。 与 DeepSeek-V3 一样，DeepSeek-V4 系列也设置了 MTP 模块和目标函数。鉴于 MTP 策略已在 DeepSeek-V3 中得到验证，我们在 DeepSeek-V4 系列中不做修改，采用相同策略。
2.2 流形约束超连接
如图 2 所示，DeepSeek-V4 系列引入了流形约束超连接（Manifold-Constrained Hyper-Connections, mHC）（Xie et al., 2026），用于增强相邻 Transformer block 之间的传统残差连接。与朴素超连接（naive Hyper-Connections, HC）（Zhu et al., 2025）相比，mHC 的核心思想是将残差映射约束到一个特定流形上，从而在保持模型表达能力的同时，增强跨层信号传播的稳定性。本小节将简要介绍标准 HC，并描述我们如何设计 mHC 以实现稳定训练。
标准超连接
标准 HC 将残差流的宽度扩大 n_hc 倍。具体来说，残差流的形状从：
[
\mathbb{R}^{d}
]
扩展为：
[
\mathbb{R}^{n_{\mathrm{hc}} \times d}
]
其中，(d) 是实际层输入的隐藏维度。令：
[
X_l = [x_{l,1}; \ldots ; x_{l,n_{\mathrm{hc}}}]^T \in \mathbb{R}^{n_{\mathrm{hc}} \times d}
]
表示第 (l) 层之前的残差状态。HC 引入三个线性映射：输入映射
[
A_l \in \mathbb{R}^{1 \times n_{\mathrm{hc}}}
]
残差变换
[
B_l \in \mathbb{R}^{n_{\mathrm{hc}} \times n_{\mathrm{hc}}}
]
以及输出映射
[
C_l \in \mathbb{R}^{n_{\mathrm{hc}} \times 1}
]
残差状态的更新可表示为：
[
X_{l+1} = B_l X_l + C_l F_l(A_l X_l)
\tag{1}
]
公式理解：
(A_l X_l) 先把扩展后的多个残差分支混合成实际输入；(F_l(\cdot)) 是第 (l) 层本身，例如 MoE 层；(C_l) 再把层输出分配回扩展残差流；(B_l X_l) 则表示旧残差状态自身的线性传递。整体上，这是“多条残差通道之间的可学习混合 + 当前层输出注入”。
其中，(F_l) 表示第 (l) 层，例如一个 MoE 层，其输入和输出形状均为 (\mathbb{R}^{d})。注意，实际层输入 (A_l X_l \in \mathbb{R}^{d}) 仍然是 (d) 维，因此扩展后的残差宽度不会影响内部层的设计。HC 将残差宽度与实际隐藏维度解耦，提供了一条互补的扩展轴，同时计算开销很小，因为 (n_{\mathrm{hc}}) 通常远小于隐藏维度 (d)。然而，尽管 HC 已显示出提升模型性能的潜力，我们发现，当堆叠多层时，训练经常出现数值不稳定，这阻碍了 HC 的扩展。
流形约束残差映射
mHC 的核心创新是将残差映射矩阵 (B_l) 约束到双随机矩阵流形，即 Birkhoff 多面体 (\mathcal{M})，从而增强跨层信号传播的稳定性：
[
B_l \in \mathcal{M} \coloneqq
\left{
M \in \mathbb{R}^{n \times n}
\mid
M\mathbf{1}_n = \mathbf{1}_n,
\mathbf{1}_n^T M = \mathbf{1}_n^T,
M \ge 0
\right}
\tag{2}
]
公式理解：
这里的 (\mathcal{M}) 是所有“双随机矩阵”的集合：每一行求和为 1，每一列求和也为 1，并且所有元素非负。把 (B_l) 限制在这个集合里，可以防止残差变换把信号无限放大。
该约束确保映射矩阵的谱范数 (|B_l|_2) 被限制在 1 以内，因此残差变换是非扩张的，这提升了前向传播和反向传播期间的数值稳定性。此外，集合 (\mathcal{M}) 在矩阵乘法下封闭，这保证了在深层堆叠 mHC 的场景中仍能保持稳定。另外，输入变换 (A_l) 和输出变换 (C_l) 也通过 Sigmoid 函数被约束为非负且有界，以避免信号抵消的风险。
动态参数化
三个线性映射的参数是动态生成的，并被分解为动态的、输入相关的分量，以及静态的、输入无关的分量。给定输入：
[
X_l \in \mathbb{R}^{n_{\mathrm{hc}} \times d}
]
首先将其展平并归一化：
[
\hat{X}l = \mathrm{RMSNorm}(\mathrm{vec}(X_l)) \in \mathbb{R}^{1 \times n{\mathrm{hc}}d}
]
然后，我们遵循传统 HC 的方式，生成无约束的原始参数：
[
\tilde{A}l \in \mathbb{R}^{1 \times n{\mathrm{hc}}},
\quad
\tilde{B}l \in \mathbb{R}^{n{\mathrm{hc}} \times n_{\mathrm{hc}}},
\quad
\tilde{C}l \in \mathbb{R}^{n{\mathrm{hc}} \times 1}
]
具体为：
[
\tilde{A}_l
\alpha_l^{\mathrm{pre}}
\cdot
(\hat{X}_l W_l^{\mathrm{pre}})
+
S_l^{\mathrm{pre}}
\tag{3}
]
公式理解：
这是生成输入混合矩阵 (A_l) 的“原始版本”。它由输入相关项 (\hat{X}_l W_l^{\mathrm{pre}}) 和静态偏置 (S_l^{\mathrm{pre}}) 组成，并由门控系数 (\alpha_l^{\mathrm{pre}}) 控制动态部分的强度。
[
\tilde{B}_l
\alpha_l^{\mathrm{res}}
\cdot
\mathrm{Mat}(\hat{X}_l W_l^{\mathrm{res}})
+
S_l^{\mathrm{res}}
\tag{4}
]
公式理解：
这是生成残差映射 (B_l) 的原始矩阵。(\mathrm{Mat}(\cdot)) 会把向量重塑为 (n_{\mathrm{hc}} \times n_{\mathrm{hc}}) 的矩阵，使残差流之间可以动态混合。
[
\tilde{C}_l
\alpha_l^{\mathrm{post}}
\cdot
(\hat{X}_l W_l{\mathrm{post}})T
+
S_l^{\mathrm{post}}
\tag{5}
]
公式理解：
这是生成输出映射 (C_l) 的原始版本，用于决定当前层输出如何注入到扩展残差流的各个分支中。
其中，
[
W_l^{\mathrm{pre}}, W_l^{\mathrm{post}}
\in
\mathbb{R}^{n_{\mathrm{hc}}d \times n_{\mathrm{hc}}}
]
以及
[
W_l^{\mathrm{res}}
\in
\mathbb{R}^{n_{\mathrm{hc}}d \times n_{\mathrm{hc}}^2}
]
是用于生成动态分量的可学习参数；(\mathrm{Mat}(\cdot)) 将大小为 (1 \times n_{\mathrm{hc}}^2) 的向量重塑为大小为 (n_{\mathrm{hc}} \times n_{\mathrm{hc}}) 的矩阵；
[
S_l^{\mathrm{pre}} \in \mathbb{R}^{1 \times n_{\mathrm{hc}}},
\quad
S_l^{\mathrm{post}} \in \mathbb{R}^{n_{\mathrm{hc}} \times 1},
\quad
S_l^{\mathrm{res}} \in \mathbb{R}^{n_{\mathrm{hc}} \times n_{\mathrm{hc}}}
]
是可学习的静态偏置；而
[
\alpha_l{\mathrm{pre}},\alpha_l{\mathrm{res}},\alpha_l^{\mathrm{post}} \in \mathbb{R}
]
是可学习的门控因子，并初始化为较小的值。
应用参数约束
在获得无约束的原始参数 (\tilde{A}_l,\tilde{B}_l,\tilde{C}_l) 后，我们对其应用前文所述的约束，以增强数值稳定性。具体来说，对于输入映射和输出映射，我们使用 Sigmoid 函数 (\sigma(\cdot)) 来确保它们非负且有界：
[
A_l = \sigma(\tilde{A}_l)
\tag{6}
]
公式理解：
通过 Sigmoid，(A_l) 的元素被压到 ((0,1)) 区间，避免输入混合时出现过大或负值。
[
C_l = 2\sigma(\tilde{C}_l)
\tag{7}
]
公式理解：
(C_l) 被压到 ((0,2)) 区间。乘以 2 让输出注入残差流时仍有足够幅度，但保持有界。
至于残差映射 (\tilde{B}_l)，我们将其投影到双随机矩阵流形 (\mathcal{M})。这通过 Sinkhorn-Knopp 算法实现：该算法首先对 (\tilde{B}_l) 应用指数函数以确保正值，得到：
[
M^{(0)} = \exp(\tilde{B}_l)
]
然后迭代地进行列归一化和行归一化：
[
M^{(t)} = T_r(T_c(M^{(t-1)}))
\tag{8}
]
公式理解：
(T_c) 表示列归一化，(T_r) 表示行归一化。反复做“列归一化 + 行归一化”，矩阵会逐渐接近每行每列都和为 1 的双随机矩阵。
其中，(T_r) 和 (T_c) 分别表示行归一化和列归一化。该迭代会收敛到一个受约束的双随机矩阵：
[
B_l = M^{(t_{\max})}
]
我们选择 (t_{\max}=20) 作为实际使用中的取值。
2.3 结合 CSA 和 HCA 的混合注意力
随着上下文长度达到极端规模，注意力机制会成为模型中的主要计算瓶颈。对于 DeepSeek-V4，我们设计了两种高效注意力架构——压缩稀疏注意力（Compressed Sparse Attention, CSA）和重压缩注意力（Heavily Compressed Attention, HCA）——并采用二者交错的混合配置，从而显著降低长文本场景中的注意力计算成本。CSA 同时结合压缩和稀疏注意力策略：它首先将每 (m) 个 token 的 Key-Value（KV）cache 压缩成一个条目，然后应用 DeepSeek Sparse Attention（DSA）（DeepSeek-AI, 2025），其中每个 query token 只关注 (k) 个压缩后的 KV 条目。HCA 则以极端压缩为目标，将每 (m’)（(\gg m)）个 token 的 KV cache 合并成一个条目。CSA 和 HCA 的混合架构显著提升了 DeepSeek-V4 系列的长上下文效率，使一百万 token 上下文在实践中成为可能。本小节描述我们混合注意力架构的核心技术；我们也提供了一个开源实现¹，以无歧义地说明更多细节。
¹ https://huggingface.co/deepseek-ai/DeepSeek-V4-Pro/tree/main/inference
2.3.1 压缩稀疏注意力
CSA 的核心架构如图 3 所示：它首先将每 (m) 个 token 的 KV cache 压缩成一个条目，然后应用 DeepSeek Sparse Attention 进一步加速。
图 3｜ CSA 的核心架构。它将 KV 条目的数量压缩到原来的 (1/m)，然后应用 DeepSeek Sparse Attention 进一步加速。此外，一小组滑动窗口 KV 条目会与被选中的压缩 KV 条目结合，以增强局部细粒度依赖。
压缩 Key-Value 条目
令：
[
H \in \mathbb{R}^{n \times d}
]
表示一段输入隐藏状态序列，其中 (n) 是序列长度，(d) 是隐藏维度。CSA 首先计算两组 KV 条目：
[
C^a, C^b \in \mathbb{R}^{n \times c}
]
以及它们对应的压缩权重：
[
Z^a, Z^b \in \mathbb{R}^{n \times c}
]
其中 © 是 head 维度：
[
C^a = H \cdot W_{aKV},
\quad
C^b = H \cdot W_{bKV}
\tag{9}
]
公式理解：
输入隐藏状态 (H) 通过两个不同的线性投影，生成两组候选 KV 表示 (C^a) 和 (C^b)。这为后续“重叠压缩”提供两套来源。
[
Z^a = H \cdot W_{aZ},
\quad
Z^b = H \cdot W_{bZ}
\tag{10}
]
公式理解：
(Z^a) 和 (Z^b) 是压缩时的权重分数，用来决定每个 token 的 KV 表示在压缩块中贡献多少。
其中：
[
W_{aKV}, W_{bKV}, W_{aZ}, W_{bZ}
\in
\mathbb{R}^{d \times c}
]
是可训练参数。接下来，(C^a) 和 (C^b) 中每 (m) 个 KV 条目，会根据其压缩权重和可学习的位置偏置：
[
B^a, B^b \in \mathbb{R}^{m \times c}
]
被压缩为一个条目，产生：
[
C^{\mathrm{Comp}} \in \mathbb{R}^{\frac{n}{m} \times c}
]
每个压缩条目：
[
C_i^{\mathrm{Comp}} \in \mathbb{R}^{c}
]
按如下方式计算：
[
[
S^a_{mi:m(i+1)-1};
S^b_{m(i-1):mi-1}
]
\mathrm{Softmax}{\mathrm{row}}
\left(
[
Z^a{mi:m(i+1)-1} + B^a;
Z^b_{m(i-1):mi-1} + B^b
]
\right)
\tag{11}
]
公式理解：
这里把当前 (C^a) 块和前一个 (C^b) 块的权重拼接起来，对总共 (2m) 个位置做 softmax。这样每个压缩条目会从相邻两个块中自适应选择信息。
[
C_i^{\mathrm{Comp}}
\sum_{j=mi}^{m(i+1)-1}
S^a_j \odot C^a_j
+
\sum_{j=m(i-1)}^{mi-1}
S^b_j \odot C^b_j
\tag{12}
]
公式理解：
压缩条目 (C_i^{\mathrm{Comp}}) 是两部分加权和：当前块的 (C^a) 信息，加上前一块的 (C^b) 信息。(\odot) 表示逐元素相乘，因此每个维度都可以有自己的压缩权重。
其中，(\odot) 表示 Hadamard 积；(\mathrm{Softmax}{\mathrm{row}}(\cdot)) 表示沿行维度执行 softmax 操作，也就是对来自 (Z^a) 和 (Z^b) 的总共 (2m) 个元素进行归一化。当 (i=0) 时，(Z^b{m(i-1):mi-1}) 会用负无穷填充，(C^b_{m(i-1):mi-1}) 会用零填充。注意，每个 (C_i^{\mathrm{Comp}}) 都来自 (2m) 个 KV 条目，但用于 (C_i^{\mathrm{Comp}}) 的 (C^b) 索引和用于 (C_{i-1}^{\mathrm{Comp}}) 的 (C^a) 索引是重叠的。因此，CSA 实际上将序列长度压缩到原来的 (1/m)。
用于稀疏选择的 Lightning Indexer
获得压缩 KV 条目 (C^{\mathrm{Comp}}) 后，CSA 应用 DSA 策略，为核心注意力选择 top-k 个压缩 KV 条目。首先，CSA 执行与 (C^{\mathrm{Comp}}) 相同的压缩操作，得到压缩后的 indexer keys：
[
K^{\mathrm{IComp}} \in \mathbb{R}^{\frac{n}{m} \times c_I}
]
其中 (c_I) 是 indexer head 维度。然后，对于一个 query token (t)，我们以低秩方式生成 indexer queries：
[
{q^I_{t,1}; q^I_{t,2}; \ldots ; qI_{t,n_hI}}
]
具体为：
[
c^Q_t = h_t \cdot W_{DQ}
\tag{13}
]
公式理解：
(h_t) 是当前 query token 的隐藏状态。它先被降维投影为压缩 latent 向量 (c_t^Q)，这样可以降低后续生成 query 的计算量。
[
[
q^I_{t,1}; q^I_{t,2}; \ldots ; qI_{t,n_hI}
]
q^I_t
c^Q_t \cdot W_{IUQ}
\tag{14}
]
公式理解：
压缩 latent 向量 (c_t^Q) 再被上投影，生成多个 indexer query head，用于和压缩 indexer key 计算匹配分数。
其中，(h_t \in \mathbb{R}^d) 是 query token (t) 的输入隐藏状态；(c^Q_t \in \mathbb{R}^{d_c}) 是 query 的压缩 latent 向量；(d_c) 表示 query 压缩维度；(n_h^I) 表示 indexer query head 的数量；
[
W_{DQ} \in \mathbb{R}^{d \times d_c}
]
以及
[
W_{IUQ} \in \mathbb{R}^{d_c \times c_I n_h^I}
]
分别是 indexer query 的下投影矩阵和上投影矩阵。接下来，query token (t) 与一个先前压缩块 (s) 之间的 index score (I_{t,s} \in \mathbb{R})，其中
[
s < \mathrm{Floor}\left(\frac{t}{m}\right)
]
按如下方式计算：
[
[
w^I_{t,1}; w^I_{t,2}; \ldots ; wI_{t,n_hI}
]
w^I_t
h_t \cdot W_w
\tag{15}
]
公式理解：
这里为不同的 indexer head 生成权重 (w^I_{t,h})，表示每个 head 在稀疏选择中有多重要。
[
I_{t,s}
\sum_{h=1}{n_hI}
w^I_{t,h}
\cdot
\mathrm{ReLU}
\left(
q^I_{t,h} \cdot K_s^{\mathrm{IComp}}
\right)
\tag{16}
]
公式理解：
每个 indexer head 计算 query 与压缩块 key 的相似度，并通过 ReLU 保留非负匹配信号，再按 head 权重加权求和，得到 query token (t) 对压缩块 (s) 的选择分数。
其中，
[
W_w \in \mathbb{R}^{d \times n_h^I}
]
是可学习矩阵；(w^I_{t,h} \in \mathbb{R}) 是第 (h) 个 indexer head 的权重。对于 query token (t)，给定其 index scores (I_{t,:})，我们使用 top-k selector 有选择地保留一部分压缩 KV 条目：
[
C_t^{\mathrm{SprsComp}}
]
用于后续核心注意力：
[
C_t^{\mathrm{SprsComp}}
\left{
C_s^{\mathrm{Comp}}
\mid
I_{t,s} \in \mathrm{Top}\text{-}k(I_{t,:})
\right}
\tag{17}
]
公式理解：
对当前 token，只保留 index score 最高的 (k) 个压缩 KV 条目。这样注意力不再看所有历史压缩块，而只看最相关的一小部分，从而降低计算量。
共享 Key-Value 的 MQA
选择稀疏 KV 条目后，CSA 以多查询注意力（Multi-Query Attention, MQA）（Shazeer, 2019）的方式执行核心注意力，其中 (C_t^{\mathrm{SprsComp}}) 中的每个压缩 KV 条目同时作为 attention key 和 value。具体来说，对于 query token (t)，我们首先从压缩 latent 向量 (c_t^Q) 生成 attention queries：
[
{q_{t,1}; q_{t,2}; \ldots ; q_{t,n_h}}
]
即：
[
[
q_{t,1}; q_{t,2}; \ldots ; q_{t,n_h}
]
q_t
c^Q_t \cdot W_{UQ}
\tag{18}
]
公式理解：
这里复用了之前的 query latent 向量 (c_t^Q)，再通过上投影生成普通注意力的多个 query heads。
其中，(n_h) 表示 query head 的数量；
[
W_{UQ} \in \mathbb{R}^{d_c \times c n_h}
]
是 query 的上投影矩阵。注意，latent query 向量 (c_t^Q) 与 indexer queries 所使用的是同一个。接下来，我们在 ({q_{t,i}}) 和 (C_t^{\mathrm{SprsComp}}) 上执行 MQA：
[
o_{t,i}
\mathrm{CoreAttn}
\left(
\mathrm{query}=q_{t,i},
\mathrm{key}=C_t^{\mathrm{SprsComp}},
\mathrm{value}=C_t^{\mathrm{SprsComp}}
\right)
\tag{19}
]
公式理解：
对第 (i) 个 query head，用选中的压缩 KV 条目同时作为 key 和 value 执行核心注意力，得到该 head 的输出 (o_{t,i})。
其中，(o_{t,i} \in \mathbb{R}^{c}) 是第 (t) 个 token 上第 (i) 个 head 的核心注意力输出；(\mathrm{CoreAttn}(\cdot)) 表示核心注意力操作。
分组输出投影
在 DeepSeek-V4 的配置中，(c n_h) 非常大。因此，如果直接将核心注意力操作的输出：
[
[o_{t,1}; o_{t,2}; \ldots ; o_{t,n_h}]
o_t
\in
\mathbb{R}^{c n_h}
]
投影到 (d) 维隐藏状态，会带来很大的计算负担。为降低该成本，我们设计了一种分组输出投影策略。具体来说，我们首先将 (n_h) 个输出拆分为 (g) 组，然后对于每组输出：
[
o^G_{t,i} \in \mathbb{R}^{\frac{c n_h}{g}}
]
将其投影为一个 (d_g) 维中间输出：
[
o^{G’}_{t,i} \in \mathbb{R}^{d_g}
]
其中：
[
d_g < \frac{c n_h}{g}
]
最后，我们将中间输出：
[
[
o^{G’}{t,1};
o^{G’}{t,2};
\ldots;
o^{G’}_{t,g}
]
\in
\mathbb{R}^{d_g g}
]
投影为最终注意力输出：
[
\hat{o}_t \in \mathbb{R}^{d}
]
2.3.2 重压缩注意力
HCA 的核心架构如图 4 所示，它以更重的方式压缩 KV cache，但不使用稀疏注意力。
图 4｜ HCA 的核心架构。它执行更强的压缩，其中 (m’)（(\gg m)）个 token 的 KV 条目会被合并为一个。此外，我们也额外引入一小组滑动窗口 KV 条目，以增强局部细粒度依赖。
压缩 Key-Value 条目
总体上，HCA 的压缩策略与 CSA 类似，但采用更大的压缩率 (m’)（(\gg m)），并且不执行重叠压缩。令：
[
H \in \mathbb{R}^{n \times d}
]
表示一段输入隐藏状态序列。HCA 首先计算原始 KV 条目：
[
C \in \mathbb{R}^{n \times c}
]
以及其对应的压缩权重：
[
Z \in \mathbb{R}^{n \times c}
]
具体为：
[
C = H \cdot W_{KV}
\tag{20}
]
公式理解：
输入隐藏状态 (H) 被投影为 KV 条目 ©，这些条目之后会按大块进行压缩。
[
Z = H \cdot W_Z
\tag{21}
]
公式理解：
(Z) 是每个 KV 条目的压缩权重分数，用来决定压缩时每个 token 的贡献。
其中：
[
W_{KV}, W_Z \in \mathbb{R}^{d \times c}
]
是可训练参数。接下来，© 中每 (m’) 个 KV 条目会根据压缩权重和可学习位置偏置：
[
B \in \mathbb{R}^{m’ \times c}
]
被压缩成一个条目，产生：
[
C^{\mathrm{Comp}} \in \mathbb{R}^{\frac{n}{m’} \times c}
]
每个压缩条目：
[
C_i^{\mathrm{Comp}} \in \mathbb{R}^{c}
]
按如下方式计算：
[
S_{m’i:m’(i+1)-1}
\mathrm{Softmax}{\mathrm{row}}
\left(
Z{m’i:m’(i+1)-1} + B
\right)
\tag{22}
]
公式理解：
对一个长度为 (m’) 的块内所有 token 计算 softmax 权重，用来决定这些 token 在压缩表示中的占比。
[
C_i^{\mathrm{Comp}}
\sum_{j=m’i}^{m’(i+1)-1}
S_j \odot C_j
\tag{23}
]
公式理解：
把 (m’) 个 KV 条目按权重加权求和，得到一个压缩 KV 条目。与 CSA 不同，这里不做重叠压缩，也不做稀疏选择。
通过这一压缩操作，HCA 将序列长度压缩到原来的：
[
\frac{1}{m’}
]
共享 Key-Value MQA 和分组输出投影
HCA 也采用与 CSA 相同的共享 KV MQA 和分组输出投影策略。在 KV 压缩之后，对于 query token (t)，HCA 首先以低秩方式生成 attention queries：
[
{q_{t,1}; q_{t,2}; \ldots ; q_{t,n_h}}
]
具体为：
[
c^Q_t = h_t \cdot W_{DQ}
\tag{24}
]
公式理解：
先把当前 token 的隐藏状态 (h_t) 压缩成 latent query 向量 (c_t^Q)，降低生成多头 query 的成本。
[
[
q_{t,1}; q_{t,2}; \ldots ; q_{t,n_h}
]
q_t
c^Q_t \cdot W_{UQ}
\tag{25}
]
公式理解：
再从压缩 latent 向量生成多个 attention query head。
其中，(h_t \in \mathbb{R}^{d}) 是 query token (t) 的输入隐藏状态；(n_h) 表示 query head 的数量；
[
W_{DQ} \in \mathbb{R}^{d \times d_c}
]
以及
[
W_{UQ} \in \mathbb{R}^{d_c \times c n_h}
]
分别是 query 的下投影矩阵和上投影矩阵。接下来，我们在 ({q_{t,i}}) 和 (C^{\mathrm{Comp}}) 上执行 MQA：
[
o_{t,i}
\mathrm{CoreAttn}
\left(
\mathrm{query}=q_{t,i},
\mathrm{key}=C^{\mathrm{Comp}},
\mathrm{value}=C^{\mathrm{Comp}}
\right)
\tag{26}
]
公式理解：
HCA 不做 top-k 稀疏选择，而是让 query 关注所有重压缩后的 KV 条目。因为 (m’) 很大，压缩后的条目数已经很少，所以仍然高效。
其中，(o_{t,i} \in \mathbb{R}^{c}) 是第 (t) 个 token 上第 (i) 个 head 的核心注意力输出。接下来，与 CSA 一样，HCA 将 (n_h) 个输出拆分为 (g) 组。对于每组输出：
[
o^G_{t,i} \in \mathbb{R}^{\frac{c n_h}{g}}
]
HCA 将其投影到一个 (d_g) 维中间输出：
[
o^{G’}_{t,i} \in \mathbb{R}^{d_g}
]
其中：
[
d_g < \frac{c n_h}{g}
]
最后，HCA 将中间输出：
[
[
o^{G’}{t,1};
o^{G’}{t,2};
\ldots;
o^{G’}_{t,g}
]
\in
\mathbb{R}^{d_g g}
]
投影到最终注意力输出：
[
\hat{o}_t \in \mathbb{R}^{d}
]
2.3.3 其他细节
除了上文描述的 CSA 和 HCA 核心架构之外，我们的混合注意力还包含若干其他技术。为使行文清晰，我们在上文介绍中省略了这些附加技术，并将在本小节中简要描述。此外，本小节只关注这些技术的核心思想，为简洁起见可能省略一些微小细节。我们鼓励读者参考我们的开源实现，以获得无歧义的细节。
Query 和 Key-Value 条目归一化
对于 CSA 和 HCA，我们都在核心注意力操作之前，对 queries 的每个 head 以及压缩 KV 条目的唯一 head 额外执行一次 RMSNorm 操作。该归一化避免了注意力 logits 爆炸，并可能提升训练稳定性。
部分旋转位置嵌入
对于 CSA 和 HCA，我们部分地将旋转位置嵌入（Rotary Positional Embedding, RoPE）（Su et al., 2024）应用于 attention queries、KV 条目和核心注意力输出。具体来说，对于 CSA 和 HCA 中使用的每个 query 向量和 KV 条目向量，我们将 RoPE 应用于其最后 64 个维度。由于 KV 条目同时作为 attention keys 和 values，朴素的核心注意力输出 ({o_{t,i}}) 会携带绝对位置嵌入，这些绝对位置嵌入来自 KV 条目的加权和。作为应对措施，我们也在每个 (o_{t,i}) 的最后 64 个维度上应用位置为 (-i) 的 RoPE。通过这种方式，核心注意力的输出也会携带相对位置嵌入——每个 KV 条目对核心注意力输出的贡献也会与 query 和 KV 条目之间的距离相关。
滑动窗口注意力的附加分支
为了在 CSA 和 HCA 中严格保持因果性，每个 query 只关注先前的压缩 KV blocks。因此，query 无法访问其自身压缩块内其他 token 的信息。同时，在语言建模中，最近的 token 通常与 query token 具有更高相关性。基于这些原因，我们以滑动窗口方式为 CSA 和 HCA 都引入一个补充注意力分支，以更好地建模局部依赖。具体来说，对于每个 query token，我们额外生成对应最近 (n_{\mathrm{win}}) 个 token 的 (n_{\mathrm{win}}) 个未压缩 KV 条目。在 CSA 和 HCA 的核心注意力中，这些滑动窗口中的 KV 条目会与压缩 KV 条目一起使用。
Attention Sink
在 CSA 和 HCA 的核心注意力中，我们采用 attention sink 技巧（OpenAI, 2025; Xiao et al., 2024）。具体来说，我们设置一组可学习的 sink logits：
[
{z’_1, z’2, \ldots, z’{n_h}}
]
对于第 (h) 个 attention head，(\mathrm{Exp}(z’_h)) 会被加到注意力分数的分母中：
[
s_{h,i,j}
\frac{
\mathrm{Exp}(z_{h,i,j})
}{
\sum_k \mathrm{Exp}(z_{h,i,k}) + \mathrm{Exp}(z’_h)
}
\tag{27}
]
公式理解：
普通 softmax 中，所有注意力权重之和通常为 1。这里额外在分母加了一个“sink”项 (\mathrm{Exp}(z’_h))，使真实 token/块上的注意力总和可以小于 1，甚至接近 0。也就是说，模型可以选择“少关注任何历史内容”。
其中，(s_{h,i,j}, z_{h,i,j} \in \mathbb{R}) 分别表示第 (h) 个 attention head 中，第 (i) 个 query token 与第 (j) 个先前 token 或压缩块之间的 attention score 和 attention logit。该技术允许每个 query head 将其总注意力分数调整为不等于 1，甚至接近 0。
2.3.4 效率讨论
由于采用混合 CSA 和 HCA，并结合低精度计算和存储，DeepSeek-V4 系列的注意力模块在 attention FLOPs 和 KV cache 大小方面都实现了显著效率提升，尤其是在长上下文场景中。首先，我们对 KV 条目采用混合存储格式：旋转位置嵌入（RoPE）维度使用 BF16 精度，而剩余维度使用 FP8 精度。与纯 BF16 存储相比，这种混合表示几乎将 KV cache 大小减半。其次，lightning indexer 内部的注意力计算以 FP4 精度执行，这在极长上下文下加速了注意力操作。第三，相对于 DeepSeek-V3.2，DeepSeek-V4 系列选择了更小的 attention top-k，从而提升了短文本和中等长度文本上的模型效率。最后，也是最重要的是，压缩注意力和混合注意力技术显著减少了 KV cache 大小和计算 FLOPs。
以 head dimension 为 128 的 BF16 GQA8（Ainslie et al., 2023）作为基线——这是 LLM 注意力的一种常见配置——在 1M 上下文设置下，DeepSeek-V4 系列的 KV cache 大小可以被大幅降低到该基线的大约 2%。此外，即便与 DeepSeek-V3.2（DeepSeek-AI, 2025）这一已经很高效的基线相比，DeepSeek-V4 系列仍然展现出显著的效率优势。它们的推理 FLOPs 和 KV cache 大小对比如图 1 右侧所示。
2.4 Muon 优化器
由于 Muon（Jordan et al., 2024; Liu et al., 2025）优化器具有更快收敛和更好的训练稳定性，我们在 DeepSeek-V4 系列的大部分模块中采用它。我们的 Muon 优化完整算法总结于算法 1。
算法 1：用于 DeepSeek-V4 的 Muon 优化器
要求： 学习率 (\eta)，动量 (\mu)，权重衰减 (\lambda)，更新重缩放因子 (\gamma)
1: for each training step t do
2: for each logically independent weight W ∈ R^{n×m} do
3: G_t = ∇_W L_t(W_{t−1}) ⊲ Compute gradients
4: M_t = μM_{t−1} + G_t ⊲ Accumulate momentum buffer
5: O'_t = HybridNewtonSchulz(μM_t + G_t)
⊲ Nesterov trick and hybrid Newton-Schulz
6: O_t = O'_t · sqrt(max(n, m)) · γ
⊲ Rescale the update RMS
7: W_t = W_{t−1} · (1 − ηλ) − ηO_t
⊲ Perform weight decay and update
8: end for
9: end for
算法理解：
Muon 先计算梯度 (G_t)，再累积动量 (M_t)。之后用 Hybrid Newton-Schulz 对更新方向进行近似正交化，使更新矩阵更稳定。随后对更新幅度进行缩放，并结合权重衰减完成参数更新。
基本配置
我们对 embedding 模块、prediction head 模块、mHC 模块的静态偏置和门控因子，以及所有 RMSNorm 模块的权重，保留 AdamW（Loshchilov and Hutter, 2017）优化器。所有其他模块都使用 Muon 更新。遵循 Liu et al. (2025)，我们也对 Muon 参数应用权重衰减，使用 Nesterov（Jordan et al., 2024; Nesterov, 1983）技巧，并重缩放更新矩阵的均方根（Root Mean Square, RMS），以复用我们的 AdamW 超参数。与他们不同的是，我们使用混合 Newton-Schulz 迭代来进行正交化。
混合 Newton-Schulz 迭代
对于给定矩阵 (M)，令其奇异值分解（Singular Value Decomposition, SVD）为：
[
M = U \Sigma V^T
]
Newton-Schulz 迭代的目标是将 (M) 近似正交化为：
[
UV^T
]
通常，首先会将 (M) 归一化为：
[
M_0 = \frac{M}{|M|_F}
]
以确保其最大奇异值不超过 1。然后，每次 Newton-Schulz 迭代执行如下操作：
[
M_k
aM_{k-1}
+
b(M_{k-1}M_{k-1}^T)M_{k-1}
+
c(M_{k-1}M_{k-1}T)2M_{k-1}
\tag{28}
]
公式理解：
这个迭代通过多项式变换逐步把矩阵的奇异值推向 1。直观上，它让更新矩阵更接近“正交方向”，从而避免某些方向更新过强、某些方向更新过弱。
我们的混合 Newton-Schulz 在两个不同阶段中执行 10 次迭代。在前 8 步中，我们使用系数：
[
(a,b,c) = (3.4445, -4.7750, 2.0315)
]
以推动快速收敛，使奇异值接近 1。在最后 2 步中，我们切换到系数：
[
(a,b,c) = (2, -1.5, 0.5)
]
从而将奇异值精确稳定在 1 附近。
避免注意力 logits 爆炸
DeepSeek-V4 系列的注意力架构允许我们直接在 attention queries 和 KV entries 上应用 RMSNorm，这有效防止了 attention logits 爆炸。因此，我们在 Muon 优化器中不使用 QK-Clip 技术（Liu et al., 2025）。
下面是 General Infrastructures（第 3 节） 的忠实翻译；括号内引用保留原文不翻译。公式尽量按原样还原，并在公式下方加了简短理解说明。
3. 通用基础设施
3.1 专家并行中的细粒度通信-计算重叠
专家混合（Mixture-of-Experts, MoE）可以通过专家并行（Expert Parallelism, EP）进行加速。然而，EP 需要复杂的节点间通信，并对互连带宽和延迟提出了很高要求。为了缓解 EP 中的通信瓶颈，并在较低互连带宽需求下实现更高的端到端性能，我们提出了一种细粒度 EP 方案，将通信和计算融合到一个单一的流水线 kernel 中，以实现通信-计算重叠。
通信延迟可以被隐藏
我们的 EP 方案的关键洞察是：在 MoE 层中，通信延迟可以有效地隐藏在计算之下。如图 5 所示，在 DeepSeek-V4 系列中，每个 MoE 层主要可以分解为四个阶段：两个通信受限阶段，即 Dispatch 和 Combine；以及两个计算受限阶段，即 Linear-1 和 Linear-2。我们的 profiling 显示，在单个 MoE 层内部，通信总耗时小于计算总耗时。因此，将通信和计算融合进一个统一流水线后，计算仍然是主导瓶颈，这意味着系统可以容忍较低的互连带宽，而不会降低端到端性能。
图 5｜ 我们的 EP 方案与相关工作的示意图。Comet（Zhang et al., 2025b）分别将 Dispatch 与 Linear-1 重叠，将 Linear-2 与 Combine 重叠。我们的 EP 方案通过将专家拆分并调度为多个 wave，实现了更细粒度的重叠。理论加速比是在 DeepSeek-V4-Flash 架构配置下评估的。
细粒度 EP 方案
为了进一步降低互连带宽需求并放大重叠带来的收益，我们引入了一种更细粒度的专家划分方案。受许多相关工作启发（Aimuyo et al., 2025; Zhang et al., 2025b），我们将专家拆分并调度为多个 wave。每个 wave 包含一小部分专家。一旦某个 wave 内所有专家完成通信，计算就可以立即开始，而不必等待其他专家。在稳态下，当前 wave 的计算、下一个 wave 的 token 传输，以及已完成专家的结果发送会同时进行，如图 5 所示。这在专家之间形成了一个细粒度流水线，使计算和通信在整个 wave 过程中都保持连续。基于 wave 的调度提升了极端场景下的性能，例如强化学习（Reinforcement Learning, RL）rollout，这类场景通常会遇到长尾小 batch。
性能和开源 Mega-Kernel
我们在 NVIDIA GPU 和 HUAWEI Ascend NPU 平台上验证了该细粒度 EP 方案。与强非融合基线相比，它在通用推理工作负载上实现了 1.50 ∼ 1.73× 的加速；在延迟敏感场景中，例如 RL rollout 和高速 agent 服务，最高可实现 1.96× 的加速。我们已经开源了名为 MegaMoE² 的基于 CUDA 的 mega-kernel 实现，作为 DeepGEMM 的一个组件。
² https://github.com/deepseek-ai/DeepGEMM/pull/304
观察与建议
我们分享 kernel 开发中的观察和经验，并向硬件厂商提出一些建议，希望有助于高效硬件设计，并实现更好的软硬件协同设计：
计算-通信比。 完全的通信-计算重叠取决于计算-通信比，而不仅仅取决于带宽。记峰值计算吞吐为 ©，互连带宽为 (B)。当满足以下条件时，通信可以被完全隐藏：
[
\frac{C}{B} \leq \frac{V_{\mathrm{comp}}}{V_{\mathrm{comm}}}
]
公式理解：
左边 (\frac{C}{B}) 表示“每单位带宽对应多少计算能力”；右边 (\frac{V_{\mathrm{comp}}}{V_{\mathrm{comm}}}) 表示任务本身“每单位通信量对应多少计算量”。如果硬件的计算/带宽比例不超过任务的计算/通信比例，那么通信就能被计算时间覆盖掉。
其中，(V_{\mathrm{comp}}) 表示计算量，(V_{\mathrm{comm}}) 表示通信量。对于 DeepSeek-V4-Pro，每个 token-expert pair 需要 (6hd) FLOPs（SwiGLU gate、up 和 down projections），但只需要 (3h) bytes 的通信量（FP8 Dispatch + BF16 Combine），因此可简化为：
[
\frac{C}{B} \leq 2d = 6144 \ \mathrm{FLOPs/Byte}.
]
公式理解：
这里 (d) 是模型中间维度相关的量。对于 DeepSeek-V4-Pro，该阈值为 6144 FLOPs/Byte，意思是：只要硬件的计算吞吐与互连带宽比例不超过这个数，通信就可以被计算隐藏。
也就是说，每 1 GBps 的互连带宽足以为 6.1 TFLOP/s 的计算隐藏通信。一旦带宽达到这一阈值，它就不再是瓶颈；继续投入额外芯片面积来提升带宽，会带来递减收益。我们鼓励未来硬件设计瞄准这样的平衡点，而不是无条件地扩展带宽。
功耗预算。 极端 kernel 融合会同时让计算、内存和网络处于高负载状态，使功耗限制成为关键性能瓶颈。我们建议未来硬件设计为这种完全并发工作负载提供足够的功耗余量。
通信原语。 我们采用 pull-based 方法，即每个 GPU 主动从远端 GPU 读取数据，从而避免细粒度 push 带来的高通知延迟。未来如果硬件具备更低延迟的跨 GPU 信号机制，push 将变得可行，并可支持更自然的通信模式。
激活函数。 我们建议用一种低成本的逐元素激活函数替代 SwiGLU，该激活函数不涉及指数或除法操作。这可以直接减轻 post-GEMM 处理负担；并且在相同参数预算下，移除 gate projection 会扩大中间维度 (d)，进一步放宽带宽需求。
3.2 使用 TileLang 进行灵活高效的 Kernel 开发
在实践中，我们复杂精巧的模型架构原本会产生数百个细粒度 Torch ATen operator。我们采用 TileLang（Wang et al., 2026）开发一组融合 kernel，以替代其中绝大多数 operator，从而以最小工作量实现最优性能。它也允许我们在验证阶段快速原型化 attention variants 等算子。这些 kernel 在模型架构开发、大规模训练，以及最终的推理服务生产部署中都发挥关键作用。作为一种领域专用语言（Domain-Specific Language, DSL），TileLang 在开发效率与运行时效率之间取得平衡，使我们能够快速开发，同时在同一代码库中支持深入的迭代优化。此外，我们与 TileLang 社区紧密合作，以促进更加敏捷、高效且稳定的 kernel 开发流程。
通过 Host Codegen 降低调用开销
随着加速器性能不断提升，CPU 侧的编排开销变得越来越突出。对于小型且高度优化的 kernel，这种固定的 host 开销很容易限制利用率和吞吐。该开销的一个常见来源是 host 侧逻辑，例如运行时契约检查，通常为了灵活性而用 Python 编写，因此会产生固定的每次调用成本。
我们通过 Host Codegen 缓解这一开销，即将大多数 host 侧逻辑移入生成的 host code。具体来说，我们首先在 IR（Intermediate Representation）层面共同生成 device kernel 和轻量级 host launcher，并嵌入从语言前端解析出的必要元数据，例如数据类型、rank/shape 约束，以及 stride/layout 假设。随后，launcher 被 lowering 为基于 TVM-FFI（Chen et al., 2018）框架的 host source code；TVM-FFI 的紧凑调用约定和零拷贝 tensor 互操作共同最小化了 host 侧开销。在运行时，这些生成的 host code 执行验证和参数封送，将所有每次调用检查都从 Python 执行路径中移出。我们的测量显示，CPU 侧验证开销从数十或数百微秒下降到每次调用不到一微秒。
SMT-Solver 辅助的形式化整数分析
TileLang kernel 涉及复杂的 tensor 索引算术，需要强大的形式化整数分析。在 layout inference、memory hazard detection 和 bound analysis 等编译 pass 中，编译器必须验证整数表达式是否满足特定性质，以启用相应优化。因此，更强的形式化分析能力可以解锁更高级、更复杂的优化机会。
为此，我们将 Z3 SMT solver（De Moura and Bjørner, 2008）集成到 TileLang 的代数系统中，为 tensor programs 中的大多数整数表达式提供形式化分析能力。我们通过将 TileLang 的整数表达式转换为 Z3 的无量词非线性整数算术（quantifier-free non-linear integer arithmetic, QF_NIA），在计算开销和形式表达能力之间取得平衡。基于整数线性规划（Integer Linear Programming, ILP）求解器，QF_NIA 能够无缝解决 kernel 中常见的标准线性整数表达式。此外，其内在的非线性推理能力可以有效处理高级挑战，例如可变 tensor shape 上的向量化。在合理资源限制下，Z3 提升了整体优化性能，同时将编译时间开销限制在仅几秒钟。它在多个 pass 中产生了显著影响，包括向量化、barrier 插入和代码简化。
数值精度与逐位可复现性
在生产环境中，数值正确性和可复现性与原始吞吐同样关键。因此，我们默认优先保证精度：在编译器层面禁用 fast-math 优化；影响精度的近似操作仅作为显式、可选的前端 operator 提供，例如 T.__exp、T.__log 和 T.__sin。相反，当需要严格 IEEE-754 语义时，TileLang 提供带显式舍入模式的 IEEE-compliant intrinsics，例如 T.ieee_fsqrt、T.ieee_fdiv 和 T.ieee_add，使开发者能够精确指定数值行为。
我们也以逐位可复现性为目标，用于将 kernel 与手写 CUDA baseline 进行验证。我们将 TileLang 的代数简化和 lowering 规则与主流 CUDA 工具链（例如 NVCC）对齐，以避免引入意外位级差异的变换。layout annotations（例如 T.annotate_layout）进一步允许用户固定与 layout 相关的 lowering 决策，使求值和累加顺序与参考 CUDA 实现保持一致，从而在需要时实现逐位相同的输出。我们的评估显示，这些面向准确性和可复现性的设计选择并不会牺牲性能：在保守默认设置下，TileLang kernel 仍然具有竞争力，同时也暴露了一些旋钮，可选择性放宽数值约束以获得更高速度。
3.3 高性能 Batch-Invariant 和确定性 Kernel 库
为了实现高效训练和推理，我们开发了一套全面的高性能计算 kernel。除了基本功能和最大化硬件利用率之外，另一个关键设计目标是确保预训练、后训练和推理流水线之间的训练可复现性和逐位对齐。因此，我们以最小性能开销实现了端到端、逐位 batch-invariant 和确定性 kernel。这些 kernel 有助于调试、稳定性分析，以及保持一致的后训练行为。
Batch Invariance
Batch invariance 确保任意给定 token 的输出保持逐位相同，不受其在 batch 中位置的影响。为了实现 batch invariance，主要挑战如下：
Attention。 为了实现 batch invariance，我们不能使用 split-KV 方法（Dao et al., 2023），该方法会将单个序列的 attention 计算分配到多个流式多处理器（Stream Multiprocessors, SMs）上，以平衡 SM 负载。然而，放弃这一技术会导致严重的 wave-quantization 问题³，从而对 GPU 利用率产生不利影响。为了解决这个问题，我们为 batch-invariant decoding 开发了一种 dual-kernel 策略。第一个 kernel 在单个 SM 内计算整个序列的 attention 输出，确保在完全占用的 wave 中具有高吞吐。第二个 kernel 为了最小化最后一个部分填充 wave 的延迟并缓解 wave-quantization，会使用多个 SM 处理单个序列。为了保证这两个 kernel 的逐位一致性，我们仔细设计了第二个 kernel 的计算路径，以确保其累加顺序与第一个 kernel 相同。此外，第二个 kernel 在线程块集群中使用 distributed shared memory⁴，实现跨 SM 的高速数据交换。该 dual-kernel 方法有效地将 batch-invariant decoding 的开销限制到可以忽略不计。
³ https://docs.nvidia.com/deeplearning/performance/dl-performance-matrix-multiplication/index.html#wave-quant
⁴ https://docs.nvidia.com/cuda/cuda-programming-guide/02-basics/writing-cuda-kernels.html#distributed-shared-memory
矩阵乘法。 传统 cuBLAS 库（NVIDIA Corporation, 2024）无法实现 batch invariance。因此，我们端到端地用 DeepGEMM（Zhao et al., 2025）替代它。此外，对于很小的 batch size，传统实现通常会采用 split-k（Osama et al., 2023）技术来提升性能。遗憾的是，split-k 技术无法保证 batch invariance，而这是 DeepSeek-V4 中的一个关键特性。因此，我们在大多数场景中放弃 split-k，但这可能导致性能下降。为了解决这一点，我们引入了一组优化，使我们的矩阵乘法实现能够在多数主要场景中匹配甚至超越标准 split-k 的性能。
确定性
确定性训练对于调试硬件或软件问题非常有益。此外，当训练出现异常（例如 loss spike）时，确定性使研究人员能够更容易定位数值原因，并进一步改进模型设计。训练中的非确定性通常源于非确定性的累加顺序，往往是由于使用 atomic addition 指令造成的。该问题主要出现在反向传播期间，尤其是在以下部分：
Attention Backward。 在稀疏 attention 反向传播的传统实现中，我们使用 atomicAdd 来累加 KV tokens 的梯度。由于浮点加法不满足结合律，这会引入非确定性。为了解决这个问题，我们为每个 SM 分配单独的累加缓冲区，随后在所有缓冲区之间执行全局确定性求和。
MoE Backward。 当来自不同 rank 的多个 SM 同时向接收 rank 上的同一个缓冲区写入数据时，协商写入位置也会引入非确定性。为了解决这一点，我们在每个单独 rank 内设计了 token order pre-processing 机制，并结合跨多个 rank 的 buffer isolation。该策略确保 expert parallelism 的发送结果以及 MoE backward pass 中的累加顺序都具有确定性。
mHC 中的矩阵乘法。 mHC 涉及一种输出维度仅为 24 的矩阵乘法。对于很小的 batch size，我们不得不使用 split-k（Osama et al., 2023）算法，而其朴素实现会导致非确定性。为克服这一问题，我们分别输出每个 split 部分，并在后续 kernel 中执行确定性 reduction，从而同时保留性能和确定性。
3.4 FP4 量化感知训练
为了在部署时实现推理加速和内存节省，我们在后训练阶段引入量化感知训练（Quantization-Aware Training, QAT）（Jacob et al., 2018），使模型能够适应量化带来的精度退化。我们将 FP4（MXFP4）量化（Rouhani et al., 2023）应用于两个组件：（1）MoE expert weights，这是 GPU 内存占用的主要来源之一（OpenAI, 2025）；（2）CSA indexer 中的 Query-Key（QK）路径，在该路径中，QK activations 完全以 FP4 形式缓存、加载和相乘，从而加速长上下文场景中的 attention score 计算。此外，在这一 QAT 过程中，我们进一步将 index scores (I_{:,:}) 从 FP32 量化到 BF16。该优化使 top-k selector 获得 2× 加速，同时保留 99.7% 的 KV entry recall rate。
对于 MoE expert weights，遵循 QAT 的常见实践，优化器维护的 FP32 master weights 首先被量化到 FP4，然后再反量化回 FP8 用于计算。值得注意的是，我们的 FP4-to-FP8 反量化是无损的。这是因为 FP8（E4M3）相比 FP4（E2M1）多 2 个 exponent bits，具有更大的动态范围。因此，只要每个 FP8 quantization block（128 × 128 tiles）内部 FP4 sub-blocks（1 × 32 tiles）的最大 scale factor 与最小 scale factor 之比不超过某个阈值，细粒度 scale 信息就可以被 FP8 扩展后的动态范围完全吸收。我们通过经验验证，当前权重满足这一条件。这使整个 QAT pipeline 可以完全复用现有 FP8 训练框架，而无需任何修改。在反向传播中，梯度是相对于前向传播中的同一组 FP8 weights 计算的，并直接传播回 FP32 master weights，这等价于通过量化操作应用 Straight-Through Estimator（STE）。这也避免了重新量化转置权重的需要。
在 RL 训练的推理和 rollout 阶段中，由于不涉及反向传播，我们直接使用真实的 FP4 量化权重，而不是模拟量化。这确保采样期间的模型行为与在线部署完全一致，同时也减少了 kernel memory loading，从而实现实际加速，并显著降低内存消耗。我们对 CSA indexer 中的 QK 路径也采用类似处理。
3.5 训练框架
我们的训练框架建立在为 DeepSeek-V3（DeepSeek-AI, 2024）开发的可扩展且高效的基础设施之上。在训练 DeepSeek-V4 时，我们继承了这一稳健基础，同时引入若干关键创新，以适配其新的架构组件——具体包括 Muon 优化器、mHC 和混合注意力机制——并同时保持较高训练效率和稳定性。
3.5.1 Muon 的高效实现
Muon 优化器需要完整的梯度矩阵来计算参数更新，这在与零冗余优化器（Zero Redundancy Optimizer, ZeRO）（Rajbhandari et al., 2020）结合时会带来挑战。传统 ZeRO 是为 AdamW 这类逐元素优化器设计的，其中单个参数矩阵可以被切分并分布到多个 rank 上更新。为了解决这一冲突，我们为 Muon 设计了一种混合 ZeRO bucket assignment 策略。
对于 dense parameters，我们限制 ZeRO parallelism 的最大规模，并采用 knapsack algorithm 将参数矩阵分配给这些 rank，确保每个 rank 管理的负载大致均衡。每个 rank 上的 bucket 会被 padding 到与所有 rank 中最大 bucket 相同的大小，以便高效执行 reduce-scatter 操作。在我们的设置中，这种 padding 通常带来小于 10% 的内存开销，其中每个 rank 管理不超过五个参数矩阵。当 data parallelism 的总体规模超过 ZeRO 的限制时，我们会在额外的数据并行组中冗余计算 Muon update，用计算换取更低的总 bucket memory。
对于 MoE parameters，我们独立优化每个 expert。我们首先 flatten 所有层中所有 expert 的 SwiGLU（Shazeer, 2020）down projection matrices，随后 flatten up projection matrices 和 gate matrices。然后，我们对 flatten 后的向量进行 padding，以确保可以在不切分任何逻辑独立矩阵的情况下，将该向量均匀分配到所有 rank。鉴于 expert 数量很大，我们不对 MoE parameters 的 ZeRO parallelism 施加限制，并且 padding 开销也可以忽略不计。
此外，在每个 rank 上，形状相同的连续参数会被自动合并，从而可以批量执行 Newton-Schulz 迭代，以获得更好的硬件利用率。进一步地，我们观察到，当使用 BF16 矩阵乘法计算时，Muon 中的 Newton-Schulz 迭代仍然保持稳定。利用这一点，我们进一步以 stochastic rounding 的方式，将需要在数据并行 rank 之间同步的 MoE gradients 量化为 BF16 精度，将通信量减半。为了避免低精度加法器引入的累积误差，我们将传统基于 tree 或 ring 的 reduce-scatter collectives 替换为两阶段方法。首先，all-to-all 操作在 rank 之间交换局部 gradients；然后每个 rank 在本地以 FP32 执行求和。该设计保持了数值稳健性。
3.5.2 mHC 的高性价比、内存高效实现
与传统残差连接相比，引入 mHC 会增加 activation memory consumption，以及 pipeline stages 之间的通信量。为了缓解这些成本，我们实现了若干优化策略。
首先，我们为训练和推理仔细设计并实现了 mHC 的 fused kernels。其次，我们引入一种 recomputation 策略，用于选择性 checkpoint 中间 tensor。具体而言，我们重新计算层间的大多数 hidden states 以及所有 normalized layer inputs，同时避免重新计算计算密集型操作。这在节省内存和计算开销之间取得了平衡。第三，我们调整 DualPipe 1F1B overlapping scheme，以适应增加的 pipeline communication，并使 mHC 中的某些操作能够并发执行。
综合来看，这些优化将 mHC 的 wall-time overhead 限制到 overlapped 1F1B pipeline stage 的仅 6.7%。更多工程优化细节可参见专门的 mHC 论文（Xie et al., 2026）。
3.5.3 面向长上下文注意力的上下文并行
传统上下文并行（Context Parallelism, CP）沿序列维度进行切分，每个 rank 维护连续的 (s) 个 token。这给我们的压缩注意力机制，即 CSA 和 HCA，带来两个挑战。一方面，训练样本是由多个序列 packed 而成的，每个序列会按因子 (m)（或 (m’)）独立压缩，且少于 (m) 个的尾部 token 会被丢弃。因此，压缩后的 KV 长度通常小于：
[
\frac{s}{m}
]
公式理解：
每个 rank 原本有 (s) 个连续 token。如果每 (m) 个 token 压缩成 1 个 KV 条目，理想长度是 (s/m)。但由于不同样本序列边界和尾部丢弃，实际压缩长度通常会比 (s/m) 更短，并且各 rank 不一致。
并且会在不同 rank 之间变化。另一方面，压缩需要 (m) 个连续 KV entries，这些 entries 可能跨越两个相邻 CP rank 的边界。
为了解决这些挑战，我们设计了一种两阶段通信方法。在第一阶段，每个 rank (i) 将其最后 (m) 个未压缩 KV entries 发送给 rank (i+1)。然后，rank (i+1) 将部分收到的 entries 与其本地的 (s) 个未压缩 KV entries 一起压缩，产生固定长度为：
[
\frac{s}{m} + 1
]
公式理解：
多出来的 (+1) 是为了覆盖跨 rank 边界的压缩块。这样即使一个压缩块横跨两个 rank，也能被正确构造。
的压缩 entries，其中存在一些 padding entries。在第二阶段，跨所有 CP ranks 的 all-gather 操作会收集本地压缩后的 KV entries。然后，一个 fused select-and-pad operator 将它们重组为完整的压缩 KV entries 集合，总长度为：
[
\mathrm{cp_size} \cdot \frac{s}{m}
]
公式理解：
(\mathrm{cp_size}) 是 CP rank 数量。每个 rank 最终贡献 (s/m) 个压缩条目，因此全局总长度是 (\mathrm{cp_size} \cdot s/m)。多余 padding 会放到末尾，避免影响可见范围。
任何 padding entries 都会被放在尾部。对于 HCA 和 CSA 中的 indexer，每个 query token 对压缩 KV entries 的可见范围可以通过规则预先计算。对于 CSA 中的 sparse attention，top-(k) selector 会显式指定每个 query 可见的压缩 KV entries 的索引。
3.5.4 用于灵活 Activation Checkpointing 的扩展自动微分
传统 activation checkpointing 实现以整个 module 为粒度工作，在反向传播期间决定是否保留或重新计算其输出 activations。这种粗粒度通常会导致 recomputation cost 与 activation memory footprint 之间的权衡并非最优。另一种方法是手动实现整个层的前向和反向逻辑，并显式管理 tensor checkpointing states。虽然这可以实现细粒度控制，但会失去自动微分框架的便利性，大幅增加开发复杂度。
为了在不牺牲编程效率的情况下实现细粒度控制，我们实现了一种带自动微分支持的 tensor-level activation checkpointing 机制。借助这一机制，开发者只需要实现前向传播，并选择性地标注各个 tensor 用于自动 checkpointing 和 recomputation。我们的框架利用 TorchFX（Reed et al., 2022）追踪完整计算图。对于每个被标注的 tensor，它会执行一次反向遍历，以识别重新计算该 tensor 所需的最小子图。我们将这些最小子图定义为 recomputation graphs，并在相应梯度计算之前，将它们插入反向逻辑中。
与手动实现相比，这一设计在训练期间不会引入额外开销。该框架中的 recomputation 是通过直接释放被标注 tensor 的 GPU memory，并复用重新计算出的 tensor 的 storage pointer 来实现的，不涉及任何 GPU memory copy。此外，由于 graph tracing 会具体执行模型，我们可以追踪每个 tensor 的底层 storage pointer，这使得对于共享 storage 的 tensor，例如 reshape 操作的输入和输出，可以自动去重 recomputation。这使开发者在标注 recomputation 时无需推理低层内存细节。
3.6 推理框架
我们的推理框架大体继承自 DeepSeek-V3，但在 KV Cache 管理方面有所不同。
3.6.1 KV Cache 结构与管理
为了高效管理 DeepSeek-V4 中由混合注意力机制产生的异构 KV caches，我们设计了一种定制化 KV cache layout。该 layout 如图 6 所示，下面将对其进行详细阐述。
DeepSeek-V4 中的异构 KV 条目
DeepSeek-V4 系列中的混合注意力机制引入了多种类型的 KV entries，它们具有不同的 Key-Value（KV）cache size 和 update rules。用于稀疏选择的 lightning indexer 在 KV cache 中引入了额外维度，其 embedding size 与主 attention 中的 embedding size 不同。CSA 和 HCA 中采用的压缩技术分别将序列长度按如下因子缩减：
[
\frac{1}{m}
]
[
\frac{1}{m’}
]
公式理解：
CSA 每 (m) 个 token 压缩成 1 个 KV 条目，HCA 每 (m’) 个 token 压缩成 1 个 KV 条目，所以 cache 长度分别变成原来的 (1/m) 和 (1/m’)。
从而降低整体 KV cache size。因此，不同层之间的 KV cache size 会有所不同。此外，滑动窗口注意力（Sliding Window Attention, SWA）层也具有不同的 KV cache size，以及独立的 cache hit 和 eviction policies。在 compression branch 中，每 (m) 个 token 生成一个 KV entry。当剩余 token 数量不足以执行压缩时，所有 pending tokens 及其相关 hidden states 必须保留在一个 buffer 中，直到可以执行压缩操作。这些 buffered tokens 表示一个由位置上下文决定的 sequence state，并且也在 KV cache 框架中进行管理。
管理混合注意力 KV Cache 的挑战
混合注意力机制违反了 PagedAttention 及其变体背后的基本假设。尽管最近的 hybrid KV cache 管理算法，例如 Jenga（Zhang et al., 2025a）和 Hymba（Dong et al., 2025），面向通用 hybrid attention 模型或特定结构，但仍有两个主要障碍阻止我们在 PagedAttention 框架下跨所有层整合 KV caches：
第一， 多样化的 cache policies，例如 Sliding Window Attention 中使用的策略。
第二， 高性能 attention kernels 施加的约束，包括 alignment requirements。
图 6｜ DeepSeek-V4 的 KV cache layout 示意图。KV cache 被组织为两个主要组件：用于 CSA/HCA 的 classical KV cache，以及用于 SWA 和 CSA/HCA 中尚未准备好压缩的 token 的 state cache。在 state cache 中，每个 request 被分配一个固定大小的 cache block。在该 block 内，SWA segment 存储对应最近 (n_{\mathrm{win}}) 个 token 的 KV entries，而 CSA/HCA segment 存储尚未准备压缩的 uncompressed tail states。在 classical KV cache 中，我们为每个 request 分配多个 block。每个 cache block 覆盖：
[
\mathrm{lcm}(m,m’)
]
个原始 token，产生：
[
k_1 = \frac{\mathrm{lcm}(m,m’)}{m}
]
个 CSA compressed tokens，以及：
[
k_2 = \frac{\mathrm{lcm}(m,m’)}{m’}
]
个 HCA compressed tokens。
公式理解：
(\mathrm{lcm}(m,m’)) 是 (m) 和 (m’) 的最小公倍数。用它作为 block 覆盖的原始 token 数，可以同时兼容 CSA 的压缩粒度 (m) 和 HCA 的压缩粒度 (m’)。因此，一个 block 内 CSA 会产生 (k_1) 个压缩 token，HCA 会产生 (k_2) 个压缩 token。
为了实现 DeepSeek-V4 的高效 KV cache 管理，我们设计了相应策略来克服这两个挑战。
用于 SWA 和未压缩尾部 Token 的 State Cache
为了解决第一个障碍，我们采用了一种替代性的 cache management 机制。由于 SWA 的设计目标是在有限 KV cache size 下提升性能，因此将其与 compression branch 中的 uncompressed tail tokens 一起视为 state-space model 是合理的。相应的 KV cache 因此可以被看作是一个 sequence-specific state，只依赖于当前位置。因此，我们预先分配一个固定且有限大小的 state cache pool，并将其动态分配给每个 sequence。
Sparse Attention Kernel 协同设计
关于第二个障碍，传统高性能 attention kernels 通常假设每个 block 有固定数量 (B) 个 token，以优化性能。这在 CSA 中对应：
[
B \cdot m
]
个原始 token，在 HCA 中对应：
[
B \cdot m’
]
个原始 token。
公式理解：
如果 kernel 以 (B) 个压缩 token 为一个 block，那么 CSA 的一个 block 实际覆盖 (B \times m) 个原始 token；HCA 的一个 block 覆盖 (B \times m’) 个原始 token。
通过采用高性能 sparse-attention kernel，不同层可以容纳每个 block 中可变数量的 token，而不会造成性能退化。实现这一点需要对 KV cache layout 和 sparse attention kernel 进行协同设计。例如，将 block padding 到 cache line 对齐可以提升性能。因此，对于压缩比为 (m) 的 CSA 和压缩比为 (m’) 的 HCA，每个 block 的原始 token 数可以是以下值的任意倍数：
[
\mathrm{lcm}(m,m’)
]
公式理解：
用 (m) 和 (m’) 的最小公倍数作为基本单位，可以保证一个 block 同时对 CSA 和 HCA 都是“整齐可切分”的，不会破坏两种压缩结构的对齐。
其中，(\mathrm{lcm}(m,m’)) 是这两个压缩比的最小公倍数。
3.6.2 磁盘 KV Cache 存储
在服务 DeepSeek-V4 时，我们利用一种磁盘 KV cache storage 机制，来消除共享前缀请求中的重复 prefilling。对于 CSA/HCA 中的 compressed KV entries，以及 Sliding Window Attention（SWA）中的 uncompressed KV entries，我们分别设计了不同的存储管理方案。
对于 CSA 和 HCA，我们简单地将所有 compressed KV entries 存储到磁盘。当某个 request 命中已存储的 prefix 时，我们读取并复用与该 prefix 对应的 compressed KV entries，直到最后一个完整的 compression block。特别地，对于 tail incomplete block 中的 prefix tokens，我们仍然需要重新计算它们，以恢复 uncompressed KV entries，因为 CSA 和 HCA 中的 uncompressed KV entries 并不会被存储。
对于 SWA KV entries，由于它们未被压缩且存在于每一层，其体积大约是 compressed CSA 和 HCA KV entries 的 8 倍。为了高效处理这些大型 SWA KV entries，我们提出并实现了三种不同策略来管理磁盘上的 SWA KV entries，每种策略都提供了 storage overhead 与 computational redundancy 之间的不同权衡：
Full SWA Caching。 该策略存储所有 token 的完整 SWA KV entries，从而保证计算零冗余。在这一策略下，命中 prefix 的 SWA KV entries 可以仅通过读取该 prefix 内最后 (n_{\mathrm{win}}) 个 token 的磁盘 cache 来重构。尽管它实现了计算零冗余，但对于现代基于 SSD 的存储系统而言，该策略效率不高——每个命中 request 只会访问已存储 SWA KV cache 中的一小部分，这会导致不均衡的写密集型访问模式。
Periodic Checkpointing。 该策略每隔 § 个 token checkpoint 一次最后 (n_{\mathrm{win}}) 个 token 的 SWA KV entries，其中 § 是一个可调参数。对于命中 prefix，我们加载最近的 checkpointed state，然后重新计算剩余 tail tokens。通过调节 §，该策略可以按需在存储和计算之间进行权衡。
Zero SWA Caching。 该策略不存储任何 SWA KV entries。对于命中 prefix，我们需要执行更多 recomputation 来恢复 SWA KV entries。具体来说，在每个 attention layer 中，每个 token 的 SWA KV entry 只依赖于前一层中最近 (n_{\mathrm{win}}) 个 token 的 SWA KV entries。因此，利用已缓存的 CSA 和 HCA KV entries，只需要重新计算最后：
[
n_{\mathrm{win}} \cdot L
]
个 token，就足以为一个 (L)-layer 模型恢复最后 (n_{\mathrm{win}}) 个 SWA KV entries。
公式理解：
(n_{\mathrm{win}}) 是滑动窗口大小，(L) 是层数。因为每层只需要上一层最近 (n_{\mathrm{win}}) 个 token 的 SWA 状态，所以沿层传播恢复时，最坏只需回算 (n_{\mathrm{win}} \times L) 个 token 的范围。
根据具体部署场景，我们会选择最合适的策略，以实现期望的存储与计算权衡。
5. 后训练
5.1 后训练流程
在预训练之后，我们进行了后训练阶段，以得到 DeepSeek-V4 系列的最终模型。尽管训练流程在很大程度上与 DeepSeek-V3.2 保持一致，但有一个关键的方法性替换：原本的混合强化学习（RL）阶段被完全替换为基于策略的蒸馏（On-Policy Distillation，OPD）。
5.1.1 专家模型训练
领域专家的开发沿用了 DeepSeek-V3.2 的训练流程。具体而言，每个模型都依次经过初始微调阶段，以及随后在领域特定提示和奖励信号指导下的强化学习（RL）阶段。对于 RL 阶段，我们实现了 Group Relative Policy Optimization（GRPO）算法，并将其超参数保持在与我们先前研究高度一致的范围内。
推理强度。 众所周知，模型在推理任务上的表现本质上由所投入的计算强度决定。因此，我们在不同的 RL 配置下训练了不同的专家模型，以促进面向不同推理能力的模型发展。如表 2 所示，DeepSeek-V4-Pro 和 DeepSeek-V4-Flash 都支持三种特定的推理强度模式。对于每种模式，我们在 RL 训练期间采用不同的长度惩罚和上下文窗口，从而导致推理输出 token 长度不同。为了整合这些不同的推理模式，我们使用由 <think> 和 </think> token 标记的专门响应格式。此外，对于“Think Max”模式，我们会在系统提示词开头预置一条特定指令来引导模型的推理过程，如表 3 所示。
生成式奖励模型。 通常，易于验证的任务可以通过简单的基于规则的验证器或测试用例来有效优化。
然而，在 DeepSeek-V4 系列的后训练阶段，我们不再使用这类传统的标量式奖励模型。相反，为了处理难以验证的任务，我们构建了由评分标准（rubric）引导的 RL 数据，并使用生成式奖励模型（Generative Reward Model，GRM）来评估策略轨迹。关键的是，我们直接对 GRM 本身施加 RL 优化。在这一范式中，actor 网络本身就充当 GRM，使得模型在优化标准生成能力的同时，也能联合优化其评估（判别）能力。通过将这两个角色统一起来，模型内部的推理能力被自然融合进评估过程，从而产生非常稳健的评分。此外，这种方法只需少量但多样化的人类标注，就能获得更优表现，因为模型利用自身逻辑可以更好地泛化到复杂任务。
工具调用格式与特殊 token。 与上一版本一致，我们使用专门的 <think></think> 标签来划分推理路径。在 DeepSeek-V4 系列中，我们引入了新的工具调用格式，使用特殊的 |DSML| token，并采用基于 XML 的工具调用格式，如表 4 所示。实验表明，这种 XML 格式能有效减少转义失败并降低工具调用错误，从而为模型与工具的交互提供更稳健的接口。
交错思考。 DeepSeek-V3.2 引入了一种上下文管理策略：在工具结果往返中保留推理轨迹，但在新用户消息到来时将其丢弃。虽然这种做法有效，但在复杂的智能体工作流中仍会造成不必要的 token 浪费——每次新的用户轮次都会清空所有已积累的推理内容，迫使模型从头重建问题求解状态。借助 DeepSeek-V4 系列扩展到 100 万 token 的上下文窗口，我们进一步改进了这一机制，以最大化交错思考在智能体环境中的效果。
- 工具调用场景。 如图 7(a) 所示，所有推理内容在整个对话过程中都会被完整保留。不同于 DeepSeek-V3.2 在每次新的用户轮次中都会丢弃思考轨迹，DeepSeek-V4 系列会在所有轮次之间保留完整的推理历史，包括跨越用户消息边界。这使得模型能够在长时程智能体任务中维持连贯、累积式的思维链。
- 一般对话场景。 如图 7(b) 所示，原有策略保持不变：当新用户消息到来时，会丢弃前一轮的推理内容，以便在持续推理轨迹收益有限的场景中保持上下文简洁。
与 DeepSeek-V3.2 一样，若某些智能体框架通过用户消息来模拟工具交互（例如 Terminus），则可能不会触发工具调用上下文路径，因此无法受益于增强的推理保留机制。对于这类架构，我们仍建议使用 non-think 模型。
Quick Instruction。 在聊天机器人场景中，响应生成前必须先执行若干辅助任务（例如判断是否需要触发网页搜索、意图识别等）。传统上，这些任务由单独的小模型处理，因为它无法复用已有的 KV cache，所以会导致重复的 prefill。为了解决这一限制，我们引入了 Quick Instruction。我们将一组专用的特殊 token 直接附加到输入序列中，每个 token 对应一个特定辅助任务。通过直接复用已经计算好的 KV cache，这一机制完全避免了重复 prefill，并允许某些任务（例如生成搜索查询、判断权威性和领域）并行执行。因此，这种方法显著降低了用户感知的首 token 时间（TTFT），并消除了维护和迭代额外小模型的工程开销。支持的 Quick Instruction token 见表 5。
5.1.2 基于策略蒸馏
在通过专门微调和强化学习训练出多个领域专家之后，我们采用多教师的基于策略蒸馏（OPD）作为将专家能力合并到最终模型中的主要技术。OPD 已经成为一种有效的后训练范式，能够将领域专家的知识和能力高效迁移到一个统一模型中。其实现方式是让学生模型从其自身生成轨迹上的教师模型输出分布中学习。形式上，给定一组 (N) 个专家模型 ({\pi_{E_1}, \pi_{E_2}, \ldots, \pi_{E_N}})，OPD 的目标函数定义为：
[
L_{OPD}(\theta)=\sum_{i=1}^{N} w_i \cdot D_{KL}(\pi_\theta \parallel \pi_{E_i})
]
在该公式中，(w_i) 表示分配给每个专家的权重，通常由该专家的重要性决定。计算反向 KL 损失 (D_{KL}(\pi_\theta \parallel \pi_{E_i})) 需要从学生模型 (\pi_\theta) 中采样训练轨迹，以保持 on-policy 学习。其底层逻辑保证统一策略 (\pi_\theta) 会根据当前任务上下文，选择性地从相关的专门专家中学习（例如数学推理任务对齐数学专家，编程任务对齐代码专家）。通过这一机制，物理上分离的专家权重中的知识被在 logits 层面对齐后整合到统一参数空间中，从而实际避免了传统权重合并或混合 RL 技术中常见的性能退化问题。在这一阶段，我们使用了十多个覆盖不同领域的教师模型来蒸馏一个学生模型。
此前工作通常会将全词表 KL 损失简化为每个 token 位置上的 token 级 KL 估计，并在策略损失计算中用 (\mathrm{sg},\log \frac{\pi_{E_i}(y_t|x,y_{<t})}{\pi_\theta(y_t|x,y_{<t})})（其中 sg 表示 stop-gradient 操作）作为逐 token 的优势估计。尽管这种做法资源效率较高，但会导致梯度估计方差较大，并经常引发训练不稳定。因此，我们在 OPD 中采用了全词表的 logit 蒸馏。保留完整的 logits 分布来计算反向 KL 损失，可以获得更稳定的梯度估计，并确保教师知识被忠实蒸馏。下一小节将介绍使全词表 OPD 能够在规模上落地的工程工作。
5.2 RL 与 OPD 基础设施
我们的后训练基础设施建立在为 DeepSeek-V3.2 开发的可扩展框架之上。具体而言，我们集成了第 3.5 节中描述的相同分布式训练栈，以及此前介绍的高效自回归采样 rollout 引擎。在此基础上，我们在本工作中引入了以下主要增强。这些设计使得涉及十多个不同教师模型的超长上下文 RL 与 OPD 合并任务能够高效执行，从而大幅加快模型发布的迭代周期。
5.2.1 FP4 量化集成
我们采用 FP4（MXFP4）量化来加速 rollout 以及所有仅推理前向过程，包括教师模型和参考模型的前向过程，从而降低内存流量和采样延迟。如第 3.4 节所述，我们在 rollout 和推理阶段直接使用原生 FP4 权重。对于训练步骤，FP4 量化通过无损的 FP4 到 FP8 反量化步骤来模拟，这样可以无缝复用现有的 FP8 混合精度框架（配合 FP32 主权重），且无需修改反向传播管线。
5.2.2 面向全词表 OPD 的高效教师调度
我们的框架支持全词表的基于策略蒸馏，且教师数量在设计上可近乎无限，每个教师都可能具有万亿级参数。为实现这一点，所有教师权重都会卸载到一个中心化分布式存储中，并在教师前向传播时按需加载，同时使用类似 ZeRO 的参数分片来缓解 I/O 和 DRAM 压力。此外，即便将 logits 写入磁盘，若对所有教师显式构造词表大小 (|V|>100k) 的 logits 仍然是不可承受的。对此，我们在前向过程中只缓存最后一层教师隐藏状态到一个中心化缓冲区中。训练时，这些缓存状态会被取回并送入对应的预测头模块，按需重建完整 logits。该设计几乎不增加重计算开销，同时完全避免了显式构造 logits 带来的内存负担。为了缓解教师预测头带来的 GPU 显存占用，我们在数据分发时按照教师索引对训练样本排序。这样可确保每个 mini-batch 中每个不同教师头只会被加载一次，并且在任意时刻设备内存中最多只保留一个教师头。所有参数和隐藏状态的加载/卸载操作都在后台异步进行，不会阻塞关键路径上的计算。最后，教师与学生 logits 之间的精确 KL 散度由专门的 TileLang 内核计算，以加速该过程并减少动态内存分配。
5.2.3 可抢占且具容错能力的 rollout 服务
为了在为高优先级任务快速分配硬件资源的同时最大化 GPU 资源利用率，我们的 GPU 集群采用了集群级抢占式任务调度器，任何正在运行的任务都可能在任意时刻被抢占。与此同时，大规模 GPU 集群中硬件故障也很常见。为此，我们为 RL/OPD rollout 实现了一个可抢占且具容错能力的 LLM 生成服务。
当为某个请求生成一个新 token 时，我们会立即将其追加到该请求的写前日志（WAL）中。在抢占发生时，我们暂停推理引擎并保存未完成请求的 KV cache。恢复时，我们使用持久化的 WAL 和保存的 KV cache 继续解码。即使发生致命硬件错误，我们也可以利用 WAL 中持久化的 token 重新执行 prefill，从而重建 KV cache。
需要强调的是，从头重生成未完成请求在数学上是错误的，因为这会引入长度偏置。由于较短的响应更可能在中断中幸存下来，从头重生成会使模型在发生中断时更倾向于输出更短的序列。如果推理栈具有 batch-invariant 和 deterministic 特性，那么这一正确性问题也可以通过在采样器所用伪随机数生成器上使用一致种子来重新生成而得到修复。不过，这仍然需要额外重新执行解码阶段，因此效率远不如我们的 token 粒度 WAL 方法。
5.2.4 面向百万 token 上下文的 RL 框架扩展
我们针对百万 token 序列上的高效 RL 和 OPD 引入了有针对性的优化。在 rollout 阶段，我们采用了第 5.2.3 节所述的可抢占且具容错能力的 rollout 服务。在推理和训练阶段，我们将 rollout 数据格式拆分为轻量级元数据和按 token 的重字段。在数据分发过程中，整个 rollout 数据的元数据可以被加载用于全局打乱和打包布局计算。重的按 token 字段则通过共享内存数据加载器读取，以消除节点内数据冗余，并在 mini-batch 粒度上于消费后立即释放，从而显著降低 CPU 和 GPU 内存压力。设备上的 mini-batch 数量会根据工作负载动态确定，以在计算吞吐和 I/O 重叠之间取得高效平衡。
5.2.5 面向智能体 AI 的沙箱基础设施
为了满足后训练和评测期间智能体 AI 的多样化执行需求，我们构建了一个生产级沙箱平台 DeepSeek Elastic Compute（DSec）。DSec 由三个 Rust 组件组成——API 网关（Apiserver）、按主机部署的代理（Edge）以及集群监控器（Watcher）——它们通过自定义 RPC 协议互联，并基于 3FS 分布式文件系统横向扩展。在生产环境中，一个 DSec 集群可以管理数十万个并发沙箱实例。
DSec 的设计受到四点观察的驱动：第一，智能体工作负载高度异构，从轻量级函数调用到完整的软件工程流水线不等，并伴随不同的操作系统与安全需求；第二，环境镜像数量众多且体积庞大，但又必须快速加载并支持迭代式定制；第三，高密度部署需要高效利用 CPU 和内存；第四，沙箱生命周期必须与 GPU 训练调度协同，包括抢占与基于检查点的恢复。基于这些观察，我们将在下文分别展开 DSec 的四个核心设计。
DSec 通过单一 Python SDK（libdsec）暴露四种执行底座。Function Call 将无状态调用派发到预热容器池，从而消除冷启动开销。Container 与 Docker 完全兼容，并利用 EROFS 的按需加载实现高效镜像组装。基于 Firecracker 的 microVM 为安全敏感、高密度部署提供虚拟机级隔离。基于 QEMU 的 fullVM 支持任意来宾操作系统。四者共享一套通用 API：命令执行、文件传输和 TTY 访问；它们之间的切换只需更改一个参数。
为了在大型且持续增长的环境镜像库下兼顾快速启动，DSec 采用分层按需加载。对于容器，基础镜像和文件系统提交内容会作为由 3FS 支撑的只读 EROFS 层直接挂载到 overlay 的 lowerdir 中。挂载时我们会将文件元数据保留在本地磁盘上，而数据块则在请求到来时从 3FS 拉取。对于 microVM，DSec 使用 overlaybd 磁盘格式：只读基础层保留在 3FS 上以供跨实例共享，而写入则进入本地 copy-on-write 层。这些快照可以链式组合，从而支持高效版本管理和毫秒级恢复。
为了适配每个集群数十万个沙箱的规模，DSec 处理了两个资源瓶颈。第一，它缓解了虚拟化环境中的重复页缓存占用，并通过内存回收实现安全的超额承诺。第二，它减轻了容器运行时中的自旋锁竞争，从而降低每个沙箱的 CPU 开销，显著提升单主机的装箱密度。
DSec 还为每个沙箱维护一个全局有序的轨迹日志，持久记录每一次命令调用及其结果。
5.3 标准基准评测
5.3.1 评测设置
知识与推理数据集包括 MMLU-Pro、GPQA、Human Last Exam（HLE）、Simple-QA Verified、Chinese-SimpleQA、LiveCodeBench-v6、CodeForces（内部基准）、HMMT 2026 Feb、Apex、Apex Shortlist、IMOAnswerBench 和 PutnamBench。
对于代码，我们在 LiveCodeBench-v6 和内部 Codeforces 基准上评测 DeepSeek-V4 系列。对于 Codeforces，我们收集了 14 场 Codeforces Division 1 比赛，共 114 道题（2025 年 5 月到 2025 年 11 月）。Elo 评分的计算方式如下：对每场比赛，我们为每道题生成 32 个候选解；然后对每道题独立地无放回抽取其中 10 个解，并随机排列成提交序列。每个提交都会由领域专家构建的测试套件进行判定。对于被解出的题目，其得分遵循 OpenAI（2025）的惩罚方案：模型获得与在相同错误次数下解出该题的人类选手的中位数相同的分数。这样会得到每个抽样提交序列的总比赛分数，然后将其转换为比赛排名，再通过标准 Codeforces 评分系统转换为估计评分。比赛级期望评分定义为在每场比赛中，对每道题的 10 个提交在所有可能随机选择和排序方式上的估计评分期望。模型的总体评分则是 14 场比赛的比赛级期望评分的平均值。
对于推理和知识任务，我们将温度设为 1.0，并将 Non-think、High 和 Max 模式的上下文窗口分别设为 8K、128K 和 384K token。对于数学任务（例如 HMMT、IMOAnswerBench、Apex 和 HLE），我们使用如下模板进行评测："{question}\nPlease reason step by step, and put your final answer within \boxed{}."。对于 DeepSeek-V4-Pro-Max 在数学任务上的评测，我们使用更能引出深层推理的模板："Solve the following problem. The problem may ask you to prove a statement, or ask for an answer. If finding an answer is required, you should come up with the answer, and your final solution should also be a rigorous proof of that answer being valid.\n\n{question}"。
对于形式化数学任务，我们在 Lean v4.28.0-rc1 上以智能体方式进行评测，能够访问 Lean 编译器和语义 tactic 搜索引擎，并在最大推理努力下最多执行 500 次工具调用。此外，我们还评测了一个更耗计算的流程：先生成候选自然语言解并通过自验证（self-verification）过滤，再将保留的解作为指导提供给形式化智能体以证明相应的 Lean 命题。该设计使用非正式推理来提升探索能力，同时通过形式化验证保持严格正确性。只有当严格验证器 Comparator 在两种设置下都接受该解时，提交才被计为正确。
我们对 K2.6 和 GLM-5.1 留空了一些条目，因为它们的 API 太忙，无法返回我们的查询结果。
对于 1M token 上下文，由于 DeepSeek-V4 系列支持 1M-token 上下文，我们选择 OpenAI MRCR 和 CorpusQA 作为长上下文场景的评测基准。我们重新评测了 Claude Opus 4.6 和 Gemini 3.1 Pro，以便统一所有模型的配置。我们没有评测 GPT-5.4，因为其 API 对我们的大部分查询没有响应。
智能体数据集包括 Terminal Bench 2.0、SWE-Verified、SWE Multilingual、SWE-Pro、BrowseComp、MCPAtlas 的公开评测集、GDPval-AA 和 Tool-Decathlon。对于代码智能体任务（SWE-Verified、Terminal-Bench、SWE-Pro、SWE Multilingual），我们使用内部开发的评测框架来评测 DeepSeek-V4 系列。该框架提供最小工具集——一个 bash 工具和一个文件编辑工具。最大交互步数设为 500，最大上下文长度设为 512K token。对于 Terminal-Bench 2.0，我们也承认 GLM-5.1 所指出的环境相关问题。不过，为保持一致性，我们仍在原始 Terminal-Bench 2.0 数据集上报告结果。对于 Terminal-Bench 2.0 Verified 子集，DeepSeek-V4-Pro 的得分约为 72.0。
对于搜索智能体任务（BrowseComp、HLE w/ tool），我们同样使用内部框架，并配备 websearch 和 Python 工具，最大交互步数设为 500，最大上下文长度设为 512K token。对于 BrowseComp，我们沿用与 DeepSeek-V3.2 相同的“全部丢弃上下文”管理策略。
5.3.2 评测结果
在表 6 中，我们给出了 DeepSeek-V4-Pro-Max 与闭源/开源模型的详细对比。“Max”、“xHigh”和“High”分别表示不同的推理强度。最佳结果用粗体标出，第二名用下划线标出。
在知识与推理方面，DeepSeek-V4-Pro-Max 在多个指标上表现出色，并在不少指标上接近最先进的闭源模型；较小的 DeepSeek-V4-Flash-Max 也在代码与数学推理任务上超越了此前最佳的开源模型 K2.6-Thinking。与此同时，DeepSeek-V4-Pro 和 DeepSeek-V4-Flash 在编程竞赛中表现优异。根据我们的评测，它们的表现可与 GPT-5.4 相比，这也是开源模型首次在该任务上与闭源模型持平。在 Codeforces 榜单上，DeepSeek-V4-Pro-Max 目前在人类候选者中排名第 23。
DeepSeek-V4 还在形式化数学任务上展现出很强的性能，无论是在智能体设置还是在高计算强度设置下都表现突出。在智能体设置下，它取得了最先进的结果，优于 Seed Prover 等此前模型；在更高计算强度的流程中，性能进一步提升，超过了 Aristotle 等系统，并达到了该设置下的最佳已知结果。
在智能体方面，DeepSeek-V4 系列在评测中表现强劲。对于代码智能体任务，DeepSeek-V4-Pro 的结果与 K2.6 和 GLM-5.1 相当，尽管这些开源模型整体上仍落后于闭源对手。DeepSeek-V4-Flash 在代码任务上不及 DeepSeek-V4-Pro，尤其是在 Terminal Bench 2.0 上。其他智能体评测也呈现出类似趋势。值得注意的是，DeepSeek-V4-Pro 在 MCPAtlas 和 Toolathlon 上表现良好，这两个评测集包含广泛的工具与 MCP 服务，说明我们的模型具备很好的泛化能力，而不仅仅是在内部框架上表现好。
5.4 真实世界任务表现
标准化基准往往难以捕捉多样化真实任务的复杂性，从而在测试结果与实际用户体验之间造成差距。为弥合这一差距，我们开发了专有的内部指标，优先考虑真实世界使用模式，而不是传统基准。这种方法确保我们的优化能够转化为可感知的实际收益。我们的评测框架特别针对 DeepSeek API 和 Chatbot 的主要使用场景，使模型表现与实际需求保持一致。
5.4.1 中文写作
DeepSeek 的主要应用场景之一是中文写作。我们对功能性写作和创意写作进行了严格评测。表 12 展示了 DeepSeek-V4-Pro 与 Gemini-3.1-Pro 在功能性写作任务上的两两比较。这些任务由常见的日常写作需求组成，提示通常简短而直接。我们选择 Gemini-3.1-Pro 作为基线，因为它在我们的评测中是中文写作表现最强的外部模型。结果表明，DeepSeek-V4-Pro 的总体胜率为 62.7%，高于基线的 34.1%；这主要是因为 Gemini 在中文写作场景下有时会让其内在风格偏好压过用户的明确要求。
表 13 展示了创意写作的比较，从两个维度进行评测：指令遵循和写作质量。与 Gemini-3.1-Pro 相比，DeepSeek-V4-Pro 在指令遵循上取得 60.0% 的胜率，在写作质量上取得 77.5% 的胜率，表明其在指令遵循上略有提升，在写作质量上有明显提升。
尽管 DeepSeek-V4-Pro 在整体用户案例分析中表现更优，但当评测限制在最困难的提示时——特别是涉及高复杂度约束或多轮场景时——Claude Opus 4.5 仍然保持性能优势。正如表 14 所示，Claude Opus 4.5 的胜率为 52.0%，而 DeepSeek-V4-Pro 为 45.9%。
5.4.2 搜索
搜索增强问答是 DeepSeek 聊天机器人的核心能力之一。在 DeepSeek 网页端和 App 中，“non-think” 模式采用检索增强搜索（RAG），而“thinking” 模式使用智能体式搜索。
检索增强搜索。我们对 DeepSeek-V4-Pro 和 DeepSeek-V3.2 在客观与主观问答类别上进行了两两比较评测。
表 9 给出了 DeepSeek-V4-Pro 中智能体搜索与检索增强搜索的比较结果。在简单客观问答、主观问答、困难客观问答和困难主观问答中，智能体搜索的胜率均高于 RAG，总体上智能体搜索为 61.7%，RAG 为 18.3%，平局为 20.0%。表 10 显示，从平均成本看，智能体搜索的 tool calls 数为 16.2，prefill 为 13649 tokens，output 为 1526 tokens；而 RAG 方案没有 tool calls，prefill 为 10453 tokens，output 为 1308 tokens。
表 11 展示了 DeepSeek-V4-Pro 与 DeepSeek-V3.2 在搜索问答任务上的内部综合评测结果。在客观问答中，DeepSeek-V4-Pro 在单值信息查找、实体信息查找、枚举型信息查找等任务上均优于 DeepSeek-V3.2；在主观问答中，它在原因分析、对比、寻求建议、推荐、攻略计划、评价看法和趋势分析等子类上也表现更好。总体上，DeepSeek-V4-Pro 的胜率为 28.1%，DeepSeek-V3.2 为 10.4%，平局为 61.5%。
5.4.3 白领任务
由于开放式任务的性质，自动化指标通常难以捕捉高质量回答的细微差别。因此，我们开展了人工评测来比较 DeepSeek-V4-Pro-Max 与 Opus-4.6-Max 的表现。标注者对模型输出在四个维度上进行盲评：任务完成度、指令遵循、内容质量和格式美观度。
如图 11 所示，DeepSeek-V4-Pro-Max 在多样化中文白领任务上优于 Opus-4.6-Max，取得了 63% 的不败率，并且在分析、生成和编辑任务上都表现出持续优势。图 12 中的详细维度得分显示，模型的主要优势在于任务完成度和内容质量。具体而言，DeepSeek-V4-Pro-Max 会主动预判用户的隐含意图，经常补充额外洞见和自我验证步骤。它在长篇生成方面也表现出色，能够给出深入、连贯的叙述，而不是像 Opus-4.6-Max 那样常常给出过于简单的项目符号列表。此外，该模型严格遵循正式的专业规范，例如标准化的中文层级编号。
然而，在指令遵循方面，它有时会忽略特定的格式约束，略逊于 Opus。此外，它在将长文本输入压缩为简洁摘要方面也不够擅长。最后，它在幻灯片的整体视觉设计方面仍有较大的提升空间。图 13、14 和 15 展示了若干测试案例；由于某些输出篇幅过长，仅显示了部分页面。
5.4.4 代码智能体
为了评测我们的编码智能体能力，我们从真实的内部研发工作负载中整理任务。我们收集了约 200 个来自 50 多位内部工程师的高难度任务，覆盖功能开发、缺陷修复、重构和诊断，涉及 PyTorch、CUDA、Rust 和 C++ 等多种技术栈。每个任务都附带原始仓库、对应执行环境和人工标注的评分标准；经过严格质量筛选后，最终保留 30 个任务作为评测集。正如表 8 所示，DeepSeek-V4-Pro 显著优于 Claude Sonnet 4.5，并接近 Claude Opus 4.5 的水平。
在一项面向 DeepSeek 开发者和研究员的调查中（(N=85)）——这些人都在日常工作中使用过 DeepSeek-V4-Pro 进行智能体编码——我们询问他们：与其他前沿模型相比，DeepSeek-V4-Pro 是否已经适合成为默认且主要的编码模型。52% 的人回答“是”，39% 倾向于“是”，少于 9% 的人回答“否”。受访者认为 DeepSeek-V4-Pro 在大多数任务上都能给出令人满意的结果，但也指出它偶尔会有一些小错误、会误解模糊提示，并且有时会过度思考。
6. 结论、局限性与未来方向
在这项工作中，我们提出了 DeepSeek-V4 系列的预览版本，目标是面向下一代大型语言模型，突破超长上下文处理的效率瓶颈。通过结合整合 CSA 与 HCA 的混合注意力架构，DeepSeek-V4 系列在长序列效率方面实现了显著跃升。架构创新加上广泛的基础设施优化，使其能够高效原生支持百万 token 上下文，并为未来的 test-time scaling、长时程任务以及在线学习等新兴范式奠定了必要基础。评测结果表明，DeepSeek-V4-Pro-Max——即 DeepSeek-V4-Pro 的最大推理强度模式——重新定义了开源模型的 SOTA：它在知识基准上显著优于此前的开源模型，在接近前沿闭源模型的同时取得了更强的推理性能，并展现出具有竞争力的智能体能力。与此同时，DeepSeek-V4-Flash-Max 在保持高度成本效率架构的同时，也获得了与领先闭源模型相当的推理表现。我们相信，DeepSeek-V4 系列为开源模型开启了百万长度上下文的新时代，并为更好的效率、规模与智能铺平了道路。
为了追求极致的长上下文效率，DeepSeek-V4 系列采用了大胆的架构设计。为了降低风险，我们保留了许多经过初步验证的组件和技巧；这些组件虽然有效，但也使架构相对复杂。在未来的迭代中，我们将开展更全面、更有原则性的研究，把架构提炼为最核心的设计，在不牺牲性能的前提下让其更加优雅。与此同时，尽管 Anticipatory Routing 和 SwiGLU Clamping 已被证明能有效缓解训练不稳定，但其底层原理仍然没有被充分理解。我们将积极研究训练稳定性的基础问题，并加强内部指标监控，力求形成一种更有原则、可预测的稳定大规模训练方法。
此外，除了 MoE 和稀疏注意力架构之外，我们还会主动探索新的模型稀疏维度——例如更稀疏的 embedding 模块——以在不牺牲能力的前提下进一步提升计算和内存效率。我们也会持续研究低延迟架构和系统技术，使长上下文部署与交互更加响应迅速。
AtomGit 是由开放原子开源基金会联合 CSDN 等生态伙伴共同推出的新一代开源与人工智能协作平台。平台坚持“开放、中立、公益”的理念，把代码托管、模型共享、数据集托管、智能体开发体验和算力服务整合在一起，为开发者提供从开发、训练到部署的一站式体验。
更多推荐
9
0- 0
已为社区贡献31条内容
所有评论(0)