PRM过程奖励模型与GRPO算法：数学推理模型的第二代演进

TL;DR
在RL101中介绍了第一代模型中基于SFT+RM+PPO构建的基础对齐能力。但是标准的 RLHF 仅检查最终答案，难以解决多步推理中的错误，特别是对于数学推理和复杂的逻辑任务有很多缺陷。因此第二代模型主要是增强推理能力，即System 2 thinking（慢思考和逻辑推理），让AI模型在每次决策前进行相对漫长的深思熟虑。

这一篇我们将详细介绍思维链（COT）、思维树（TOT）、思维图（GOT）、Branch-Solve-Merge（BSM）、System 2 Attention（S2A）、Rephrase and Respond（RaR）、MCTS、Self-Play等方法在第二代模型中曾经尝试过的一些方法。然后我们会基于《DeepSeekMath》[1]来展开介绍一下GRPO算法。然后下一篇文章详细分析一下DeepSeek-R1/V3.2/GRM相关的论文。

本文目录如下：

1. Overview
2. Test-Time Computation框架
2.1 从一些例子谈起
2.2 Test-Time Computation的统一视角:Proposer + Verifier
2.3 如何以最优方式扩展Test-Time Computation
2.3.1 改进Verifier
2.3.1.1 PRM打分机制
2.3.1.2 针对PRM的搜索方法
2.3.2 优化Proposer
2.3.2.1 SFT训练一个修正模型
2.3.2.2 推理时使用修正模型
2.3.3 MCTS搜索策略
2.3.3.1 MCTS算法介绍
2.3.3.2 以rStar为例
3. PRM模型训练
4. 以DeepSeek-Math为例
4.1 SFT
4.2 GRPO
4.2.1 从PPO到GRPO
4.2.2 GRPO 和 奖励模型
5. 统一范式
5.1 各种对齐算法对比
5.1.1 SFT
5.1.2 RFT
5.1.3 Online RFT
5.1.4 DPO
5.1.5 PPO
5.1.6 GRPO
5.2 不同对齐算法的分析
5.2.1 数据源分析
5.2.2 奖励来源分析
5.2.3 梯度系数分析
6. 总结

1. Overview

在以ChatGPT为代表的第一代SFT+RM+PPO模型发布后，我们也逐渐遇到了很多问题：

• 问题1：复杂数学/推理任务仍然很差  
• 问题2：代码生成错误率高，无法自我修正  
• 问题3：多步骤任务经常中途失败  
• 问题4：幻觉的影响，即模型“自信地犯错”并胡言乱语  

在前一篇文章谈到过主要的问题有几个方面：

1. 稀疏且模糊的奖励信号：这是最致命的问题。想象一个需要20步才能解决的复杂数学题。如果模型在第2步就犯了一个微小的计算错误，导致最终答案错误，那么ORM只会给出一个冷冰冰的“0分”。模型完全不知道是哪一步错了，它只知道“这次尝试失败了”。对于模型来说，一个99%正确的解和一个完全错误的解，得到的反馈可能完全一样。这种非0即1的稀疏奖励使得学习效率极低。另一个稀疏奖励的直接后果是Credit分配相关的问题：当一个长序列行为（生成解答）只在最后得到一个奖励时，我们很难将这个奖励（或惩罚）公平地分配给序列中的每一步行为。模型无法判断到底是哪个词、哪个公式导致了最终的成功或失败。

2. Reward Hacking：由于奖励只看结果，模型可能会学会一些“投机取巧”的方法。例如，它可能发现某些问题可以通过猜测或套用一个看似正确但不严谨的模板来得到正确答案。结果奖励模型会奖励这种行为，但模型并没有真正学会逻辑推理。这就像是一个学生不做演算，靠背答案来通过考试，知识并没有内化。

正是这些问题，使得LLM在处理复杂推理任务（如数学问题）时不可靠，正确率低。这本质上是一个序列决策问题，模型需要生成一系列的token，最终形成一个完整的解题步骤和答案。那么我们势必要对整个过程进行详细的评估，也就是需要构造一个过程奖励模型（Process Reward Model, PRM）。它会审查解答的每一步，并对每一步的正确性给出一个分数。例如，“第一步，设变量，正确（1分）”；“第二步，列出方程，正确（1分）”；“第三步，化简方程，计算错误（0分）”。

另一方面，假设在整个过程中，从某一个步骤开始错了，需要回溯到正确的位置继续探索，或者有些数学问题需要枚举或者递归解决。这样就引入了一些搜索机制。

PRM的出现，不仅革新了模型的训练方式，更关键的是，它为“测试时间扩展/计算”（Test-Time Scaling/Computation）打开了大门。这个概念的核心思想是：与其只依赖于更大、更昂贵的模型（扩展训练成本），我们不如让一个相对较小的模型在遇到难题时，投入更多的“思考时间”（即测试时的计算资源）来寻找最佳答案。

PRM正是实现这一点的关键。因为PRM能够评估中间步骤，它可以在模型生成答案的过程中实时引导，帮助模型像下棋一样进行“深思熟虑”的搜索：探索多种可能性，剪掉错误的推理分支，并将计算力集中在最有希望的路径上。最终，这形成了一种新的性能提升范式：通过智能地在测试时分配计算资源，一个更小的模型在特定任务上，其表现甚至可以超越一个大很多倍但只会“草率作答”的巨型模型，实现了计算效率的飞跃。

渣注
对于Test-Time Scaling做一个简单的类比。想象一下，你要提升一个AI助手的解题能力。你有两种方法：  

1. “送去读博”（Train-Time compute）：花费巨大的时间和金钱，把它训练成一个拥有海量知识的“超级大脑”（即通过训练扩大模型规模）。这个“超级大脑”反应很快，但打造成本极高。  
2. “给它一支笔和一沓草稿纸”（Test-Time Compute）：我们不追求极致的大脑，而是用一个“优秀本科生”级别的大脑。当它遇到难题时，我们允许它在草稿纸上反复演算、尝试多种方法、自我检查和修改。  

第二种方法可以更好的扩展，并且让AI通过以下方式打草稿（Thinking）：  

• 遇到简单题，就快速检查一遍，改改小错误就行了（即迭代修正策略）。  
• 遇到中等难题，就要多想几种可能性，像下棋一样推演几步看看哪条路对（即搜索策略，例如Beam Search）。  
• 遇到超级难题，可能得天马行空地想出很多种完全不同的解法，再从中选一个看起来最靠谱的（即广泛采样策略，例如Best-of-N）。

2. Test-Time Computation框架

人类倾向于在难题上思考更长时间，以可靠地提高其决策质量。我们能否将类似的能力赋予当今的大型语言模型（LLMs）？更具体地说，给定一个具有挑战性的输入查询，我们能否让语言模型在测试时最有效地利用额外的计算，以提高其响应的准确性？理论上，通过在测试时应用额外的计算，LLM应该能做得比它被训练去做的更好。接下来我们以比较有代表性的两篇文章来介绍整个Test-Time Computation框架：

• OpenAI：《Let’s Verify Step by Step》[2]  
• Google DeepMind：《Scaling LLM Test-Time Compute Optimally can be More Effective than Scaling Model Parameters》[3]

2.1 从一些例子谈起

Test-Time Computation的实质是什么？相对于原来的LLM有什么变化？首先它定义了算力消耗在推理阶段，也就是说不变动模型已经训练完成的权重情况下，去通过推理阶段的运算改变模型预测输出的分布，使得模型能够生成更好的答案。

一个很自然的想法是，我们通过在原始Prompt的基础上添加一组额外的 token（例如构造CoT Prompt），使 LLM 基于这个增强后的上下文生成一个被修改后的分布来输出更好的答案，如下例子所示：

这一部分更详细的内容可以参考论文《Chain-of-Thought Prompting Elicits Reasoning in Large Language Models》[4]。当你的Prompt描述的越细致，模型的输出效果可能就越好。同时更长的Prompt实质上也增加了推理时间的算力开销。

但是，我们不可能为各种问题都去“手工”构建这么精细的Prompt，是不是能让模型自己来一步步的构造呢？在这个过程中我们以一个生活化的场景来做比喻。

假设你刚搬到一个新地方，想找到附近最好吃的一家餐馆。“最好吃的餐馆”就是我们想得到的理想答案。但这个答案你一开始是不知道的。你会怎么做呢？

传统的LLM
你问他：“附近哪家好吃？” 他凭直觉回答：“街角那家‘渣B拉面’好像还行。”
‘渣B拉面’可能只是他随便想到的，完全不靠谱。质量没保证。

Best-of-N + ORM
你觉得LLM的输出不靠谱，可能会继续问一个问题，多推荐附近几家餐馆，LLM凭感觉给你推荐了5家餐馆（这就是 N=5 的采样）：

1. 渣B拉面  
2. 李氏快餐  
3. 赵家烧烤  
4. 孙奶奶饺子馆  
5. 周黑鸭  

然后打开大众点评（作为ORM的结果验证者）来得到餐馆的评分，最终评分如下：

1. 渣B拉面：3.5星  
2. 李氏快餐：3.2星  
3. 赵家烧烤：4.3星  
4. 孙奶奶饺子馆：4.1星  
5. 周黑鸭：4.8星（其实是一家卖鸭脖的，但评分最高）  

但是大众点评的评分（ORM）可能有水分，或者不符合你的口味。它把不是餐馆的“周黑鸭”评为最高分，说明这个“结果验证者”有局限。另一方面如果LLM推荐的这5家本身都很一般，你也只能从中选一个相对不那么差的。

PRM + 树搜索
这次，你请来了一位真正的本地美食家老饕（他就是 PRM / 过程验证者）。你不再让LLM一次性想5个，而是让他和你一起边走边找。

1. 第一步：你们站在十字路口。LLM说：“我们可以往东走，那边好像有吃的；或者往南走，我记得也有。”（这是生成两个“第一步”的提议）  
2. 过程验证：美食家老饕立刻说：“别往东！东边都是写字楼，没什么好吃的。往南走，那条街有几十年历史了，肯定有地道小馆。”（这是 PRM 对第一步进行打分和剪枝）  
3. 第二步：你们往南走。LLM指着一家装修豪华的海鲜酒楼说：“这家看起来不错！”（这是生成“第二步”的提议）  
4. 过程验证：老饕又发话了：“这家是连锁店，没特色，宰游客的。你看它旁边那条不起眼的小巷子，闻到香味了吗？往巷子里走。”（这是 PRM 再次指导方向）  
5. 找到答案：你们走进巷子，发现一家没有招牌但座无虚席的小店，这就是传说中的神级小馆。

这个过程就是树搜索：

• 你们的每一步选择，都构成了一棵“探索之树”。  
• 老饕（PRM）在每个分岔路口，都帮你排除了不好的选择，把你的精力（计算资源）集中在最有希望的路径上。  
• 这种方法比场景二的“先列出5个再比较”要高效得多，也更可能找到真正的好答案。

MCMC
你找餐馆的过程，就像在一个巨大的“美食地图”上移动。

• 你的提议者（LLM）负责在你的当前位置附近，提出下一个要去的地方。  
• 你的验证者（美食家老饕）负责判断这个提议好不好，决定你是否“移动”到那个新地方。  

通过LLM不断地“提议”，和老饕不断地“把关”，你在这张地图上的位置，就从一个随机的起点，慢慢地、一步步地逼近那个“全城最好吃餐馆”的最终目标点。

这个“提议-验证-移动”的循环过程，就是MCMC。它把一个大海捞针的难题，分解成了一系列更简单的、局部的决策。

2.2 Test-Time Computation的统一视角：Proposer + Verifier

在Google DeepMind这篇论文的第二章中，作者想做一件事：把所有五花八门的“让AI深度思考”的方法，梳理成一个简单清晰的框架。他们说，无论方法多复杂，归根结底都是在做两件事中的一件，或者两件都做。

想象AI在解题，这个过程可以分为两步：

1. 提出想法（Proposer）：AI大脑里冒出各种解题思路。  
2. 筛选想法（Verifier）：从这些思路里挑出最好的一个。

要让 AI 更聪明，就可以从这两个环节入手：

1. 改进Proposer
这就像是提升AI的“第一直觉”或“创造力”，让它更容易想出靠谱的思路。怎么做呢？

• 训练时的方法：SFT/RL：就像给运动员做专项训练一样，用一些高级的训练技巧（比如强化学习）专门针对解题任务来“打磨”AI，让它天生就更擅长这类问题，代表性的方法：STaR / ReSTEM  
• 测试时的方法：自我反思：教会AI一种“自我修正”的思考模式。当它想出一个答案后，不会马上停下，而是会对自己说：“等一下，我再看看这个答案，哪里可以改进一下？” 然后它会基于上一个答案，提出一个更好的新答案。这种方法是在回答问题当时动态地提升自己。

2. 改进Verifier
这就像是给AI配一个火眼金睛的裁判，帮它从一堆想法里选出真正的黄金。

• ORM（结果验证者）：粗略的裁判：最简单的方法是让AI想出N个完整的答案，然后让“裁判”看一眼最终结果，挑一个它觉得最顺眼的。这就是我们常说的“Best-of-N”。  
• PRM（过程验证者）：精细的裁判：更高级的“裁判”不止看最终结果，它会盯着AI解题的每一步。AI每写一步，它就评判一下：“嗯，这步走得不错” 或者 “等等，这步可能有问题”。这种“过程裁判”（PRM）能提供更精细的指导，帮助AI在解题过程中进行更智能的探索，就像在迷宫里每一步都有人指路，而不是走到死胡同才知道错了。

对于论文中提到的几种方法按照这个统一的框架总结整理如下：

2.3 如何以最优方式扩展Test-Time Computation

在统一了各种方法之后，我们现在希望理解如何最有效地利用测试时计算来提升语言模型在给定提示上的性能。具体来说，我们希望回答：

在有一笔固定的“思考预算”（比如允许模型额外计算1分钟），应该如何最聪明地花掉这些算力？

对于同样是一分钟的预算，我们可以：

• 并行策略（广撒网）：让AI用1分钟同时想出60个完全不同的答案，然后挑最好的。  
• 串行策略（深度打磨）：让AI用10秒钟想出一个答案，然后用剩下的50秒对这个答案进行5轮修改和完善。  
• 混合策略：先并行想出8个初步想法，然后对每个想法分别进行深度打磨。

那么哪种策略最好？DeepMind这篇论文作者的直觉是：这取决于问题的难度。

• 对于简单题，模型的第一直觉通常就差不离了。这时候用“深度打磨”策略，稍作修改，效果就很好。  
• 对于难题，模型的第一直觉可能完全错了。这时候就需要“广撒网”，探索各种风马牛不相及的解题思路，增加“撞大运”撞上正确思路的概率。

基于这个直觉，作者正式提出了他们的核心观点：“计算最优扩展策略”。简单来说：针对每一个具体的问题和每一笔特定的预算，都能找到那个能让正确率最大化的分配算力的方法（即某个超参数组合）。大概的步骤如下：

1. 给问题划分难度等级。怎么判断一个问题对模型来说是难是易？不是人说了算，而是让AI自己“感受”。具体做法是，让模型先对着一个问题快速地做上千次（比如2048次），看看它能做对几次。  

   • 如果做对的比例很高，那就是简单题。  
   • 如果几乎没做对过，那就是究极难题。通过这种方式，他们把所有问题分成了5个难度等级，从1级（最简单）到5级（最难）。  

2. 为每个难度等级“定制”最佳策略。现在，他们就可以针对每一个难度等级来寻找最佳的算力分配策略了。比如，他们会去测试：  

   • 对于“难度2”的问题，在“1分钟预算”下，是“并行60个”效果好，还是“串行打磨6次”效果好？  
   • 对于“难度4”的问题，在“5分钟预算”下，哪种混合策略最强？经过大量的实验，他们就能为每个难度等级都找到一套“最优攻略”。  

3. 以后再遇到一个新问题，模型会先判断它属于哪个难度等级，然后直接调用该等级对应的“最优攻略”来解决它。

渣注
实质上这个算力分配的问题是在RL中的一个经典的问题，如何平衡探索（Exploration）vs. 利用（Exploitation）。接下来我们将分开讨论，首先探讨如何改进Verifier，即在采用PRM如何指导模型在多个答案中的探索和利用。然后再来讨论如何优化Proposer。

2.3.1 改进Verifier

首先作者对于两种 Verifier 进行了对比分析，通过一些实验发现 PRM 优于 ORM。具体如何训练这样一个 PRM 我们将在后续的章节中详细展开，这里我们只需要了解在第二代的模型中Verifier从 ORM 到了 PRM，那么基于 PRM 应该如何探索呢？

前一篇文章谈到了 KL 惩罚是一种“软约束”，它惩罚偏离，而不指导方向。另一方面 KL 惩罚只在策略模型做出“出格”行为后才施加惩罚。它并没有主动提供信息，告诉模型在保持“正常”的同时，应该朝哪个有益的方向去探索。实际上我们需要通过 PRM 和 RL 的方法让模型自己去找到一个更有益的方向进行探索。

关于PRM的训练，我们将在稍后的章节补充。

2.3.1.1 PRM打分机制

另一方面，对于从 PRM 可以用来为一组从基础模型中采样的答案里的每一个独立步骤进行打分。为了用 PRM 来选出 N 个答案中最好的一个（best-of-N），我们需要一个函数，它能够聚合每个答案的所有步骤级分数，以确定正确答案的最佳候选者。

步骤级聚合（从“过程”到“结论”）
这个阶段的目标是为每一个候选答案计算一个总分。例如，分步骤的分数是 [0.9, 0.8, 1.0]：

• 如果使用乘积法，总分就是 0.9 × 0.8 × 1.0 = 0.72。但是只要中间有一个步骤的分数很低（比如0.1），整个解法的总分就会被急剧拉低，即使其他步骤都完美。  
• 如果使用最小值法，总分就是 min(0.9, 0.8, 1.0) = 0.8。它完全忽略了其他所有步骤的分数。一个解法可能有9步都是0.99分，只有一步是0.8分，它的总分就会和另一个只有一步0.8分的糟糕解法一样。  

还有一种方法是末位法，只采用最后一个步骤的PRM分数作为整个解法的总分。这看起来很奇怪，仿佛丢弃了所有中间信息。但是PRM 被训练来预测“从当前步骤开始，最终能得到正确答案的概率”。实质上就构成一个 RL 算法的价值函数。

答案间聚合（从“多个结论”到“最终裁决”）
现在，N个候选解法每个都有了一个总分。下一步是在它们之间做出选择。标准 Best-of-N 直接选择总分最高的那个候选解法，并把它的答案作为最终答案。但是，假设有两个解法，A和B。A的答案是“5”，总分是0.9。B的答案也是“5”，总分是0.88。C的答案是“6”，总分是0.91。标准Best-of-N会选择C，因为它的分数最高。但实际上，有两个独立的、高分数的“证据”都指向了答案“5”，这似乎更可信。

因此需要一种分组加权的 Best-of-N 方法。例如有 4 个答案：

• 解法A：答案“5”，分数0.9  
• 解法B：答案“5”，分数0.88  
• 解法C：答案“6”，分数0.91  
• 解法D：答案“5”，分数0.7  

首先根据答案分组：

• “5”组：{A, B, D}  
• “6”组：{C}  

然后分组加权：

• “5”组的总权重 = 0.9 + 0.88 + 0.7 = 2.48  
• “6”组的总权重 = 0.91  

2.3.1.2 针对PRM的搜索方法

有了完善的打分方法后，那么我们就可以来考虑 PRM 的进行探索，主要有如下几种搜索算法：

• Best-of-N 加权：基准方法。像海选一样，产生 N 个独立的完整答案，然后用 PRM 加权投票选出最终答案。这种方法探索范围广，但没有方向性。这是最简单的蒙特卡洛方法。它通过随机采样来近似全局最优解。它的优点是无偏性（理论上只要采样足够多，总能找到最优解），并且是全局探索（global exploration）。缺点是采样效率极低，尤其是在解空间巨大且优解稀疏的情况下（如复杂数学问题）。  

• Beam Search：一种更聪明的搜索。它每走一步，都保留最有希望的几个“半成品”答案，然后从这些半成品出发继续下一步。这是一种贪心策略，旨在利用PRM的每一步指导，尽快找到高分路径。这是一种启发式搜索，具体来说是贪婪最佳优先搜索（Greedy Best-First Search）的一种变体。PRM在这里扮演了启发函数（heuristic function）的角色，用来估计一个节点（部分解）到目标的距离。它的本质是利用（exploitation），相信启发函数能引导到最优解。  

• Lookahead Search：Beam Search的加强版。在决定下一步走哪里时，它会“向前看 k 步”，模拟一下如果走了这一步，k步之后的情况会如何，然后用这个未来的结果来评估当前的选择。这旨在克服Beam Search的“短视”问题。这是对启发函数的改进。通过 k 步前瞻，它试图计算一个更精确的价值函数，类似于强化学习中的 n-step return 的思想。它可以被看作是蒙特卡洛树搜索（MCTS） 在一个确定性环境下的简化版本（没有UCT项来平衡探索与利用）。

对于搜索策略如何选择？通常需要考虑两个维度：

• 在算力预算固定时，哪种策略最优？  
• 对于不同难度的问题，哪种策略最优？  

作者做了一些实验：

对于第一个问题如下左图所示，在较小的生成预算下，Beam Search显著优于best-of-N。然而，随着预算的扩大，这些优势大大减弱，Beam Search的表现常常低于best-of-N基线。而Lookahead Search在相同的生成预算下通常表现不如其他方法，这可能是由于Lookahead展开所引入的额外计算导致的。

实际上在固定算力预算下寻找最优算法的过程可以被看作一个巨大的由语言模型所有可能输出构成的图（graph）中进行搜索。目标是找到一条从问题到正确答案的路径，该路径的价值（由PRM评估）最高。选择哪一种算法实质核心矛盾在于 探索（Exploration） vs. 利用（Exploitation）。Best-of-N 是纯粹的探索，Beam Search是强烈的利用。

对于第二个问题，虽然在总体上，Beam Search和best-of-N在高生成预算下表现相似，但在难度分箱上评估它们的效能揭示了非常不同的趋势。

• 在简单问题上（1级和2级），两种方法中更强的Beam Search，随着生成预算的增加性能下降，显示出利用PRM信号的迹象。  
• 在较难的问题上（3级和4级），Beam Search持续优于best-of-N。  
• 在最难的问题上（5级），没有任何方法取得太多有意义的进展。  

Beam Search在简单问题上随着算力预算增加反而失败是“利用”一个有缺陷的启发函数（PRM）的恶果。当基础模型本身已经能很好地“探索”到正确答案附近时，一个有噪声的启发函数反而会把搜索带偏。这说明，提升性能的关键不仅仅在于设计更强的搜索算法（更强的“利用”），也在于提升启发函数的质量，即 PRM 的准确性和鲁棒性。

2.3.2 优化Proposer

如何让模型从一开始就生成更高质量的“提议”，从而减少对后续挑选过程的依赖？

2.3.2.1 SFT训练一个修正模型

首先，我们是否可以通过SFT让模型能够按照给定的格式生成结果？即训练一个“修正模型”（Revision Model）

例如我们构造包含一系列错误答案后跟一个正确答案的轨迹，然后我们可以在这些轨迹上运行SFT。对于数据构造，如下所示：

我们可以按照如下方式构建数据集：

1. 对一个问题并行采样，一次性生成大量（如64个）答案。  
2. 区分出其中的正确答案和错误答案。  
3. 为每个正确答案，从错误答案池中挑选几个，“伪造”出一条修正历史。比如 [错误答案1, 错误答案2] -> [正确答案]。  
4. 智能配对：为了使修正更有意义，作者使用字符编辑距离（Character Edit Distance） 来优先选择与正确答案“长得像”的错误答案作为修正前的版本。例如你要教一个孩子从一个错误的算式 2 + 3 = 6 改正到正确的算式 2 + 3 = 5。

• 有意义的修正：孩子看到 2 + 3 = 6 后，意识到是计算结果错了，于是把 6 改成了 5。这个过程中，他保留了 2 + 3 这部分正确的推理，只修改了错误的部分。这是我们希望模型学习的。  
• 无意义的修正：孩子看到 2 + 3 = 6 后，完全无视它，重新在旁边写下 2 + 3 = 5。从结果上看，他也得到了正确答案，但他并没有学会“从错误中定位并修正问题”这个关键技能。他只是学会了“遇到错误就重来”。

这样构建出的训练数据对（错误答案 -> 正确答案）就具有了以下特点：

• 错误答案和正确答案在形式上非常相似。  
• 这很可能意味着它们在解题思路上也大部分重合，只是在某个关键点上犯了小错误（比如一个计算错误、一个笔误、一个逻辑跳步）。  
• 通过学习大量这样的例子，模型就能学会定位并修复这些细微的、局部的错误，而不是简单粗暴地推倒重来。这就是所谓的“更有意义的修正”。

理想情况下，我们希望正确答案与上下文中提供的错误答案相关联，以便有效地教模型识别上下文中提供的示例中的错误，然后通过进行编辑来纠正这些错误，而不是完全忽略上下文中的示例并从头再试。

渣注
实际上这一个“修正模型”（Revision Model）是在试图通过SFT产生一个自我修正的处理格式，使得模型在推理阶段会根据这样的格式（范式）进行处理。

2.3.2.2 推理时使用修正模型

给定一个在前一节SFT好的修正模型 M，对于一个问题 Q，我们可以在推理时从模型采样到一个修正序列。对于相同的预算，例如采样 N 次，我们有两种方法：

并行采样
通过一个Batch N，并行的一次性地、独立地从模型中采样 N 个不同的答案。每个采样过程之间没有信息交换。采样i 不知道 采样j 的结果。这是一个广度优先搜索，N 个成员同时开始，各自独立地想出一种完整的解法，最后汇总起来挑最好的。

在比较 N 个不同的答案时，可以选择多数投票的方式，也可以通过Verifier对每个答案进行打分处理。

顺序采样
修正序列产生如下：

1. 生成初始答案：模型首先像一个普通LLM一样，只根据问题生成第一个答案。  
2. 第一次修正：模型将问题 Q 和第一个答案 o_1 一起作为输入，生成第一个修正版。  
3. 第二次修正：模型将问题 Q 和历史答案 o_1, o_2 一起作为输入，生成第二个修正版。  
4. ...依此类推，直到达到预设的计算预算（例如，N步修正）。

虽然训练的时候修正模型只在最多四个先前答案的上下文中进行训练，但我们可以通过将上下文截断为最近的四个修正响应来采样更长的链。例如当我们进行第五次修正时，模型的输入不是 Q, o_1, o_2, o_3, o_4, o_5，而是 Q, o_2, o_3, o_4, o_5，因为模型“看不懂”超过4个历史答案的输入。

这种做法类似于深度优先搜索，就像一个解题者，写出初稿，然后反复修改，每一次修改都试图让答案变得更好。

通过实验，随着从修正模型中采样更长的链，模型在每一步的pass@1 逐渐提高，这表明我们能够有效地教模型从上下文中先前答案所犯的错误中学习。

但是，推理时存在分布偏移：

• 训练时：模型的输入历史总是错误答案。它学会的是“从错误中找到正确”。  
• 推理时：在修正序列中，某个答案 o_i 可能已经是正确答案了。当这个正确的 o_i 被送入模型作为历史时，模型可能会“犯糊涂”。因为它没在训练中见过这种情况，它可能会机械地应用它学到的“修改”模式，无意中把一个正确的答案改成错误的。

作者发现，“大约38%的正确答案会被转换回不正确的答案”。为了解决上述挑战，不能信任修正序列的自然终点，而是需要一个选择机制 来从整个修正序列 {o_1, ..., o_N} 中挑选出最好的一个。这就像是一个作家写了10个修改稿，他不会默认第10稿就是最终稿，而是会把10个稿子都摆出来，从中挑选出最满意的一版。

作者给出了两种方法：

1. 顺序多数投票：从修正序列 {o_1, ..., o_N} 中提取出每一个答案的最终数值（例如，答案分别是 "5", "6", "5", "5", "7"）。统计哪个数值出现的次数最多。在这个例子里，"5" 出现了3次。最终答案就是 "5"。  
2. 基于Verifier的选择：使用一个PRM，对修正序列中的每一个答案 o_i 进行打分。选择分数最高的那个答案作为最终答案。

对于并行采样和顺序采样，作者进行了一些实验，结果如下图所示，无论是使用基于验证器的选择机制还是基于多数投票的选择机制，顺序采样解决方案都优于并行采样。

然而，并行采样答案可能更像一个全局搜索过程，理论上可以覆盖许多完全不同的解决问题的方法，例如，不同的候选者可能利用完全不同的高层方法。另一方面，顺序采样可能更像一个局部优化过程，修正那些已经大体在正确轨道上的响应。两者互补的策略是否会更好呢？

为了理解如何最优地分配顺序和并行计算，作者对多种不同的比率进行了一次扫描。在左图中看到，在给定的生成预算下，存在一个理想的顺序与并行比率，该比率能实现最大准确率。而在右图中看到，理想的顺序与并行比率根据给定问题的难度而变化。特别是，简单问题更多地受益于顺序修正，而在难题上，在顺序和并行计算之间取得平衡是最佳的。

2.3.3 MCTS搜索策略

在前一节中讨论了并行采样和顺序采样以及在两种采样算法中的算力分配的问题。接下来聪明的你肯定会想到，其实本质上它是在“探索”（并行采样）和“利用”（顺序采样）之间的平衡，是通过一个固定的、手动的超参数（并行/顺序比率）来实现的。对于强化学习算法而言，本质上需要在“探索”和“利用”之间平衡，如何能够做到动态的进行平衡呢？

既然 PRM 能够对过程中的每一步打分评估，那么我们在搜索策略上是否可以借鉴MCTS（蒙特卡洛树搜索策略）呢？

2.3.3.1 MCTS算法介绍

MCTS 在一个单一的、共享的树结构中进行探索。这棵树代表了所有可能的解题路径。MCTS 通过 UCT 公式，能动态地将计算资源分配给当前看来最有希望的分支。如果一条路径在模拟中反复得到高分，MCTS 就会投入更多精力去探索这条路径的深层细节。如果一条之前看起来很有希望的路径，深入探索后发现是个死胡同（模拟得分变低），MCTS 会自然地减少对它的关注，并将资源转移到其他“探索性”的分支上。它能做到“及时止损”和“灵活转向”。

MCTS的算法每轮迭代分为四步：

1. 选择（Selection）：从树的根节点（当前状态）开始，沿着树向下遍历，直到找到一个“有潜力”的叶子节点。“有潜力”意味着这个节点还没有被完全探索过。通常的做法是在每一层，使用一个选择策略来决定进入哪个子节点。这个策略必须平衡 “利用” 和 “探索”。最常用的策略就是 UCT 公式。算法会一直向下走，直到遇到一个没有被扩展过的节点，或者该节点是终止节点。  
2. 扩展（Expansion）：当“选择”步骤到达一个叶子节点 L 时，如果这个节点不是一个终止状态，就在树中为它创建一个或多个子节点。通常的做法是根据当前状态 L 所有可能的合法动作，创建新的子节点。例如，在LLM中，就是生成下一个可能的token或者基于SFT后产生的一个新的答案的attempt。通常不会一次性创建所有子节点，而是创建一个，然后立即进入下一步。  
3. 推演（Simulation / Rollout）：即快速地对“扩展”步骤中新创建的节点进行一次价值评估。例如LLM中产生一个新的attempt答案，并通过Verifier评估。  
4. 反向传播（Backpropagation / Update）：将“模拟”步骤得到的结果更新回从根节点到该新节点的整条路径上。即从新节点开始，沿着路径一路向上返回到根节点。对于路径上的每一个节点，都更新它的两个核心统计数据：访问次数（N）：N(C) 和 价值（Q）：Q(C)。这样，路径上所有节点的价值估计都会因为这次模拟而变得更精确一点。

这个四步循环会重复执行。每一次循环，树都会增长一点，并且树上节点的价值估计也会变得更可靠。当总的计算预算用完后，算法就从根节点的直接子节点中，选择一个最稳健的作为最终决策。

UCT（Upper Confidence Bound applied to Trees）是 MCTS “选择”阶段的核心，当你站在一个节点，面前有几个子节点可以选择时：

• 利用（Exploitation）：你应该选择那个过去平均得分最高的子节点。这是最安全的选择。  
• 探索（Exploration）：你也应该去试试那些没怎么走过的、甚至得分不高的子节点，因为它们背后可能隐藏着一个更好的答案。

UCT 公式为每个候选的动作（子节点） a 计算一个分数：

• s：当前节点（状态）。  
• a：要评估的候选动作（子节点）。  

利用项  

• Q(s, a)：动作 a 累积的总奖励。  
• N(s, a)：动作 a 被选择的次数。
  这个比值就是动作 a 的平均奖励。它代表了根据现有经验，选择 a 有多好。这个值越高，说明 a 过去表现越好，我们就越倾向于“利用”它。

探索项  

• N(s)：节点 s 的父节点的总访问次数。  
• c：探索常数（Exploration Constant）。这是一个超参数，用来平衡利用和探索的重要性。c 越大，算法就越倾向于探索。
  这个项的核心是 sqrt(N(s) / N(s, a))。当一个动作 a 被选择的次数 N(s, a) 很少时，这个项的值就会很大，从而提升 a 的UCT分数，鼓励算法去“探索”这个未知的选项。随着总访问次数 N(s) 的增加，所有子节点的探索压力都会随之增加，促使算法不断探索。对数函数 log(N(s)) 的存在保证了随着时间的推移，探索的紧迫性会逐渐减弱，使得算法最终会收敛到最优的动作上。

2.3.3.2 以rStar为例

基于MCTS比较有代表性的工作是《rStar: Mutual Reasoning Makes Smaller LLMs Stronger Problem-Solvers》[5]。rStar采用计算资源更友好，更易于部署的小型语言模型（SLMs），通过将推理过程分解为一个生成-判别（Generation-Discrimination）的自博弈过程（self-play）来提升复杂推理任务的能力。

• 生成器（Generator）：一个目标SLM，结合MCTS和一系列类似人类推理行为的动作，负责探索并生成多种可能的高质量的解题路径。  
• 判别器（Discriminator）：另一个与目标SLM能力相近的SLM，负责验证生成器给出的路径是否可靠。

Self-play Mutual Generation
形式上，对于一个给定的问题 q 和一个目标SLM π，MCTS会增强 π 来增量式地构建一个搜索树 T。如图所示，根节点代表问题 q，一条边代表一个动作 a，每个子节点是由 π 在相应动作下生成的中间步骤 s。从根节点到叶子节点（表示为 s_K，也称为终端节点）的一条路径构成了一个候选解决方案轨迹 τ。从搜索树 T 中，可以提取一个解决方案轨迹集合 {τ_1, ..., τ_K}。目标是找到能够为给定问题得出正确答案的轨迹。

在rStar中考虑到了人类是如何进行推理的。引入了一系列动作：

• A1：提出一个单步思路。该动作提示LLM根据已有的推理步骤，为给定问题生成下一步的单步思路。与生成完整思路的CoT不同，这种方法简化了推理过程，使LLM能够做出更好的决策。  
• A2：提出剩余的思路步骤。该动作不只是每个状态生成一个步骤，而是与标准CoT对齐，通过“快思考”在更少的步骤中解决简单问题。在给定已生成的推理步骤的情况下，它提示LLM直接产出剩余步骤，直到得出最终答案。  
• A3：提出下一个子问题及其答案。该动作将复杂问题分解为一系列更简单的子问题并按顺序解决。  
• A4：再次回答子问题。考虑到A3可能没有正确回答子问题，rStar提出这个动作来重新回答它。为了提高准确性，该动作提示LLM使用少样本CoT。  
• A5：重述问题/子问题。在分析错误案例时，发现许多错误是由于LLM误解了问题。例如，它可能会忽略问题中给出的某个特定条件。因此，rStar提出了一个新动作来更简单地重述问题，提示LLM清晰地列出问题陈述中给出的所有条件。

以上5个动作定义了一个高度多样化的动作空间 A。在每一步 t，MCTS从这个空间中选择一个动作 a_t。然后我们用这个动作 a_t 来提示LLM，根据当前状态（即之前生成的轨迹 τ_{<t}）生成下一个推理步骤 s_t。注意，某些动作需要顺序。例如，A4只能在A3之后发生，A5只能在根问题之后发生。

关于奖励函数设计上，彻底摒弃SLM不可靠的中间步骤自我评估。奖励的唯一来源是最终结果。rStar将 R(s_t) 定义为在动作 a_t 下生成的节点 s_t 的奖励值。最初，所有未探索节点的 R(s_t) 都被赋值为0，导致随机的树扩展。当到达第一个终端节点 s_K 时，根据它是否得到正确答案来计算一个奖励分数 R(s_K)。这个分数随后会沿着轨迹 τ 反向传播给每个中间节点。具体来说，对于每个 s_i（其中 i < K），其 R(s_i) 值更新如下：R(s_i) ← R(s_i) + R(s_K)。为了计算终端节点的 R(s_K)，使用自洽性多数投票的置信度作为奖励值。

Rollout生成采用了标准的MCTS算法，为了获得更准确的奖励估计执行多次rollout。为了平衡探索和利用，使用了UCT来选择每个节点。

使用互洽性选择推理轨迹
在传统的MCTS中，通常只根据特定指标选择一条轨迹作为最终解决方案，例如从rollout迭代中选择奖励最高的路径。rStar发现很难定义一个单一的指标来可靠地选择包含正确答案的轨迹。因此收集所有轨迹，并提出使用“互洽性”进行答案选择。rStar还引入了另一个SLM π_d 作为判别器，为每个候选轨迹提供外部的无监督反馈。

具体来说，对于轨迹 τ_j，rStar遮盖从一个随机采样的步骤 s_i 开始的推理步骤。然后将前面的推理轨迹 τ_{<i} 作为提示提供给 π_d，让它为问题补完剩余的步骤。由于提供了前面的 i 个推理步骤作为提示，从而增加了SLM π_d 能提供正确答案的可能性。如图所示，rStar比较 π_d 补完的答案是否与原始轨迹 τ_j 的答案匹配。如果它们一致，就认为 τ_j 是一条用于最终选择的有效轨迹。

做一个简单的类比，生成器（SLM1）写了100份草稿，但不知道哪份是对的。判别器（SLM2）就像一个“同伴审稿人”。对每一份草稿，审稿人不是从头读到尾，而是随机遮住后半部分，只看前半部分的推导，然后自己尝试把后半部分写完。如果他写完后的最终答案和原稿的答案一模一样，他就会给这份草稿点个赞，认为它“逻辑自洽，思路贯通”。

最后通过将其奖励与终端节点在rollout中获得的置信度得分相乘，来计算每个轨迹的最终分数。得分最高的轨迹被选为解决方案。这综合了MCTS搜索过程中的全局评价（奖励）和局部rollout的稳定性（置信度），是一个更鲁棒的决策标准。

渣注
基于MCTS算法的rStar也有一些缺点。它通过牺牲巨大的计算资源，来换取在复杂决策空间中的导航能力。另一方面是奖励稀疏的问题，奖励信号来自于终局。如果一个正确的解需要非常长的步骤序列才能达成，并且只有完全正确才有奖励（稀疏奖励），那么通过随机或半随机的rollout策略偶然“撞”到这个正确解的概率微乎其微。这会导致整个搜索过程几乎接收不到任何正向反馈，算法无法学习到有价值的路径。  

接下来两章，我们以数学类的任务为例，通过 Math-Shepherd 介绍一下如何构造数据训练 PRM 模型，然后我们再以DeepSeek-math为例介绍一下GRPO算法。

3. PRM模型训练

对于 PRM 模型的训练，过去通常需要练依赖昂贵人工标注。《Math-Shepherd: Verify and Reinforce LLMs Step-by-step without Human Annotations》[6] 这篇文章则通过使用自动化过程标注（Automatic Process Annotation）来构建 PRM。另一方面这个算法也是后面我们介绍DeepSeekMath和GRPO时所需要使用的 PRM 模型。

一个解 S 可以被拆分为 K 步 s_1, s_2, ..., s_K，每一步 s_i 都有自己的标签 y_i 和奖励 r_i。对于 PRM，我们定义一个步骤的质量为推导出正确答案的潜力。这个潜力如何定义和计算？如何在没有人类参与的情况下，自动地为推理过程中的每一步生成一个质量标签，从而为训练PRM提供数据？

为了量化和估计给定推理步骤 s_i 的潜力，作者使用一个补全器（completer）。如图所示，从该步骤开始完成 m 个后续的推理过程：s_{i+1}, ..., s_{i+m}，其中 o_j 和 K_j 分别是第 j 个补全解的解码答案和总步数。然后，基于所有解码答案 {o_1, ..., o_m} 的正确性来估计该步骤的潜力。

作者使用两种方法来估计步骤 s_i 的质量 q_i：硬估计（Hard Estimation, HE）和软估计（Soft Estimation, SE）。

• HE是一种二元标签。它回答的问题是：“从 s_i 出发，有没有可能得到正确答案？”。只要有一种可能，这一步就被认为是“有潜力的”。  
• SE是一个0到1之间的连续分数。它回答的问题是：“从 s_i 出发，得到正确答案的概率有多大？”。这个分数提供了更丰富、更细粒度的信息。

我们来举一个更完整的例子。通常会基于一个问题集来构建自动标注，例如GSM8K。其中每个问题都带有一个唯一的确定的标准答案。我们来看下面这道题：

• 标准答案：35  
• 待标注的解题方案：  
  • s_1: "There are 80/100 * 10 = 8 more purple flowers than yellow flowers."（紫色的花比黄色的多8朵。）  
  • s_2: "So in Mark's garden, there are 10 + 8 = 18 purple flowers."（所以马克的花园里有18朵紫色的花。）  
  • s_3: "Purple and yellow flowers sum up to 10 + 18 = 28 flowers."（紫色和黄色的花总共有28朵。）  
  • s_4: "That means in Mark's garden there are 25/100 * 28 = 7 green flowers."（这意味着马克的花园里有7朵绿色的花。）  
  • s_5: "So in total Mark has 28 + 7 = 35 plants in his garden."（所以马克花园里总共有35株植物。）  
  • s_6: （Final Answer）"35"  

接下来我们将对 s_1 到 s_5 的每一步进行自动化的标注。例如当我们需要标注步骤 s_2 时：

1. 截取前缀 s_1, s_2: "There are 80/100 * 10 = 8 more purple flowers than yellow flowers. So in Mark's garden, there are 10 + 8 = 18 purple flowers."  
2. 将 s_1, s_2 输入补全器，生成10条路径。  
   • 路径 1: "Purple and yellow flowers sum up to 10 + 18 = 28 flowers.", “answer 35”  
   • 路径 2: "Purple and yellow flowers sum up to 10 + 18 = 28 flowers.", “answer 35”  
   • ...  
   • 路径 10: "Purple and yellow flowers sum up to 10 + 18 = 38 flowers.", “answer 48”  
3. 收集答案 {35, 35, ..., 48}  
4. 质量评估：  
   • 硬估计（HE）：1（因为至少有一个答案是35）  
   • 软估计（SE）：0.9（因为10次中有9次得到35）  

最终生成一条数据点：("问题...", "So in Mark's garden, there are 10 + 8 = 18 purple flowers.", 0.9)

现在，让我们假设我们正在标注另一个解题方案，其中第二步出现了错误：

• s_1: "There are 80/100 * 10 = 8 more purple flowers than yellow flowers."  
• s_2: "So in Mark's garden, there are 10 + 8 = 28 purple flowers."（这是一个计算错误）  

我们要来标注这个错误的步骤 s_2：

1. 截取前缀 s_1, s_2: "There are 80/100 * 10 = 8 more purple flowers than yellow flowers. So in Mark's garden, there are 10 + 8 = 28 purple flowers."  
2. 将这个包含错误信息的前缀 s_1, s_2 输入补全器。一个遵循逻辑的补全器会基于"紫花有28朵"这个错误的前提继续推理。  
   • 路径 1: "...黄花和紫花总共 10 + 28 = 38. 绿花有 0.25 * 38 = 9.5. 总共有 38 + 9.5 = 47.5. 答案是 47.5"  
   • 路径 2: "...黄花和紫花 10+28=38. 绿花 0.25*38=9.5. 四舍五入为10. 总共 38+10=48. 答案是 48"  
   • ...（可能会有各种基于错误前提的后续）  
   • 一个极小的可能性：补全器可能在后续步骤中"自我纠正"或者犯下另一个"负负得正"的错误，碰巧得到了正确答案35。比如: "...黄花和紫花10+28=38. 绿花数量是黄花和紫花总和的错误地理解为25%少, 即 38 * 0.75 = 28.5. 总数是38+28.5=66.5..."（这个例子很难凑出35）。  
   • 我们假设在10次模拟中，0次得到了正确答案35。  
3. 收集答案 {47.5, 48, 47.5, 47, ...}（一个不包含35的集合）  
4. 质量评估：  
   • 正确答案数量：0  
   • 硬估计（HE）：0（因为没有一个答案是35）  
   • 软估计（SE）：0.0  

最终数据点：
("问题...", "So in Mark's garden, there are 10 + 8 = 28 purple flowers.", 0.0)

最终标注结果汇总

通过这种方式，无需人类判断哪一步是对是错，math-shepherd仅需要标准答案就可以为正确的步骤赋予了高分，为错误的步骤赋予了低分。数据集标注完成后，我们就可以进行 PRM 训练了，PRM本身通常也是一个基于Transformer架构的大语言模型，和用于生成答案的LLM在结构上是同源的。仅是在输出头位置添加一个线性层，这个线性层将LLM输出的高维向量映射到一个单一的标量值（logit）。

对于数据集，我们可以构造拼接一个输入：

[INST] You are a math expert. Evaluate the correctness of the following step in the context of the solution.
Problem: <问题文本>
Solution Context: <s_1, s_2, ..., s_{i-1}> 的文本>
Current Step: <s_i 的文本>
[/INST]

然后训练的时候，对于HE估计，实际上就成了一个二元分类问题。使用标准的二元交叉熵损失来计算模型的预测概率 p̂ 和真实标签 y。论文提到，使用HE标签时，他们可以将训练转化为一个标准的语言建模流程。这是怎么做到的呢？他们可以选择词汇表中的两个不常用的特殊token，比如 [GOOD] 和 [BAD]。然后，将训练目标从"预测一个概率值"变为"预测下一个token是[GOOD]还是[BAD]"。

对于SE估计则是一个回归问题。常见的损失函数是MSE：
模型的目标是让其输出的概率 p̂ 精确地逼近真实的"潜力"分数 q。

训练完 PRM 模型后，可以利用这个 PRM 并使用 PPO 对原来的基础模型，实际上我们就需要在原来模型产生的多个候选答案中选出最好的一个。这个过程可以分为两个策略：

策略一：纯PRM排序
假设对于一个问题 q，我们已经让一个生成器 LLM 生成了 N 个候选解 {o_1, ..., o_N}。

1. 逐步评分：  

   • PRM(s_1) -> 0.95（这一步很棒）  
   • PRM(s_2) -> 0.92（这一步也不错）  
   • PRM(s_3) -> 0.1（这一步很可疑！）  
   • 对于每一个候选解 o_i，将其分解为一个个推理步骤 s_1, ..., s_K。  
   • 将每个步骤 s_j 连同问题 q 一起输入到已经训练好的 PRM 中。  
   • PRM 会为每一步输出一个分数 p̂(s_j)，这个分数代表了该步骤的"正确性"或"潜力"。分数范围通常是 0 到 1。  
   • 例子：对于候选解 o_1:  
     • s_1: "Step 1 text" → 0.95  
     • s_2: "Step 2 text" → 0.92  
     • s_3: "Step 3 text" → 0.1  

2. 聚合得到解的总分：  

   • 现在，我们需要为整个候选解 o_i 计算一个总分 score(o_i)。  
   • 论文采用了（Lightman et al., 2023）的策略：使用所有步骤中的最低分作为整个解的总分。  
   • 例子：对于上面的 o_1，其总分是：score(o_1) = min(0.95, 0.92, 0.1) = 0.1  
   • 为什么用最低分？ 这个策略背后的逻辑是 "木桶效应" 原则。在严谨的数学或逻辑推理中，只要链条中有一个环节出错，整个推理就是无效的，最终结果也就不再可信。因此，一个解的可靠性取决于它最不可靠的那一步。使用最低分作为总分，能够非常有效地惩罚那些哪怕只有一个小错误的解，即使其他步骤都完美无瑕。这种策略对错误的容忍度极低，非常适合要求严谨性的数学任务。  

3. 选择最佳解（Selecting the Best Solution）：  

   • 计算出所有 N 个候选解的总分后，选择分数最高的那个解作为最终的输出。  
   • 例子：  
     • score(o_1) = 0.1  
     • score(o_2) = 0.92（这个解的每一步分数都至少有0.92）  
     • score(o_3) = 0.05  
     • ...  
     • 最终，模型会选择 o_2 作为答案。  

策略二：PRM与自洽性结合排序（PRM + Self-Consistency）
这个策略融合了 PRM 的精确打分能力和自洽性（Self-Consistency） 的思想。自洽性的核心思想是："如果模型通过不同的推理路径多次得到同一个答案，那么这个答案很可能是正确的"。具体流程如下：

1. 逐步评分：与策略一完全相同，首先计算出每个候选解 o_i 的总分 score(o_i)（同样使用最低分策略）。  

2. 按答案分组：  

   • 组 "35": {o_1, o_3, o_4}  
   • 组 "42": {o_2, o_5}  
   • o_1: ... 答案是 35  
   • o_2: ... 答案是 42  
   • o_3: ... 答案是 35  
   • o_4: ... 答案是 35  
   • o_5: ... 答案是 42  
   • 检查所有 N 个候选解的最终答案。  
   • 将具有相同最终答案的解分到同一个组里。  
   • 例子：假设我们有 5 个候选解：  
     • 我们会得到两个组：  
     • "35"组: {o_1, o_3, o_4}  
     • "42"组: {o_2, o_5}  

3. 计算每个答案组的总分：  

   • 组 "35" 的总分: score(o_1) + score(o_3) + score(o_4)  
   • 组 "42" 的总分: score(o_2) + score(o_5)  
   • score(o_i) 是第 i 个解的最终答案。  
   • 这个公式的含义是：对于每个可能的最终答案 a（比如 "35", "42"），把它所有对应的解的分数加起来。  
   • 对于每个答案组，将组内所有解的 PRM 分数相加，作为这个答案组的总分。  
   • 论文给出的公式是：score_group(a) = Σ_{o_i ∈ group_a} score(o_i)  
   • 例子：假设我们已经算出了每个解的分数：  
     • score(o_1) = 0.92, score(o_2) = 0.88, score(o_3) = 0.9, score(o_4) = 0.85, score(o_5) = 0.7  
     • 现在计算每个答案组的总分：  
     • "35"组总分 = 0.92 + 0.9 + 0.85 = 2.67  
     • "42"组总分 = 0.88 + 0.7 = 1.58  

4. 选择最佳答案：  

   • 选择总分最高的那个答案组，该组对应的答案就是最终的预测答案。  
   • 例子：因为 2.67 > 1.58，所以最终选择的答案是 35。

4. 以DeepSeek-Math为例

下面我们以《DeepSeekMath: Pushing the Limits of Mathematical Reasoning in Open Language Models》[7] 为例，来看看整个Reasoning模型的训练过程，同时也通过它来解释一下 GRPO 算法。

DeepSeekMath 7B模型在DeepSeek-Coder-Base-v1.5 7B的基础上，使用了从Common Crawl中筛选出的1200亿个与数学相关的token，连同自然语言和代码数据，进行了持续预训练。然后得到了DeepSeekMath-Base，继续通过指令微调得到了DeepSeekMath-Instruct。通过GRPO算法进行强化学习获得最终模型DeepSeekMath-RL。预训练相关的内容我们在这篇中暂时略去，主要分析一下SFT和RL的流程。

4.1 SFT

在SFT过程中，DeepSeekMath谈到了如何构建数学指令微调数据集，并且覆盖了不同数学领域和不同复杂程度的中英文问题。这些问题都配有以下格式的解决方案：

1. 思维链（CoT），它属于纯文字讲解，就像老师在黑板上一步步写推理过程。这种格式完全使用自然语言进行逻辑推理和计算，前面已经有一些示例了，具体可以参考文章《Language Models are Multilingual Chain-of-Thought Reasoners》[8]。  
2. PoT，它属于一种程序思维，直接写一段代码来计算出答案。如下是它和CoT的对比，详细内容可以参考论文《Program of Thoughts Prompting: Disentangling Computation from Reasoning for Numerical Reasoning Tasks》[9]。

3. 工具集成（Tool-Integrated）：它属于一种文字+代码混合的方法，像人一样，先用文字分析问题，遇到复杂计算时，调用代码这个“计算器”来帮忙。详细内容可以参考《ToRA: A Tool-Integrated Reasoning Agent for Mathematical Problem Solving》[10]如下所示：

作者对GSM8K和MATH问题标注了工具集成的解决方案，并采用了[MathInstruct][11]和[lila-ood][12]的训练集，其中问题以CoT或PoT格式解决。然后英语数据集涵盖了代数、概率、数论、微积分和几何等多个数学领域。同时也收集了很多中文的K12数学问题，使用CoT和工具集成两种格式。

4.2 GRPO

在DeepSeekMath中，采用了Group Relative Policy Optimization（GRPO）算法。

4.2.1 从PPO到GRPO

PPO 是一个Actor-Critic的RL算法，广泛用于第一代LLM的RL微调阶段用于对齐相关的任务。具体来说，它通过最大化以下Agent目标来优化LLM：

其中：

• $\pi_\theta$ 和 $\pi_{\text{old}}$ 分别是当前和旧的策略模型  
• $q$ 和 $o$ 分别是从问题数据集和旧策略 $\pi_{\text{old}}$ 中采样的问题和输出  
• $\varepsilon$ 是PPO中为稳定训练而引入的与裁剪相关的超参数。  
• $A^{\text{PPO}}$ 是优势（advantage），它是基于奖励 $r$ 和一个学习到的价值函数 $V$，通过广义优势估计（GAE）计算得出的。  

因此，在PPO中，需要一个价值函数与策略模型一同训练，并且为了缓解对奖励模型的过度优化，标准方法是在每个token的奖励中加入一个来自参考模型的逐token KL散度惩罚，即：

其中，$r_{\phi}$ 是奖励模型，$\pi_{\text{ref}}$ 是参考模型（通常是初始的SFT模型），$\beta$ 是KL惩罚的系数。

由于PPO中使用的价值函数通常是与策略模型大小相当的另一个模型，这带来了巨大的内存和计算负担。此外，在RL训练期间，价值函数在计算优势时被用作基线（baseline）以减少方差。然而在LLM的场景下，通常只有最后一个token被奖励模型赋予一个奖励分数，这可能会使训练一个在每个token上都准确的价值函数变得复杂。

为了解决这个问题，如图所示，作者提出了组相对策略优化（GRPO）。它避免了像PPO那样需要额外的价值函数近似，而是使用对同一问题生成的多个采样输出的平均奖励作为基线。

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

与PPO中使用的KL惩罚项不同，使用以下无偏估计器来估计KL散度，这个估计量保证为正。

符号详解  

• $\mathcal{J}_{\text{GRPO}}(\theta)$：GRPO的目标函数，是模型参数 $\theta$ 的函数。  
• $\mathbb{E}$：数学期望符号，表示对括号内表达式求平均值。  
• $q \sim \mathcal{D}$：从问题数据集 $\mathcal{D}$ 中采样一个问题 $q$。  
• $o_i \sim \pi_{\text{old}}(\cdot|q)$：对于问题 $q$，使用旧的策略模型 $\pi_{\text{old}}$（即上一轮迭代的策略模型）采样一个包含 $G$ 个输出的组（Group），记为 {o_1, ..., o_G}。  

---

• $\pi_\theta(o_{i,t}|q, o_{i,<t})$：当前的策略模型 $\pi_\theta$ 在给定问题 $q$ 和已生成的部分输出 $o_{i,<t}$ 的情况下，生成下一个 Token（token）$o_{i,t}$ 的概率。  
• $\pi_{\text{old}}$：旧的策略模型，用于采样数据。并用来计算重要性采样比率。  
• $\rho_{t,i} = \frac{\pi_\theta(o_{i,t}|q, o_{i,<t})}{\pi_{\text{old}}(o_{i,t}|q, o_{i,<t})}$：重要性采样比率（Importance Sampling Ratio）。它衡量了当前策略 $\pi_\theta$ 和旧的采样策略 $\pi_{\text{old}}$ 在生成同一个 Token 上的概率差异。如果比率>1，说明当前策略更倾向于生成这个 Token。  

---

• $\hat{A}_{t,i}$：优势函数（Advantage Function）的估计值。表示在token $o_{i,t}$ 采取某个动作（即生成某个 Token）比该组内的"平均"动作要好多少。这个值是基于组内奖励的相对比较计算出来的，而不是像PPO那样依赖一个独立的价值模型。  
• $\text{clip}(\cdot, 1-\varepsilon, 1+\varepsilon)$：裁剪函数。将第一个参数的值限制在 $[1-\varepsilon, 1+\varepsilon]$ 区间内。这也是沿用了PPO中的关键部分，用于防止策略更新步子太大导致训练不稳定。  
• $\min(\cdot, \cdot)$：取两者中的较小值。结合clip，构成了一个偏悲观目标函数，避免训练不稳定。  

---

• $\beta$：KL散度惩罚项的系数，是一个超参数，用于控制正则化的强度。  
• $\text{KL}(\cdot \parallel \cdot)$：KL散度（Kullback-Leibler Divergence）。衡量当前策略 $\pi_\theta$ 与一个固定的参考策略 $\pi_{\text{ref}}$（通常是SFT阶段结束后的模型）之间的差异。这是一个正则化项，防止模型为了追求高奖励而"忘记"其基础的语言能力。

我们可以从内到外地理解这个复杂的公式，并来详细分析一下具体的步骤：

1. 核心部分：  

   • $\rho_{t,i} \hat{A}_{t,i}$：这是基础的策略梯度项。如果优势 $\hat{A}_{t,i}$ 为正（即当前动作比平均要好），算法会倾向于增大 $\rho_{t,i}$，从而增加这个动作出现的概率。如果优势为负，则会减小 $\rho_{t,i}$。  
   • $\text{clip}(\rho_{t,i}, 1-\varepsilon, 1+\varepsilon) \hat{A}_{t,i}$：这是裁剪后的版本。它将概率比率限制在一个小范围内。  
   • min的意义：当 $\rho_{t,i} \leq 1+\varepsilon$ 时，目标是最大化 $\rho_{t,i} \hat{A}_{t,i}$。但如果 $\rho_{t,i}$ 变得太大，超过 $1+\varepsilon$，那么 min 函数会选择裁剪后的项，从而限制了单步更新的幅度。这就像是给优化器踩了一个刹车，防止它过于激进。当 $\rho_{t,i} < 1-\varepsilon$ 时，min函数不起作用，惩罚会完整生效。  

2. 正则化项：  

   • 这是一个惩罚项。算法在最大化 $\min[\dots]$ 部分的同时，也会试图最小化 $\text{KL}(\cdot \parallel \cdot)$。这意味着模型在学习新技能（追求高奖励）时，不能与它最初的样子（参考模型 $\pi_{\text{ref}}$）相差太远，从而保证了生成内容的基本质量和风格，避免了“模式崩溃”（mode collapse）。  

3. 求和与期望：  

   • 内层求和 $\frac{1}{|o_i|} \sum_{t=1}^{|o_i|}$：对单个输出 $o_i$ 中的每一个 Token $o_{i,t}$ 计算上述 {...} 中的值，然后取平均（$\frac{1}{|o_i|}$）。  
   • 中层求和 $\frac{1}{G} \sum_{i=1}^{G}$：对一个组内的 $G$ 个不同输出的平均值再进行平均（$\frac{1}{G}$）。  
   • 外层期望 $\mathbb{E}_{q \sim \mathcal{D}}$：对许多不同的问题 $q$ 和从这些问题生成的许多组输出重复上述过程，取最终的平均值。这保证了优化的全局性，而非针对个别样本。

然后我们来看和PPO相比，GRPO的区别是什么？

1. 优势函数的计算方式（如何产生 $\hat{A}_{t,i}$）：  

   • PPO：PPO使用一个独立的，需要额外训练的价值模型（Value Model / Critic） 来计算优势函数 $\hat{A}_{t,i}$。这需要维护一个与策略模型同样大小的 critic 模型，消耗大量的显存和计算资源。  
   • GRPO：GRPO完全抛弃了价值模型。它通过在一个组（$G$ 个样本）内进行相对比较来估计优势。例如，一个简单的实现是：计算组内所有样本的最终奖励的平均值 mean(r) 和标准差 std(r)。对于样本 $o_i$，其归一化后的奖励 z_i = (r_i - mean(r)) / std(r) 就可以作为其所有 Token 的优势 $\hat{A}_{t,i}$。这种方法用批内统计量（in-batch statistics） 代替了学习出来的价值函数。  

2. KL散度正则化的位置：  

   • PPO：PPO通常将KL惩罚项加在奖励信号 $r_{\text{total}}$ 内部。这使得奖励本身就包含了对策略偏离的惩罚。  
   • GRPO：GRPO将KL惩罚项直接放在了最终的目标函数中，与PPO的核心目标 min[...] 并列。这种做法更直接，逻辑上更清晰地分离了"追求目标"和"保持稳定"这两个任务。

渣注
该公式定义了GRPO算法要优化的目标函数 $\mathcal{J}_{\text{GRPO}}(\theta)$。优化的目标是找到一组模型参数 $\theta$，使得这个目标函数 $\mathcal{J}_{\text{GRPO}}(\theta)$ 的值最大化。$\hat{A}_{t,i}$ 是仅基于组内相对奖励计算出的优势，GRPO利用组内相对方式计算优势的方法，与奖励模型的比较特性非常吻合，因为奖励模型通常是在对同一问题的不同输出进行比较的数据集上训练的。另外，GRPO不是在奖励中加入KL惩罚，而是通过直接在损失中加入训练策略与参考策略之间的KL散度来进行正则化，从而避免了使 $\hat{A}_{t,i}$ 的计算复杂化。从本质上讲，该函数旨在最大化一组采样输出的期望优势（Expected Advantage），同时通过KL散度约束，防止新策略偏离初始的参考策略太远。  

关于 KL 项如何放置，哪种是更好的，您肯定也有一些疑问。我们将在稍后的章节来详细展开分析一下，并阐述几个GRPO算法的变体。

而为了让大家更好的理解GRPO算法，我们以“厨师团队比赛”的比喻来解释GRPO：

• 问题 q：比赛题目是“做一道创新的番茄炒蛋”。  
• 旧策略模型 $\pi_{\text{old}}$：团队里有 $G$ 个厨师，他们是上一轮比赛后的状态。  
• 采样 $G=64$：64个厨师根据自己的理解，每人炒出了一盘番茄炒蛋。  
• 奖励模型 $r_\phi$：一位美食评论家（奖励模型）给这64盘菜一一打分。  
• GRPO的核心创新（计算 $\hat{A}_{t,i}$）：  
  • 对得了95分的厨师A说：“你的做法太棒了，比平均水平高了25分！你的每一个步骤（每个 Token $o_{i,t}$）都充满了正优势。”  
  • 对得了50分的厨师B说：“你的做法有点问题，比平均水平低了20分。你的步骤里充满了负优势。”  
  • 传统PPO的做法：会有一个“理论专家”（价值模型/Critic），他不尝菜，而是根据每个步骤（比如“先放油还是先放蛋”）来预测这道菜最终能得多少分。这个专家很贵，而且可能不准。  
  • GRPO的做法：团队负责人（GRPO算法）采取了一个更聪明、更省钱的办法。他不雇佣理论专家，而是直接把64盘菜的分数收集起来，算出一个平均分，比如70分。  
  • 然后他告诉每个厨师他的“相对优势”：  
  • 厨师A：95 - 70 = +25  
  • 厨师B：50 - 70 = -20  
• 策略更新（最大化 $\mathcal{J}_{\text{GRPO}}(\theta)$）：  
  • PPO-Clip项：团队开始学习。大家会重点模仿厨师A的菜谱（增加高概率 Token 的概率），并极力避免厨师B的错误（降低低概率 Token 的概率）。但为了防止学得太猛，把菜做得太奇怪（策略更新过大），负责人定了个规矩：“每次最多只能调整一点点！”（clip函数）。  
  • KL正则化项：同时，餐厅老板（参考模型 $\pi_{\text{ref}}$）提醒大家：“在创新的同时，别忘了我们餐厅番茄炒蛋的基本风味（SFT后的基础能力）！不能跑偏太远。”谁的菜谱偏离基础风味太远，就会被扣分（KL散度惩罚）。  

通过这种方式，整个团队（策略模型 $\pi_\theta$）的厨艺在保持基本功的同时，稳步地向着更高分的方向提升。

GRPO最显著的优势。在标准的PPO训练中，GPU需要同时加载四个模型：策略模型（Actor）、价值模型（Critic）、参考模型，和奖励模型。其中Actor和Critic通常是同样大小的。GRPO通过去掉价值模型，直接节省了这大量显存。这是一个巨大的节省，它意味着：

• 可以在显存较小的GPU上训练更大的模型。  
• 可以在同样的硬件上使用更大的批处理大小，提升训练吞吐量。  
• 降低了多节点训练时的模型并行或流水线并行的复杂性。  

而从计算开销来看：

• 采样阶段：GRPO的计算开销增加了。它需要为每个prompt生成 $G$ 个样本，这是一个计算密集型的前向传播过程。  
• 训练阶段：GRPO的计算开销减少了。它省去了价值模型的前向和反向传播。  

GRPO用更重的采样/推理开销换取了更轻的训练/更新开销和更低的内存占用。在LLM训练中，显存往往是比计算吞吐量更紧张的资源瓶颈，因此这个权衡非常划算。而且，采样阶段的 $G$ 次独立生成可以高度并行化，效率很高。

4.2.2 GRPO 和 奖励模型

对于奖励模型，如果使用 ORM。形式上对于每个问题 q，从旧策略模型 $\pi_{\text{old}}$ 中采样一组输出 {o_1, ..., o_G}。然后使用一个奖励模型对这些输出进行评分，相应地产生 $G$ 个奖励 {r_1, ..., r_G}。随后，通过减去组平均值并除以组标准差来对这些奖励进行归一化。结果监督在每个输出 o_i 的末尾提供归一化奖励，并将输出中所有token的优势 $\hat{A}_{t,i}$ 都设置为这个归一化奖励，即 $\hat{A}_{t,i} = z_i = (r_i - \text{mean}(r)) / \text{std}(r)$，然后通过最大化公式(3)中定义的目标来优化策略。

如果使用PRM，作者采用了本文第三章介绍的 Math-Shepherd 的方式。它在每个推理步骤的末尾提供奖励。形式上，给定问题 q 和 $G$ 个采样的输出 {o_1, ..., o_G}，一个过程奖励模型被用来对输出的每个步骤进行评分，产生相应的奖励：

其中 $j_i$ 是第 $i$ 步的结束token索引，$K_i$ 是第 $i$ 个输出的总步数。也用平均值和标准差对这些奖励进行归一化，即 $\hat{r}_{i,j} = (r_{i,j} - \text{mean}(r)) / \text{std}(r)$。随后，过程监督将每个token的优势计算为从该token往后的所有步骤的归一化奖励之和，即 $\hat{A}_{t,i} = \sum_{j=t}^{K_i} \hat{r}_{i,j}$，然后通过最大化公式(3)中定义的目标来优化策略。

随着强化学习训练过程的推进，旧的奖励模型可能不足以监督当前的策略模型。因此，作者也探索了使用GRPO的迭代式RL。如算法1所示，在迭代GRPO中，根据策略模型的采样结果为奖励模型生成新的训练集，并使用包含10%历史数据的回放机制持续训练旧的奖励模型。然后，将参考模型设置为当前的策略模型，并用新的奖励模型持续训练策略模型。

更简单的描述是，想象一下，一个学生（策略模型 $\pi_\theta$）和一个老师（奖励模型 $r_\phi$）。

• 初始阶段：学生很弱，老师能轻易地分辨出他的好坏答案。  
• 学生进步后：学生变得越来越聪明，他的答案质量越来越高，甚至能写出一些老师之前没见过的好答案。这时，原来的老师可能就“眼拙”了，无法再准确地分辨出学生答案的细微差别。老师的评分能力成了学生进一步提高的瓶颈。  
• 迭代式RL的解决方案：让老师也“进修”！每次学生生成一批新的、更高水平的答案后，我们把这些新答案拿去训练老师，让老师也提升自己的鉴赏水平。这样，升级后的老师就能继续有效地指导已经变强的学生。  

这个“学生”和“老师”交替进步，螺旋上升的过程，就是迭代式RL。具体的算法流程我们展开解释一下：

首先：将当前策略模型初始化为初始模型。然后内部可以将其分解为三个嵌套的循环：

1. 最外层 - 迭代循环（Iteration Loop, $I$ in Algorithm 1）：  

   • 步骤3：它创建了一个新的“锚点”。在本轮迭代中，无论策略模型 $\pi_\theta$ 如何更新，KL散度的惩罚目标 $\pi_{\text{ref}}$ 都保持不变。这确保了在一个迭代周期内，策略不会偏离其“起点”太远。  
   • 步骤12：Update $r_\phi$：更新奖励模型。到下一轮迭代时，这个“起点”会被更新为上一轮训练结束后的新策略。  
   • 目的：实现策略模型和奖励模型的共同进化。  
   • 流程：  

2. 中间层 - 训练步骤循环（Step Loop, $M$ in Algorithm 1）：是RL的主循环。  

   • 探索（Exploration）：Sample G outputs（步骤7）。探索是RL的核心，模型通过尝试不同的输出来发现哪些是好的。  
   • 评估（Evaluation）：Compute rewards 和 Compute $\hat{A}_{t,i}$（步骤8-9）。对探索的结果进行打分，并计算出用于梯度更新的优势信号。  
   • 利用（Exploitation）：Update the policy model（步骤10/11）。根据优势信号，强化好的行为，抑制坏的行为。  
   • 目的：在一次迭代中，通过多次小步更新来优化策略和奖励模型。  
   • 流程：  

3. 最内层 - GRPO优化循环（GRPO Loop, $\mu$ in Algorithm 1）：  

   • 目的：在同一批采样数据上进行多次梯度更新，提高数据利用率。  
   • 解释：步骤7-9生成了一批数据，这批数据的采集是有成本的（主要是时间成本）。为了不浪费这些宝贵的数据，GRPO可以在这同一批数据上进行多次（$\mu$ 次）的梯度更新。如果 $\mu = 1$，就是每次采样后只更新一次，数据利用率较低；如果 $\mu = 4$，就能更充分地从这批数据中学习。  

最后在更新奖励模型 $r_\phi$ 时有一个重放机制，为什么需要重放？如果奖励模型只用最新的数据进行训练，它可能会对之前见过的、质量稍差但仍然有用的数据失去辨别能力，导致其评分标准发生漂移。“包含10%的历史数据”意味着每次更新奖励模型时，训练数据由两部分构成：90%是刚刚由最新策略模型生成的新鲜数据，10%是从过去所有轮次中随机抽取的历史数据。它有如下好处：

1. 防止遗忘：确保奖励模型能持续稳定地评估各种质量水平的输出。  
2. 提高数据效率：重复利用旧数据，降低了对新数据的依赖。  
3. 平滑评分标准：避免奖励模型的评分标准因策略模型的短期波动而剧烈变化。  

迭代式的RL也有一些潜在的挑战和风险：

1. Reward Hacking：它是迭代式RL最大的风险。策略模型非常善于发现奖励模型的漏洞。随着迭代进行，策略模型可能学会生成一些在“语法”或“形式”上能获得高分，但实际上内容是错误或无意义的答案。例如，它可能发现只要答案格式工整，包含某些关键词，奖励模型就会给高分，于是它就专门生成这种“金玉其外，败絮其中”的答案。  
2. 训练稳定性：这是一个非常复杂的动态系统。策略和奖励模型相互影响，可能会导致训练过程震荡或发散。超参数的选择（如学习率，KL系数 $\beta$，迭代次数 $I$）变得异常敏感和关键。  
3. 计算成本：迭代式RL的计算成本极高。每一轮迭代都需要大量的采样和多次模型更新，整个过程非常耗时耗力。  
4. “回音室效应”：如果初始奖励模型存在某些偏见，迭代过程可能会放大这种偏见。策略模型会生成符合这种偏见的内容，然后奖励模型因为看到了更多这样的内容而更加确信自己的偏见是正确的，形成恶性循环。“重放机制”可以在一定程度上缓解，但无法根除此问题。  

在DeepSeekMath中采用了 Math-Shepherd 的方式构建的PRM进行训练。通过实验还得出了一些结论：

代码训练有益于程序辅助的数学推理
作者为了研究代码训练如何影响数学推理，试验了以下两阶段训练和单阶段训练设置：

两阶段训练（Two-Stage Training）  

• 400B代码Token训练 → 150B数学Token训练：先用400B的代码token训练DeepSeek-LLM 1.3B，然后再用150B的数学token进行训练。  
• 400B通用Token训练 → 150B数学Token训练：作为一个对照实验，在第一阶段用通用token（从DeepSeek-AI创建的大规模通用语料库中采样）替代代码token进行训练，试图研究代码token相比通用token在提升数学推理上的优势。  

单阶段训练（One-Stage Training）  

• 150B数学Token训练：直接用150B的数学token训练DeepSeek-LLM 1.3B。  
• 混合400B代码Token和150B数学Token进行训练：在代码之后进行数学训练会降低编码性能。我们研究了将代码token与数学token混合进行单阶段训练，是否仍能提高数学推理能力，并缓解灾难性遗忘问题。  

该实验相关的结论：

• 代码训练有益于程序辅助的数学推理，无论是在两阶段训练还是单阶段训练设置下。在两阶段设置下，仅代码训练本身就已经显著增强了使用Python解决GSM8K和MATH问题的能力。第二阶段的数学训练带来了进一步的提升。有趣的是，在单阶段设置下，将代码和数学token混合能有效缓解两阶段训练中出现的灾难性遗忘问题，并同时促进了编码能力和程序辅助的数学推理能力。  
• 代码训练也提升了不使用工具的数学推理能力。在两阶段训练设置下，初始阶段的代码训练已经带来了中等程度的增强。它还提高了后续数学训练的效率，最终带来了最佳性能。然而，将代码和数学token混合进行单阶段训练，损害了不使用工具的数学推理能力。一个猜想是，DeepSeek-LLM 1.3B由于其规模有限，缺乏同时充分吸收代码和数学数据的能力。

渣注
对于“带工具”推理（PoT/Tool-integrated）：这个结论非常直观。代码本身就是一种形式化的，逻辑严谨的语言。训练模型写代码，就是在训练它将自然语言描述的问题转化为精确的算法步骤。这种“问题形式化”的能力正是PoT的核心。因此，代码训练直接强化了模型使用程序解决问题的能力。  

对于“不带工具”推理（CoT）：这个发现更有趣。它暗示了代码训练带来的能力是可迁移的。代码训练教会了模型什么？  

• 逻辑和结构：编程强制要求严格的逻辑顺序，变量定义与使用，函数调用等结构化思维。这种思维模式与数学证明中的分步推理，定义引理，引用定理等过程高度同构。  
• 抽象能力：好的代码是抽象的。程序员需要将具体问题抽象成通用的函数或类。这种抽象思维能力对于理解数学概念和解决复杂问题至关重要。  
• 因果链条：代码的执行是严格的因果链条。模型在学习代码时，也在学习这种长距离的依赖关系和因果推理，这对CoT中保持长推理步骤的连贯性非常有帮助。  

关于“混合训练损害CoT”的猜想：作者猜想1.3B模型规模太小，无法同时处理两种任务。这个猜想合理，涉及到模型的容量（capacity）问题。在有限的参数空间内，两种不同但相关的任务（数学文本生成 vs 代码生成）会争抢模型资源，导致“跷跷板效应”。这也暗示了，对于多任务学习，模型规模是一个关键的促成因素。 更大的模型可能有足够的容量同时精通两者。

5. 对齐算法统一范式

DeepSeekMath论文中的5.2节提供一个统一的范式来分析不同的训练方法，如SFT、RFT、DPO、PPO、GRPO，并进一步进行实验来探索该统一范式的要素。通常，一个训练方法关于参数 $\theta$ 的梯度可以写为：

这个公式表达的是任意一个基于梯度优化的对齐算法 $\mathcal{J}$ 在更新模型参数 $\theta$ 时所使用的梯度 $\nabla_\theta \mathcal{J}(\theta)$ 的通用形式。它的目标不是计算一个值，而是提供一个分析框架，用来解构和比较不同的训练方法。它揭示了所有这些方法的共同点和差异所在。

符号详解  

• $\nabla_\theta \mathcal{J}(\theta)$：算法 $\mathcal{J}$ 的目标函数 $\mathcal{J}(\theta)$ 对模型参数 $\theta$ 的梯度。这是模型更新的方向和大小。  
• $\mathcal{J}$：代表一个具体的算法，例如 SFT、RFT、DPO、PPO、GRPO。  
• $\mathbb{E}_{(q,o) \sim \mathcal{D}_\text{data}}$：[第一部分：数据源] 数学期望。下标表示，我们是对从某个数据分布 $\mathcal{D}_\text{data}$ 中采样的（问题，输出）对 $(q, o)$ 取平均。这个 $\mathcal{D}_\text{data}$ 是不同算法的第一个关键区别。  
  • 对于SFT，$\mathcal{D}_\text{data}$ 是人工标注的专家数据集。  
  • 对于RFT/DPO（离线方法），$\mathcal{D}_\text{data}$ 是由固定的SFT模型生成的数据集。  
  • 对于PPO/GRPO（在线方法），$\mathcal{D}_\text{data}$ 是由正在训练的实时策略模型生成的数据集。  
• $\frac{1}{|o|} \sum_{t=1}^{|o|}$：对一个输出序列 $o$ 中的所有 token $o_t$ 取平均。  
• $GC(q, o, t, r)$：[第二部分：梯度系数]（Gradient Coefficient）。这是算法 $\mathcal{J}$ 的核心。它是一个标量，决定了在当前token $o_t$ 上的学习信号的强度和方向（正/负）。  
  • 它的值依赖于问题 $q$，整个输出 $o$，当前 token 位置 $t$，以及一个广义的奖励函数 $r$。  
  • 这里的“奖励函数”是一个广义概念，它可以是：  
  • 一个硬编码的“规则”（如RFT中的答案正确性检查）。  
  • 人类的偏好标签（如DPO）。  
  • 一个训练出来的神经网络奖励模型（如PPO/GRPO）。  
  • $GC$ 的计算方式是不同算法的第二个，也是最核心的区别。  
• $\nabla_\theta \log \pi_\theta(o_t | q, o_{<t})$：[第三部分：策略梯度方向] 这是策略梯度定理的标准形式。  
  • $\log \pi_\theta(o_t | q, o_{<t})$：这是一个 token 在当前模型下的对数概率。  
  • $\nabla_\theta$：对参数求梯度。  
  • 这个向量指明了参数空间中的一个方向：“如果我朝着这个方向更新参数 $\theta$，那么下次在同样的前文下，生成这个 token $o_t$ 的概率就会增加”。

所有这些推导都源于强化学习中的一个基础定理：策略梯度定理（Policy Gradient Theorem）。其最简单的形式是：

其中，$\tau$ 是一条完整的轨迹（在LLM中就是一个完整的输出序列），$R(\tau)$ 是这条轨迹的总回报。通过一系列数学变换（如使用重要性采样，引入基线，使用优势函数等），可以得到各种算法的梯度形式。

$\nabla_\theta \log \pi_\theta(a_t | s_t)$ 是策略梯度定理的核心，它指明了“应该朝哪个方向调整参数才能增加这个动作的概率”。而 梯度系数GC 则扮演了 $R(\tau)$（回报或优势）的角色，它告诉我们“这次调整的幅度和正负应该是多少”。

这个公式结构上表达了：“梯度 = 期望（系数 × 方向）”。不同的对齐算法，其本质差异可以归结为三个方面：

• 数据源（Data Source）：数据源分为两类，在线采样和离线采样。在线采样指训练数据来自实时训练策略模型的探索结果，而离线采样指训练数据来自初始SFT模型的采样结果。RFT和DPO遵循离线风格，而Online RFT和GRPO遵循在线风格。  
• 奖励函数（Reward Function）：是训练奖励信号的来源，主要分为 ORM 和 PRM 两种。  
• 梯度系数（Gradient Coefficient, GC）：不同的算法会用于处理训练数据和奖励信号，得到不同的梯度系数 $GC$，该系数决定了对数据的惩罚或强化幅度。

5.1 各种对齐算法对比

几种算法对比如下，我们将逐个小节展开。

5.1.1 SFT

监督微调（Supervised Fine-tuning, SFT）的目标是最大化以下目标函数：

$\mathcal{J}_{\text{SFT}}(\theta)$ 的梯度是：

• 数据源：SFT所使用的数据集。  
• 奖励函数：这可以被看作是人类的选择。  
• 梯度系数：始终设为1。

5.1.2 RFT

拒绝采样微调首先从监督微调后的大语言模型中为每个问题采样多个输出，然后在那些答案正确的采样输出上训练大语言模型。形式上，RFT的目标是最大化以下目标函数：

$\mathcal{J}_{\text{RFT}}(\theta)$ 的梯度是：

• 数据源：SFT数据集中的问题，加上从SFT模型中采样得到的输出。  
• 奖励函数：规则（答案是否正确）。  
• 梯度系数：$\mathbb{I}[o \text{ is correct}]$

5.1.3 Online RFT

RFT和Online RFT唯一的区别是，Online RFT的输出是从实时的策略模型 $\pi_\theta$ 中采样的，而不是从SFT模型 $\pi_{\text{SFT}}$ 中采样的。因此，Online RFT的梯度是：

5.1.4 DPO

DPO的目标函数是：

$\mathcal{J}_{\text{DPO}}(\theta)$ 的梯度是：

• 数据源：SFT数据集中的问题，加上从SFT模型中采样得到的输出。  
• 奖励函数：通用领域中的人类偏好（在数学任务中可以是“规则”）。  
• 梯度系数：$\beta \cdot \sigma'\left( \beta \left( r_\theta(o^+|q) - r_\theta(o^-|q) \right) \right) \cdot \nabla_\theta r_\theta(o^+_t|q, o^+_{<t})$

5.1.5 PPO

PPO的目标函数是：

为了简化分析，假设每次探索后模型只更新一次，从而保证 $\pi_{\text{old}} = \pi_\theta$。在这种情况下，我们可以移除min和clip操作：

$\mathcal{J}_{\text{PPO}}(\theta)$ 的梯度是：

• 数据源：SFT数据集中的问题，加上从策略模型中采样得到的输出。  
• 奖励函数：奖励模型。  
• 梯度系数：$A^{\text{PPO}}_t = \delta_t + (\gamma \lambda) \delta_{t+1} + (\gamma \lambda)^2 \delta_{t+2} + \dots$，其中 $\delta_t = r_t + \gamma V(s_{t+1}) - V(s_t)$ 是TD误差，它是由应用广义优势估计（GAE），基于奖励 $r$ 和一个学习出来的价值函数 $V$ 计算得出的。

5.1.6 GRPO

GRPO的目标函数是（同样假设 $\mu = 1$ 以简化分析）：

$\mathcal{J}_{\text{GRPO}}(\theta)$ 的梯度是：

• 数据源：SFT数据集中的问题，加上从策略模型中采样得到的输出。  
• 奖励函数：奖励模型。  
• 梯度系数：$\hat{A}_{t,i} = \frac{1}{G} \sum_{j=1}^{G} \left( r_{i,j} - \frac{1}{G} \sum_{k=1}^{G} r_{k,j} \right)$，其中 $r_{i,j}$ 是基于组内奖励分数计算的。

5.2 不同对齐算法的分析

5.2.1 数据源分析

这个维度将算法划分为两大类：

• 离线方法：SFT、RFT、DPO：它们的训练数据都是一次性生成且固定不变的。数据来源于固定的专家标注（$\mathcal{D}_{\text{SFT}}$）或固定的SFT模型（$\pi_{\text{SFT}}$）。这是一个静态的学习过程。模型的认知边界被初始数据集牢牢地框定了。无论算法多精妙，模型都无法学会超越这个数据集范畴的新知识或新技能。它们的本质是在一个固定的知识空间内进行重新排序和概率分布调整。DPO的论文标题《Your Language Model is Secretly a Reward Model》也暗示了这一点：它是在挖掘SFT模型内部已经存在的，但未被显式表达出来的偏好信息。  
• 在线方法：Online RFT、PPO、GRPO：它们的训练数据是通过与环境（或自身）的实时交互动态生成的。数据来源于当前正在被优化的策略模型 $\pi_\theta$。这是一个动态的，探索性的学习过程。随着 $\pi_\theta$ 的进化，它会生成之前从未见过的新输出，从而不断扩展学习的边界。理论上，这使得模型的能力可以持续地自我提升（self-improvement），超越初始数据集的限制。这也是强化学习最核心的能力。  

作者发现在两个基准上，Online RFT显著优于RFT。具体来说，Online RFT在训练早期与RFT相当，但在后期获得了绝对优势，展示了在线训练的优越性。这很直观，因为在初始阶段，actor和SFT模型非常相似，采样的数据只有微小差异。然而，在后期，从actor采样的数据将表现出更显著的差异，实时数据采样将提供更大的优势。

因此整个演进脉络从离线到在线，是从利用已有知识到探索未知世界的飞跃。

5.2.2 奖励来源分析

这个维度揭示了算法获取“好坏”判断信号的来源。

• 隐式/无奖励（SFT）：SFT没有明确的奖励函数。它隐式地假设所有专家数据都是“奖励为1”的完美示范。  
• 基于规则（Rule-based）：RFT、Online RFT、DPO（在数学任务中）：奖励信号是由一个确定性的，人类编写的逻辑产生的。在数学任务中，这个规则就是“检查最终答案是否与标准答案一致”。  
  • 优点：信号清晰，无噪声，无偏差，成本低。  
  • 缺点：  
    1. 过于刚性：无法处理答案形式多样但语义相同的情况。  
    2. 缺乏过程信息：“答案对”这个信号无法区分“思路巧妙的正确答案”和“碰巧蒙对的答案”。  
    3. 适用范围有限：只能用于有明确可验证答案的任务。对于开放性问题，规则无能为力。  
• 基于模型（Model-based）：PPO、GRPO：  
  • 特点：奖励信号是由一个学习出来的神经网络模型（$r_\phi$） 产生的。这个奖励模型本身通过学习人类偏好数据（例如，（答案A > 答案B））来获得“品味”。  
  • 优点：  
    1. 更灵活，更人性化：能捕捉模糊的，多维度的“好”（如“思路清晰”，“表达优雅”）。  
    2. 可泛化：能对从未见过的输出进行打分。  
    3. 可提供过程奖励：可以训练一个奖励模型来为推理的中间步骤打分。  
  • 缺点：  
    1. 可能存在偏差和噪声：奖励模型毕竟是个模型，它可能被“欺骗”（Reward Hacking）。  
    2. 训练成本高：需要额外的数据和计算资源来训练这个奖励模型。  

因此整个演进脉络从规则到模型，同时也对于奖励模型，也逐渐从ORM到PRM的演进。GRPO+PS（过程监督，PRM）比GRPO+OS（结果监督， ORM）表现出更优越的性能，表明使用细粒度的，感知步骤的梯度系数的好处。此外，作者探索了迭代式RL，在实验中进行了两轮迭代。并注意到迭代式RL显著提高了性能，特别是在第一次迭代时。

5.2.3 梯度系数分析

这个角度的分析也非常有意义：

• SFT（GC=1）：它代表了 “全盘接受” 对专家数据中的每个 token 都给予同等的正面激励。反映出了一种简单盲从的处理性格，属于一种模仿学习的范式。  

  • 分析：SFT的GC是常数1。这意味着它对所有SFT数据中的 token 都给予同等的，正向的梯度。它是一种无差别强化。  
  • 行为：“不管三七二十一，只要是专家数据，就给我学！”。这种方法的优点是简单直接，缺点是无法区分专家数据中可能存在的噪声或次优部分。  

• RFT、Online RFT（GC=$\mathbb{I}[o \text{ is correct}]$）：它代表了“非黑即白” 的过滤方式，开始有了好坏之分，但判断标准是二元的，粗糙的。属于一种严厉，绝对化的过滤学习范式。  

  • 分析：RFT的GC是一个0/1指示函数。只有当整个输出的最终答案正确时，GC才为1，否则为0。  
  • 行为：“答案对的，整个句子每个字都值得学；答案错的，整个句子一个字都别学！”。这是一种粗粒度的，“成王败寇”式的强化。它比SFT进了一步，开始进行筛选。但缺点是“一刀切”，忽略了错误答案中可能包含的正确推理步骤。  

• DPO（GC=$\beta \cdot \sigma'(\cdot) \cdot \nabla_\theta r_\theta$）：它代表了 “权衡利弊” 的处理方式，基于偏好对的预测差异来动态调整学习权重。当模型已经很好地满足了偏好时，学习力度就减小。形象的说，这属于一种圆滑，务实的学习范式。  

  • 分析：DPO的梯度系数很复杂，但其核心是 sigmoid 函数 $\sigma(\cdot)$。Sigmoid函数的值域在(0, 1)之间。当模型对偏好对 $(o^+, o^-)$ 的隐式奖励估计与真实偏好一致时，$\sigma(\cdot)$ 接近1；当估计与真实偏好相反时，$\sigma(\cdot)$ 接近0。（注意：论文公式13和14似乎有误，DPO的梯度系数应分别作用于正负样本，并且与 $r_\theta$ 的参数相关，但这里我们遵循其推导逻辑）。简单来说，DPO的GC是一个连续的，介于0和1之间的权重，反映了当前模型违反人类偏好的程度。  
  • 行为：“对于这个偏好对，你模型预测的差距越大，我给你的梯度信号就越弱；预测的差距越小甚至搞反了，我给你的梯度信号就越强”。它是一种基于偏好差异的自适应加权强化。  

• PPO/GRPO（GC= $A^{\text{PPO}}_t$ / $\hat{A}_{t,i}$）：它代表了 “优化” 的处理方式，不再满足于“对”，而是追求“更好”。它引入了“基线”（baseline）的概念，它引入了负向惩罚，对差的输出进行抑制。关注的是相对提升。这是从监督学习范式向强化学习范式的关键转变。  

  • 分析：GRPO的GC由两部分组成：组相对优势 $\hat{A}_{t,i}$ 和KL惩罚的梯度部分。核心是 $\hat{A}_{t,i}$。  
  • 行为：与PPO类似，也是有正有负，细粒度的强化。关键区别在于，这个“平均水平”不是由一个学习出来的价值模型 $V$ 提供的，而是由同一批次内其他样本的真实表现提供的。这是一种基于经验样本统计的相对强化。  
  • KL惩罚项的梯度部分 $\nabla_\theta \text{KL}(\cdot \parallel \cdot)$ 很有趣。当 $\pi_\theta$ 远大于 $\pi_{\text{ref}}$ 时（策略过于自信），该项为负，产生一个抑制梯度；当 $\pi_\theta$ 远小于 $\pi_{\text{ref}}$ 时，该项为正，产生一个拉回梯度。它始终在将 $\pi_\theta$ 拉向 $\pi_{\text{ref}}$。  
  • 分析：PPO的GC是优势函数 $A^{\text{PPO}}_t$。这是一个可以为正也可以为负的连续值。它量化了在某个状态下采取某个动作比“平均水平”要好多少。  
  • 行为：“这个词生成的比平均水平好，就强化它；比平均水平差，就惩罚它。好/差得越多，强化/惩罚的力度就越大。” 这是有正有负，细粒度的，基于价值的强化。它比RFT的0/1信号精细得多，能够惩罚不好的行为，而不仅仅是忽略它们。  

整个演进脉络：从无差别模仿，到二元筛选，再到相对优化，梯度信号变得越来越精细（fine-grained），信息量越来越大（informative），越来越有导向性（directive）。

6. 总结

这篇文章从第一代RLHF模型的范式局限性开始分析，传统的RLHF（如PPO）依赖结果奖励模型（ORM），它只评估最终答案的正确性。这导致了稀疏且模糊的奖励信号，模型无法定位多步推理中的具体错误（信用分配问题），甚至可能学会投机取巧（Reward Hacking）。这严重制约了模型在数学、代码等需要严谨逻辑链条任务上的表现。

为了解决奖励稀疏问题，社区提出了PRM。它不再是“判卷老师”，而是“过程辅导员”，能够对解题的每一步进行打分，提供密集、细粒度的反馈。PRM的出现解锁了一种新的性能提升范式。与其无止境地扩大模型规模（训练时计算），不如让一个中等大小的模型在遇到难题时，投入更多的计算资源“打草稿”、“深思熟虑”（测试时计算）。这构成了第二代推理模型的核心框架：Proposer（提议者）+ Verifier（验证者）。

• 优化提议者（Proposer）：通过SFT训练自我修正模型或采用顺序采样等方法，让模型生成更高质量的初始想法和修正版本。  
• 优化验证者（Verifier）：利用PRM对中间步骤进行评估和剪枝，结合树搜索（如Beam Search、MCTS）等策略，智能地引导计算资源投向最有希望的推理路径。  

然后我们以Math-Shepherd为例展开介绍了 PRM 模型的训练过程，同时也介绍了基于GRPO算法的DeepSeekMath模型。最后通过统一的分析范式：解构对齐算法的本质，它们的本质区别在于三个维度：

• 数据源（Data Source）：是离线（Offline，如RFT/DPO）还是在线（Online，如PPO/GRPO），决定了模型是仅利用已有知识还是能探索新世界。  
• 奖励来源（Reward Source）：是基于硬性规则（Rule-based，如RFT）还是基于学习模型（Model-based，如PPO/GRPO），决定了反馈信号的刚性与灵活性。  
• 梯度系数（Gradient Coefficient，GC）：这是算法“性格”的核心。文章分析了从SFT的“全盘接受”（GC=1），到RFT的“非黑即白”（GC=0/1），再到PPO/GRPO的“相对好坏”（GC=优势A），梯度信号变得越来越精细、信息量更大、更具导向性。  

本文描绘了一条清晰的技术进化路径：为了攻克复杂的推理任务，LLM的发展正从一个依赖直觉、快速回答的“System 1”系统，向一个能够进行深思熟虑、分步推理的“System 2”系统演进。这一进化的核心驱动力是过程监督的引入和测试时计算的智能运用，以及像GRPO这样为此目标服务的高效训练算法的创新。这不仅为提升模型在数学等领域的能力指明了方向，也为未来构建更通用、更强大的AI推理系统奠定了基础。

参考资料
[1] DeepSeekMath: Pushing the Limits of Mathematical Reasoning in Open Language Models: https://arxiv.org/pdf/2402.03300
[2] Let’s Verify Step by Step: https://arxiv.org/pdf/2305.20050
[3] Scaling LLM Test-Time Compute Optimally can be More Effective than Scaling Model Parameters: https://arxiv.org/pdf/2408.03314
[4] Chain-of-Thought Prompting Elicits Reasoning in Large Language Models: https://arxiv.org/pdf/2201.11903
[5] rStar: Mutual Reasoning Makes Smaller LLMs Stronger Problem-Solvers: https://github.com/zhentingqi/rStar
[6] Math-Shepherd: Verify and Reinforce LLMs Step-by-step without Human Annotations: https://arxiv.org/pdf/2312.08935
[7] DeepSeekMath: Pushing the Limits of Mathematical Reasoning in Open Language Models: https://arxiv.org/pdf/2402.03300
[8] Language Models are Multilingual Chain-of-Thought Reasoners: https://arxiv.org/abs/2210.03057
[9] Program of Thoughts Prompting: Disentangling Computation from Reasoning for Numerical Reasoning Tasks: https://arxiv.org/pdf/2211.12588
[10] ToRA: A Tool-Integrated Reasoning Agent for Mathematical Problem Solving: https://arxiv.org/abs/2309.17452
[11] MathInstruct: https://huggingface.co/datasets/TIGER-Lab/MathInstruct
[12] lila-ood: https://huggingface.co/datasets/allenai/lila/viewer/ood/train