• DeepSeekMath: Pushing the Limits of Mathematical Reasoning in Open Language Models

PPO vs GRPO

PPO的目标函数

$$\begin{array}{rl}{\mathcal{J}}_{PPO}(\theta )& =\mathbb{E}\left[q\sim P(Q),o\sim {\pi }_{{\theta }_{\text{old }}}(O\mid q)\right]\\ & \frac{1}{|o|}\sum _{t=1}^{|o|}\min \left[\frac{{\pi }_{\theta }\left(o_t\mid q,o_{<t}\right)}{{\pi }_{{\theta }_{\text{old }}}\left(o_t\mid q,o_{<t}\right)}{A}_t,\mathrm{clip}\left(\frac{{\pi }_{\theta }\left(o_t\mid q,o_{<t}\right)}{{\pi }_{{\theta }_{\text{old }}}\left(o_t\mid q,o_{<t}\right)},1-\epsilon ,1+\epsilon \right)A_t\right]\end{array}$$

$A_t$是使用广义优势估计（GAE）基于奖励 { r ≥ t } \{r_{\ge t}\} {r≥t​}和状态价值$V_{\psi }$计算的优势值，属于Actor-Critic算法，需要联合训练策略模型和状态价值模型。通常在每一个token的奖励上添加策略模型和参考模型的KL惩罚，以避免奖励模型被过拟合而产生异常输出。
$$r_t=r_{\phi }\left(q,o_{\le t}\right)-\beta \log \frac{{\pi }_{\theta }\left(o_t\mid q,o_{<t}\right)}{{\pi }_{ref}\left(o_t\mid q,o_{<t}\right)}$$

GRPO的目标函数

PPO算法使用价值模型输出作为优势的baseline，指导策略模型更新。价值模型一般与策略模型尺寸相当，训练时占显存、耗算力。在LLM生成场景下，奖励函数给出整个响应的分数，作为最后一个token的奖励，而价值模型要预测响应中所有token的奖励，比较难。

GRPO通过对单个query采样多个response，取平均奖励作为baseline，不需要使用价值模型（foregoes critic model），目标函数为：

J G R P O ( θ ) = E [ q ∼ P ( Q ) , { o i } i = 1 G ∼ π θ o l d ( O ∣ q ) ] 1 G ∑ i = 1 G 1 ∣ o i ∣ ∑ t = 1 ∣ o i ∣ { min ⁡ [ π θ ( o i , t ∣ q , o i , < t ) π θ o l d ( o i , t ∣ q , o i , < t ) A ^ i , t , clip ⁡ ( π θ ( o i , t ∣ q , o i , < t ) π θ o l d ( o i , t ∣ q , o i , < t ) , 1 − ε , 1 + ε ) A ^ i , t ] − β D K L [ π θ ∣ ∣ π r e f ] } \begin{align*} \mathcal{J}_{G R P O}(\theta) & =\mathbb{E}\left[q \sim P(Q),\left\{o_i\right\}_{i=1}^G \sim \pi_{\theta_{o l d}}(O \mid q)\right] \\ & \frac{1}{G} \sum_{i=1}^G \frac{1}{\left|o_i\right|} \sum_{t=1}^{\left|o_i\right|}\left\{\min \left[\frac{\pi_\theta\left(o_{i, t} \mid q, o_{i,<t}\right)}{\pi_{\theta_{o l d}}\left(o_{i, t} \mid q, o_{i,<t}\right)} \hat{A}_{i, t}, \operatorname{clip}\left(\frac{\pi_\theta\left(o_{i, t} \mid q, o_{i,<t}\right)}{\pi_{\theta_{o l d}}\left(o_{i, t} \mid q, o_{i,<t}\right)}, 1-\varepsilon, 1+\varepsilon\right) \hat{A}_{i, t}\right]-\beta \mathbb{D}_{K L}\left[\pi_\theta| | \pi_{r e f}\right]\right\} \end{align*} JGRPO​(θ)​=E[q∼P(Q),{oi​}i=1G​∼πθold​​(O∣q)]G1​i=1∑G​∣oi​∣1​t=1∑∣oi​∣​{min[πθold​​(oi,t​∣q,oi,<t​)πθ​(oi,t​∣q,oi,<t​)​A^i,t​,clip(πθold​​(oi,t​∣q,oi,<t​)πθ​(oi,t​∣q,oi,<t​)​,1−ε,1+ε)A^i,t​]−βDKL​[πθ​∣∣πref​]}​

GRPO通过建立组内竞争机制，不需要外部独立的Critic。这使得比组内平均分高的响应获得正分数，低的获得负分数，鼓励模型生成比平均水平更好的响应，使得平均得分越来越高。

KL散度约束与估计

KL散度作为正则项，用于约束策略更新幅度，GRPO使用k3型的KL散度估计：
$${\mathbb{D}}_{KL}\left[{\pi }_{\theta }||{\pi }_{ref}\right]=\frac{{\pi }_{ref}\left(o_{i,t}\mid q,o_{i,<t}\right)}{{\pi }_{\theta }\left(o_{i,t}\mid q,o_{i,<t}\right)}-\log \frac{{\pi }_{ref}\left(o_{i,t}\mid q,o_{i,<t}\right)}{{\pi }_{\theta }\left(o_{i,t}\mid q,o_{i,<t}\right)}-1$$

解释： 奖励模型基于比较/偏好数据集训练，使用相对优势的RL方法与奖励模型也比较匹配。PPO方法将策略模型和参考模型的KL散度作为奖励的惩罚，GRPO不惩罚奖励，而是将KL惩罚直接放在策略损失里面，避免在$A_{i,t}$中引入复杂的计算。

通常$x$无法穷举，一般通过多次采样求平均方式估计期望，也就是无偏估计，KL散度的定义及无偏估计为
$$KL[p||q]=\sum _{x}p(x)\log \left(\frac{p(x)}{q(x)}\right)={\mathbb{E}}_{x\sim p}\left[\frac{p(x)}{q(x)}\right]\approx \frac{1}{N}\log \left(\frac{p(x)}{q(x)}\right)$$

采样与期望： 如果p中有n个不同的x，从中随机采样m个x，m>>n，则重复x的个数除以m就近似为概率p(x)。

令$r=q(x)/p(x)$，几种不同的KL散度估计：

• k1：$-\log r$，无偏、高方差，半数样本为负（KL为正），偏差比较高。
• k2：$\frac{1}{2}(\log r{)}^2$，有偏、低方差，始终为正，明确反映出分布之间的偏离程度。
• k3：$-\log r+(r-1)$：无偏、低方差，始终为正。启发式设计，k1加上期望为0，并且与其负相关的项。
  • $p(x)$和$q(x)$分步接近时，$r$的期望为1，新增项$r-1$为0；
  • $r$增大，k1项$-\log (r)$减小，新增项$(r-1)$增加；
  • 直观表达，$log(p/q)+(q/p-1)$，$p(x)$大于$q(x)$时，k1大于0，新增修正项小于1；

ORM监督RL的结果

对于每个query $q$，从${\pi }_{{\theta }_{old}}$中采样一组输出 G = { o 1 , o 2 , ⋯ , o G } G=\{o_1,o_2,\cdots,o_{G}\} G={o1​,o2​,⋯,oG​}，奖励模型对这些输出（或者说结果Outcome）打分 r = { r 1 , r 2 , ⋯ , r G } {\bf r}=\{r_1,r_2,\cdots,r_{G}\} r={r1​,r2​,⋯,rG​}，将这些奖励标准化可作为每个输出$o_i$在结束位置的组内相对优势：
$${\hat{A}}_{i,t}={\tilde{r}}_i=\frac{r_i-\mathrm{mean}(\mathbf{r})}{\mathrm{std}(\mathbf{r})}$$

PRM监督RL的过程

结果监督仅提供了每个输出在结束位置的奖励，不足以监督复杂的数学推理任务。为监督过程，对每个推理步骤打分：
$$\mathbf{R}=\left\{\left\{r_1^{index(1)},\cdots ,r_1^{index\left(K_1\right)}\right\},\cdots ,\left\{r_G^{index(1)},\cdots ,r_G^{index\left(K_G\right)}\right\}\right\}$$

其中$index(j)$表示第$j$步的结束token，标准化的步骤奖励为
$${\tilde{r}}_i^{index(j)}=\frac{r_i^{index(j)}-\mathrm{mean}(\mathbf{R})}{\mathrm{std}(\mathbf{R})}$$

每一个token的优势等于之后所有步骤的标准化奖励和：
$${\hat{A}}_{i,t}=\sum _{index(j)\ge t}{\tilde{r}}_i^{index(j)}$$

迭代RL

随着策略模型更新，奖励模型可能不足以监督策略模型。GRPO使用迭代的方式，从新的策略模型中采样数据，加上10%的历史数据，以继续训练方式更新奖励模型。之后，将最新的策略模型设置为参考模型，继续训练策略模型，重复上述过程。

算法流程

奖励模型使用base模型初始化，经由偏好数据训练而得。

GRPO损失的不同版本

GRPO目标可以定义为
$${\mathcal{L}}_{\mathrm{GRPO}}(\theta )=-\frac{1}{G}\sum _{i=1}^G\frac{1}{\left|o_i\right|}\sum _{t=1}^{|o_i|}{l}_{i,t},w.t.l_{i,t}=\frac{{\pi }_{\theta }\left(o_{i,t}\mid q,o_{i,<t}\right)}{{\left[{\pi }_{\theta }\left(o_{i,t}\mid q,o_{i,<t}\right)\right]}_{\mathrm{no}\mathrm{grad}}}{\hat{A}}_{i,t}-\beta {\mathbb{D}}_{\mathrm{KL}}\left[{\pi }_{\theta }\Vert {\pi }_{\mathrm{ref}}\right]$$

DAPO指出，GRPO使用sample-level损失，在long-COT场景下，对long-response惩罚不足，导致其输出质量比较低。DAPO使用token-level损失，所有response中的每个token的奖励更加平衡，不受response长度的影响。
$${\mathcal{L}}_{\mathrm{DAPO}}(\theta )=-\frac{1}{{\sum }_{i=1}^G\left|o_i\right|}\sum _{i=1}^G\sum _{t=1}^{|o_i|}{l}_{i,t}$$

Dr. GRPO指出，DAPO没有完全消除不同response长度偏差的影响，为了更彻底的消除，其使用常数替代序列长度：
$${\mathcal{L}}_{\text{Dr. GRPO}}(\theta )=-\frac{1}{LG}\sum _{i=1}^G\sum _{t=1}^{|o_i|}{l}_{i,t}$$

GRPO源码解析

代码库trl中GRPOTrainer的实现，继承于Transformers Trainer，重载_prepare_inputs和compute_loss方法

源码在这里：https://github.com/huggingface/trl/blob/v0.18.1/trl/trainer/grpo_trainer.py

算法过程

1. 构造批次输入prompts：
   • 使用自定义的RepeatSampler采样批次，对同一prompt重复采样多次，并且能够跨进程同步分组；
   • 风格为generate或chat_completions，执行左padding、左truncate；
2. 采样completions： _prepare_inputs中调用_generate_and_score_completions，参数为temperature=0.9，top_p=1.0、max_new_tokens=256：
   • 若使用vllm server：
     • 权重同步：确保policy model和vllm model的参数同步；
     • 数据并行采样：主进程上gather其它进程上的prompts，为每个不重复的prompt生成num_generations个completions；
     • 广播分配：主进程上broadcast所有completions到其它进程，对应进程截取自己prompts对应的completions；
   • 若使用transformers标准的model.generate：
     • 独立生成每个prompt的completion，包含重复的prompt（同一prompt多次prefill），计算低效；
3. 处理completion padding：
   • 根据completion中EOS的位置计算completion长度，并mask首个EOS后的token，只保留有效的completion token；
   • mask所有没有EOS的completion，避免异常completion对loss影响过大（可选）；
4. 计算old_logprobs：若使用相同completion多次迭代优化，计算当前policy model的logprobs作为old_logprobs，用于后续epoch中计算概率比率；
5. 计算scores：每个reward model/reward func计算每条prompt+completion的score并加权，得到每条sentence的score；
6. 计算advantages：gather所有进程上的scores，分组标准化，即奖励 - 奖励均值 / 奖励标准差（可选）；
7. 计算loss：
   • 计算policy model的logprobs；
   • 计算reference model的ref_logprobs；
   • 计算policy model和reference model之间在每个completion token的kl散度，使用k3无偏估计：kl=log(p/q)+(q/p-1)，如果p和q都是对数概率，则kl=p-q+exp(q-p)-1，即kl损失；
   • 使用logprobs和old_logprobs计算概率比率并裁剪，限制参数更新幅度（重要性采样，PPO算法的核心），利用裁剪后概率比率clamped_ratio、advantage和completion mask，计算每个token的策略损失；
   • 损失加权求和：加权求和token-level的策略损失和kl损失，kl损失权重小，非主导；
   • 损失均值化：loss有多种求和/平均方式，bnpo loss不考虑每条样本的completion长度的影响，取所有token的平均loss。grpo_loss对每条completion依次在token-level、sample-level上求和平均，对长completion的惩罚不足；
   • 使用梯度下降更新policy model；