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

摘要

通用推理是人工智能领域长期存在且艰巨的挑战。以大语言模型（LLMs）（Brown 等人，2020；OpenAI，2023）和思维链提示（Wei 等人，2022b）为代表的近期突破，在基础推理任务上取得了相当大的成功。然而，这种成功在很大程度上依赖于大量的人工标注演示，且模型的能力对于更复杂的问题仍然不足。在此，我们展示了可以通过纯强化学习（RL）来激发大语言模型的推理能力，从而无需人工标注的推理轨迹。所提出的强化学习框架促进了高级推理模式的涌现，例如自我反思、验证和动态策略调整。因此，训练后的模型在数学、编程竞赛和 STEM 领域等可验证任务上取得了优异的性能，超越了通过传统监督学习在人工演示上训练的同类模型。此外，这些大规模模型所展现出的涌现推理模式可以被系统地利用，以指导和增强较小模型的推理能力。

1. 引言

推理能力是人类智能的基石，它支持从数学问题求解到逻辑推演和编程等复杂的认知任务。人工智能的最新进展表明，当大语言模型（LLMs）扩展到足够的规模时，可以表现出涌现行为，包括推理能力（Kaplan 等人，2020；Wei 等人，2022a）。然而，在预训练中实现这种能力通常需要大量的计算资源。与此同时，一项互补的研究表明，大语言模型可以通过思维链（CoT）提示得到有效增强。这种技术涉及提供精心设计的少样本示例，或使用诸如“让我们一步步思考”（Kojima 等人，2022；Wei 等人，2022b）之类的极简提示，使模型能够产生中间推理步骤，从而显著提高其在复杂任务上的性能。同样，当模型在训练后阶段学习高质量、多步推理轨迹时，也观察到了进一步的性能提升（Chung 等人，2024；OpenAI，2023）。尽管这些方法很有效，但它们存在明显的局限性。它们对人工标注推理轨迹的依赖阻碍了可扩展性，并引入了认知偏差。此外，通过限制模型复制人类思维过程，其性能本质上受到人类提供的示例的上限限制，这阻碍了对更优越、非人类推理路径的探索。

为了解决这些问题，我们旨在探索大语言模型在强化学习框架中通过自我进化发展推理能力的潜力，并尽量减少对人工标注工作的依赖。具体而言，我们基于 DeepSeek-V3-Base（DeepSeek-AI，2024b），并采用组相对策略优化（GRPO）（Shao 等人，2024）作为我们的强化学习框架。奖励信号仅基于最终预测与真实答案的正确性，而不对推理过程本身施加约束。值得注意的是，我们在强化学习训练之前绕过了传统的监督微调（SFT）阶段。这一设计选择源于我们的假设：人类定义的推理模式可能会限制模型探索，而无限制的强化学习训练可以更好地激发大语言模型中新颖推理能力的涌现。通过这一过程（详见第 2 节），我们的模型（称为 DeepSeek-R1-Zero）自然地发展出了多样化且复杂的推理行为。在解决推理问题时，模型倾向于生成更长的回答，并在每个回答中结合验证、反思和对替代方法的探索。尽管我们没有明确教导模型如何推理，但它通过强化学习成功地学习到了改进的推理策略。

尽管 DeepSeek-R1-Zero 展示了出色的推理能力，但它面临着可读性差和语言混合等挑战，有时会在单个思维链回答中混合使用英语和中文。此外，DeepSeek-R1-Zero 基于规则的强化学习训练阶段狭隘地专注于推理任务，导致其在写作和开放域问答等更广泛领域的性能有限。为了解决这些挑战，我们引入了 DeepSeek-R1，这是一个通过多阶段学习框架训练的模型，该框架集成了拒绝采样、强化学习和监督微调，详见第 3 节。这一训练流水线使 DeepSeek-R1 能够继承其前身 DeepSeek-R1-Zero 的推理能力，同时通过额外的非推理数据使模型行为与人类偏好保持一致。

为了以更低的能源成本实现对强大人工智能的更广泛访问，我们蒸馏了几个较小的模型并将其公开。这些蒸馏模型表现出强大的推理能力，超越了其原始指令微调同类模型的性能。我们相信，这些指令微调版本也将通过提供宝贵的资源，帮助研究界理解长思维链（CoT）推理模型背后的机制，并促进更强大的推理模型的开发。我们将 DeepSeek-R1 系列模型发布在 https://huggingface.co/deepseek-ai。

2. DeepSeek-R1-Zero

我们首先详细阐述 DeepSeek-R1-Zero 的训练，它完全依赖于强化学习，无需监督微调。为了促进大规模强化学习的效率，我们采用了组相对策略优化（GRPO）（Shao 等人，2024）。

2.1. 组相对策略优化

GRPO（Shao 等人，2024）是我们采用的用于训练 DeepSeek-R1-Zero 和 DeepSeek-R1 的强化学习算法。它最初是为了简化训练过程并减少近端策略优化（PPO）（Schulman 等人，2017）的资源消耗而提出的，PPO 广泛用于大语言模型的强化学习阶段（Ouyang 等人，2022）。

对于每个问题 $q$ ，GRPO 从旧策略 $\pi_{\theta_{\text{old}}}$ 中采样一组输出 $\{o_1, o_2, \dots, o_G\}$ ，然后通过最大化以下目标来优化策略模型 $\pi_\theta$ ：

\mathcal{J}_{\text{GRPO}}(\theta) = \mathbb{E}[q \sim P(Q), \{o_i\}_{i=1}^G \sim \pi_{\theta_{\text{old}}}(o|q)] \\ \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 - \epsilon, 1 + \epsilon \right) A_i \right) - \beta D_{\text{KL}} (\pi_\theta || \pi_{\text{ref}}) \right), \tag{1}

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}

其中 $\pi_{\text{ref}}$ 是参考策略， $\epsilon$ 和 $\beta$ 是超参数， $A_i$ 是优势，使用对应于每组中输出的一组奖励 $\{r_1, r_2, \dots, r_G\}$ 计算得出：

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

我们在补充材料 A.3 中对 GRPO 和 PPO 进行了比较。为了训练 DeepSeek-R1-Zero，我们将学习率设置为 3e-6，KL 系数设置为 0.001，采样温度设置为 1 以进行 rollout。对于每个问题，我们在 8.2k 步之前采样 16 个输出，最大长度为 32,768 个 token，之后为 65,536 个 token。结果，DeepSeek-R1-Zero 的性能和响应长度在 8.2k 步时均出现显著跳跃，训练持续了总共 10,400 步，对应于 1.6 个训练 epoch。每个训练步骤包含 32 个独特的问题，导致训练批次大小为 512。每 400 步，我们用最新的策略模型替换参考模型。为了加速训练，每个 rollout 生成 8,192 个输出，这些输出被随机分成 16 个小批次，并且仅训练单个内部 epoch。

| 表 1 | DeepSeek-R1-Zero 的模板。训练期间 prompt 将被替换为具体的推理问题。 | | :--- | | 用户和助手之间的对话。用户提出一个问题，助手解决它。助手首先在脑海中思考推理过程，然后向用户提供答案。推理过程和答案分别包含在 <think>...</think> 和 <answer>...</answer> 标签中，即 <think> 此处为推理过程 </think> <answer> 此处为答案 </answer>。用户：prompt。助手： |

我们的高性能强化学习基础设施在补充材料 B.1 中进行了描述，确保了可扩展且高效的训练。

2.2. 奖励设计

奖励是训练信号的来源，它决定了强化学习优化的方向。对于 DeepSeek-R1-Zero，我们采用基于规则的奖励，为数学、编程和逻辑推理领域的数据提供精确的反馈。我们的基于规则的奖励系统主要由两种类型的奖励组成：准确性奖励和格式奖励。

准确性奖励评估回答是否正确。例如，在具有确定性结果的数学问题中，要求模型以指定格式（例如，在方框内）提供最终答案，从而实现可靠的基于规则的正确性验证。同样，对于编程竞赛提示，可以使用编译器来评估模型的回答是否符合一组预定义的测试用例，从而生成关于正确性的客观反馈。

格式奖励通过强制执行特定的格式要求来补充准确性奖励模型。特别是，模型被激励将其推理过程封装在指定的标签内，具体为 <think> 和 </think>。这确保了模型的思维过程被明确界定，增强了可解释性并促进了后续分析。

\text{Reward}_{\text{rule}} = \text{Reward}_{\text{acc}} + \text{Reward}_{\text{format}} \tag{4}

准确性奖励和格式奖励以相同的权重组合。值得注意的是，我们避免在推理任务中应用神经奖励模型——无论是基于结果还是基于过程的。这一决定基于我们的观察，即神经奖励模型在进行大规模强化学习时容易受到奖励黑客攻击（reward hacking）。此外，重新训练此类模型需要大量的计算资源，并引入了额外的复杂性到训练流水线中，从而使整体优化过程复杂化。

2.3. 激发大语言模型的推理能力

具体而言，我们将强化学习技术应用于 DeepSeek-V3 基础模型来训练 DeepSeek-R1-Zero。在训练期间，我们设计了一个简单的模板，要求 DeepSeek-R1-Zero 首先产生推理过程，然后是最终答案。我们有意将约束限制在这个结构格式上，避免任何特定于内容的偏差，以确保我们能够准确观察模型在强化学习过程中的自然进展。

图 1(a) 描绘了 DeepSeek-R1-Zero 在强化学习训练过程中在 AIME 2024 基准测试上的性能轨迹，其中 AIME 2024 的平均 pass@1 分数显示出显著增长，从最初的 15.6% 跳升至 77.9%。此外，通过利用自洽解码（Wang 等人，2023c），模型的性能可以进一步提高，达到 86.7% 的准确率。这一性能显著超过了所有人类竞争者的平均水平。除了数学竞赛，如图 10 所示，DeepSeek-R1-Zero 在编程竞赛以及研究生水平的生物学、物理学和化学问题上也取得了显著的性能。这些结果强调了强化学习在增强大语言模型推理能力方面的有效性。

DeepSeek-R1-Zero 的自我进化证明了强化学习如何能够自主增强模型的推理能力。

如图 1(b) 所示，DeepSeek-R1-Zero 在整个训练过程中表现出思维时间的稳步增加，这完全是由内在适应而非外部修改驱动的。利用长思维链（CoT），模型逐步完善其推理，生成数百到数千个 token 来探索和改进其问题解决策略。

思维时间的增加促进了复杂行为的自主发展。具体而言，DeepSeek-R1-Zero 越来越多地表现出高级推理策略，例如反思性推理和对替代解决方案的系统性探索（详见补充材料 C.2 中的图 9(a)），显著提高了其在数学和编程等可验证任务上的性能。值得注意的是，在训练期间，DeepSeek-R1-Zero 表现出了一个“顿悟时刻”（表 2），其特征是在反思过程中对“wait”一词的使用突然增加（详见补充材料 C.2 中的图 9(b)）。这一时刻标志着推理模式的明显变化，并清楚地展示了 DeepSeek-R1-Zero 的自我进化过程。

DeepSeek-R1-Zero 的自我进化强调了强化学习的力量和美感：我们不是明确地教导模型如何解决问题，而是简单地为它提供正确的激励，它就会自主发展出高级的问题解决策略。这提醒我们，强化学习有潜力解锁大语言模型更高水平的能力，为未来更自主和自适应的模型铺平道路。

3. DeepSeek-R1

尽管 DeepSeek-R1-Zero 展示了强大的推理能力，但它面临着几个问题。DeepSeek-R1-Zero 在可读性差和语言混合方面存在挑战，因为 DeepSeek-V3-Base 是在多种语言上训练的，特别是英语和中文。为了解决这些问题，我们开发了 DeepSeek-R1，其流水线如图 2 所示。

在初始阶段，我们收集了数千条展示对话式、符合人类思维过程的冷启动数据。然后应用强化学习训练，以提高模型在对话思维过程和语言一致性方面的性能。随后，我们再次应用拒绝采样和监督微调（SFT）。这一阶段将推理和非推理数据集纳入 SFT 过程，使模型不仅在推理任务中表现出色，而且展示了高级的写作能力。为了进一步使模型行为与人类偏好保持一致，我们实施了第二个强化学习阶段，旨在增强模型的有用性和无害性，同时完善其推理能力。

本节的其余部分详细介绍了该流水线的关键组件：第 3.1 节介绍了我们在强化学习阶段使用的奖励模型，第 3.2 节阐述了具体的训练方法和实施细节。我们在该阶段使用的数据在补充材料 B.3 中有详细说明。

3.1. 基于模型的奖励

对于一般数据，我们求助于奖励模型来捕捉复杂和细微场景下的人类偏好。我们基于 DeepSeek-V3 流水线，并采用类似的偏好对和训练提示分布。对于有用性，我们专门关注最终总结，确保评估强调回答对用户的效用和相关性，同时最大限度地减少对底层推理过程的干扰。对于无害性，我们评估模型的整个回答，包括推理过程和总结，以识别和减轻可能产生的任何潜在风险、偏见或有害内容。

有用奖励模型关于有用奖励模型的训练，我们首先通过使用 arena-hard 提示格式（列于补充材料 B.2）提示 DeepSeek-V3 来生成偏好对，其中每对由一个用户查询和两个候选回答组成。对于每个偏好对，我们查询 DeepSeek-V3 四次，随机将回答分配为回答 A 或回答 B，以减轻位置偏差。最终偏好分数是通过平均四次独立判断确定的，仅保留分数差异（ $\Delta$ ）超过 1 的对，以确保有意义的区分。此外，为了最大限度地减少与长度相关的偏差，我们确保整个数据集的被选择和被拒绝回答具有可比的长度。总共，我们策划了 66,000 个数据对用于训练奖励模型。此数据集中的提示均为非推理问题，来源于公开的开源数据集或明确同意共享其数据以用于模型改进的用户。我们的奖励模型架构与 DeepSeek-R1 一致，并增加了旨在预测标量偏好分数的奖励头。

\text{Reward}_{\text{helpful}} = \text{RM}_{\text{helpful}}(\text{Response}_A, \text{Response}_B) \tag{5}

有用奖励模型使用 256 的批次大小、6e-6 的学习率在训练数据集上进行了单个 epoch 的训练。训练期间的最大序列长度设置为 8192 个 token，而在奖励模型推理期间没有施加明确的限制。

安全奖励模型为了评估和提高模型安全性，我们策划了一个包含 106,000 个提示的数据集，其中模型生成的回答根据预定义的安全准则被标注为“安全”或“不安全”。与有用性奖励模型中采用的成对损失不同，安全奖励模型使用点对点方法来区分安全和不安全回答。训练超参数与有用奖励模型相同。

\text{Reward}_{\text{safety}} = \text{RM}_{\text{safety}}(\text{Response}) \tag{6}

对于一般查询，每个实例被归类为属于安全数据集或有用性数据集。分配给每个查询的一般奖励 $\text{Reward}_{\text{General}}$ 对应于相关数据集中定义的相应奖励。

3.2. 训练细节

3.2.1. 第一阶段强化学习的训练细节

在强化学习的第一阶段，我们将学习率设置为 3e-6，KL 系数设置为 0.001，GRPO 裁剪比率 $\epsilon$ 设置为 10，采样温度设置为 1 以进行 rollout。对于每个问题，我们采样 16 个输出，最大长度为 32,768。每个训练步骤包含 32 个独特的问题，导致每步的训练批次大小为 512。每 400 步，我们用最新的策略模型替换参考模型。为了加速训练，每个 rollout 生成 8,192 个输出，这些输出被随机分成 16 个小批次，并且仅训练单个内部 epoch。然而，为了减轻语言混合的问题，我们在强化学习训练期间引入了语言一致性奖励，该奖励计算为思维链（CoT）中目标语言词汇的比例。

\text{Reward}_{\text{language}} = \frac{\text{Num}(\text{Words}_{\text{target}})}{\text{Num}(\text{Words})} \tag{7}

尽管补充材料 B.6 中的消融实验表明这种对齐会导致模型性能略有下降，但该奖励与人类偏好保持一致，使其更具可读性。我们将语言一致性奖励应用于推理和非推理数据，直接将其添加到最终奖励中。

请注意，裁剪比率在训练中起着至关重要的作用。较低的值可能导致大量 token 的梯度截断，从而降低模型性能，而较高的值可能导致训练期间的不稳定性。

3.2.2. 第二阶段强化学习的训练细节

具体而言，我们使用奖励信号和多样化提示分布的组合来训练模型。对于推理数据，我们遵循 DeepSeek-R1-Zero 中概述的方法，该方法采用基于规则的奖励来指导数学、编程和逻辑推理领域的学习。在训练过程中，我们观察到思维链通常表现出语言混合，特别是当强化学习提示涉及多种语言时。对于一般数据，我们利用奖励模型来指导训练。最终，奖励信号与多样化数据分布的整合使我们能够开发出一种不仅在推理方面表现出色，而且优先考虑有用性和无害性的模型。给定一批数据，奖励可以表述为：

\text{Reward} = \text{Reward}_{\text{reasoning}} + \text{Reward}_{\text{general}} + \text{Reward}_{\text{language}} \tag{8}

其中，

\text{Reward}_{\text{reasoning}} = \text{Reward}_{\text{rule}} \tag{9}

\text{Reward}_{\text{general}} = \text{Reward}_{\text{reward\_model}} + \text{Reward}_{\text{format}} \tag{10}

强化学习的第二阶段保留了第一阶段的大部分参数，关键区别在于温度降低至 0.7，因为我们发现此阶段较高的温度会导致不连贯的生成。该阶段总共包含 1,700 个训练步骤，其中一般指令数据和基于偏好的奖励仅在最后 400 步中纳入。我们发现，使用基于模型的偏好奖励信号进行更多的训练步骤可能会导致奖励黑客攻击，这在补充材料 B.5 中有记录。总训练成本列于补充材料 B.4.4 中。

4. 实验

我们在 MMLU（Hendrycks 等人，2021）、MMLU-Redux（Gema 等人，2025）、MMLU-Pro（Wang 等人，2024）、C-Eval（Huang 等人，2023）和 CMMLU（Li 等人，2024）、IFEval（Zhou 等人，2023b）、FRAMES（Krishna 等人，2024）、GPQA Diamond（Rein 等人，2023）、SimpleQA（OpenAI，2024a）、C-SimpleQA（He 等人，2024）、SWE-Bench Verified（OpenAI，2024b）、Aider（Gauthier，2025）、LiveCodeBench（Jain 等人，2024）（2024-08 – 2025-01）、Codeforces（Mirzayanov，2025）、中国全国高中数学奥林匹克（CNMO 2024）（CMS，2024）和 2024 年美国数学邀请赛（AIME 2024）（MAA，2024）上评估了我们的模型。这些基准测试的详细信息列于补充材料 D 中。

表 3 总结了 DeepSeek-R1 在图 2 中概述的多个发展阶段的性能。DeepSeek-R1-Zero 和 DeepSeek-R1 Dev1 之间的比较揭示了指令遵循方面的实质性改进，这由 IF-Eval 和 ArenaHard 基准测试上的更高分数证明。然而，由于冷启动数据集的规模有限，Dev1 与 DeepSeek-R1-Zero 相比在推理性能上表现出部分下降，最显著的是在 AIME 基准测试上。相比之下，DeepSeek-R1 Dev2 展示了在需要高级推理技能的基准测试上的显著性能增强，包括那些专注于代码生成、数学问题求解和 STEM 相关任务的基准测试。针对通用任务的基准测试（如 AlpacaEval 2.0）显示出边际改进。这些结果表明，面向推理的强化学习显著增强了推理能力，同时对用户偏好导向的基准测试影响有限。

DeepSeek-R1 Dev3 将推理和非推理数据集整合到 SFT 流水线中，从而增强了模型在推理和通用语言生成任务中的熟练度。与 Dev2 相比，DeepSeek-R1 Dev3 在 AlpacaEval 2.0 和 Aider-Polyglot 上取得了显著的性能改进，这归功于大规模非推理语料库和代码工程数据集的纳入。最后，在 DeepSeek-R1 Dev3 上使用混合推理聚焦和通用数据进行的全面强化学习训练产生了最终的 DeepSeek-R1。代码和数学基准测试出现了边际改进，因为实质性的推理特定强化学习已在之前的阶段完成。最终 DeepSeek-R1 的主要进步在于通用指令遵循和用户偏好基准测试，AlpacaEval 2.0 提高了 25%，ArenaHard 提高了 17%。

此外，我们在补充材料 D.2 中将 DeepSeek-R1 与其他模型进行了比较。模型安全评估在补充材料 D.3 中提供。补充材料 E 中提供了全面的分析，包括与 DeepSeek-V3 的比较、对新鲜测试集的性能评估、按类别划分的数学能力分析以及对测试时扩展行为的调查。补充材料 F 显示，强大的推理能力可以转移到较小的模型中。

5. 伦理与安全声明

随着 DeepSeek-R1 推理能力的提升，我们深刻认识到潜在的伦理风险。例如，R1 可能会受到越狱攻击，导致生成危险内容（如爆炸物制造计划），而增强的推理能力使模型能够提供具有更好操作可行性和可执行性的计划。此外，公共模型也容易受到进一步的微调，这可能会损害固有的安全保护。

在补充材料 D.3 中，我们从多个角度提出了全面的安全报告，包括在开源和内部安全评估基准测试上的性能，以及跨多种语言和针对越狱攻击的安全级别。这些全面的安全分析得出结论，与其它最先进的模型相比，DeepSeek-R1 模型的固有安全级别通常处于中等水平（与 GPT-4o (2024-05-13) 相当）。此外，当与风险控制系统结合使用时，模型的安全级别会提升到更高的标准。

6. 结论、局限性和未来工作

我们介绍了 DeepSeek-R1-Zero 和 DeepSeek-R1，它们依赖大规模强化学习来激发模型的推理行为。我们的结果表明，预训练检查点本质上具有复杂推理任务的巨大潜力。我们相信，释放这一潜力的关键不在于大规模的人工标注，而在于提供困难的推理问题、可靠的验证器以及足够的强化学习计算资源。复杂的推理行为（如自我验证和反思）在强化学习过程中自然涌现。

即使 DeepSeek-R1 在推理基准测试上取得了前沿结果，它仍然面临以下几个能力局限：

结构化输出和工具使用：目前，DeepSeek-R1 的结构化输出能力与现有模型相比仍然次优。此外，DeepSeek-R1 无法利用工具（如搜索引擎和计算器）来提高输出性能。然而，由于构建用于结构化输出和工具使用的强化学习环境并不困难，我们相信这个问题将在下一个版本中得到解决。

Token 效率：与传统的测试时计算扩展方法（如多数投票或蒙特卡洛树搜索（MCTS））不同，DeepSeek-R1 在推理过程中根据手头问题的复杂性动态分配计算资源。具体而言，它使用较少的 token 来解决简单任务，同时为复杂任务生成更多的 token。尽管如此，在 token 效率方面仍有进一步优化的空间，因为在回答简单问题时仍然观察到过度推理（表现为过度思考）的情况。

语言混合：DeepSeek-R1 目前针对中文和英语进行了优化，这可能导致在处理其他语言的查询时出现语言混合问题。例如，即使查询不是英语或中文，DeepSeek-R1 也可能在推理和回答中使用英语。我们旨在在未来的更新中解决这一局限性。该局限性可能与基础检查点 DeepSeek-V3-Base 主要使用中文和英语有关，因此它在两种语言的推理中能取得更好的结果。

提示工程：在评估 DeepSeek-R1 时，我们观察到它对提示很敏感。少样本提示会持续降低其性能。因此，我们建议用户直接描述问题，并使用零样本设置指定输出格式以获得最佳结果。

软件工程任务：由于评估时间长，影响了强化学习过程的效率，大规模强化学习尚未广泛应用于软件工程任务。因此，DeepSeek-R1 在软件工程基准测试上并未表现出比 DeepSeek-V3 的巨大改进。未来的版本将通过在软件工程数据上实施拒绝采样或在强化学习过程中纳入异步评估来解决此问题，以提高效率。

除了特定的能力局限外，纯强化学习方法本身也存在固有的挑战：

奖励黑客攻击：纯强化学习的成功取决于可靠的奖励信号。在本研究中，我们通过推理领域的基于规则的奖励模型（RM）确保了奖励的可靠性。然而，对于某些任务（如写作），这种可靠的 RM 很难构建。如果奖励信号由模型而不是预定义规则分配，随着训练的进行，它就更容易受到利用，这意味着策略模型可能会找到捷径来黑掉奖励模型。因此，对于无法通过可靠奖励模型有效评估的复杂任务，扩展纯强化学习方法仍然是一个开放的挑战。

在这项工作中，对于无法获得可靠信号的任务，DeepSeek-R1 使用人工标注来创建监督数据，并且仅进行数百步的强化学习。我们希望在未来能够获得一个稳健的奖励模型来解决这些问题。

随着 DeepSeek-R1 等纯强化学习方法的出现，未来在解决任何可以由验证器有效评估的任务方面都具有巨大的潜力，无论其对人类的复杂程度如何。配备此类高级强化学习技术的机器有望在这些领域超越人类能力，这得益于它们通过试错迭代优化性能的能力。然而，对于构建可靠奖励模型本身就很困难的任务，挑战依然存在。在这种情况下，缺乏稳健的反馈机制可能会阻碍进展，这表明未来的研究应侧重于开发创新的方法来定义和完善这些复杂、较难验证问题的奖励结构。

此外，在推理过程中利用工具具有巨大的前景。无论是利用编译器或搜索引擎等工具来检索或计算必要信息，还是采用外部工具（如生物或化学试剂）来验证现实世界中的最终结果，这种工具增强推理的整合都可能极大地增强机器驱动解决方案的范围和准确性。

7. 作者列表

作者列表按贡献角色组织，每个类别内的人员按名字字母顺序排列。标有星号（*）的作者不再隶属于我们的团队。

核心贡献者：Daya Guo, Dejian Yang, Haowei Zhang, Junxiao Song, Peiyi Wang, Qihao Zhu, Runxin Xu, Ruoyu Zhang, Shirong Ma, Xiao Bi, Xiaokang Zhang, Xingkai Yu, Yu Wu, Z.F. Wu, Zhibin Gou, Zhihong Shao, Zhuoshu Li, Ziyi Gao。

核心作者的贡献：Peiyi Wang 和 Daya Guo 共同证明了基于结果的强化学习诱导了大语言模型中长思维链模式的涌现，实现了突破性的推理能力。他们对 R1-Zero 的创建做出了同等贡献，他们的工作为 R1 奠定了基础。Daya Guo 还为 MOE 模型的强化学习训练稳定性做出了贡献。Junxiao Song 提出了 GRPO 算法，实现了初始版本，并引入了针对数学任务的基于规则的奖励。GRPO 算法随后由 Peiyi Wang 和 Runxin Xu 进行了改进。Zhibin Gou 提出了大规模 PPO 裁剪策略以增强 GRPO 性能，并与 Zhihong Shao 和 Junxiao Song 一起证明了其重要性。关于数据迭代、奖励设计和评估，特定团队在不同领域领导了工作：Qihao Zhu、Z.F. Wu 和 Dejian Yang 专注于代码任务；Zhihong Shao、Zhibin Gou 和 Junxiao Song 专注于数学任务；Peiyi Wang、Ruoyu Zhang、Runxin Xu 和 Yu Wu 领导了其他推理和通用任务的工作。此外，Qihao Zhu 和 Zhihong Shao 为强化学习的数据选择策略做出了贡献，而 Zhuoshu Li 和 Yu Wu 共同领导了整个项目的数据标注工作。在系统方面，Xiao Bi、Xingkai Yu、Shirong Ma、Xiaokang Zhang、Haowei Zhang 和 Ziyi Gao 实现了强化学习流水线，优化了系统效率并解决了大规模训练中的稳定性问题。最后，Zhibin Gou、Daya Guo 和 Ruoyu Zhang 监督了最终训练阶段并监控了模型训练动态。Zhibin Gou 领导了 R1-distill 系列的开发。

贡献者：Aixin Liu, Bing Xue, Bingxuan Wang, Bochao Wu, Bei Feng, Chengda Lu, Chenggang Zhao, Chengqi Deng, Chong Ruan, Damai Dai, Deli Chen, Dongjie Ji, Erhang Li, Fangyun Lin, Fucong Dai, Fuli Luo*, Guangbo Hao, Guanting Chen, Guowei Li, H. Zhang, Hanwei Xu, Honghui Ding, Huazuo Gao, Hui Qu, Hui Li, Jianzhong Guo, Jiashi Li, Jingchang Chen, Jingyang Yuan, Jinhao Tu, Junjie Qiu, Junlong Li, J.L. Cai, Jiaqi Ni, Jian Liang, Jin Chen, Kai Dong, Kai Hu*, Kaichao You, Kaige Gao, Kang Guan, Kexin Huang, Kuai Yu, Lean Wang, Lecong Zhang, Liang Zhao, Litong Wang, Liyue Zhang, Lei Xu, Leyi Xia, Mingchuan Zhang, Minghua Zhang, Minghui Tang, Mingxu Zhou, Meng Li, Miaojun Wang, Mingming Li, Ning Tian, Panpan Huang, Peng Zhang, Qiancheng Wang, Qinyu Chen, Qiushi Du, Ruiqi Ge, Ruisong Zhang, Ruizhe Pan, Runji Wang, R.J. Chen, R.L. Jin, Ruyi Chen, Shanghao Lu, Shangyan Zhou, Shanhuang Chen, Shengfeng Ye, Shiyu Wang, Shuiping Yu, Shunfeng Zhou, Shuting Pan, S.S. Li, Shuang Zhou, Shaoqing Wu, Shengfeng Ye, Tao Yun, Tian Pei, Tianyu Sun, T. Wang, Wangding Zeng, Wen Liu, Wenfeng Liang, Wenjun Gao, Wenqin Yu*, Wentao Zhang, W.L. Xiao, Wei An, Xiaodong Liu, Xiaohan Wang, Xiaokang Chen, Xiaotao Nie, Xin Cheng, Xin Liu, Xin Xie, Xingchao Liu, Xinyu Yang, Xinyuan Li, Xuecheng Su, Xuheng Lin, X.Q. Li, Xiangyue Jin, Xiaojin Shen, Xiaosha Chen, Xiaowen Sun, Xiaoxiang Wang, Xinnan Song, Xinyi Zhou, Xianzu Wang, Xinxia Shan, Y.K. Li, Y.Q. Wang, Y.X. Wei, Yang Zhang, Yanhong Xu, Yao Li, Yao Zhao, Yaofeng Sun, Yaohui Wang, Yi Yu, Yichao Zhang, Yifan Shi, Yiliang Xiong, Ying He, Yishi Piao, Yisong Wang, Yixuan Tan, Yiyang Ma*, Yiyuan Liu, Yongqiang Guo, Yuan Ou, Yuduan Wang, Yue Gong, Yuheng Zou, Yujia He, Yunfan Xiong, Yuxiang Luo, Yuxiang You, Yuxuan Liu, Yuyang Zhou, Y.X. Zhu, Yanping Huang, Yaohui Li, Yi Zheng, Yuchen Zhu, Yunxian Ma, Ying Tang, Yukun Zha, Yuting Yan, Z.Z. Ren, Zehui Ren, Zhangli Sha, Zhe Fu, Zhean Xu, Zhenda Xie, Zhengyan Zhang, Zhewen Hao, Zhicheng Ma, Zhigang Yan, Zhiyu Wu, Zihui Gu, Zijia Zhu, Zijun Liu*, Zilin Li, Ziwei Xie, Ziyang Song, Zizheng Pan, Zhen Huang, Zhipeng Xu, Zhongyu Zhang, Zhen Zhang。

附录

A. 背景

A.1. DeepSeek-V3

DeepSeek V3（DeepSeek-AI，2024b）是由 DeepSeek 开发的先进开源大语言模型。DeepSeek V3 于 2024 年 12 月发布，代表了人工智能创新的重大飞跃，旨在与 OpenAI 的 GPT-4 和 Meta 的 Llama 3.1 等领先模型竞争，同时保持卓越的成本效率和性能。DeepSeek V3 基于混合专家（MoE）架构，拥有 6710 亿总参数，每个 token 激活 370 亿参数，优化了效率和能力。它在 14.8 万亿高质量、多样化 token 的庞大数据集上进行了预训练，随后进行了监督微调和强化学习，以增强其在各个领域的能力。该模型结合了诸如多头潜在注意力（MLA）（DeepSeek-AI，2024a）以实现高效推理、无辅助损失的负载均衡策略以及多 Token 预测（MTP）（Gloeckle 等人，2024）等创新功能，以提高性能，特别是在数学和编程等任务中。

对于 DeepSeek-V3-Base 的训练数据，我们专门使用纯网页和电子书，而不包含任何合成数据。然而，我们观察到一些网页包含大量由 OpenAI 模型生成的答案，这可能导致基础模型间接从其他强大模型中获取知识。尽管如此，我们在预训练冷却阶段并没有刻意包含由 OpenAI 生成的合成数据；此阶段使用的所有数据都是自然产生的，并通过网络爬虫收集。预训练数据集包含大量的数学和代码相关内容，这表明 DeepSeek-V3-Base 已经接触过大量的推理轨迹数据。这种广泛的接触使模型具备了生成合理解决方案候选的能力，强化学习可以从中有效地识别和优化高质量的输出。我们按照附录 D.1 中的描述对预训练数据进行了去污染处理。DeepSeek-V3-Base 的训练数据主要是中文和英语，这可能是导致在缺乏语言一致性奖励时 DeepSeek-R1-Zero 出现语言混合的原因。

在本文中，我们使用符号 DeepSeek-V3-Base 作为基础模型，DeepSeek-V3 作为指令微调模型。值得注意的是，DeepSeek-R1 和 DeepSeek-R1-Zero 是在 DeepSeek-V3-Base 之上训练的，而 DeepSeek-R1 利用了来自 DeepSeek-V3 SFT 数据的非推理数据。DeepSeek-R1-Dev1、DeepSeek-R1-Dev2 和 DeepSeek-R1-Dev3 是 DeepSeek-R1 的中间检查点。

A.2. 传统的训练后范式

训练后阶段已成为完善预训练大语言模型以满足特定性能目标并符合人类期望的重要步骤。一种广泛采用的两阶段训练后框架是 SFT 随后进行强化学习（Ouyang 等人，2022）。

监督微调（SFT）通过在针对特定任务定制的输入-输出对的策划数据集上进行训练来完善预训练的大语言模型。该过程采用监督学习目标，通常是最小化模型预测与标注真实值之间的交叉熵损失（Brown 等人，2020）。例如，在对话应用中，SFT 可能会利用明确提供所需回答的对话数据集，使模型能够根据预定义的标准调整其输出（Radford 等人，2019）。SFT 提供了几个引人注目的好处。首先，它通过利用高质量示例实现精确的任务对齐，允许模型在客户支持或技术文档等领域表现出色（Radford 等人，2019）。其次，它对预训练权重的依赖确保了计算效率，比从头开始训练需要更少的资源。最后，显式输入-输出映射的使用增强了可解释性，因为模型的学习过程直接与可观察的数据相关联，从而最大限度地降低了异常行为的风险（Ouyang 等人，2022）。尽管有其优势，但 SFT 的性能取决于训练数据集的质量和多样性；狭窄或有偏见的数据会损害模型泛化到新上下文的能力（Brown 等人，2020）。此外，SFT 的静态性质（优化固定输出）可能无法捕捉不断变化的人类偏好或细微的目标。策划高质量数据集的劳动密集型过程进一步增加了其可扩展性的难度，因为数据中的错误或不一致可能会传播到模型的行为中（Ouyang 等人，2022）。

在 SFT 之后，强化学习通过针对奖励信号优化其输出来进一步完善大语言模型。在此阶段，模型与环境（通常是基于人类反馈训练的奖励模型）交互，并调整其行为以最大化累积奖励。这种方法的一个突出实例是基于人类反馈的强化学习（RLHF），其中奖励函数编码了人类偏好（Christiano 等人，2017）。因此，强化学习将重点从静态监督转移到动态优化。值得注意的是，强化学习减少了对大量标注资源的需求；虽然 SFT 要求为每个输入-输出对提供完全标注的数据集，但强化学习可以在较小的人类评估集或训练好的奖励模型（甚至是基于规则的奖励模型）上运行，从而显著降低了标注负担。

SFT 和强化学习的顺序应用结合了它们的互补优势。SFT 通过将模型建立在策划的示例中来建立稳健的、特定于任务的基线，而强化学习则完善了这一基础，以与更广泛的、以人为本的目标保持一致（Ouyang 等人，2022）。例如，SFT 可能确保对话系统中的语法准确性，而强化学习则优化参与度和简洁性，正如 InstructGPT 的开发所证明的那样（Ouyang 等人，2022）。这种混合方法已被证明在产生既精确又适应性强的模型方面是有效的。

在本研究中，我们证明了 SFT 阶段可能会阻碍模型探索和发展有效推理策略的能力。这种局限性产生的原因是，作为 SFT 期间目标的由人类提供的回答并不总是模型学习的最优选择；它们通常省略了关键的推理组件，例如显式的反思和验证步骤。为了解决这个问题，DeepSeek-R1-Zero 实现了模型本身对推理模式的直接探索，独立于人类先验。通过这种自我探索发现的推理轨迹随后被蒸馏并用于训练其他模型，从而促进了更稳健和可泛化的推理能力的获取。

A.3. GRPO 与 PPO 的比较

组相对策略优化（GRPO）（Shao 等人，2024）是我们采用的用于训练 DeepSeek-R1-Zero 和 DeepSeek-R1 的强化学习算法。它最初是为了简化训练过程并减少近端策略优化（PPO）（Schulman 等人，2017）的资源消耗而提出的，PPO 广泛用于大语言模型的强化学习阶段（Ouyang 等人，2022）。关于 GRPO 和 PPO 的全面比较，请参见图 3。

对于每个问题 $q$ ，GRPO 从旧策略中采样一组输出 $\{o_1, o_2, \dots, o_G\}$ ，然后通过最大化以下目标来优化策略模型 $\pi_\theta$ ：

\mathcal{J}_{\text{GRPO}}(\theta) = \mathbb{E}[q \sim P(Q), \{o_i\}_{i=1}^G \sim \pi_{\theta_{\text{old}}}(o|q)] \\ \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 - \epsilon, 1 + \epsilon \right) A_i \right) - \beta D_{\text{KL}} (\pi_\theta || \pi_{\text{ref}}) \right), \tag{11}

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{12}

其中 $\pi_{\text{ref}}$ 是参考策略， $\epsilon$ 和 $\beta$ 是超参数， $A_i$ 是优势，使用对应于每组中输出的一组奖励 $\{r_1, r_2, \dots, r_G\}$ 计算得出：

A_i = \frac{r_i - \text{mean}(\{r_1, r_2, \dots, r_G\})}{\text{std}(\{r_1, r_2, \dots, r_G\})} \tag{13}

相比之下，在 PPO 中，优势通常通过应用广义优势估计（GAE）（Schulman 等人，2015）来计算，这不仅基于奖励，还基于学习到的价值模型。由于价值模型的大小通常与策略模型相似，它引入了显著的内存和计算开销。此外，价值模型的训练目标是预测从当前位置开始的预期累积奖励，基于从开始到当前位置生成的 token。这本质上是困难的，特别是当只有最终结果奖励可用时。当训练长思维链推理模型时，这一挑战变得更加明显。随着输出长度的增加，模型在生成过程中更有可能参与反思和修订等行为，这意味着最初生成的内容可能会在稍后被修订或反驳，这使得基于部分回答预测最终奖励变得更加不可行。

GRPO 和 PPO 之间的另一个关键区别是训练策略与参考策略之间的 Kullback–Leibler (KL) 散度如何纳入训练过程。在 GRPO 中，KL 散度的无偏估计器（Schulman，2020）直接添加到损失函数中，如公式 11 所示，而在 PPO 中，每 token 的 KL 惩罚作为密集奖励添加到每个 token 中（Ouyang 等人，2022）。由于强化学习的优化目标是最大化累积奖励，PPO 的方法惩罚了累积 KL 散度，这可能会隐式地惩罚回答的长度，从而防止模型回答长度的增加。此外，由于我们可能会在训练长思维链推理模型的场景中训练数千步，训练策略可能会与初始参考策略产生显著偏离。为了平衡训练策略可以探索的范围和训练的稳定性，我们在实际训练过程中定期将参考策略更新为最新策略。

图 4 比较了使用 DeepSeek-Coder-V2-Lite（16B MoE，具有 2.4B 激活参数）在 MATH 任务上 PPO 和 GRPO 的性能。与 GRPO 不同，PPO 需要额外的超参数调整——特别是 GAE 中的 $\lambda$ 系数——并且对该参数高度敏感。当 $\lambda$ 设置为 0.95（大多数开源 PPO 实现中的默认值）时，PPO 的性能明显差于 GRPO。然而，通过仔细调整（将 $\lambda$ 设置为 1.0），PPO 的性能显著提高，接近 GRPO。

虽然 PPO 在适当调整后可以达到相当的性能，但它需要额外的计算成本来进行超参数优化。此外，考虑到与训练额外价值模型相关的内存和计算开销，GRPO 提供了一种更实用的替代方案，特别是在资源受限的情况下训练大规模模型时。

B. 训练细节

B.1. 强化学习基础设施

在大模型上进行强化学习训练对基础设施提出了很高的要求。我们的强化学习框架采用了解耦和可扩展的结构，以促进不同模型和算法的无缝集成。在此框架内，我们结合了模块内和模块间优化技术，以确保训练效率和可扩展性。

具体而言，如图 5 所示，该框架被划分为四个不同的模块，每个模块对应强化学习流水线的特定阶段：

Rollout 模块：提示从训练数据集中加载，并均匀分发到多个 vLLM（Kwon 等人，2023）工作节点，每个节点配备 actor 模型，以采样多个回答。对于 DeepSeek-V3 MoE 架构，我们在节点间实施专家并行策略以减少内存访问开销，并部署热点专家的冗余副本以平衡不同专家之间的计算负载。多 Token 预测（MTP）组件也被用于自推测解码，显著加速了解码速度，并有效地最大限度地减少了最长样本的完成时间。
Inference 模块：该模块加载奖励模型和参考模型，对 rollout 阶段生成的样本执行前向传递，从而获得基于模型的奖励和其他基本信息。
基于规则的奖励模块：该模块计算模型生成回答的基于规则的奖励。设计了一个统一的接口来容纳各种实现（例如，代码执行器、答案匹配器、格式检查器等）。尽管此模块不需要将模型加载到 GPU 内存中，但其执行往往很耗时。为了解决这个问题，采用了异步调度方法，将其执行与 Rollout 和 Inference 模块重叠，有效地隐藏了相关的延迟。
训练模块：该模块加载 actor 模型和 critic 模型（如果需要），以计算损失并更新模型参数。它为各种强化学习算法（例如 PPO、GRPO、DPO 等）提供了灵活的支持。为了最大限度地减少由序列填充引起的计算浪费并平衡设备间的负载，我们设计了以下数据打包策略：首先，全局批次中的所有数据按长度排序，并分发到数据并行组内的进程中；随后，在每个进程内，应用最佳拟合（Best-Fit）策略将数据打包成具有最小填充的固定长度块；最后，调整块的数量以在所有进程中保持相等。此外，我们集成了 DeepSeek-V3 训练中使用的 DualPipe 算法，以实现高效的流水线并行。

值得注意的是，在每个模块完成（不包括基于规则的奖励模块）后，该阶段使用的模型实例会自动从 VRAM 卸载到系统内存或磁盘存储中，从而为后续阶段释放 VRAM。

B.2. 奖励模型提示

text
请作为一名公正的法官，评估两个 AI 助手对下方显示的用户提示所提供的回答的质量。您将获得助手 A 的回答和助手 B 的回答。您的工作是评估哪个助手的回答更好。
在评估任何回答之前，请先通过生成您自己对该提示的回答来开始您的评估。您必须在判断任何回答之前提供您的答案。
在评估助手的回答时，请将两个助手的回答与您的答案进行比较。您必须识别并纠正任何错误或不准确的信息。
然后考虑助手的回答是否有帮助、相关且简洁。有帮助意味着回答正确地响应了提示或遵循了指令。请注意，当用户提示有任何歧义或不止一种解释时，询问用户以获取澄清或更多信息比基于假设提供答案更有帮助和适当。相关意味着回答的所有部分都与所问的问题紧密相关或适当。简洁意味着回答清晰，不冗长或过度。
然后根据需要考虑助手回答的创造性和新颖性。最后，识别助手回答中缺失的任何重要信息，如果包含这些信息将对响应用户提示有益。
在提供解释后，您必须仅输出以下选项之一作为您的最终判决，并附上标签：
1. 助手 A 明显更好：[[A≫B]]
2. 助手 A 略好：[[A>B]]
3. 平局，相对相同：[[A=B]]
4. 助手 B 略好：[[B>A]]
5. 助手 B 明显更好：[[B≫A]]
示例输出：我的最终判决是平局：[[A=B]]。

表 4	强化学习数据和任务描述。
数据类型	提示数量
数学	26K
代码	17K
STEM	22K
逻辑	15K
通用	66K

B.3. 数据配方

B.3.1. 强化学习数据

推理强化学习数据包括四个类别：数学、编程、STEM 和逻辑问题。此外，我们还在 DeepSeek-R1 的训练中纳入了通用强化学习数据，以提高模型的有用性和无害性。所有问题均为中文或英语。强化学习数据的描述可以在表 4 中找到，我们将在此逐一描述每种数据类型的详细信息：

数学数据集：由 26k 个定量推理问题组成，包括数学考试题和竞赛题。提示 token 的平均数量为 122。该数据集涵盖了代数、微积分、概率和几何等各种数学领域。问题的难度范围从区域竞赛到国际奥林匹克竞赛。对于每个问题，模型被期望产生一个分步推理过程，最终得出最终答案，该答案可以是数值（例如，“5”）、数学表达式（例如，“ $x^2 + 3x - 2$ ”）或方程（例如，“ $y = 2x + 1$ ”）。数学证明被排除在外，因为很难确定其正确性。出于强化学习的目的，我们通过将预测答案与参考答案进行匹配来计算推理过程的奖励。如果答案与参考答案一致，则奖励赋值为 1；否则，赋值为 0。
编程数据集：包括 17k 个算法竞赛问题，以及 8k 个 Bug 修复问题。算法竞赛问题类似于 Codeforces 或 LeetCode 等平台上的问题。每个问题通常包括详细的问题描述、约束和多个输入-输出示例。任务是编写一个能够正确且高效地解决问题的完整函数或程序，并通过一组全面的隐藏测试用例来评估正确性和性能。这些问题测试算法技能，包括动态规划、图论、字符串操作和数据结构使用。 Bug 修复问题提取自现实世界的 GitHub 问题。每个任务提供一个问题描述、源代码的 Bug 版本以及一组部分或完全失败的单元测试。目标是理解问题的意图，定位并修复代码中的缺陷，并确保修正后的版本通过所有单元测试。
STEM 数据集：包含 22k 个选择题，涵盖物理、化学和生物等主题。STEM 任务中的每个问题都呈现一个特定学科的问题，并附有四个到八个答案选项。模型被要求根据给定的上下文和领域知识选择最科学准确的答案。提示 token 的平均数量为 161。具体而言，该数据集包括 15.5% 的物理、30.7% 的生物、46.5% 的化学以及 7.3% 的其他主题，如健康和医学。由于所有 STEM 问题都是多项选择题，因此根据是否匹配正确选项来分配二进制奖励。
逻辑数据集：包含 15k 个旨在评估模型在广泛逻辑挑战中的推理能力的问题。该数据集包括现实世界和合成生成的问题。所有问题都支持自动评估，平均提示长度约为 420 个 token。数据集的现实世界部分包含从网络上获取的多样化问题选择，包括脑筋急转弯、经典逻辑谜题和知识密集型问题。这些问题以多项选择格式呈现，以确保客观和一致的评估。合成部分主要由两类组成：代码-IO 问题和谜题任务。代码-IO 问题是使用 Li 等人（2025）引入的数据流水线生成的，该流水线将竞争性编程问题及其相应的输入-输出测试用例转换为可验证的逻辑推理问题。谜题任务包括旨在评估特定推理能力的问题。例如，密码谜题旨在评估模型识别和应用密码方案中的模式或执行字符串操作的能力；逻辑谜题专注于复杂约束下的演绎推理，例如从一组固定的前提中推断出有效的结论（例如，斑马谜题）；算术谜题测试模型的数值推理（例如概率问题和 24 点游戏）。
通用数据集：由 66k 个旨在评估有用性的问题组成，涵盖创意写作、编辑、事实问答和角色扮演等各种类别。此外，该数据集还包括 12,000 个专注于评估无害性的问题。为了确保稳健的验证，使用了两个奖励模型，每个模型都在模型生成的关于有用性和无害性的排序回答的策划数据集上进行训练。我们训练有用奖励模型进行了单个 epoch，训练期间的最大序列长度为 8192 个 token。然而，当部署模型来生成奖励信号时，我们没有对正在评估的输入序列施加任何明确的长度限制。

B.3.2. DeepSeek-R1 冷启动

对于 DeepSeek-R1，我们构建并收集了少量长思维链（CoT）数据，以将模型微调为初始强化学习 actor。其动机主要是产品驱动的，重点在于增强用户体验。当推理过程符合第一人称视角的思维模式时，用户往往会发现回答更直观、更具吸引力。例如，DeepSeek-R1-Zero 在解决问题时更倾向于使用代词“我们”或完全避免使用第一人称代词，而 DeepSeek-R1 倾向于更频繁地使用“我”。此外，我们承认此类模式可能会引起用户不必要的信任。在此，我们想强调，观察到的生动推理模式主要反映了 DeepSeek 设计的启发式方法，而不是表明模型已经内在获得了类似人类的智能或自主的问题解决能力。

在冷启动数据创建中，我们更倾向于从理解问题开始，随后是包含反思和验证的详细推理的思维过程。整个思维过程中使用的语言以第一人称视角呈现。此外，保持语言一致性对于最佳用户体验至关重要。如果没有适当的控制，模型回答可能会包含不同语言的混合，无论查询中使用的语言如何。这种不一致可能会破坏理解并降低用户满意度。因此，仔细的完善对于确保回答保持连贯并与用户意图保持一致至关重要。尽管如此，我们承认 DeepSeek-R1-Zero 产生的原始思维链（CoT）推理可能具有超越当前人类先验的潜力。具体而言，我们首先聘请人工标注员将推理轨迹转换为更自然、人类对话的风格。修改后的数据对随后被用作示例，以提示大语言模型以类似风格重写额外数据。所有模型生成的输出随后都经过第二轮人工验证，以确保质量和一致性。

text
Listing 1 | 用于生成人类可读解决方案的提示。
## Question
{question}
## Thought process
{thought_process}
---
基于上述思维过程，提供一个清晰、易于遵循且格式良好的问题解决方案。使用与问题相同的语言。
解决方案必须严格遵循以下要求：
- 保持忠实并与给定的思维过程一致。不要添加原始思维过程中未显示的新的推理步骤或结论。
- 在清晰、格式良好的 LaTeX 中展示导致最终答案的关键步骤。
- 使用 \boxed{} 表示最终答案。
- 保持简洁。避免口语化。不要在解决方案中使用“思维过程”之类的短语。
您的回答应直接以解决方案开始，不要包含任何其他内容。您的任务仅是根据提供的思维过程编写解决方案。不要尝试自己解决问题。

具体而言，我们首先收集数千个高质量、多样化的推理提示。对于每个提示，我们使用温度相对较高的 1.0 的 DeepSeek-R1-Zero 生成多个推理轨迹。接下来，我们过滤这些生成结果，仅保留那些具有正确最终答案和可读格式的回答。对于数学输出，我们使用 sympy (https://www.sympy.org/) 进行解析和表达式比较；对于格式，我们应用诸如重复检测和语言混合过滤等规则。最后，我们提示 DeepSeek-V3 完善推理和总结，以确保正确的格式和符合人类习惯的表达。特别是，为了解决语言混合问题，我们指示 DeepSeek-V3 “将思维过程翻译成与问题相同的语言。” 由于 DeepSeek-R1-Zero 的总结仅提供了最终答案，我们使用 Listing 1 中的总结提示来生成一个简洁、人类可读的解决方案，概述了推理步骤和最终结果。

对于代码数据，我们收集了大量竞争性编程问题。具体而言，我们从多个在线评测（OJ）平台编译了大量的竞争性编程问题，具体为来自 Codeforces 的 5151 个问题和来自 AtCoder 的 2504 个问题。由于原始测试用例在这些平台上不是公开可用的，我们开发了一种为每个问题创建可靠测试用例的方法。

我们的方法涉及使用 DeepSeek-V2.5 生成候选测试用例，随后进行严格的验证过程。具体而言，我们提示 DeepSeek-V2.5 编写 Python 程序，生成针对每个问题要求定制的测试用例，如 Listing 2 所示。

在获得大量候选测试用例后，我们实施了两阶段过滤程序。首先，我们使用正确的提交来消除产生错误输出的无效测试用例。然后，我们战略性地选择了成功识别不正确提交中缺陷的测试用例子集。此过程确保了我们的最终测试用例能够正确区分每个问题的正确和不正确解决方案。

text
Listing 2 | 用于为代码问题生成测试用例的提示。
<USER>
Question:
给定一个字符串 word 和一个整数 k。
如果 word 的子字符串 s 是完整的，则满足：
每个字符在 s 中恰好出现 k 次。
两个相邻字符之间的差异最多为 2。也就是说，对于 s 中的任意两个相邻字符 c1 和 c2，它们在字母表中的位置的绝对差最多为 2。
返回 word 中完整子字符串的数量。
子字符串是字符串中非空的连续字符序列。
**Input**
第一行包含一个整数 t，即测试用例的数量。
每个测试用例的第一行包含一个字符串 word。
每个测试用例的第二行包含一个整数 k。
保证 word 仅由小写英文字母组成，并且所有测试用例中 |word| 的总和不超过 10^5。
**Output**
对于每个测试用例，打印一个整数，即 word 中完整子字符串的数量。
**Example**
Input
'''
2
igigee
2
aaabbbccc
3
'''
Output
'''
3
6
'''
构建一些随机输入生成器来生成多样化和对抗性的输入，这些输入足够大，以使不正确的代码超过时间限制。
</USER>
<ASSISTANT>
首先构建一个用于大数据且具有 10 个相同长度测试用例的随机输入生成器。
'''python
import random
import string
def generate_random_string(l_min, l_max):
length = random.randint(l_min, l_max)
seq = ''.join(random.choices(string.ascii_lowercase, k=length))
k = random.randint(1, length)

python
return f"{seq}\n{k}"
t = 10 # 测试用例的数量
testcase = [generate_random_string(10000, 10000) for _ in range(t)]
print(t)
print("\n".join(testcase))
'''
首先构建一个用于大数据且具有 10 个不同长度测试用例的随机输入生成器。
'''python
import random
import string
def generate_random_string(l_min, l_max):
length = random.randint(l_min, l_max)
seq = ''.join(random.choices(string.ascii_lowercase, k=length))
k = random.randint(1, length)
return f"{seq}\n{k}", len(seq)
t = 10 # 测试用例的数量
testcase = []
cum_length = 0
for i in range(t):
# 每个测试用例的长度应 >= 1
cur_testcase, cur_length = generate_random_string(1, 100000 - cum_length - (t - i))
testcase.append(cur_testcase)
cum_length += cur_length
print(t)
print("\n".join(testcase))
'''
构建一个用于大数据且只有一个测试用例的随机输入生成器。
'''python
import random
import string
def generate_random_string(l_min, l_max):
...
t = 1 # 测试用例的数量
testcase = [generate_random_string(90000, 100000) for _ in range(t)]
print(t)
print("\n".join(testcase))
'''
构建一个用于重复单个字符字符串的大型对抗性输入的输入生成器。
'''python
import random
import string
def generate_single_repeated_char(l_min, l_max):
length = random.randint(l_min, l_max)

python
char = random.choice(string.ascii_lowercase)
seq = char * length
k = random.randint(1, length)
return f"{seq}\n{k}"
t = 1 # 测试用例的数量
testcase = [generate_single_repeated_char(90000, 100000) for _ in range(t)]
print(t)
print("\n".join(testcase))
'''
构建一个用于两个交替字符字符串的大型对抗性输入的输入生成器。
'''python
import random
import string
def generate_alternating_chars(l_min, l_max):
length = random.randint(l_min, l_max)
char1, char2 = random.sample(string.ascii_lowercase, 2)
seq = ''.join(char1 if i % 2 == 0 else char2 for i in range(length))
k = random.randint(1, length)
return f"{seq}\n{k}"
t = 1 # 测试用例的数量
testcase = [generate_alternating_chars(90000, 100000) for _ in range(t)]
print(t)
print("\n".join(testcase))
'''
构建一个用于字母表中顺序字符字符串的大型对抗性输入的输入生成器。
'''python
...
'''
</ASSISTANT>
Question:
Question Description
构建一些随机输入生成器来生成大型、多样化和对抗性的输入，这些输入足够大，以测试时间复杂度并使不正确的代码超过时间限制。
使用上述示例中使用的格式，在不同的代码块中返回几个输入生成器。这些生成器中的每一个都直接将 EXACTLY ONE 输入打印到 stdout。

此外，我们对 DeepSeek-V3 采用少样本提示来生成对简单数学问题的回答，例如“1 + 1 = ?”，确保输出保持简洁且结构适当。我们在 Listing 3 中提供了简单数学问题的提示。

text
Listing 3 | 用于生成简单数学问题思维链的提示。
## Question
How much is 5+4?
## Response
<think>
I need to add the numbers 5 and 4. Starting with 5, if I add 4 to it, the total will be 9. Therefore, the sum of 5 and 4 is 9.
</think>
**Solution:**
We are asked to calculate the sum of 5 and 4.
**Step 1:** Start with the number 5.
**Step 2:** Add 4 to it.
\[
5 + 4 = 9
\]
**Final Answer:** \(\boxed{9}\)
---
## Question
what is 1 plus 2
## Response
<think>
I need to determine the sum of 1 and 2.
Adding these two numbers together, 1 plus 2 equals 3.
Therefore, the answer is 3.
</think>
Sure! Let’s solve the problem step by step.
**Problem:** What is \(1 + 2\)?
**Solution:**
To find the sum of 1 and 2, simply add the two numbers together:
\[
1 + 2 = 3
\]
**Answer:**
\(\boxed{3}\)
---
## Question
{question}
## Response

text
Listing 4 | 使用 DeepSeek-V3 作为法官的示例提示。
As an advanced reasoning problem evaluation assistant, your primary responsibility is to assess the accuracy of provided answers. You will be presented with a reasoning-related question, its corresponding reference answer, and an answer requiring evaluation.
## Answer Quality Classification
You have to carefully analyze and classify the answer into one of the following two levels:
1. **correct**: The answer fully aligns with the reference answer in both reasoning process and final conclusion, and address the question without any errors or omissions.
2. **incorrect**: The answer contains major errors in key reasoning steps or the final conclusion, or completely deviates from the core of the question. This indicates a fundamental misunderstanding or error in comprehending the question.
## Question
{question}
## Reference Answer
{reference}
## Answer to be Evaluated
{answer}
## Output Format
You need to combine the question and reference answer, first provide a detailed explanation of your analysis of the answer to be evaluated, then conclude with the final answer quality classification.
Output the following content in **JSON** format, including two key:
1. ’analysis’: analysis of the answer’s correctness;
2. ’correctness’: correct/incorrect

B.3.3. 800K 监督数据

推理数据：我们策划了一大组推理提示，并通过对第一阶段强化学习训练的检查点执行拒绝采样来生成推理轨迹。在之前的阶段，我们仅包含了可以使用基于规则的奖励进行评估的数据。然而，在此阶段，我们通过纳入额外数据扩展了数据集，其中一些数据使用生成式奖励模型，通过将真实值和模型预测输入 DeepSeek-V3 进行判断，示例提示在 Listing 4 中提供。此外，由于模型输出有时混乱且难以阅读，我们过滤掉了带有混合语言、长段落和代码块的思维链。对于每个提示，我们采样多个回答并仅保留正确的回答。总共，我们收集了约 600k 条与推理相关的训练样本。

非推理数据：对于非推理数据，如写作、事实问答、自我认知和翻译，我们采用 DeepSeek-V3 流水线并重用了 DeepSeek-V3 的 SFT 数据集的部分内容。我们还纳入了专注于软件工程的数据，包括程序修复和前端 Web 开发，以增强模型解决现实世界问题的能力。对于某些非推理任务，我们调用 DeepSeek-V3 在通过提示回答问题之前生成潜在的思维链。然而，对于更简单的查询，例如“hello”，我们不在回答中提供 CoT。最终，我们收集了总共约 200k 条与推理无关的训练样本。

在设计我们的思维过程风格时，我们要求模型遵循关键原则：首先，保持每个段落简洁易懂。短段落使观点更清晰、更易于遵循。其次，采用自然且引人入胜的对话语气。我们避免使用像 markdown 这样的技术格式，以保持流畅的阅读体验。第三，最重要的是，思维过程从理解完整的用户上下文开始。这意味着分析我们的用户是谁，他们正在处理什么情况，以及他们真正需要什么——包括他们最初请求表面之下可能存在的那些未陈述的需求。

在从模型中引出这些思维过程后，人工标注员会仔细验证输出的准确性。我们的研究结果表明，这些人工推理轨迹增强了模型在解释用户查询时的精确度。具体而言，它们有效地突出了格式约束，澄清了用户意图，并阐明了输出的必要结构。这种方法论方法促进了模型与用户之间更准确和响应迅速的交互。

表 5	SFT 数据的数据统计。
领域	样本数量
数学	395285
代码	211129
STEM	10124
逻辑	10395
通用	177812
总计	804745

SFT 数据统计：表 5 总结了跨各个领域的数据统计，基于约 800,000 个监督样本。值得注意的是，大部分数据由单轮交互组成，这可能会限制 DeepSeek-R1 的多轮对话能力。我们将扩展到多轮对话数据作为未来的工作。数学相关数据主要为中文和英语，涵盖了广泛的主题和难度级别。这些问题是可验证的，可以通过确定性规则或参考特定的真实答案来验证。代码数据集不仅包含竞争性编程问题，还包含调试任务和面向项目的编程查询。STEM 和逻辑相关问题，虽然在数量上比数学和代码少，但来源于公开的教科书和在线存储库。通用领域查询是多样化的，主要为中文和英语，包括创意写作、开放式问答、角色扮演场景等任务。

SFT 轨迹示例：我们在 Listing 5、6 和 7 中提供了与数学、代码和非推理相关的 SFT轨迹示例。

text
Listing 5 | 来自数学相关推理数据的 SFT 轨迹示例。
## Question
对于正整数 $n$，定义 $S_n$ 为和 \[ \sum_{k=1}^n \sqrt{(2k-1)^2+a_k^2}, \] 的最小值，其中 $a_1,a_2,\ldots,a_n$ 是和为 17 的正实数。存在唯一的正整数 $n$，使得 $S_n$ 也是一个整数。求这个 $n$。
## Response
<think>
好的，我正在尝试解决这个问题，我需要找到一个正整数 \( n \)，使得 \( S_n \)，即和 \( \sum_{k=1}^n \sqrt{(2k-1)^2 + a_k^2} \) 的最小值，是一个整数。这里，\( a_1, a_2, \ldots, a_n \) 是和为 17 的正实数。

嗯，好的，让我分解一下。我知道当你有一个像这样的平方根之和时，它通常与几何有关，也许是最小化距离。它让我想起了那个问题，你必须将路径分解为具有特定斜率的段以最小化总距离。也许这类似于在楼梯中找到最短路径。

让我可视化一下。每一项 \( \sqrt{(2k - 1)^2 + a_k^2} \) 看起来都像是一个直角三角形的斜边，其直角边为 \( (2k - 1) \) 和 \( a_k \)。所以，如果我想象一个网格，其中对于每一步 \( k \)，我水平移动 \( a_k \)，垂直移动 \( (2k - 1) \)，那么 \( S_n \) 将是这条路径的总长度。

现在，所有 \( a_k \) 的和是 17，这将是总的水平距离。我需要弄清楚垂直距离，它们是基于 \( k \) 固定下来的。所以总的垂直距离将是 \( \sum_{k=1}^n (2k - 1) \)。让我计算一下：
和 \( \sum_{k=1}^n (2k - 1) \) 等于 \( 2 \sum_{k=1}^n k - \sum_{k=1}^n 1 = 2 \cdot \frac{n(n + 1)}{2} - n = n(n + 1) - n = n^2 \)。所以总的垂直距离是 \( n^2 \)。

等一下，所以整个设置就像是从原点移动到点 \( (17, n^2) \)，包含 \( n \) 个段。每一段都有一个水平分量 \( a_k \) 和一个垂直分量 \( (2k - 1) \)。但实际上，如果我们可以以某种方式组合所有这些段，这条从 \( (0, 0) \) 到 \( (17, n^2) \) 的整个路径可以被视为一条直线。

但我们不能改变段数 \( n \)；每一段的垂直分量是固定的。然而，只要它们的和是 17，水平分量 \( a_k \) 就可以调整。所以，为了找到最小总距离，也许我们可以认为每一段都在最优地贡献总路径。如果我们按比例缩放每个水平分量 \( a_k \)，也许这也对应于缩放垂直分量。

或者，我可以考虑微积分优化技术。如果我需要最小化和 \( \sum_{k=1}^n \sqrt{(2k - 1)^2 + a_k^2} \)，受限于 \( \sum_{k=1}^n a_k = 17 \)，我可以使用拉格朗日乘数法。

让我设置拉格朗日函数。令 \( L = \sum_{k=1}^n \sqrt{(2k - 1)^2 + a_k^2} + \lambda \left(17 - \sum_{k=1}^n a_k\right) \)。

对每个 \( a_k \) 取 \( L \) 的导数：
\( \frac{\partial L}{\partial a_k} = \frac{a_k}{\sqrt{(2k - 1)^2 + a_k^2}} - \lambda = 0 \)。

所以，对于每个 \( k \)，我们有 \( \frac{a_k}{\sqrt{(2k - 1)^2 + a_k^2}} = \lambda \)。
让我解出 \( a_k \)：
两边平方得到 \( \frac{a_k^2}{(2k - 1)^2 + a_k^2} = \lambda^2 \)。
重排项：\( a_k^2 = \lambda^2 \left( (2k - 1)^2 + a_k^2 \right) \)。
两边同时除以 \( a_k^2 \)（假设 \( a_k \neq 0 \)）：\( 1 = \lambda^2 \left( \frac{(2k - 1)^2}{a_k^2} + 1 \right) \)。

简化：\( 1 - \lambda^2 = \lambda^2 \cdot \frac{(2k - 1)^2}{a_k^2} \)。
然后，\( \frac{(2k - 1)^2}{a_k^2} = \frac{1 - \lambda^2}{\lambda^2} \)。
因此，\( \frac{2k - 1}{a_k} = \sqrt{\frac{1 - \lambda^2}{\lambda^2}} = \frac{\sqrt{1 - \lambda^2}}{\lambda} \)。

让我记 \( c = \frac{\sqrt{1 - \lambda^2}}{\lambda} \)。那么，\( a_k = \frac{2k - 1}{c} \)。
所以，每个 \( a_k \) 都与 \( (2k - 1) \) 成正比。也就是说，\( a_k = \frac{2k - 1}{c} \)。

由于所有 \( a_k \) 的和是 17，我们可以写成：
\( \sum_{k=1}^n a_k = \sum_{k=1}^n \frac{2k - 1}{c} = \frac{1}{c} \sum_{k=1}^n (2k - 1) \)。

早些时候，我发现 \( \sum_{k=1}^n (2k - 1) = n^2 \)。因此，
\( \frac{n^2}{c} = 17 \) => \( c = \frac{n^2}{17} \)。
因此，\( a_k = \frac{2k - 1}{c} = \frac{(2k - 1) \cdot 17}{n^2} \)。

现在，回到 \( S_n \) 的原始表达式：
\( S_n = \sum_{k=1}^n \sqrt{(2k - 1)^2 + a_k^2} \)。
代入 \( a_k = \frac{17(2k - 1)}{n^2} \)，我们得到：
\( \sqrt{(2k - 1)^2 + \left( \frac{17(2k - 1)}{n^2} \right)^2 } = (2k - 1) \sqrt{1 + \left( \frac{17}{n^2} \right)^2 } \)。

所以，将该平方根从和中提取出来：
\( S_n = \sqrt{1 + \left( \frac{17}{n^2} \right)^2 } \cdot \sum_{k=1}^n (2k - 1) \)。
我们已经知道 \( \sum_{k=1}^n (2k - 1) = n^2 \)，所以这简化为：
\( S_n = \sqrt{1 + \left( \frac{17}{n^2} \right)^2 } \cdot n^2 = \sqrt{n^4 + 17^2} = \sqrt{n^4 + 289} \)。

等等，这似乎太简化了。让我检查一下我的步骤：
1. 我正确设置了拉格朗日函数。
2. 取导数并发现 \( a_k = \frac{2k - 1}{c} \)。
3. 将它们求和得到 \( c = \frac{n^2}{17} \)。
4. 代回 \( S_n \) 并提取出 \( (2k - 1) \)，所以每一项变为 \( (2k - 1) \sqrt{1 + \left( \frac{17}{n^2} \right)^2 } \)。
5. 由于 \( \sum (2k - 1) = n^2 \)，所以总和是 \( n^2 \times \sqrt{1 + \left( \frac{17}{n^2} \right)^2 } = \sqrt{n^4 + 17^2} \)。

是的，这似乎检查无误。所以，\( S_n = \sqrt{n^4 + 289} \)。等等，\( 17^2 \) 是 289。
因此，\( S_n = \sqrt{n^4 + 289} \)。我们需要它是一个整数。
所以，我需要找到一个整数 \( n \)，使得 \( n^4 + 289 \) 是一个完全平方数。
让我记 \( S_n = m \)，其中 \( m \) 是一个整数，所以：
\( n^4 + 289 = m^2 \)。

这意味着 \( m^2 - n^4 = 289 \)。
嗯，289 是 \( 17^2 \)。所以，\( m^2 - n^4 = 17^2 \)。这可以写成：
\( m^2 - n^4 = (17)^2 \)。

看着这个方程，它是一个平方差。
等等，\( m^2 - n^4 = (m - n^2)(m + n^2) = 17^2 = 289 \)。
所以，我们有 \( (m - n^2)(m + n^2) = 289 \)。
由于 \( m \) 和 \( n \) 是正整数，\( m - n^2 \) 和 \( m + n^2 \) 都是正整数且是 289 的因子。此外，\( m + n^2 > m - n^2 \)。

所以，由于 289 是 \( 17^2 \)，它的正因子对是 (1, 289) 和 (17, 17)。
因此，因子对是：
1. \( m - n^2 = 1 \) 且 \( m + n^2 = 289 \)。
2. \( m - n^2 = 17 \) 且 \( m + n^2 = 17 \)。

但第二种情况给出 \( m - n^2 = 17 \) 且 \( m + n^2 = 17 \)。
相减方程：\( (m + n^2) - (m - n^2) = 17 - 17 \) => \( 2n^2 = 0 \) => \( n^2 = 0 \)。但 \( n \) 是一个正整数，所以这种情况无效。

所以，我们只考虑第一种因子对：\( m - n^2 = 1 \) 且 \( m + n^2 = 289 \)。
相加两个方程：\( (m - n^2) + (m + n^2) = 1 + 289 \) => \( 2m = 290 \) => \( m = 145 \)。
相减两个方程：\( (m + n^2) - (m - n^2) = 289 - 1 \) => \( 2n^2 = 288 \) => \( n^2 = 144 \) => \( n = 12 \)，因为 \( n \) 是正数。

因此，\( n = 12 \)。
在得出结论之前，让我验证一下 \( S_n = \sqrt{12^4 + 17^2} = \sqrt{20736 + 289} = \sqrt{21025} = 145 \)，这确实是一个整数。
这是唯一的 \( n \) 吗？问题说有一个唯一的正整数 \( n \)，所以这一定是那个。

**Final Answer**
唯一的正整数 \( n \) 是 \boxed{12}。
</think>

text
Listing 6 | 来自代码相关推理数据的 SFT 轨迹示例。
## Question
在这个 kata 中，你的工作是创建一个 Dictionary 类，你可以向其中添加单词及其条目。示例：
'''python
>>> d = Dictionary()
>>> d.newentry('Apple', 'A fruit that grows on trees')
>>> print(d.look('Apple'))
A fruit that grows on trees
>>> print(d.look('Banana'))
Can’t find entry for Banana
'''
祝你好运，编码愉快！
这是设置代码：
'''python
class Dictionary():
def __init__(self):
# Your code
pass
def newentry(self, word, definition):
# Your code
pass
def look(self, key):
# your code
pass
'''
## Response
<think>
好的，我需要创建一个名为 Dictionary 的 Python 类。该类应该允许添加单词及其定义并查找它们。嗯，让我们考虑一下设置。

所以，当创建一个 Dictionary 对象时，比如 d = Dictionary()，我可能需要某种数据结构来存储单词及其条目。字典似乎非常适合这一点，因为它可以保存键值对，其中键是单词，值是定义。

所以在 __init__ 方法中，我应该初始化一个空字典。比如 self.entries = {}。

然后，有 newentry 方法。此方法接受两个参数：单词和定义。所以在 newentry 中，我需要将单词作为键，定义作为值添加到 self.entries 字典中。

现在，look 方法是用一个键调用的。如果键存在，它需要返回定义，否则返回一个字符串，说明找不到该条目。例如，查找 'Apple' 返回定义，但查找 'Banana' 返回 'Can’t find entry for Banana'。

等等，它如何处理大小写敏感性？我想我们假设键是大小写敏感的，按照传递的字符串。所以 'Apple' 与 'apple' 不同。

所以 look 函数的步骤是：检查键是否在 self.entries 中。如果是，返回该值。如果不是，返回特定的字符串。

把它们放在一起：
对于 __init__：
def __init__(self):
self.entries = {}

对于 newentry：
def newentry(self, word, definition):
self.entries[word] = definition

对于 look：
def look(self, key):
if key in self.entries:
return self.entries[key]
else:
return f"Can’t find entry for {key}"

等等，但在示例中，当 print(d.look('Banana')) 时，它打印的消息没有引号。所以该方法返回字符串，当打印时给出该输出。

所以，是的，那是正确的。

让我测试这个逻辑。
用示例测试：
d = Dictionary()
d.newentry('Apple', 'A fruit...') --> 添加到条目。
d.look('Apple') 返回字符串，所以打印显示正确。
d.look('Banana') 返回找不到消息。

那应该有效。

我认为这是基本计划。所以设置代码是给定的，我必须填写方法。所以在代码中，就像我写的那样。

等等，有什么边缘情况吗？比如，如果单词是空字符串怎么办？或者任何其他类型？问题没有指定处理这些，所以我认为代码应该按预期工作。

另一件事：在 look 方法中，当我们执行 'if key in self.entries' 时，它是否检查作为键的存在？是的，那是正确的。

所以，要实现：
首先添加描述的 __init__、newentry 和 look 方法。
</think>
要解决这个问题，我们需要创建一个名为 Dictionary 的 Python 类，它允许添加单词及其定义并查找它们。如果单词存在，该类应返回定义，如果不存在，则返回特定消息。

### Approach
1. **Data Structure**: 使用字典将单词作为键，定义作为值存储。这允许高效的查找和添加。
2. **Initialization**: 在 ‘__init__‘ 方法中，初始化一个空字典来存储单词定义。
3. **Adding Entries**: ‘newentry‘ 方法接受一个单词及其定义，然后将此对添加到字典中。
4. **Looking Up Entries**: ‘look‘ 方法检查字典中是否存在该单词。如果存在，它返回定义；否则，它返回一条消息，指示未找到该单词。

### Solution Code
'''python
class Dictionary():
def __init__(self):
self.entries = {}

def newentry(self, word, definition):
self.entries[word] = definition

def look(self, key):
if key in self.entries:
return self.entries[key]
else:
return f"Can’t find entry for {key}"
'''

### Explanation
1. **Initialization**: ‘__init__‘ 方法设置了一个空字典 ‘self.entries‘ 来存储单词及其定义。
2. **Adding Entries**: ‘newentry‘ 方法接受两个参数，‘word‘ 和 ‘definition‘，并将它们添加到 ‘self.entries‘ 中，其中 ‘word‘ 是键，‘definition‘ 是值。
3. **Looking Up Entries**: ‘look‘ 方法检查给定的键是否存在于 ‘self.entries‘ 中。如果找到该键，则返回其对应的定义。如果没有，则返回一条消息，指示该条目不存在。

这种方法使用字典数据结构确保了单词定义的高效存储和检索，为该问题提供了最优解。

text
Listing 7 | 来自非推理写作相关数据的 SFT 轨迹示例。
## Question
write a short poem ending in "was tentacles all along"
## Response
<think>
Okay, I need to help the user write a short poem that ends with "was tentacles all along." Hmm, ending with that specific line suggests a twist or surprise, maybe something unexpected.

First, I’ll think about the theme. Tentacles make me think of sea creatures, like octopuses or squids, so perhaps an underwater setting would work well. Maybe a treasure hunt or an adventure beneath the waves could set the scene.

I want the poem to build up anticipation. Starting with something mysterious, like shadows under the sea, could create intrigue. Then, introducing elements like a sunken chest or sailors’ lore might add depth and keep the reader engaged.

Rhyme scheme is important for a poem. I’ll probably go with something simple, like AABB or ABAB, to keep it flowing smoothly. Each stanza should have four lines to maintain structure.

Now, the twist at the end should be sudden but make sense. Perhaps the treasure they seek turns out to be something entirely different. The last line needs to be impactful, so building up the suspense through the previous lines will make the ending more surprising.

Let me outline the stanzas. The first stanza could set the scene with the ocean depths and a hidden secret. The second stanza can show the action, like diving for treasure, and then reveal the unexpected tentacles.

I’ll make sure each line flows naturally and the imagery is vivid. Using words like "waves," "shadows," "caverns," and "mystery" can help paint the picture. Ending with the twist will leave the reader with a lasting impression.

Alright, putting it all together, I’ll craft two stanzas that build up to the final line, ensuring the surprise feels satisfying and the poem feels complete.
</think>
Beneath the waves, where shadows creep,
A secret stirs in the ocean deep.
A sunken chest, a sailor’s song,
The mystery whispered all along.

We dove for pearls, for gold, for lore,
Through caverns dark, to the ocean floor.
But what we found, so strange, so strong--
It wasn’t treasure... it was tentacles all along.

B.4. 超参数

B.4.1. DeepSeek-R1-Zero-Qwen-32B 的超参数

为了训练 DeepSeek-R1-Zero-Qwen-32B，我们将学习率设置为 2e-6，KL 系数设置为 0.001，采样温度设置为 1 以进行 rollout。对于每个问题，我们采样 16 个输出，最大长度为 32,768。每个训练步骤包含 32 个独特的问题，导致每步的训练批次大小为 512。每 400 步，我们用最新的策略模型替换参考模型。为了加速训练，每个 rollout 生成 8,192 个输出，这些输出被随机分成 16 个小批次，并且仅训练单个内部 epoch。

B.4.2. SFT 的超参数

对于代码启动 SFT 和第二阶段 SFT，我们使用策划的数据集对 DeepSeek-V3-Base 进行了 2-3 个 epoch 的微调，如 B.3 中所述。我们采用余弦衰减学习率调度器，从 $5 \times 10^{-5}$ 开始，逐渐降低至 $5 \times 10^{-6}$ 。最大上下文长度设置为 32,768 个 token，批次大小为 128。

B.4.3. 蒸馏的超参数

对于蒸馏，我们使用 B.3.3 节中描述的 800k 数据对相应的基模型进行了 2-3 个 epoch 的微调。基模型和初始学习率列于表 6 中。我们采用余弦衰减学习率调度器，将学习率逐渐降低至其初始值的十分之一。最大上下文长度为 32,768 个 token，批次大小为 64。

表 6	DeepSeek-R1 蒸馏模型、其对应的基模型和初始学习率。
蒸馏模型	基模型
DeepSeek-R1-Distill-Qwen-1.5B	Qwen2.5-Math-1.5B
DeepSeek-R1-Distill-Qwen-7B	Qwen2.5-Math-7B
DeepSeek-R1-Distill-Qwen-14B	Qwen2.5-14B
DeepSeek-R1-Distill-Qwen-32B	Qwen2.5-32B
DeepSeek-R1-Distill-Llama-8B	Llama-3.1-8B
DeepSeek-R1-Distill-Llama-70B	Llama-3.3-70B-Instruct

B.4.4. 训练成本

关于我们对 DeepSeek-R1 的研究，我们利用 A100 GPU 为较小模型（30B 参数）的实验做准备。来自这个较小模型的结果很有希望，这使我们能够自信地扩展到 660B R1-Zero 和 R1。对于 DeepSeek-R1-Zero 的训练，我们使用了 648 H800 GPU，该过程需要大约 198 小时。此外，在 DeepSeek-R1 的训练阶段，我们使用了相同的 648 H800 GPU，在大约 4 天或大约 80 小时内完成了该过程。为了创建 SFT 数据集，我们使用了 5K GPU 小时。详细信息显示在表 7 中。

B.5. 奖励黑客攻击

在大语言模型训练的背景下，奖励黑客攻击是指模型利用奖励函数中的缺陷或偏差，从而在没有真正与底层人类意图对齐的情况下获得高奖励分数的现象。在我们的工作中，我们在使用有用奖励模型时观察到了这种奖励黑客攻击行为。具体而言，如果奖励模型包含系统性偏差或不准确性，大语言模型可能会学习生成被模型评为高分但偏离真实人类偏好的回答。这种不一致性可能表现为在需要复杂推理的任务上性能下降，如图 6 所示。

B.6. 语言一致性奖励的消融研究

为了研究语言一致性（LC）奖励的影响，我们对 DeepSeek-R1-Distill-Qwen-7B 进行了消融实验。该模型使用与 DeepSeek-R1 相同的冷启动数据，并且在强化学习过程中也表现出语言混合。结果如图 7 所示。可以看出，如果没有 LC 奖励，随着训练步骤的增加，语言一致性会逐渐恶化。然而，当应用 LC 奖励时，在整个训练过程中保持了稳定的语言一致性。对于基准测试性能，模型在数学基准测试上保持了相当的性能，而在编程基准测试上观察到轻微的下降。尽管这种对齐导致模型性能略有下降，但该奖励与人类偏好保持一致，使输出更具可读性。

| 表 7 | DeepSeek-R1 的训练成本，假设 H800 的租赁价格为每 GPU 小时 2 美元。 | | :--- | :--- | :--- | :--- | :--- | | 训练成本 | DeepSeek-R1-Zero | SFT 数据创建 | DeepSeek-R1 | 总计 | | H800 GPU 小时 | 101K | 5K | 41K | 147K | | 美元 (USD) | $202K |$ 10K | $82K |$ 294K |

C. DeepSeek-R1-Zero 的自我进化

C.1. 训练期间 DeepSeek-R1-Zero 推理能力的进化

我们分析了 DeepSeek-R1-Zero 在按难度级别（1-5）分层的 MATH 数据集上的性能。图 8 揭示了不同的学习模式：简单问题（级别 1-3）在训练初期迅速达到高准确率（0.90-0.95）并在整个训练过程中保持稳定，而困难问题显示出显著的改进——级别 4 问题从接近 0.78 提高到 0.95，最具挑战性的级别 5 问题表现出从接近 0.55 到 0.90 的最显著改进。

人们可能会发现反直觉的是，模型在较难问题（级别 3-4）上的准确率偶尔会以微小的优势超过其在较简单问题（级别 1）上的性能。这种明显的异常源于几个数据集特征。MATH 数据集分布不均匀，级别 1 问题仅占 500 个示例中的 43 个，而更高级别每个包含约 100 个问题。因此，模型在级别 1 上 95-97% 的准确率仅代表 1-2 个未解决的问题，主要是几何问题，模型仍然在这些问题上挣扎。此外，数学类别（几何、代数等）的分布因难度级别而异，这是由于数据集的构建方法所致。同样值得注意的是，这些难度级别是基于人类对问题复杂性的感知而不是机器学习考虑因素进行标注的。

尽管在比较原始准确率百分比时存在这些细微差别，但训练趋势仍然表明，虽然较简单的推理任务（对人类而言）在训练早期就被掌握，但模型在复杂推理问题（级别 3-5）上的能力随着时间的推移显著提高。

C.2. 训练期间 DeepSeek-R1-Zero 高级推理行为的进化

我们分析了模型在训练期间推理行为的变化。

首先，如图 9(a) 所示，我们统计了一些具有代表性的反思词，包括“wait”、“mistake”、“however”、“but”、“retry”、“error”、“verify”、“wrong”、“evaluate”和“check”。这些反思词是由 3 位人类专家选出的，他们被要求思考几个反思词，然后将它们合并成最终的词表。如图所示，随着训练的进行，反思行为的频率逐渐增加。具体而言，与训练开始时相比，反思词的计数增加了 5 到 7 倍，这表明强化学习在生成长链中间 token 方面起着关键作用。

其次，特定的反思行为可能会出现在训练的特定点。对“wait”一词的分析（图 9(b)）清楚地证明了这一点。这种反思策略在训练早期几乎不存在，在 4000-7000 步之间偶尔使用，然后在 8000 步之后表现出显著的峰值。这表明模型在发展的特定阶段学习到了不同形式的反思。

总之，我们观察到模型在训练期间的反思行为逐渐增加，而某些反思模式（如“wait”的使用）出现在训练过程的特定点。

D. DeepSeek-R1 的评估

D.1. 实验设置

基准测试：我们在 MMLU（Hendrycks 等人，2021）、MMLU-Redux（Gema 等人，2025）、MMLU-Pro（Wang 等人，2024）、C-Eval（Huang 等人，2023）、IFEval（Zhou 等人，2023b）、FRAMES（Krishna 等人，2024）、GPQA Diamond（Rein 等人，2023）、SimpleQA（OpenAI，2024a）、C-SimpleQA（He 等人，2024）、SWE-Bench Verified（OpenAI，2024b）、Aider（Gauthier，2025）、LiveCodeBench（Jain 等人，2024）（2024-08 – 2025-01）、Codeforces（Mirzayanov，2025）、中国全国高中数学奥林匹克（CNMO 2024）（CMS，2024）和 2024 年美国数学邀请赛（AIME 2024）（MAA，2024）上评估了模型。

具体而言，MMLU、MMLU-Redux、MMLU-Pro、C-Eval 和 CMMLU 是旨在评估模型在通用百科知识方面性能的多项选择基准测试。这些基准测试上的更高分数表明对世界知识的更广泛理解以及以多项选择格式正确回答问题的能力。SimpleQA 和 C-SimpleQA 评估模型在长尾知识上的性能，而 GPQA 评估解决物理、化学和生物学中博士水平任务的能力。IFEval 旨在评估模型生成所需格式输出的能力。FRAMES 和 DROP 专注于评估模型在处理和推理长文档方面的性能。除了这些标准基准测试外，我们还使用 LLM 作为法官来评估我们的模型在开放式生成任务上的表现。我们遵循 AlpacaEval 2.0 和 Arena-Hard 的原始评估协议，利用 GPT-4-Turbo-1106 进行成对比较。为了减轻长度偏差，仅向评估模型提供最终总结。

LiveCodeBench 和 Codeforces 旨在衡量模型在算法竞赛任务上的性能，而 SWE-Verified 和 Aider 评估模型在现实世界软件工程问题上的能力。最后，AIME、MATH-500 和 CNMO 2024 包含测试模型在数学领域推理能力的数学问题。

对于蒸馏模型，我们报告了在 AIME 2024、MATH-500、GPQA Diamond、Codeforces 和 LiveCodeBench 上的代表性结果。

去污染：为了防止基准测试污染，我们对预训练和训练后数据实施了全面的去污染程序。DeepSeek-V3 base 的知识截止日期为 2024 年 7 月，早于 CNMO 2024 等评估基准测试，并且我们过滤掉了任何包含来自评估问题或参考解决方案的匹配 10-gram 序列的文本片段（包括网页和 GitHub 文件）。作为我们去污染工作的一个例子，仅在数学领域，我们的去污染过程就识别并删除了大约 600 万个潜在的预训练文本。对于训练后，数学 SFT 数据和强化学习训练提示完全来源于 2023 年之前的竞赛，并经历了与预训练中使用的相同的 n-gram 过滤协议，确保训练和评估数据之间没有重叠。这些措施确保我们的模型评估结果反映了真正的解决问题能力，而不是对测试数据的记忆。

然而，我们承认基于 n-gram 的去污染方法无法防止测试集的改写。因此，2024 年之前发布的基准测试可能存在污染问题。

评估提示：遵循 DeepSeek-V3 中的设置，MMLU、DROP、GPQA Diamond 和 SimpleQA 等标准基准测试使用来自 simple-evals 框架的提示进行评估。对于 MMLU-Redux，我们在零样本设置中采用 Zero-Eval 提示格式（Lin，2024）。就 MMLU-Pro、C-Eval 和 CLUE-WSC 而言，由于原始提示是少样本的，我们稍微修改了提示以适应零样本设置。少样本中的 CoT 可能会损害 DeepSeek-R1 的性能。其他数据集遵循其创建者提供的默认提示的原始评估协议。对于代码和数学基准测试，HumanEval-Mul 数据集涵盖了八种主流编程语言（Python、Java、C++、C#、JavaScript、TypeScript、PHP 和 Bash）。模型在 LiveCodeBench 上的性能使用 CoT 格式进行评估，数据收集于 2024 年 8 月至 2025 年 1 月之间。Codeforces 数据集使用来自 10 个 Div.2 竞赛的问题以及专家制作的测试用例进行评估，之后计算竞争对手的预期评分和百分比。SWE-Bench 验证结果通过 agentless 框架（Xia 等人，2024）获得。AIDER 相关基准测试使用“diff”格式进行测量。DeepSeek-R1 的输出在每个基准测试中上限为 32,768 个 token。

表 18 到表 32 展示了我们在不同基准测试上的评估格式示例。我们还详细说明了每个基准测试评估的每个大语言模型的具体能力，并在相应的表格标题中进行了说明。

基线：我们针对几个强大的基线进行了全面评估，包括 DeepSeek-V3、Claude-Sonnet-3.5-1022、GPT-4o-0513、OpenAI-o1-mini 和 OpenAI-o1-1217。由于在中国大陆访问 OpenAI-o1-1217 API 具有挑战性，我们根据官方报告报告其性能。对于蒸馏模型，我们还比较了开源模型 QwQ-32B-Preview（Qwen，2024a）。

我们将模型的最大生成长度设置为 32,768 个 token。我们发现使用贪婪解码来评估长输出推理模型会导致更高的重复率和不同检查点之间的显著变异性。因此，我们默认使用 pass@k 评估（Chen 等人，2021），并使用非零温度报告 pass@1。具体而言，我们使用 0.6 的采样温度和 0.95 的 top-p 值来为每个问题生成 k 个回答（通常在 4 到 64 之间，取决于测试集大小）。具体而言，我们对 AIME 和 GPQA 使用 k = 64，对 MATH 和 CodeForces 使用 k = 16，对 LCB 使用 k = 8。Pass@1 计算为：

\text{pass@1} = \frac{1}{k} \sum_{i=1}^k p_i

其中 $p_i$ 表示第 i 个回答的正确性。此方法提供了更可靠的性能估计。对于 AIME 2

精粹译文