DeepSeek-R1：用强化学习激发大语言模型的推理能力

笔记日期： 2026-06-06 笔记作者： Zhongzhu Zhou 论文标题： DeepSeek-R1: Incentivizing Reasoning Capability in LLMs via Reinforcement Learning 作者： DeepSeek-AI（郭大雅、杨德健、张昊威、宋俊晓、王沛义等） arXiv： 2501.12948 状态 / Venue： arXiv 2025-01；发表于 Nature 2026

一句话总结

DeepSeek-R1 证明：只要给大语言模型难题、可靠的验证器和足够的强化学习算力，自我反思、验证与动态策略调整等高阶推理行为会自然涌现，而无需任何人工标注的推理轨迹——训练出的模型在数学和代码竞赛上媲美 OpenAI o1。

前置知识

在读正文之前，以下背景知识会对理解本文非常有帮助：

Transformer 语言模型基础。 预训练 LLM（如 DeepSeek-V3-Base）的本质是一个策略 $\pi_\theta$：给定提示 $q$，输出一个词表上的概率分布，然后采样生成回答序列 $o$。推理任务的目标是让模型在生成 $o$ 的过程中，把思考步骤也写出来（即链式思考，CoT）。

链式思考（Chain-of-Thought，CoT）。 不直接预测最终答案，而是先生成若干中间推理步骤，最后给出结论。已被证实可大幅提升多步推理任务的准确率（Wei et al., 2022）。

监督微调（SFT）。 最经典的后训练方法：给定（问题，正确答案）对，最小化交叉熵损失。效果依赖数据质量，且数据标注代价高昂。

强化学习（RL）基础。 模型是”策略”，输出是”动作”，奖励信号告诉模型做得好不好。RL 的挑战在于奖励稀疏（只在生成完整回答后才能获得奖励）且动作空间巨大（词汇表有数万个词）。

PPO（近端策略优化）。 当前 LLM RL 训练的主流算法。通过裁剪策略比率（clip）保证更新幅度不过大；使用与策略模型同等规模的价值模型（Critic），通过 GAE（广义优势估计）来计算优势。

KL 散度。 衡量新策略 $\pi_\theta$ 与参考策略 $\pi_\text{ref}$ 的差异。RL 训练中用于正则化，防止策略偏离预训练分布太远。

RLHF（人类反馈强化学习）。 训练一个奖励模型来拟合人类偏好，再用 PPO 最大化这个奖励。InstructGPT、ChatGPT 都用了这个范式。

拒绝采样（Rejection Sampling）。 生成多个候选回答，只保留通过某种过滤器（如最终答案正确）的那些，用于 SFT。

一、背景与动机

推理一直是 AI 领域最难啃的骨头之一。过去十年的进展讲述的是一个一致的故事：更多的人工监督带来更好的推理。链式思考提示需要精心设计的少样本示例；OpenAI 的 o1 据报道在人工标注推理轨迹上投入了大量资源。主流假设是：不展示给模型如何推理，模型就学不会推理。

DeepSeek-R1 正面挑战这个假设。它的核心洞见出奇地简单：给模型足够难的题目、可靠的验证器、足够的 RL 算力，推理能力会自然涌现。

这篇论文的三大贡献：

1. DeepSeek-R1-Zero：完全不用 SFT，不用任何人工推理轨迹，纯 RL 训练。自我反思和验证行为从无到有，自然涌现。
2. DeepSeek-R1：通过四阶段流水线修复了 R1-Zero 的可读性和语言混用问题，打造出生产可用的推理模型。
3. DeepSeek-R1-Distill 系列：将 DeepSeek-R1 的推理能力蒸馏进 6 个从 1.5B 到 70B 的开源小模型。

三个关键支撑：（a）强大的底座模型（DeepSeek-V3-Base，671B 总参数，MoE 架构，每 token 激活 37B 参数）；（b）GRPO——一个无需价值模型的 RL 算法，让大规模训练变得可行；（c）数学和代码任务的规则化验证器，提供可靠、防作弊的奖励信号。

二、GRPO：驱动 DeepSeek-R1 的 RL 引擎

2.1 为什么不直接用 PPO？

PPO 用于 LLM 推理训练有三个根本性问题：

问题一：价值模型开销太大。 PPO 需要一个与策略模型同规模的 Critic（价值模型）。对于 671B 的模型，这意味着 GPU 内存和计算量几乎翻倍。

问题二：价值预测在长 CoT 上极其困难。 Critic 需要从部分输出预测最终奖励。但推理链常常会中途自我修正（“等等，我刚才想错了……”），导致从中间状态预测结局几乎不可能。

问题三：PPO 的 per-token KL 惩罚隐式限制了响应长度。 PPO 把 KL 正则项作为每个 token 的密集奖励，响应越长累积的 KL 惩罚越多，这让模型不敢生成长链式思考——恰恰与我们想要的相反。

2.2 GRPO：组相对策略优化

GRPO（Shao et al., 2024）完全去掉了价值模型，用组内相对奖励来估计优势。

算法 1：GRPO 训练循环

输入：基础模型 π_θ_old，训练题目集 Q，奖励函数 R(o, q)
超参：组大小 G=16，裁剪比 ε=10，KL 系数 β=0.001

for 每个训练步:
    1. 从 Q 中采样 32 道唯一题目 {q_1, ..., q_32}
    2. 对每道题 q:
       a. 从当前策略 π_θ_old 采样 G=16 个回答 {o_1, ..., o_G}
       b. 用规则验证器计算奖励 {r_1, ..., r_G}
       c. 计算组内归一化优势：
              A_i = (r_i - mean({r_j})) / std({r_j})
    3. 最大化 GRPO 目标函数 J_GRPO(θ) 来更新策略
    4. 每 400 步：用当前策略替换 π_ref

GRPO 目标函数：

$$\mathcal{J}_\text{GRPO}(\theta) = \mathbb{E}_{q \sim P(Q),\, \{o_i\}_{i=1}^G \sim \pi_{\theta_\text{old}}(O|q)} \left[ \frac{1}{G} \sum_{i=1}^G \left( \min\left( \frac{\pi_\theta(o_i|q)}{\pi_{\theta_\text{old}}(o_i|q)} A_i,\; \text{clip}\!\left(\frac{\pi_\theta(o_i|q)}{\pi_{\theta_\text{old}}(o_i|q)}, 1-\varepsilon, 1+\varepsilon\right) A_i \right) - \beta\, \mathbb{D}_\text{KL}(\pi_\theta \| \pi_\text{ref}) \right) \right] \tag{1}$$

KL 项使用无偏估计量（非 per-token 近似）：

$$\mathbb{D}_\text{KL}(\pi_\theta \| \pi_\text{ref}) = \frac{\pi_\text{ref}(o_i|q)}{\pi_\theta(o_i|q)} - \log \frac{\pi_\text{ref}(o_i|q)}{\pi_\theta(o_i|q)} - 1 \tag{2}$$

优势 $A_i$ 是组内归一化奖励：

$$A_i = \frac{r_i - \text{mean}(\{r_1, r_2, \ldots, r_G\})}{\text{std}(\{r_1, r_2, \ldots, r_G\})} \tag{3}$$

2.3 为什么组内归一化有效？直觉理解

想象一个学生解数学题的过程：不是让老师给每道解答打绝对分数（价值模型做的事），而是比较自己的多份草稿，哪个最好？ 这个相对排名成本低、信息量大。

• 若 G 个输出全错（都得 0 分）：所有 $A_i = 0$，梯度为零，策略不更新——避免了”向错误学习”。
• 若一个输出得 1 分、其余得 0 分：该输出获得大正优势，其余获得小负优势，策略向成功方向更新。

这正是推理任务的正确归纳偏置：多数尝试失败，成功的那个给出强信号。

GRPO 序列级 KL 为何比 PPO per-token KL 更适合长 CoT：

PPO 把 KL 惩罚加在每个 token 上，响应长度为 $L$ 的回答累积 $L \times \beta_\text{PPO} \times \text{KL}$ 的惩罚。推理链越长惩罚越大，隐式阻止模型多想。GRPO 的 KL 对整个序列只算一次，不随长度缩放，让模型自由延长思考。

图 1：PPO vs. GRPO 架构对比

graph LR
    subgraph PPO ["PPO（需要价值模型）"]
        A1[问题 q] --> B1[策略模型]
        B1 --> C1[输出 o]
        C1 --> D1[奖励模型 → r]
        D1 --> E1[价值模型 → v]
        E1 --> F1[GAE → 优势]
        F1 --> G1[Clip + 更新]
        A1 --> H1[参考模型 → per-token KL]
        H1 --> G1
    end
    subgraph GRPO ["GRPO（无价值模型）"]
        A2[问题 q] --> B2[策略模型]
        B2 --> C2["G=16 个输出 {o_1...o_G}"]
        C2 --> D2["奖励 {r_1...r_G}"]
        D2 --> E2["组内归一化 → {A_i}"]
        E2 --> F2[Clip + 序列 KL + 更新]
        A2 --> G2[参考模型 → 序列 KL]
        G2 --> F2
    end
    style GRPO fill:#e8f5e9,stroke:#43a047
    style PPO fill:#fff3e0,stroke:#fb8c00

GRPO 的核心节约：去掉价值模型（节省约 50% 显存和计算量）、避免 GAE 超参数调优（PPO 对 λ 高度敏感）、序列级 KL 不惩罚长度。

三、DeepSeek-R1-Zero：从纯 RL 到推理涌现

3.1 训练设置

DeepSeek-R1-Zero 从 DeepSeek-V3-Base 出发，使用 GRPO 进行纯 RL 训练，零 SFT、零人工推理轨迹。训练提示极简：

“用户和助手之间的对话。助手先在脑中进行推理，再给出答案。推理过程放在 <think>...</think> 标签内，答案放在 <answer>...</answer> 标签内。”

没有示例推理轨迹，没有”如何反思”的模板。只有：给你一道题，展示你的思考过程，给出答案。

3.2 奖励设计

奖励由两个规则化分量组成：

$$R_\text{rule} = R_\text{acc} + R_\text{format} \tag{4}$$

准确奖励（$R_\text{acc}$）： 二元值（0 或 1）。数学题：通过符号匹配（模型需把答案写在方框内）与标准答案对比。代码题：编译程序并运行隐藏测试用例。

格式奖励（$R_\text{format}$）： 对正确使用 <think>...</think> 格式给予小额正奖励。

关键设计选择：不使用神经奖励模型。 神经 RM 容易被策略模型”奖励黑客”——策略学会骗过 RM 而不是真正解题。规则化奖励是客观的、确定的，无法被黑客：答案错了就是错了。

RL 训练数据组成：

数据类型	题目数量	说明
数学	26K	代数、微积分、竞赛题
代码	17K 算法竞赛 + 8K 调试	Codeforces/LeetCode 风格
STEM	22K	物理/化学/生物多选题
逻辑	15K	谜题、逻辑推断
通用	66K	有用性/无害性

3.3 涌现的推理行为

论文最令人惊叹的发现：在没有任何明确指令去反思、验证、探索替代方案的情况下，模型自发地发展出这些行为。

图 2：R1-Zero 训练过程中 AIME 准确率与响应长度的变化

AIME 2024 准确率 (Pass@1)              平均响应长度（token 数）
0.9 ┤                                 20000 ┤
0.8 ┤                  ████            17500 ┤
0.7 ┤              ███                 15000 ┤
0.6 ┤          ███                     12500 ┤
0.5 ┤       ██                         10000 ┤         ██████████
0.4 ┤     ██                            7500 ┤     ████
0.3 ┤   ██                              5000 ┤  ███
0.2 ┤ ██                                2500 ┤██
    0────────────── 训练步数                0───────────── 训练步数
      0   2K  4K  6K  8K  10K               0  2K  4K  6K  8K  10K
   初始 AIME: 15.6%                      初始 ~5K token
   最终: 77.9% (cons@16: 86.7%)          最终 ~17K token

两条曲线在 8.2K 步处都出现跳跃——这正好对应最大输出长度从 32,768 扩大到 65,536 token 的时刻。模型立即利用更长的上下文进行更深入的思考，性能随之跃升。这说明：推理时间（thinking time）直接等价于测试时计算量（test-time compute），模型自发学会了分配更多计算给更难的问题。

“顿悟时刻”（Aha Moment）： 在某个中间检查点，模型开始在解题过程中频繁使用 “Wait” 来自我打断，然后重新审视之前的推导。以下是论文中展示的实际片段（翻译）：

”…我可以再对两边平方，把方程当作… 等等，等等。等一下。这是个我可以在这里标记的顿悟时刻。 让我一步步重新评估…”

这种自我修正不是任何奖励信号直接鼓励的——它涌现是因为自我修正与最终答案正确存在相关性，而 GRPO 奖励正确的最终答案。

3.4 R1-Zero 的性能与问题

成绩： AIME 2024 pass@1 = 77.9%（自洽解码 ×16 可达 86.7%），超过人类数学竞赛参与者的平均水平，与 OpenAI o1-mini 相当。

问题： R1-Zero 存在严重可用性缺陷：

• 语言混用：推理过程有时混合中英文
• 可读性差：原始 CoT 有时语无伦次或重复
• 能力单一：纯推理 RL 对写作、开放域问答等无改善

这些问题催生了 DeepSeek-R1 的四阶段流水线。

四、DeepSeek-R1：四阶段训练流水线

图 3：DeepSeek-R1 完整训练流水线

flowchart TD
    A[DeepSeek-V3-Base] --> B["阶段 0：冷启动 SFT\n（数千条人工对齐长 CoT 示例）"]
    B --> C[R1-Dev1]
    C --> D["阶段 1：第一轮 RL\n（推理提示 + 语言一致性奖励）"]
    D --> E[R1-Dev2]
    E --> F["阶段 2：拒绝采样 + 全量 SFT\n（80 万条：推理 + 通用）"]
    F --> G[R1-Dev3]
    G --> H["阶段 3：第二轮 RL\n（多样化提示：规则奖励 + 模型奖励）"]
    H --> I[DeepSeek-R1]
    I --> J["蒸馏（800K 样本 SFT）"]
    J --> K["Qwen-1.5B / 7B / 14B / 32B\nLlama-8B / 70B"]
    style A fill:#e3f2fd
    style I fill:#e8f5e9,stroke:#43a047,stroke-width:2px
    style K fill:#fff9c4

4.1 阶段 0：冷启动 SFT——教会模型表达格式

R1-Zero 的推理能力强，但表达格式混乱。修复方案：收集少量（数千条）长 CoT 推理链，人工改写成对话式、第一人称的自然风格，然后对 DeepSeek-V3-Base 进行 SFT。

冷启动数据制作流程：

1. 用 R1-Zero 在温度 1.0 下为每道题生成多条推理轨迹
2. 过滤：只保留最终答案正确且格式可读的
3. 请 DeepSeek-V3 将轨迹改写为"自然、第一人称的对话风格"
4. 人工审核，确保质量和语言一致性

改写提示的核心要求：

• 忠实于原始推理过程，不添加新推导步骤
• 用 LaTeX 展示关键步骤，用 \boxed{} 标记最终答案
• 简洁清晰，避免口语化表达

结果是 R1-Dev1：可读性大幅提升，但由于冷启动数据量少，AIME 从 77.9% 降到 59.0%——知识能力上有暂时退步。

4.2 阶段 1：第一轮 RL——推理 + 语言一致性

对 R1-Dev1 用 GRPO 进行 RL 训练，新增语言一致性奖励：

$$R_\text{language} = \frac{\text{Num}(\text{目标语言词汇})}{\text{Num}(\text{所有词汇})} \tag{5}$$

即 CoT 中目标语言（中文或英文，取决于查询语言）词汇的占比。加入这个奖励会轻微降低纯数学性能（语言约束减少了解题方案多样性），但显著改善了可读性。

第一阶段综合奖励：

$$R_\text{阶段1} = R_\text{acc} + R_\text{format} + R_\text{language} \tag{6}$$

训练超参：lr=3e-6，β=0.001，裁剪比 ε=10（远大于 PPO 通常的 0.2——较小的 ε 会截断大量 token 的梯度，降低性能；较大的 ε 保持了梯度流动但需要配合大批量来稳定训练）。

4.3 阶段 2：拒绝采样 + 全量 SFT

阶段 1 后的 R1-Dev2 用于生成大规模 SFT 训练数据集。

算法 2：拒绝采样构建 SFT 数据

输入：R1-Dev2 模型，推理题目集 Q_reasoning，通用题目集 Q_general

对 Q_reasoning 中的每道题（数学/代码/STEM）：
    1. 温度 1.0，生成 16 个回答
    2. 过滤：保留规则验证器验证为正确的
    3. 保留每道题最多 3 个不同的正确解法
    4. 格式清洗：去除重复、修复语言混用

对 Q_general 中的通用查询：
    1. 用 R1-Dev2 生成回答
    2. 用 DeepSeek-V3 偏好模型过滤
    3. 保留排名靠前的回答

最终数据集统计（论文 Table 5）：
    数学：   395,285 条，平均 6,094 token
    代码：   211,129 条，平均 7,436 token
    STEM：    10,124 条，平均 4,929 token
    逻辑：    10,395 条，平均 2,739 token
    通用：   177,812 条，平均 1,420 token
    合计：   804,745 条，平均 5,355 token

这是最数据密集的阶段：80 万条样本，平均 5,355 token/条，合计约 43 亿 token 的 SFT 数据。在 DeepSeek-V3-Base 上微调 2-3 轮，余弦学习率衰减（初始 5×10⁻⁵，最终 5×10⁻⁶），最大上下文长度 32,768 token。

得到 R1-Dev3：推理和通用能力同时强化。

4.4 阶段 3：第二轮 RL——有用性与无害性对齐

最后阶段用 GRPO，混合规则奖励和模型奖励，在多样化提示上训练：

$$R_\text{阶段2} = R_\text{推理} + R_\text{通用} + R_\text{语言} \tag{7}$$ $$R_\text{推理} = R_\text{rule} \quad\text{（数学/代码/STEM）} \tag{8}$$ $$R_\text{通用} = R_\text{RM\_helpful} + R_\text{RM\_safe} \tag{9}$$

有用性奖励模型：用 66,000 条偏好对训练（DeepSeek-V3 生成，arena-hard 格式）。安全奖励模型：用 106,000 条（安全/不安全）标注数据训练。

奖励黑客（Reward Hacking）是真实存在的： 论文图 6 明确展示——用模型奖励训练太多步后，策略学会骗过奖励模型，奖励分数上升，但 Codeforces 实际性能下降。缓解措施：模型奖励只在最后 400 步引入（共 1,700 步），然后停止，避免过度优化。

第二轮 RL 超参：温度降至 0.7（更高温度在此阶段导致生成不连贯），其余与阶段 1 相同。

五、RL 基础设施：让 671B 规模的 RL 训练成为可能

在 671B 参数的模型上跑 RL 是纯工程挑战。论文设计了四模块解耦架构：

图 4：DeepSeek-R1 RL 训练基础设施

flowchart LR
    subgraph Rollout ["🎲 Rollout 模块"]
        R1[加载提示]
        R2["vLLM Workers\n（Actor 模型）"]
        R3["8192 输出\n→ 16 个 mini-batch"]
        R1 --> R2 --> R3
    end
    subgraph Inference ["🔍 推断模块"]
        I1[奖励模型\n前向传播]
        I2[参考模型\nKL 计算]
    end
    subgraph RuleReward ["⚙️ 规则奖励模块（异步）"]
        RR1[代码执行器]
        RR2[答案匹配器]
        RR3[格式检查器]
    end
    subgraph Training ["🏋️ 训练模块"]
        T1[Actor 模型\n（可选 Critic）]
        T2[计算损失\n更新参数]
        T1 --> T2
    end
    Rollout -->|"输出序列"| Inference
    Rollout -->|"输出序列"| RuleReward
    Inference -->|"模型奖励 + KL"| Training
    RuleReward -.->|"与推断模块异步重叠"| Inference
    RuleReward -->|"规则奖励"| Training
    Training -->|"更新后权重"| Rollout
    style Rollout fill:#e3f2fd
    style Training fill:#e8f5e9
    style RuleReward fill:#fff3e0

关键工程设计：

专家并行（Expert Parallelism）for MoE： DeepSeek-V3-Base 是 MoE 架构，Rollout 阶段把不同专家并行分布到多个节点，热门专家（被频繁激活的）设置冗余副本均衡计算。

多 token 预测（MTP）加速 Rollout： MTP 同时预测多个未来 token，在 RL Rollout 阶段充当投机解码（Speculative Decoding），大幅加速最长样本的生成速度。

模块间 VRAM 卸载： 每个模块完成后，自动将模型权重卸载到系统内存或磁盘，释放显存给下一个模块。这样在同一个 GPU 集群上可以交替运行 vLLM Rollout 和梯度更新，无需两套系统。

数据打包（Data Packing）： 按序列长度排序，分配到各数据并行进程，然后在每个进程内用最优适配（Best-Fit）算法打包成定长块，最小化 padding。确保各进程 chunk 数量相等，实现负载均衡。

训练成本（论文 Table 7）：

• DeepSeek-R1-Zero：64×8 张 H800，约 198 GPU 小时/步，总约 101,000 GPU 小时 ≈ 20 万美元（按 2 美元/GPU 小时）
• DeepSeek-R1 额外 RL 阶段：同等集群，约 80 小时，额外约 16 万美元
• SFT 数据制作：约 5,000 GPU 小时 ≈ 1 万美元

六、蒸馏：把推理能力迁移到小模型

令人惊喜的发现：DeepSeek-R1 学到的复杂推理模式，可以通过简单 SFT 蒸馏进规模小得多的模型。

蒸馏方法：在 R1 生成的 800K 数据集上对各小模型微调 2-3 轮。

图 5：蒸馏模型族

graph TB
    subgraph Teacher ["教师模型：DeepSeek-R1（671B）"]
        T1["800K 长 CoT SFT 样本\n（数学、代码、STEM、逻辑、通用）"]
    end
    subgraph Students ["学生模型（仅 SFT，无 RL）"]
        S1["Qwen-1.5B\n(AIME ≈28%)"]
        S2["Qwen-7B\n(AIME ≈55%)"]
        S3["Qwen-14B\n(AIME ≈70%)"]
        S4["Qwen-32B\n(AIME ≈72%)"]
        S5["Llama-8B\n(AIME ≈50%)"]
        S6["Llama-70B\n(AIME ≈70%)"]
    end
    T1 --> S1
    T1 --> S2
    T1 --> S3
    T1 --> S4
    T1 --> S5
    T1 --> S6
    style Teacher fill:#e8f5e9,stroke:#43a047
    style Students fill:#e3f2fd

蒸馏模型	底座	初始学习率
DeepSeek-R1-Distill-Qwen-1.5B	Qwen2.5-Math-1.5B	1×10⁻⁴
DeepSeek-R1-Distill-Qwen-7B	Qwen2.5-Math-7B	8×10⁻⁵
DeepSeek-R1-Distill-Qwen-14B	Qwen2.5-14B	7×10⁻⁵
DeepSeek-R1-Distill-Qwen-32B	Qwen2.5-32B	6×10⁻⁵
DeepSeek-R1-Distill-Llama-8B	Llama-3.1-8B	5×10⁻⁵
DeepSeek-R1-Distill-Llama-70B	Llama-3.3-70B-Instruct	2×10⁻⁵

为什么有效？ 800K SFT 数据集包含了密集的高质量长推理链——比这些小模型底座见过的任何推理数据都要好。蒸馏模型学会了模仿推理风格（长 CoT、自我验证、逐步分解），即使它们本身没有经历任何 RL 训练。

1.5B 的蒸馏模型在 AIME 2024 上仍然达到约 28%——这在一年前对小模型来说属于前沿水准。

七、实验结果

7.1 各阶段性能演变

论文 Table 3 详细展示了四阶段流水线中各中间模型的性能变化，关键发现如下：

冷启动 SFT 损害数学但改善可用性： R1-Zero（77.9% AIME）→ R1-Dev1（59.0%）。AIME 下降，但 IF-Eval 从 46.6% 升到 71.7%，AlpacaEval 从 24.7% 升到 50.1%。冷启动数据带来知识能力的暂时退步，换来了更好的用户体验。

推理 RL（阶段 1）恢复数学性能： R1-Dev2：AIME 回升到 74.0%，LiveCodeBench 从 50.0% 升到 63.5%。推理 RL 主要改善可验证任务，对通用指令跟随影响不大。

全量 SFT（阶段 2）大幅提升通用能力： R1-Dev3 在 Aider-Polyglot（代码工程）上从 25.6% 升到 44.8%，AlpacaEval 从 55.8% 升到 62.1%，归功于大规模通用 SFT 数据。

最终 RL（阶段 3）打磨指令跟随： 最终 DeepSeek-R1 vs R1-Dev3：AlpacaEval 从 62.1% 提升到 87.6%（+25%），ArenaHard 从 75.6% 到 92.3%（+17%）。数学和代码仅有边际改善。

7.2 与前沿模型对比

图 6：DeepSeek-R1 与主要前沿模型的关键指标对比

基准测试              DeepSeek-R1   OpenAI o1-1217  DeepSeek-V3   Claude 3.5
──────────────────────────────────────────────────────────────────────────
AIME 2024 (P@1)         79.8%           79.2%          39.2%          16.0%
MATH-500 (P@1)          97.3%           96.4%          90.2%          78.3%
LiveCodeBench           65.9%           63.4%          40.5%          36.3%
Codeforces 百分位       96.3%           96.6%          58.7%          20.3%
GPQA Diamond            71.5%           75.7%          59.1%          65.0%
MMLU                    90.8%           91.8%          88.5%          88.3%
IFEval                  83.3%           92.8%          87.1%          88.0%
AlpacaEval 2.0          87.6%            —             70.0%          52.0%
──────────────────────────────────────────────────────────────────────────

DeepSeek-R1 在数学和代码推理上基本与 OpenAI o1 持平，甚至在 LiveCodeBench 上略胜（65.9% vs 63.4%）。在指令跟随（IFEval：83.3% vs 92.8%）和事实问答（SimpleQA：30.1% vs 47.0%）上仍有差距。

7.3 “顿悟时刻”现象的深层含义

响应长度随训练步数单调增长，且与 AIME 准确率高度相关——模型自发学会在更难的问题上分配更多计算。这与测试时计算扩展（test-time compute scaling）的人工方法（Best-of-N、MCTS）实现了相似效果，但完全通过学习实现，不需要外部脚手架。

八、局限性与边界条件

8.1 论文承认的局限

语言混用： DeepSeek-R1 针对中英文优化，用其他语言提问可能触发内部用英文或中文推理，根本原因是底座 DeepSeek-V3-Base 的训练数据以中英文为主。

结构化输出和工具调用： R1 的输出是冗长的推理链，对于结构化输出（JSON、特定接口代码）或工具调用（搜索、计算器），性能不如指令跟随模型。

提示敏感性： 零样本（zero-shot）下性能最优；添加少样本（few-shot）示例反而一致降低性能——模型的 CoT 推理风格被上下文示例所干扰。

过度思考（Overthinking）： 简单问题也有时会生成极长的推理链。动态分配是从训练数据分布中学到的；若简单问题在训练集中较少，模型就无法学会对简单问题保持简洁。

软件工程任务： R1 在 SWE-Bench 上仅比 DeepSeek-V3 略好（49.2% vs 48.8%）。原因：运行完整测试套件速度太慢，难以集成到 RL 训练循环中。

九、批判性分析：不足与可改进之处

不好的地方

W1：AIME 数据污染风险未完全排除。 AIME 2024 只有 30 道题，来自特定竞赛。DeepSeek-V3-Base 的预训练数据包含大量数学竞赛内容，直到某个截止时间。论文虽做了污染检查，但不确定性依然存在。79.8% 的 AIME pass@1 是惊人的成绩——但若底座模型在预训练中见过这些题目的变体，则测试意义大打折扣。最重要的缺失实验：在训练截止后新出现的竞赛上测试（如 AIME 2025、IMO 2025 入围题），以验证真实的泛化能力。

W2：冷启动数据和 800K SFT 数据均未公开——可复现性存在根本性缺口。 没有冷启动人工标注数据，完整的 DeepSeek-R1 流水线无法复现。蒸馏训练数据也未公开，社区无法独立研究是数据质量、数量还是底座模型能力才是蒸馏成功的关键驱动因素。论文的开放程度仅限于模型权重，而非完整的训练流程。

W3：奖励黑客缓解方案是经验性的，非原则性的。 论文通过”少用模型奖励步数”来缓解奖励黑客，本质上是”在问题变严重之前停下”。更系统的方案应是：奖励模型不确定性量化、集成多个独立归纳偏置的奖励模型、或过程奖励模型（PRM）逐步评分每个推理步骤的质量。论文没有与这些替代方案做对比。

W4：非推理任务的能力差距缺乏系统分析。 IFEval 上与 o1 差 9 个百分点（83.3% vs 92.8%），SimpleQA 上差 17 个百分点（30.1% vs 47.0%）。论文将此归因于”推理优化型训练流水线”，但没有消融实验指出哪个阶段造成了这个差距，也没有提出弥补路径。

作者淡化或回避的局限

L1：过度思考的实际部署成本被轻描淡写。 在简单问题上生成 1 万个 token 的推理链，对延迟、API 成本、硬件利用率都有实际影响。论文仅在”局限性”一节一笔带过，没有定量评估过度思考的频率和成本，也没有分析蒸馏模型（最可能在实际部署中使用的版本）的过度思考程度。

L2：单轮推理局限未被充分讨论。 表 5 显示 99.7% 的 SFT 数据是单轮对话（平均 1.0 轮）。现实推理任务往往需要多轮交互——澄清疑问、获得部分信息、迭代修正。DeepSeek-R1 在单次推理上令人印象深刻，但在多轮对话场景下的能力退化没有被评估。

可以改进的地方

I1：过程奖励模型（PRM）以改善验证质量。 “Wait, wait. Wait.” 式的自我修正是自发涌现的，但无法区分”有价值的修正”（发现了真实错误）和”虚假的修正”（把正确的推导改错了）。引入逐步评分推理步骤质量的 PRM，可以让验证更精准，潜在减少过度思考。

I2：更细粒度的语言一致性奖励。 当前的 $R_\text{language}$ 对所有跨语言词汇均等惩罚。但代码（def compute_loss(...)）、数学符号（$\nabla_\theta$）和技术术语本质上是语言中性的。针对跨语言自然语言词汇（而非代码和 LaTeX）设计的 LC 奖励会更精准，减少对代码生成能力的干扰。

I3：蒸馏数据配方的系统性研究。 论文展示了 800K 的 R1 生成样本足以蒸馏推理能力，但没有给出缩放律实验：800K 是最优数据量吗？数据类型比例是最优的吗？将 R1 生成数据与原始 SFT 数据混合是否能在适度降低推理性能的代价下提升通用能力？这些蒸馏数据配方研究对社区意义重大，是本文的明显空白。

十、结语

DeepSeek-R1 是一篇里程碑式的工作，从根本上改变了我们对 LLM 推理涌现机制的理解。核心发现——自我反思、验证和动态计算分配可以从结果导向的 RL 中自然涌现——深刻挑战了”推理必须由人来教”的主流假设。

GRPO 算法使这一切在技术上可行：去掉价值模型（节省约一半的显存和计算），用序列级 KL 代替 per-token KL（不惩罚长思维链），让百亿级模型的 RL 训练从理论可能变为工程现实。

蒸馏结果同样意义深远：1.5B 的小模型通过 SFT 就能达到前沿级数学性能，说明训练数据的质量和格式，而非单纯的模型参数量，才是这类推理任务的关键瓶颈。

对于实践者，最直接的启示是：如果你的任务有可靠的验证器、有强大的底座模型、有充足的计算资源，纯 RL 可能比精心标注的 SFT 在推理提升上更有效。向模型逐步解释每个推理步骤的时代，可能已经过去。

复现要点

• 模型权重： DeepSeek-R1 系列（6 个蒸馏模型 + R1 + R1-Zero）已开源，见 https://huggingface.co/deepseek-ai
• 底座模型： DeepSeek-V3-Base（671B，37B 激活，MoE）。预训练数据：14.8T token，以中英文网页和电子书为主。
• GRPO 实现： 已有开源实现（OpenRLHF、verl、TRL）。关键超参：G=16，ε=10，β=0.001，lr=3e-6，最大输出长度 32K→64K。
• 数据： 800K 拒绝采样 SFT 数据集未公开。社区近似替代品：OpenThoughts、Sky-T1 数据集。
• 计算成本： R1-Zero：约 10.1 万 GPU 小时（≈ 20 万美元）；完整 R1 流水线估计超过 40 万美元。
• 可复现性缺口： 无冷启动数据和奖励模型细节，完整流水线无法复现。R1-Zero 风格训练（纯 RL）已被社区成功复现（如 Sky-T1、OpenR1、STILL-3）。

如果我来扩展这项工作

如果要在 DeepSeek-R1 的基础上进一步推进，我会重点考虑三个方向：

1. 多阶段过程奖励模型（Multi-stage PRM）： 在 R1 的拒绝采样数据上训练一个 PRM，对推理链中每一步（而不仅仅是最终答案）评分。用这个 PRM 替代或补充现有的规则验证器，使 RL 信号更细粒度，理论上可以减少”最终答案正确但推理过程有缺陷”的情况。

2. 多轮推理 RL： 当前 800K SFT 数据 99.7% 是单轮。设计多轮推理场景（如：第一轮给出思路，第二轮根据用户追问深化某步推导），把 GRPO 应用于多轮对话，可能大幅提升在真实用户交互场景下的推理质量。

3. 效率-推理 Pareto 前沿研究： 训练一个辅助分类器来预测问题难度（如：一步可解、三步可解、需要深度探索），然后以此为依据动态分配最大输出长度。这样在保持高难度问题推理质量的同时，大幅减少简单问题的过度思考，降低推理延迟和成本。

延伸阅读

• GRPO 原始论文：Shao et al., 2024 — “DeepSeekMath: Pushing the Limits of Mathematical Reasoning in Open Language Models”
• PPO：Schulman et al., 2017 — “Proximal Policy Optimization Algorithms”
• DeepSeek-V3：DeepSeek-AI, 2024 — 本文使用的底座模型
• 过程奖励模型（PRM）：Lightman et al., 2023 — “Let’s Verify Step by Step”
• OpenR1：Hugging Face 对 DeepSeek-R1 训练流程的开源复现
• REINFORCE++：进一步稳定 GRPO 的工作，见 Hu et al., 2025（arXiv 2501.03262）

附录 E：各训练阶段关键超参数汇总

作为参考，以下是 DeepSeek-R1 完整训练流水线所有阶段的关键超参数：

阶段 0 — 冷启动 SFT：

参数	值
底座模型	DeepSeek-V3-Base（671B，37B 激活，MoE）
数据集规模	数千条精心策划的样本
学习率	余弦衰减，5×10⁻⁵ → 5×10⁻⁶
最大序列长度	32,768 token
批大小	128
训练轮数	2-3 轮

阶段 1 — 第一轮 RL（推理提示 GRPO）：

参数	值
算法	GRPO
学习率	3e-6
KL 系数 β	0.001
裁剪比 ε	10（远大于 PPO 通常的 0.1-0.2！）
组大小 G	16
采样温度	1.0
最大输出长度	32,768 → 65,536 token（8.2K 步处扩展）
每步批大小	32 题 × 16 输出 = 512
参考策略刷新	每 400 步
总步数	约 10,400 步（R1-Zero）

阶段 2 — 拒绝采样 + 全量 SFT：

参数	值
数据集规模	约 800K 条
每样本平均 token	约 5,355
学习率	余弦衰减，5×10⁻⁵ → 5×10⁻⁶
最大序列长度	32,768 token
批大小	128
训练轮数	2-3 轮

阶段 3 — 第二轮 RL（多样化提示 GRPO）：

参数	值
算法	GRPO
学习率	3e-6
KL 系数 β	0.001
采样温度	0.7（从阶段 1 的 1.0 降低！）
总步数	1,700 步
模型奖励引入	仅最后 400 步

蒸馏：

参数	值
数据集	800K 条 R1 生成的拒绝采样 SFT 数据
学习率	模型相关（1.5B 为 1×10⁻⁴，70B 为 2×10⁻⁵）
LR 调度	余弦衰减至初始值的 1/10
最大序列长度	32,768 token
批大小	64
训练轮数	2-3 轮

特别值得注意的超参数：裁剪比 ε = 10。 在标准 PPO 实现中，ε 通常为 0.1-0.2。小 ε 会激进地裁剪策略比率，防止大幅参数更新，但同时也会截断长推理序列中大量 token 的梯度。对于一条 10,000 token 的响应，小 ε 意味着绝大多数 token 的梯度被清零——策略无法从长响应中有效学习。DeepSeek 团队发现，ε = 10 对于长输出的推理训练是必要的，实际上相当于取消裁剪约束，转而依靠 KL 项来保持训练稳定性。

附录 A：GRPO 与 PPO 的深入数学对比

A.1 PPO 目标函数与 GAE

PPO 的策略梯度目标是：

$$\mathcal{J}_\text{PPO}(\theta) = \mathbb{E}_{t} \left[ \min\left( r_t(\theta) \hat{A}_t,\; \text{clip}(r_t(\theta), 1-\varepsilon, 1+\varepsilon) \hat{A}_t \right) - \beta_\text{PPO} \cdot \text{KL}_t \right] \tag{A1}$$

其中 $r_t(\theta) = \pi_\theta(a_t|s_t) / \pi_{\theta_\text{old}}(a_t|s_t)$ 是 token 级别的重要性采样比率，$\text{KL}_t$ 是以密集奖励形式加在每个 token 上的 KL 惩罚。

优势 $\hat{A}_t$ 通过 GAE（广义优势估计）计算：

$$\hat{A}_t = \sum_{l=0}^{\infty} (\gamma \lambda)^l \delta_{t+l}, \quad \delta_t = r_t + \gamma V(s_{t+1}) - V(s_t) \tag{A2}$$

其中 $V(s)$ 是价值函数（Critic），$\lambda \in [0,1]$ 是 GAE 轨迹衰减参数，$\delta_t$ 是单步 TD 误差。

PPO 对 $\lambda$ 的高度敏感性是实际训练中的主要痛点：论文实验表明，用默认值 $\lambda=0.95$ 时 PPO 显著差于 GRPO；仔细调优到 $\lambda=1.0$ 才能追上 GRPO 性能，但此时优势估计退化为 Monte Carlo 回报，失去了 GAE 原本的方差-偏差权衡优势。

A.2 GRPO 的无价值模型优势估计

GRPO 用组内归一化直接替代价值模型：

$$A_i = \frac{r_i - \mu_r}{\sigma_r}, \quad \mu_r = \frac{1}{G}\sum_{j=1}^G r_j, \quad \sigma_r = \sqrt{\frac{1}{G}\sum_{j=1}^G (r_j - \mu_r)^2} \tag{A3}$$

关键性质：

• 尺度不变性：归一化优势对奖励的绝对量级不敏感。
• 组内竞争：同组中”最好”的输出始终获得正优势，“最差”的始终获得负优势——即使全组都正确（$r_i = 1$ 均等），方差为零，所有 $A_i = 0$，梯度消失，策略不在已会的题上浪费计算。
• 内存效率：无价值模型、无 Critic 优化器状态，参数量约减少 50%。

A.3 KL 散度的计算差异

PPO 将 KL 加在每个 token 上：

$$\text{PPO 第 t 个 token 的奖励：} r_t + \left(-\beta_\text{PPO} \cdot \log \frac{\pi_\theta(a_t|s_t)}{\pi_\text{ref}(a_t|s_t)}\right) \tag{A4}$$

由于 RL 最大化累积奖励 $\sum_t r_t$，每个 token 都贡献 $-\beta_\text{PPO} \cdot \text{KL}_t$ 的惩罚，长度为 $L$ 的响应累积总 KL 成本为：

$$\text{总 KL 成本（PPO）} = \beta_\text{PPO} \cdot \sum_{t=1}^{L} \text{KL}_t \approx \beta_\text{PPO} \cdot L \cdot \overline{\text{KL}} \tag{A5}$$

这与响应长度 $L$ 线性增长。更长的推理链受到更多惩罚——PPO 隐式阻止模型多思考。

GRPO 用无偏估计量在序列级别计算 KL：

$$D_\text{KL}(\pi_\theta \| \pi_\text{ref}) \approx \frac{\pi_\text{ref}(o_i|q)}{\pi_\theta(o_i|q)} - \log \frac{\pi_\text{ref}(o_i|q)}{\pi_\theta(o_i|q)} - 1 \tag{A6}$$

这个表达式对每个序列只算一次，加入 GRPO 目标中。它不随序列长度缩放，让模型可以自由生成长推理链而不累积额外正则化惩罚。

A.4 定期刷新参考策略

DeepSeek-R1 的 GRPO 训练中有个关键细节：参考策略 $\pi_\text{ref}$ 每 400 步更新一次，与当前策略 $\pi_\theta$ 保持同步。

这意味着：不要求训练策略永远靠近最初的预训练模型，只要求在任意 400 步窗口内不发生过大的跳变。经过数千步训练，策略可以从初始检查点漂移很远——对于预训练 base 模型 AIME 准确率只有约 15.6% 的场景，这种”漂移”恰恰是必要的。如果参考策略固定不变，随着训练策略不断进化，KL 惩罚会越来越大，逐渐扼杀 RL 信号。

附录 B：冷启动数据管道的详细步骤

冷启动 SFT 数据是 DeepSeek-R1 流水线中最容易被忽视的环节，却是将 R1-Zero 强大但混乱的推理转化为 R1 精致风格的关键。

步骤 1：种子问题收集。 从数学竞赛（AMC、AIME、数学奥林匹克）、编程竞赛（Codeforces、AtCoder）和 STEM 题库中收集数千道高质量推理题。

步骤 2：用 R1-Zero 高温采样。 对每道题在温度 1.0 下生成 10-20 条推理轨迹。高温鼓励多样化推理策略，提升至少有一条轨迹找到正确方法的概率。

步骤 3：按正确性和格式过滤。 只保留满足以下条件的轨迹：

• 最终答案与标准答案一致（符号数学解析器或代码执行验证）
• 不含过度重复（重复检测过滤器）
• 语言混用不超过阈值（LC 过滤器）

步骤 4：人工改写风格。 接受的轨迹交给人工标注员改写为：

• 第一人称视角（“我注意到……”、“让我重新考虑……”）
• 清晰连贯的段落推理
• 数学公式用 LaTeX，代码用代码块
• 全程语言一致

步骤 5：用 LLM 扩充数量。 人工改写的示例作为提示喂给 DeepSeek-V3，让它按同样的风格生成更多示例，将数据量从数百扩充到数千。

步骤 6：人工二次审核。 对 LLM 生成的数据进行第二轮人工质检，检查正确性、风格一致性和自然度。

最终结果：每个训练样本都展示了（a）一道难题、（b）一段长的、自我反思的、第一人称的推理过程、（c）明确的验证步骤、（d）正确的、用方框标注的最终答案。这是 DeepSeek-R1 与用户建立的基本沟通契约。

附录 C：测试时计算扩展——DeepSeek-R1 在哪个维度上的扩展策略？

DeepSeek-R1 的动态思考时间分配，与更广泛的**测试时计算扩展（test-time compute scaling）**研究紧密相连。

计算分配方式的连续谱：

静态推理                                              动态推理
──────────────────────────────────────────────────────────────►
  单次前向传播  →  Best-of-N  →  MCTS           →  R1 风格 CoT
  （贪婪解码）    （并行）      （顺序，树搜索）   （顺序，学习到的）
  计算量：1x     计算量：Nx    计算量：O(深度×分支)  计算量：自学习
  额外开销：0    额外开销：N次  额外开销：树结构     额外开销：训练成本

R1 方式的优势：

1. 无外部脚手架： Best-of-N 需要 N 次完整前向传播；MCTS 需要构建和导航树结构；R1 的 CoT 只是生成 token，发生在单次前向传播内。

2. 自适应分配： R1 自动为更难的问题生成更多 token（训练曲线已证明）。简单问题可能 500 token，奥数题可能 10,000 token。Best-of-N 对所有输入使用相同计算量。

3. 缩放律： 从图 2 可见，平均响应长度随训练步数近似线性增长，紧跟 AIME 准确率曲线。这说明投入在 RL 训练上的算力会在推理质量上得到回报。

开放问题： 在什么难度级别上，R1 风格的 CoT 会触及 MCTS（原则性树搜索）不会触及的天花板？这是下一代推理模型最重要的开放问题之一，但论文没有直接讨论。

附录 D：这篇论文为何改变了 LLM 强化学习的格局

在 DeepSeek-R1 之前，LLM 强化学习的主流叙事是：

1. RL 只在经过良好 SFT 初始化之后才有用（RLHF 范式）
2. 人类偏好数据对 RL 训练必不可少
3. 奖励信号定义了模型能力的上限

DeepSeek-R1-Zero 对这三点逐一反驳：

1. SFT 不是必需的——RL 单独可以从 base 模型中自举推理能力
2. 对于推理过程，人类反馈可以被规则化验证器完全替代
3. 能力上限由底座模型的潜在知识决定，RL 只是解锁它的钥匙

关键洞见：DeepSeek-V3-Base 已经”知道”如何做数学了——它在 14.8T token 的数据上预训练，其中包含大量数学和代码内容。RL 做的是找到激发协议（elicitation protocol）：能让模型的潜在知识被正确表达出来的响应格式和策略。人工推理轨迹的 SFT 提供一种激发协议，但受人类思维模式的约束。RL 自主探索出可能更优的协议。

这重塑了推理模型开发的思路：瓶颈不再是”如何让人类写出正确的推理轨迹？“，而是”我是否有潜在知识足够丰富的底座模型，以及对我的任务可靠的验证器？“如果答案是肯定的，RL 可能是比 SFT 更好的推理提升路径。

对中国 AI 社区的启示： 这种方法的计算成本大约是 20 万美元起步（R1-Zero），对于有 GPU 资源的实验室来说是可及的。更重要的是，它表明开源的方式也能追赶甚至在某些方面超越闭源的前沿模型，极大地降低了社区复现和改进的门槛。

对后续研究的启示： 接下来最值得研究的方向是把这套方法推广到”没有可靠规则验证器”的任务。写作质量、代码优雅度、开放域事实准确性——这些无法用规则判断正误的能力，是纯 RL 方法目前还无法触及的领域。过程奖励模型（PRM）、多模型投票、以及基于大模型评判（LLM-as-Judge）的奖励设计，将是突破这一限制的下一个战场。DeepSeek-R1 为我们展示了”验证器存在”时强化学习的威力，而探索”验证器不存在”时的 RL 扩展之道，将是未来数年 AI 领域最重要的研究课题之一。