DeepSeek-V4: Towards Highly Efficient Million-Token Context Intelligence

model deepseek-v4

MoElong-contextcompressed-attentionsparse-attentionmHCMuon-optimizer

DeepSeek-V4: Towards Highly Efficient Million-Token Context Intelligence #

DeepSeek-AI | 2026-04 | https://huggingface.co/deepseek-ai/DeepSeek-V4-Pro/resolve/main/DeepSeek_V4.pdf Category: model | Tags: MoE, long-context, compressed-attention, sparse-attention, mHC, Muon-optimizer, FP4-QAT, million-token

§1 TL;DR #

DeepSeek-V4 系列包含两款原生支持百万 token 上下文的 MoE 语言模型：V4-Pro（1.6T 总参/49B 激活） 和 V4-Flash（284B 总参/13B 激活）。核心创新在于 hybrid CSA+HCA attention 架构——CSA 将 KV cache 沿序列维度 4× 压缩后再做 sparse top-k 选择，HCA 以 128× 更激进的压缩率做 dense attention——配合 mHC（Manifold-Constrained Hyper-Connections） 增强残差连接稳定性，以及 Muon optimizer 加速收敛。在 1M token 场景下，V4-Pro 的单 token 推理 FLOPs 仅为 V3.2 的 27%，KV cache 仅为 10%；V4-Flash 更分别低至 10% 和 7%。V4-Pro-Max 在 Knowledge、Reasoning、Agent、Long-Context 四个维度全面重新定义了开源模型 SOTA——SimpleQA 超出开源第二名 20 个百分点，Codeforces rating 3206 超过 GPT-5.4，Putnam-2025 达到 120/120 满分，首次在 1M 学术 benchmark 上超越 Gemini-3.1-Pro。

§2 核心三问 #

Q1 痛点：长上下文推理效率的根本瓶颈 #

Figure 1: V4-Pro-Max 性能对比及效率优势

Paper's Figure 1 (caption: "Left: benchmark performance of DeepSeek-V4-Pro-Max and its counterparts. Right: inference FLOPs and KV cache size of DeepSeek-V4 series and DeepSeek-V3.2.").

Reasoning model 的 test-time scaling 范式依赖于大量中间推理 token 的生成。但 vanilla attention 的二次复杂度使得超长上下文（>128K）的计算和内存成本急剧膨胀：

计算瓶颈：在 1M context 下，标准 attention 的 FLOPs 主导推理延迟，使 test-time scaling 的收益被推理成本抵消
内存瓶颈：KV cache 线性增长，1M token × BF16 GQA8 × 128 head dim 的 KV cache 规模巨大，制约 batch size 和吞吐
质量-效率 trade-off：现有高效 attention 方案（linear attention、稀疏 attention）往往牺牲长程依赖建模能力
MoE 训练稳定性：万亿参数 MoE 模型训练中 routing 引发的 outlier 和 loss spike 问题尚未根本解决
推理部署复杂性：混合 attention 架构引入异构 KV cache，打破 PagedAttention 等标准推理框架的假设

DeepSeek-V3.2 虽然性能强大（671B/37B，MLA attention），但其 KV cache 和 FLOPs 在 1M context 下仍然是 V4 的 10× 和 3.7×。打破这一效率墙是本文的核心动机。

Q2 方法：Hybrid Compressed Attention + mHC + Muon 的协同创新 #

Figure 2: V4 整体架构

Paper's Figure 2 (caption: "Overall architecture of DeepSeek-V4 series. We use hybrid CSA and HCA for attention layers, DeepSeekMoE for feed-forward layers, and strengthen conventional residual connections with mHC.").

DeepSeek-V4 保留 V3 的 DeepSeekMoE 和 MTP 框架，在三个关键维度升级：

2.1 CSA — Compressed Sparse Attention #

Figure 3: CSA 核心架构

Paper's Figure 3 (caption: "Core architectures of CSA. It compresses the number of KV entries to 1/m times, and then applies DeepSeek Sparse Attention for further acceleration.").

CSA 的设计逻辑是"先压缩、再稀疏"，两步叠加获得极高的效率增益：

KV 压缩：输入 H ∈ R^(n×d) 生成两组 KV entries C_a, C_b 及压缩权重 Z_a, Z_b，每 m=4 个连续 KV entries 通过 softmax 加权（含可学习位置偏置）压缩为 1 个。相邻块有 overlap，每个压缩 entry 实际融合 2m 个原始 entry。序列长度压缩为 1/m
Lightning Indexer：在压缩后的 KV 上做稀疏选择。n_h^I=64 个 indexer head 产生索引分数，通过 weighted ReLU-gated dot product 计算每个压缩 entry 的重要性，top-k 选择（V4-Pro k=1024, V4-Flash k=512）保留最相关的子集
Shared KV MQA：核心 attention 采用 Multi-Query Attention，每个压缩 KV entry 同时作为 key 和 value
Grouped Output Projection：将 attention 输出分 g 组独立投影，降低输出投影成本

效率分析：CSA 综合压缩率 = m × (n/top_k) ≈ 序列长度/256（V4-Pro）或 /128（V4-Flash），在 1M 序列下仅保留约千级 KV entries 参与每个 query 的 attention。

2.2 HCA — Heavily Compressed Attention #

Figure 4: HCA 核心架构

Paper's Figure 4 (caption: "Core architectures of HCA. It performs heavier compression, where the KV entries of m' (≫ m) tokens will be consolidated into one.").

HCA 是 CSA 的极端压缩对应物，采用 更大压缩率 m'=128 但保持 dense attention（不做稀疏选择）：

压缩方式与 CSA 类似但无 overlap，每 128 个 token 的 KV entries 压缩为 1 个
保留全序列所有压缩 entry 做 dense attention，依赖压缩本身提供的全局上下文覆盖
查询生成和输出投影与 CSA 结构一致

设计直觉：CSA 提供精细化的局部+稀疏全局关注，HCA 提供粗粒度但完整的全局覆盖。两者交错排列（interleaved），在不同层分别捕获不同粒度的长程依赖。

2.3 辅助机制 #

Sliding Window Attention (SWA)：每个 query 额外关注最近 n_win=128 个未压缩 token，弥补同块内尚未压缩的 token 信息
Partial RoPE：仅在 attention 查询和 KV entries 的最后 64 维应用 RoPE。由于 KV entries 同时作为 key 和 value，在输出上应用位置 -i 的 RoPE 作为反向补偿
Q/KV Normalization：核心 attention 前对 query 和 KV entries 各维度做 RMSNorm，防止 logit 爆炸
Attention Sink：每个 head 引入可学习 sink logit z'_h 加入 attention 分母，允许 attention 权重总和不为 1 甚至接近 0

2.4 mHC — Manifold-Constrained Hyper-Connections #

mHC 解决标准 Hyper-Connections (HC) 的数值不稳定问题。HC 将残差流宽度扩展 n_hc=4 倍，通过三组线性映射（pre A_l, residual B_l, post C_l）更新隐状态：

$$X_{l+1} = B_l X_l + C_l F_l(A_l X_l)$$

核心约束：将 B_l 限制在 doubly stochastic matrices 的 Birkhoff polytope M 上：

保证 ‖B_l‖₂ ≤ 1（非扩张性）
M 对矩阵乘法封闭，深度堆叠仍保持稳定
A_l 和 C_l 通过 Sigmoid 约束为非负有界

投影方式：通过 Sinkhorn-Knopp 算法（t_max=20 次迭代）将 exp(B̃_l) 投影到 M。参数动态生成，分解为 input-dependent（通过 RMSNorm + 投影矩阵）和 input-independent（静态偏置 + gating 因子 α 初始化为小值）两部分。

代价控制：mHC 的 wall-time 开销仅占 overlapped 1F1B pipeline stage 的 6.7%，通过 fused kernel + selective recomputation + DualPipe 调整实现。

2.5 Muon Optimizer #

Muon 用于除 embedding/prediction head/RMSNorm/mHC 静态参数以外的所有模块（这些仍用 AdamW）。核心是 Newton-Schulz 迭代近似正交化：

Hybrid 策略：10 次迭代分两阶段——前 8 次 (a,b,c)=(3.4445, −4.7750, 2.0315) 快速收敛，后 2 次 (2, −1.5, 0.5) 稳定到奇异值=1
Newton-Schulz 使用 BF16 矩阵乘法即可稳定
MoE 梯度通信量通过 BF16 随机舍入减半
配合 Hybrid ZeRO：dense 参数用 knapsack 算法分配到 ranks，MoE 参数每个 expert 独立优化

2.6 效率总览 #

Figure 6: KV cache 布局

Paper's Figure 6 (caption: "Illustration of the KV cache Layout for DeepSeek-V4.").

指标	V4-Pro vs V3.2 (1M)	V4-Flash vs V3.2 (1M)	vs BF16 GQA8 baseline (1M)
FLOPs (单 token)	27% (3.7× 降低)	10% (10× 降低)	—
KV cache	10% (9.5× 降低)	7% (14× 降低)	~2%

混合精度存储进一步压缩：RoPE 维度 BF16，其余 FP8，Lightning indexer attention 用 FP4。FP4 routed expert 权重在未来硬件上理论效率可再提升 1/3。

2.7 KV Cache 压缩机制详解：真正的存储缩减而非仅计算优化 #

CSA/HCA 的压缩是序列维度上的真实存储缩减——压缩后原始 KV 即被丢弃，长期只存压缩条目。容易产生的误解是"c=512 和 MLA 的 latent 512 维一样，没省"——但省的不是 head 维度，而是条目数量。

每原始 token 的 KV 存储对比：

	每 token 存储的 KV 条目数	每条目维度	折合每 token 存储
V3 MLA	1 条/token	576 (512 latent + 64 RoPE)	576 floats
V4 CSA 层	1 条/4 tokens	512	~128 floats/tok
V4 HCA 层	1 条/128 tokens	512	~4 floats/tok

压缩的生命周期——推理时分两级管理：


┌───────────────────────────────────────────┐
│ State Cache（固定大小，per request 预分配）  │
│ ┌──────────────┬────────────────────────┐ │
│ │ SWA KV       │ 未压缩尾部             │ │
│ │ 最近 128 tok  │ <m 个待压缩 token       │ │
│ │ 未压缩,每层存 │ 凑齐 m 个后压缩→下方    │ │
│ └──────────────┴────────────────────────┘ │
├───────────────────────────────────────────┤
│ Classical KV Cache（分块增长）              │
│ ┌──────┬──────┬──────┬──────┐            │
│ │ Blk 0│ Blk 1│ Blk 2│ ...  │            │
│ │ CSA 压缩条目 + HCA 压缩条目 + Indexer KV │            │
│ └──────┴──────┴──────┴──────┘            │
│ 每块 = lcm(m, m') 个原始 token 的压缩产物  │
└───────────────────────────────────────────┘

攒够才压缩：decode 时逐 token 生成，未凑齐 m 个的 tail tokens 暂存 State Cache 的未压缩区域
压缩后丢弃原始 KV：一旦 m 个 token 凑齐，通过 softmax 加权聚合为 1 条压缩 entry，存入 Classical KV Cache。原始 m 个 KV 随即丢弃，不再占用显存
State Cache 大小固定：SWA 窗口最多 n_win=128 token + CSA 未压缩尾部最多 m-1=3 token + HCA 未压缩尾部最多 m'-1=127 token，无论总序列多长都是常数

DSA Indexer 也在压缩粒度上操作——这是另一个关键细节。Indexer 不需要看到所有原始 KV：

Indexer key 做同样的压缩操作——每 m 个原始 token 的 indexer key 聚合为 1 条压缩 indexer key K^IComp
新 query token 的 indexer query 与 n/m 条压缩 indexer key（而非 n 条原始 key）计算 index score
Top-k 选出的也是压缩粒度的 KV entry（每条代表 4 个原始 token 的加权聚合）

这意味着在 1M context 下，indexer 只需对 250K 条压缩 key 评分（FP4 精度），而非 1M 条原始 key。再 top-1024 后仅 1024 条参与 core attention——整个链路从存储到计算都在压缩粒度上运行。

Q3 结果 #

标准 Benchmark（V4-Pro-Max vs 前沿闭源模型） #

场景	指标	V4-Pro-Max	对比最佳闭源	条件
Knowledge	SimpleQA-Verified	57.9	Gemini-3.1-Pro 75.6	开源 SOTA，超第二名 20pp
Knowledge	Chinese-SimpleQA	84.4	Gemini-3.1-Pro 85.9	接近持平
Knowledge	MMLU-Pro	领先 Kimi/GLM	—	略超
Reasoning	LiveCodeBench-v6	93.5	Gemini-3.1-Pro 91.7	超越
Reasoning	Codeforces	3206	GPT-5.4 3168	超越，人类排名第 23
Reasoning	Putnam-2025	120/120	—	满分
Reasoning	Apex Shortlist	90.2	Gemini-3.1-Pro 89.1	超越
Agent	SWE-Verified	80.6	Opus-4.6 80.8	持平
Agent	Terminal Bench 2.0	67.9	GPT-5.4 75.1	仍有差距
Agent	MCPAtlas	73.6	Opus-4.6 73.8	持平
Long-Context	MRCR 1M	超 Gemini-3.1-Pro	—	1M 学术 benchmark SOTA
Long-Context	CorpusQA	超 Gemini-3.1-Pro	—	全面领先

Base 模型对比 #

指标	V3.2-Base (37B/671B)	V4-Flash-Base (13B/284B)	V4-Pro-Base (49B/1.6T)
MMLU	87.8	88.7	90.1
MMLU-Pro	65.5	68.3	73.5
SimpleQA-Verified	28.3	30.1	55.2
HumanEval	62.8	69.5	76.8
LongBench-V2	40.2	44.7	51.5

V4-Flash 以不到 V3.2 一半的激活参数在多数 benchmark 上超越 V3.2；V4-Pro 进一步在 knowledge-intensive 任务上实现跨越式提升。

实际应用表现 #

中文写作：vs Gemini-3.1-Pro 功能性写作胜率 62.7% vs 34.1%，创意写作质量胜率 77.5%
White-Collar 任务：vs Opus-4.6-Max 总体胜率 53% vs 37%，任务完成度 98.32 vs 96.68
Code Agent：内部 30 题 pass rate 67%（vs Sonnet 4.5 47%, Opus 4.5 70%, Opus 4.6 Thinking 80%）
内部调研：85 名开发者中 52% 选择 V4-Pro 作为默认编码模型，39% 倾向于选择

§3 架构与方法 #

3.1 Model Architecture #

3.1.1 模型配置 #

参数	V4-Flash	V4-Pro
Transformer 层数	43	61
Hidden dim d	4096	7168
总参数 / 激活参数	284B / 13B	1.6T / 49B
前两层 attention	Pure SWA	HCA
后续层 attention	Interleaved CSA + HCA	Interleaved CSA + HCA
CSA m / top-k	4 / 512	4 / 1024
HCA m'	128	128
Attention heads n_h	64	128
KV dim c / d_c	512 / 1024	512 / 1536
Output groups g / d_g	8 / 1024	16 / 1024
Sliding window n_win	128	128
Indexer heads n_h^I / dim c_I	64 / 128	64 / 128
MoE: shared + routed experts	1 + 256	1 + 384
Expert intermediate dim	2048	3072
Active experts / token	6	6
Hash routing 前 N 层	3	3
MTP depth	1	1
mHC n_hc / t_max	4 / 20	4 / 20

与 V3 的关键差异：

Attention：MLA → hybrid CSA+HCA。V3 的 Multi-head Latent Attention 被完全替换
MoE routing：Sigmoid(·) → Sqrt(Softplus(·))；去除 routing 目标节点约束，重新设计并行策略
初始层：从 dense FFN 改为 Hash routing MoE（前 3 层），routing 目标由预定义 hash 函数决定
残差连接：标准 residual → mHC（n_hc=4），残差流宽度扩大 4×
优化器：AdamW → 混合 AdamW+Muon
Active experts：从 8 降到 6（但总 expert 数增加）

3.1.2 CSA 详细架构 #

CSA 的数据流分为四个阶段：

Stage 1 — KV 压缩：

输入 H ∈ R^(n×d) 通过两组投影产生 KV entries C_a, C_b ∈ R^(n×c) 和压缩权重 Z_a, Z_b ∈ R^(n×c)。每 m 个连续 entry 用 softmax(Z + B) 加权求和为一个压缩 entry，其中 B ∈ R^(m×c) 是可学习位置偏置。两组 entry 有 overlap（偏移 m/2），实际每个压缩 entry 融合 2m=8 个原始 entry。最终序列长度从 n 降到 n/m。

Stage 2 — Lightning Indexer：

用低秩方式（c^Q_t → W → indexer queries）产生 n_h^I=64 个 indexer head 的查询向量。每个 head 对所有压缩 entry 计算索引分数（weighted ReLU-gated dot product），跨 head 加权聚合后 top-k 选择保留最重要的压缩 entry 子集。FP4 精度下计算 indexer attention，BF16 量化 index scores 后 top-k，99.7% recall rate。

Stage 3 — Shared KV MQA：

在 top-k 选定的压缩 entry 上做 MQA。每个压缩 entry 同时作为 key 和 value。Query 从共享压缩潜变量 c^Q_t 产生。SWA 的 n_win=128 个未压缩 token 的 KV entries 与压缩 entry 拼接参与 attention。

Stage 4 — Grouped Output Projection：

n_h × c 维的 attention 输出分 g 组，每组投影到 d_g 维中间输出，再投影到最终 d 维。

3.1.3 HCA 详细架构 #

HCA 结构与 CSA 共享核心组件，但有两个关键差异：

更大压缩率：m'=128 vs m=4，每 128 个 token 压缩为 1 个，且无 overlap
Dense attention：不做稀疏选择，直接对所有压缩 entry 做 full attention

1M token 序列经 HCA 压缩后仅 ~7800 个 entry，足以在 dense attention 下高效计算。HCA 层提供粗粒度全局覆盖，与 CSA 层的精细稀疏关注互补。

3.1.4 mHC 技术细节 #

mHC 的完整计算流程：

Input preparation：X_l（n_hc × d 维）经 flatten + RMSNorm
Dynamic parameter generation：通过投影矩阵 W^{pre,res,post}_l + 静态偏置 S + gating α（初始化小值）生成无约束参数 Ã_l, B̃_l, C̃_l
Constraint projection：
A_l = σ(Ã_l)，C_l = 2σ(C̃_l)：Sigmoid 保证非负有界
B_l = Sinkhorn(exp(B̃_l), t_max=20)：投影到 doubly stochastic 矩阵流形
Update：$X_{l+1} = B_l X_l + C_l F_l(A_l X_l)$

为什么是 doubly stochastic：doubly stochastic matrix 的谱范数 ≤ 1，保证残差映射是非扩张的。Birkhoff polytope M 对矩阵乘法封闭，意味着深度堆叠 ∏B_l 仍然有界。这从数学上保证了深层网络的梯度不会指数膨胀。

3.2 Infrastructure #

3.2.1 MoE Expert Parallelism — Fine-Grained Overlap #

Figure 5: EP 通信-计算重叠

Paper's Figure 5 (caption: "Illustration of our EP scheme with related works. Comet overlaps Dispatch with Linear-1, and Linear-2 with Combine, separately. Our EP scheme achieves a finer-grained overlapping.").

MoE 层分解为 4 阶段：Dispatch（通信）→ Linear-1（计算）→ Linear-2（计算）→ Combine（通信）。

核心 insight：总通信时间 < 总计算时间，因此理论上通信可完全隐藏于计算之下。

实现方式：将 expert 分割为多个 wave，每个 wave 是一小批 expert。一个 wave 的计算与下一个 wave 的通信并行进行。稳态时，当前 wave 计算、下一 wave 传输、已完成 wave 的结果回传三者并发执行。

性能：

通用推理场景：1.50–1.73× 加速（vs naive EP）
低延迟场景（RL rollout / agent serving）：最高 1.96×
vs Comet：理论 1.92× vs 1.42×
已开源为 DeepGEMM 中的 MegaMoE

对硬件的四个建议：

通信带宽每 GBps 可隐藏 6.1 TFLOP/s 计算（V4-Pro: C/B ≤ 6144 FLOPs/Byte）
极端 kernel fusion 驱动所有组件同时高负载，需充足功耗余量
Push-based 通信（vs 当前 pull-based）需更低延迟的跨 GPU signaling
建议用低成本逐元素 activation 替代 SwiGLU（避免 exp/div 操作）

3.2.2 TileLang DSL #

复杂模型架构本会产生数百个细粒度 Torch ATen 算子。TileLang 将绝大多数替换为融合 kernel：

Host Codegen：设备 kernel 与轻量 host launcher 在 IR 层共同生成，CPU 端验证开销从数十/数百微秒降到 <1μs
SMT-Solver-Assisted Formal Analysis：集成 Z3 SMT solver 进行整数表达式形式分析（QF_NIA），解决 vectorization、barrier 插入、代码简化
数值精度与可复现性：默认禁用 fast-math；精度影响的近似操作需显式 opt-in（T.__exp, T.__log）；IEEE-compliant 内置函数带显式 rounding mode；layout annotation 固定 layout-dependent 决策

3.2.3 Batch-Invariant and Deterministic Kernels #

目标：训练可复现性 + pre-training/post-training/inference 三条 pipeline 的 bitwise 对齐。

Attention batch invariance：不能用 split-KV。双 kernel 策略——kernel 1 在单 SM 上处理完整序列（高吞吐），kernel 2 用多 SM 处理单序列（低延迟，最后 partial wave）。kernel 2 保持相同累加顺序
MatMul batch invariance：端到端替换 cuBLAS 为 DeepGEMM，放弃 split-k，通过优化在多数场景匹配或超越标准 split-k 性能
Attention backward 确定性：传统 sparse attention backward 用 atomicAdd 引入非确定性。方案：每 SM 独立累加 buffer + 全局确定性求和
MoE backward 确定性：预处理 token 顺序 + 跨 rank 的 buffer 隔离
mHC MatMul 确定性：输出维度仅 24，小 batch 用 split-k，每部分独立输出后确定性 reduction

3.2.4 FP4 Quantization-Aware Training #

FP4（MXFP4, E2M1）QAT 在 post-training 阶段引入：

应用范围：

MoE expert 权重：FP32 master weights → FP4 量化 → FP4-to-FP8 无损反量化（FP8 E4M3 比 FP4 E2M1 多 2 个 exponent bit）→ FP8 计算。梯度通过 STE 传播
CSA indexer QK path：QK activations 以 FP4 缓存/加载/乘法
Index scores：FP32 → BF16 量化，top-k selector 获得 2× 加速，99.7% recall

部署一致性：推理和 RL rollout（无反向传播）直接使用真实 FP4 量化权重，确保训练-部署一致。

3.2.5 Training Framework #

Muon 的高效实现：Hybrid ZeRO bucket 分配——dense 参数用 knapsack 算法均衡分配到 ranks（padding <10%），MoE 参数按 expert 独立分配。相同形状参数自动合并做 batched Newton-Schulz。梯度通信用 BF16（随机舍入）减半通信量，两阶段 all-to-all + 本地 FP32 求和
mHC 实现：fused kernel + selective tensor-level checkpointing + DualPipe 调整，wall-time 开销仅 6.7%
Contextual Parallelism (CP)：压缩 attention 的 CP 面临两个挑战——packed 序列的变长压缩 KV、m 个连续 entry 可能跨 CP rank 边界。两阶段通信解决：第一阶段 rank i 向 rank i+1 发送最后 m 个未压缩 KV entry，后者本地压缩；第二阶段 all-gather 收集压缩 entry
Tensor-Level Activation Checkpointing：开发者标注单个 tensor，框架用 TorchFX 追踪计算图，自动识别最小 recomputation 子图。通过释放 GPU 内存并复用 storage pointer 实现，无内存拷贝

3.2.6 Inference Framework #

继承 V3 推理框架，核心差异在 KV Cache 管理：

异构 KV Cache 布局（Figure 6）：

State Cache：固定大小块，存放 SWA 和未完成压缩的 tail token（类似 state-space model）
Classical KV Cache：块大小为 lcm(m, m') 个原始 token，包含 CSA 和 HCA 的压缩 entry
Lightning indexer 有独立的 embedding size
不同层有不同 cache hit/eviction 策略
高性能 kernel 的对齐约束通过 co-design 的 KV cache layout 满足

On-Disk KV Cache（三种策略）：

Full SWA Caching：存完整 SWA KV，零冗余但 SSD 写密集
Periodic Checkpointing：每 p 个 token checkpoint SWA 的最近 n_win 个 token，平衡存储和计算
Zero SWA Caching：不存 SWA，从 on-disk CSA/HCA entries 恢复时重算最后 n_win·L 个 token 的 SWA KV

3.3 Pre-Training #

3.3.1 数据 #

基于 V3 数据增强：

过滤批量自动生成和模板化内容（防 model collapse）
数学和编程保持核心地位
Mid-training 阶段加入 agentic 数据
扩大多语言语料覆盖长尾知识
强调长文档数据（科学论文、技术报告）
总量 32T+ token，词表 128K（少量新 special token）
采用 sample-level attention masking（区别于 V3）

3.3.2 训练设置 #

参数	V4-Flash	V4-Pro
训练 token 数	32T	33T
最大 batch size	75.5M tokens	94.4M tokens
Peak LR	2.7×10⁻⁴	2.0×10⁻⁴
End LR	2.7×10⁻⁵	2.0×10⁻⁵
LR warmup	2000 steps linear	2000 steps linear
LR schedule	Maintained → cosine decay	Maintained → cosine decay
序列长度调度	4K → 16K → 64K → 1M	4K → 16K → 64K → 1M
Dense attention warmup	首 1T tokens	更长的 warmup
Sparse attention 引入	64K 阶段 + indexer warmup	同上
MTP loss weight	0.3 → 0.1 (LR decay 时)	同
Balance loss weight	0.0001	同

3.3.3 训练稳定性 #

万亿参数 MoE 模型的 loss spike 与 MoE 层的 outlier 直接相关，routing 机制放大了 outlier 的影响。两个有效技术：

Anticipatory Routing：将 backbone 和 routing 网络的参数更新解耦。在 step t，用当前参数 θ_t 计算特征，但 routing indices 来自 θ_{t-Δt}（提前 Δt 步计算并缓存）。基础设施优化将额外开销控制在 ~20%。自动检测触发——仅在 loss spike 发生时启用，稳定后回退到标准训练。

SwiGLU Clamping：将 SwiGLU 的线性分量 clamp 到 [-10, 10]，gate 上界 cap 到 10。实验证明有效消除 outlier 且不影响性能。

3.4 Post-Training #

3.4.1 Specialist Training #

采用 V3.2 的 domain specialist 范式：每个领域模型经过初始 fine-tuning + GRPO RL 优化。

Reasoning Efforts（三种模式）：

模式	特性	适用场景
Non-think	快速直觉式响应	常规任务
Think High	有意识的逻辑分析	复杂问题
Think Max	推理能力推向极限	最高难度

不同模式使用不同的 length penalty 和 context window
Think Max 使用特殊 system prompt injection 要求"绝对最大推理努力，不允许捷径"
标记界定推理内容

Generative Reward Model (GRM)：难验证任务不再用标量 reward model，而是用 Generative Reward Model + rubric-guided RL data。Actor 网络本身就是 GRM，同时优化评判和生成能力。

Interleaved Thinking（V4 的上下文管理创新）：

Figure 7: V4 思维管理

Paper's Figure 7 (caption: "Thinking management of DeepSeek-V4 series.").

Tool-calling 场景：所有推理内容在整个对话中完全保留（包括跨 user message 边界），充分利用 1M token 上下文
通用对话场景：保留 V3.2 策略——新 user message 时丢弃前轮推理

Quick Instruction：在输入末尾追加 special token 触发辅助任务（搜索决策、标题生成、查询提取、来源权威性评估、域分类、URL 提取），复用已有 KV cache，避免维护独立小模型。多个任务可并行执行。

3.4.2 On-Policy Distillation (OPD) #

多教师 OPD 替代 V3.2 的 mixed RL 阶段，将 10+ 个 domain specialist 合并为统一模型：

目标函数：student π_θ 与各 expert π_{E_i} 的 reverse KL divergence 加权和。Reverse KL 要求从 student 自身做 on-policy 采样。

关键改进：摒弃先前工作的 token-level KL 估计（高方差、不稳定），采用 full-vocabulary logit distillation——保留完整 logit 分布，获得稳定梯度估计。

Teacher 调度：支持无限数量的万亿参数教师模型。教师权重 offload 到集中式分布式存储；按需加载，ZeRO-like 参数分片。仅缓存最后一层 hidden states（非 full logits），prediction head 实时重建 logits。训练样本按 teacher index 排序——每个 mini-batch 中每个 teacher head 仅加载一次，设备内存中最多一个 head。

3.4.3 RL/OPD Infrastructure #

FP4 集成：rollout 和所有 inference-only forward pass 使用原生 FP4 权重
Fault-tolerant Rollout：Token-granular Write-Ahead Log (WAL)。抢占时暂停 engine + 保存 KV cache；硬件错误时从 WAL 重做 prefill。从头重新生成未完成请求是数学上错误的（引入 length bias）
Million-token RL：rollout 数据解耦为轻量 metadata（全局 shuffle）和重量级 per-token fields（shared-memory loader + mini-batch 粒度释放）
DSec Sandbox：生产级 Rust 沙箱平台，管理数十万并发沙箱实例。四种执行底座（Function Call / Container / microVM / fullVM），3FS 分布式文件系统支撑，轨迹日志支持确定性重放

§4 Highlights #

核心技术壁垒 #

CSA+HCA 混合架构设计：看似简单的"压缩+稀疏"组合，实际需要大量工程验证——compression overlap、Lightning Indexer 的 FP4 化、Partial RoPE 的正确应用、Attention Sink 的引入。每个细节的缺失都可能导致长上下文质量显著下降
mHC 的 Birkhoff polytope 约束：从理论（doubly stochastic 保证非扩张性）到工程（Sinkhorn-Knopp 20 次迭代 + dynamic parameter generation + fused kernel）的完整闭环，替代方案（naive HC）的不稳定性意味着这不是可轻易绕过的设计
MoE 训练稳定性的两个 trick：Anticipatory Routing 和 SwiGLU Clamping 看似 ad-hoc，但针对的是万亿参数 MoE 独有的 routing-induced outlier 问题。作者承认理论理解不足，这反而说明这是经验驱动的硬工程
端到端 bitwise 确定性：从 attention、MatMul 到 MoE backward、mHC MatMul 的全链路确定性 kernel，是 reproduce 和 debug 万亿参数模型的基础设施前提

Architecture Design 洞见 #

"压缩+稀疏" vs "压缩+稠密" 互补：CSA（4× 压缩 + sparse top-k）和 HCA（128× 压缩 + dense）的 interleave 是本文最核心的设计直觉。CSA 层负责"精确找到最相关的上下文片段"，HCA 层负责"粗粒度理解全局结构"。这比纯稀疏或纯压缩方案更优
mHC 的必要性：在 compressed attention 下信息必须经过残差流在层间传递；标准 residual 的表达能力不足以支撑这种信息流模式。mHC 通过扩展残差流宽度 4× 并保持非扩张性来解决这个瓶颈
MoE routing 的演进：Sigmoid → Sqrt(Softplus) + Hash routing（前 3 层）+ 去除节点约束。这一系列改变反映了对 routing 稳定性和灵活性的持续探索
Active experts 减少（8→6）但总 experts 增加：每 token 激活更少 expert 降低通信和计算成本，但通过增加总 expert 数保持或扩大模型容量

与前代差异 #

维度	DeepSeek-V3/V3.2	DeepSeek-V4
Attention	MLA (Multi-head Latent Attention)	Hybrid CSA + HCA
KV cache (1M)	基准 100%	V4-Pro 10%, V4-Flash 7%
FLOPs (1M)	基准 100%	V4-Pro 27%, V4-Flash 10%
残差连接	Standard residual	mHC (4× 宽度, doubly stochastic)
Optimizer	AdamW	Hybrid AdamW + Muon
MoE activation	Sigmoid	Sqrt(Softplus)
Active experts	8	6
FFN 前 N 层	Dense FFN	Hash routing MoE
精度	FP8 training	FP8 + FP4 QAT (post-training)
最大上下文	128K → 扩展	原生 1M
Post-training	Mixed RL	Specialist + OPD
推理框架	PagedAttention-compatible	异构 KV cache + on-disk

Limitations #

架构复杂度：保留了大量 V3 验证过的组件同时引入新机制，整体架构较为复杂。作者明确表示未来将精简到最本质设计
稳定性理论不足：Anticipatory Routing 和 SwiGLU Clamping 有效但缺乏理论解释，属于经验性方案
Agent 能力仍有差距：Terminal Bench 2.0（67.9 vs GPT-5.4 75.1）等复杂 agent 场景仍落后闭源前沿 7+ 分
Knowledge retrieval 差距：SimpleQA-Verified 57.9 vs Gemini-3.1-Pro 75.6，在事实性知识上仍有显著差距
单一模态：目前仅支持文本，多模态能力正在开发中
未来方向：模型稀疏性的新维度探索（sparse embedding）、低延迟架构、更好的数据合成策略

Appendix: 模型架构图（基于 inference/model.py） #

代码来源：https://huggingface.co/deepseek-ai/DeepSeek-V4-Pro/blob/main/inference/model.py

A1. Top-Level 模型流 #

flowchart TB IN["Input Tokens"] EMB["ParallelEmbedding
vocab=129280, d=4096"] HC_EXP["HC Expand
unsqueeze(2).repeat(1,1,hc_mult=4,1)
→ [b, s, 4, d]"] subgraph BLOCKS["× L layers (Block)"] direction TB B_HC1["mHC Pre (Attn)
hc_attn_fn → Sinkhorn → pre/post/comb"] B_NORM1["attn_norm: RMSNorm"] B_ATTN["Attention
CSA(ratio=4) / HCA(ratio=128) / SWA(ratio=0)"] B_HCP1["mHC Post (Attn)
post×output + comb×residual"] B_HC2["mHC Pre (FFN)
hc_ffn_fn → Sinkhorn"] B_NORM2["ffn_norm: RMSNorm"] B_MOE["MoE FFN
Gate(√softplus) → top-6 routed + 1 shared"] B_HCP2["mHC Post (FFN) → [b,s,4,d]"] B_HC1 --> B_NORM1 --> B_ATTN --> B_HCP1 B_HCP1 --> B_HC2 --> B_NORM2 --> B_MOE --> B_HCP2 end HC_HEAD["HC Head
hc_head → weighted sum → [b,s,d]"] LOGITS["RMSNorm → lm_head → Logits [b,s,V]"] MTP["MTP Block
e_proj(embed) + h_proj(h) → Block → logits"] IN --> EMB --> HC_EXP --> BLOCKS --> HC_HEAD --> LOGITS BLOCKS -.-> MTP

A2. Block — Transformer Layer with mHC #

flowchart TB X_IN["X ∈ [b, s, hc=4, d]"] subgraph ATTN_BRANCH["Attention Branch"] direction TB HC_PRE_A["mHC Pre
flatten→RMSNorm→F.linear(hc_attn_fn)×rsqrt
→ hc_split_sinkhorn → pre,post,comb"] ANORM["attn_norm: RMSNorm(d)"] ATTN["Attention
compress_ratios[layer_id]:
0→SWA only | 4→CSA | 128→HCA"] HC_POST_A["mHC Post
post×output + Σ comb×residual"] HC_PRE_A --> ANORM --> ATTN --> HC_POST_A end subgraph FFN_BRANCH["FFN Branch"] direction TB HC_PRE_F["mHC Pre (FFN)"] FNORM["ffn_norm: RMSNorm(d)"] MOE["MoE
Gate: sqrtsoftplus + bias (routing)
Hash routing for first n_hash_layers
6 active / 256 routed + 1 shared
Expert: SwiGLU (clamp ±10)"] HC_POST_F["mHC Post (FFN)"] HC_PRE_F --> FNORM --> MOE --> HC_POST_F end X_IN --> ATTN_BRANCH --> FFN_BRANCH X_IN -.->|residual| HC_POST_A HC_POST_A -.->|residual| HC_POST_F

A3. CSA — Compressed Sparse Attention (compress_ratio=4) #

flowchart TB X["x ∈ [b, s, d]"] subgraph Q_PATH["Q Path"] direction TB WQA["wq_a: Linear(d → q_lora_rank)"] QN["q_norm: RMSNorm(q_lora_rank)"] WQB["wq_b: ColParallel(q_lora → n_h×c)
reshape → [n_h=64, c=512]"] QNORM["per-head RMSNorm"] QROPE["RoPE(last 64d)"] WQA --> QN --> WQB --> QNORM --> QROPE end subgraph SWA_KV["SWA KV Path"] direction TB WKV["wkv: Linear(d → c=512)"] KVN["kv_norm: RMSNorm(c)"] KVROPE["RoPE(last 64d) + FP8 quant(non-rope)"] WIN_CACHE["Window KV Cache
circular buffer, size=128"] WKV --> KVN --> KVROPE --> WIN_CACHE end subgraph COMPRESSOR["Compressor (m=4, overlap=True)"] direction TB C_WKV["wkv: Linear(d → 2×c=1024)
两半: overlap half + current half"] C_WGATE["wgate: Linear(d → 2×c=1024)"] C_APE["+ APE: learnable [m, 2×c]"] C_OVL["overlap_transform: 拼接前一块的 first half"] C_SOFT["softmax(gate+APE) × kv → weighted sum
2m=8 entries → 1 compressed entry"] C_NORM["RMSNorm → RoPE(last 64d) → FP8 quant"] C_CACHE["Compressed KV Cache
n/4 entries, c=512 each"] C_WKV --> C_WGATE --> C_APE --> C_OVL --> C_SOFT --> C_NORM --> C_CACHE end subgraph INDEXER["Lightning Indexer"] direction TB I_COMP["Own Compressor(c_I=128)
Hadamard rotation + FP4 quant"] I_Q["wq_b(qr) → [n_h^I=64, c_I=128]
RoPE → Hadamard → FP4"] I_W["weights_proj(x) → [n_h^I]"] I_SCORE["score = Σ w·ReLU(q·K^IComp)
across n_h^I heads"] I_TOPK["top-k (k=512/1024)"] I_COMP --> I_SCORE I_Q --> I_SCORE I_W --> I_SCORE I_SCORE --> I_TOPK end SPARSE["sparse_attn(q, kv, attn_sink, topk_idxs)
topk_idxs = SWA window idxs ∪ Indexer top-k idxs
gather KV → MQA (shared key-value) → output"] INV_ROPE["inverse RoPE(output, last 64d)"] subgraph O_PROJ["Grouped Output Projection"] direction TB O_RESHAPE["reshape [g=8 groups, n_h/g × c]"] O_WOA["wo_a per group: [n_h/g×c → o_lora=1024]"] O_WOB["wo_b: RowParallel(g×o_lora → d)"] O_RESHAPE --> O_WOA --> O_WOB end X --> Q_PATH & SWA_KV & COMPRESSOR & INDEXER Q_PATH --> SPARSE SWA_KV --> SPARSE COMPRESSOR --> SPARSE INDEXER --> SPARSE SPARSE --> INV_ROPE --> O_PROJ

A4. HCA — Heavily Compressed Attention (compress_ratio=128) #

flowchart TB X["x ∈ [b, s, d]"] subgraph Q_PATH["Q Path (same as CSA)"] direction TB WQA["wq_a → q_norm → wq_b"] QNORM["reshape [n_h, c=512] → RMSNorm → RoPE(64d)"] WQA --> QNORM end subgraph SWA_KV["SWA KV (same as CSA)"] direction TB WKV["wkv → kv_norm → RoPE → FP8"] WIN["Window Cache (circular, 128)"] WKV --> WIN end subgraph COMPRESSOR["Compressor (m'=128, overlap=False)"] direction TB C_WKV2["wkv: Linear(d → c=512)
NO overlap (coff=1)"] C_WGATE2["wgate: Linear(d → c=512)"] C_APE2["+ APE: learnable [128, 512]"] C_SOFT2["softmax(gate+APE) × kv
128 entries → 1 compressed"] C_NORM2["RMSNorm → RoPE → FP8"] C_CACHE2["Compressed KV Cache
n/128 entries (1M→~7.8K)"] C_WKV2 --> C_WGATE2 --> C_APE2 --> C_SOFT2 --> C_NORM2 --> C_CACHE2 end NO_IDX["No Indexer — dense attend ALL entries
get_compress_topk_idxs: all indices"] DENSE["sparse_attn(q, kv, attn_sink, all_idxs)
SWA window ∪ ALL compressed entries → dense attend"] OPROJ["inverse RoPE → Grouped O Proj"] X --> Q_PATH & SWA_KV & COMPRESSOR COMPRESSOR --> NO_IDX Q_PATH --> DENSE SWA_KV --> DENSE NO_IDX --> DENSE DENSE --> OPROJ

A5. Lightning Indexer 内部 #

flowchart TB X["x ∈ [b, s, d]"] QR["qr (from wq_a + q_norm)"] subgraph IDX_KV["Indexer 自有 Compressor (c_I=128)"] direction TB IK_WKV["wkv: Linear(d → 2×128)"] IK_WGATE["wgate: Linear(d → 2×128)"] IK_OVERLAP["overlap softmax + weighted sum
m=4 tokens → 1 entry"] IK_NORM["RMSNorm → RoPE(64d)"] IK_HAD["Hadamard rotation (fast_hadamard_transform)"] IK_FP4["FP4 in-place quantize"] IK_CACHE["K^IComp cache [n/4, c_I=128]"] IK_WKV --> IK_WGATE --> IK_OVERLAP --> IK_NORM --> IK_HAD --> IK_FP4 --> IK_CACHE end subgraph IDX_Q["Indexer Query"] direction TB IQ_WQB["wq_b: ColParallel(q_lora → n_h^I × c_I)
= q_lora → 64×128"] IQ_ROPE["RoPE(last 64d)"] IQ_HAD2["Hadamard rotation"] IQ_FP4_2["FP4 in-place quantize"] IQ_WQB --> IQ_ROPE --> IQ_HAD2 --> IQ_FP4_2 end W_PROJ["weights_proj: Linear(d → n_h^I=64)
× softmax_scale × n_heads^{-0.5}"] SCORE["einsum('bshd,btd->bsht', q, K^IComp)
→ ReLU → × weights → sum over heads
→ index_score [b, s, n/4]"] TOPK["top-k selection
k=512 (Flash) / 1024 (Pro)"] OUT["topk_idxs + offset → sparse_attn"] X --> IDX_KV QR --> IDX_Q X --> W_PROJ IDX_KV --> SCORE IDX_Q --> SCORE W_PROJ --> SCORE SCORE --> TOPK --> OUT

A6. mHC — Manifold-Constrained Hyper-Connections #

flowchart LR subgraph HC_PRE["hc_pre (入口: [b,s,4,d] → [b,s,d])"] direction TB P_IN["X ∈ [b, s, hc=4, d]
残差流: 4 copies"] P_FLAT["flatten → [b, s, 4×d]"] P_RSQRT["rsqrt(mean(x²) + eps)
manual RMSNorm"] P_LINEAR["F.linear(x, hc_fn) × rsqrt
hc_fn: [mix_hc=24, 4×d]"] P_SINK["hc_split_sinkhorn(mixes, scale, base, 4, 20, eps)"] P_PRE["pre = σ(Ã) ∈ [b,s,4]
input mixing weights"] P_POST["post = 2σ(C̃) ∈ [b,s,4]
output expansion weights"] P_COMB["comb = Sinkhorn(exp(B̃), 20 iters)
∈ [b,s,4,4] doubly stochastic"] P_SUM["y = Σᵢ pre[i] × X[:,:,i,:]
→ [b, s, d]"] P_IN --> P_FLAT --> P_RSQRT --> P_LINEAR --> P_SINK P_SINK --> P_PRE & P_POST & P_COMB P_PRE --> P_SUM end LAYER["Norm → Attention/MoE
→ output ∈ [b,s,d]"] subgraph HC_POST["hc_post (出口: [b,s,d] → [b,s,4,d])"] direction TB Q_OUT["output ∈ [b,s,d]"] Q_RES["residual ∈ [b,s,4,d]"] Q_EXPAND["Y[i] = post[i]×output
+ Σⱼ comb[i,j]×residual[j]
→ [b, s, 4, d]"] Q_OUT --> Q_EXPAND Q_RES --> Q_EXPAND end HC_PRE --> LAYER --> HC_POST

关键代码-图对照 #

代码构件	对应图	关键实现细节
`Transformer.__init__`	A1	`h = embed(x).unsqueeze(2).repeat(1,1,hc_mult,1)` 创建 4 份副本
`Block.forward`	A2	每个 Block 对 Attn 和 FFN 各做一次 `hc_pre` / `hc_post`
`Attention.forward`	A3/A4	`compress_ratio` 决定层类型: 0=SWA, 4=CSA, 128=HCA
`Compressor.forward`	A3/A4	`overlap = (compress_ratio == 4)`: CSA 有 overlap, HCA 无
`Indexer.forward`	A5	自有 Compressor 用 `rotate=True` (Hadamard) + FP4
`Block.hc_pre/hc_post`	A6	`hc_split_sinkhorn` 是 kernel 调用, 分裂出 pre/post/comb
`Gate.forward`	A2	`sqrtsoftplus = sqrt(softplus(x))`, bias 仅影响选 expert 不影响权重
`Expert.forward`	A2	SwiGLU: `silu(gate)×clamp(up)`, shared expert 无 clamp