强化学习算法:GRPO
paperreading
本文字数:6.9k 字 | 阅读时长 ≈ 28 min

强化学习算法:GRPO

paperreading
本文字数:6.9k 字 | 阅读时长 ≈ 28 min

强化学习专项:1. 基本概念 · 2. DQN · 3. Policy Gradient · 4. PPO · 5. 如何理解强化学习 · 6. GRPO(本文) · 7. DPO

1. 从 PPO 到 GRPO

在 PPO 中,Actor 需要知道:当前动作带来的结果,比这个状态下通常能取得的结果好多少。为此,我们训练 Critic 预测状态价值,再结合 reward,通过 GAE 计算优势。

如果任务变成让语言模型回答一道数学题,可以换一种办法:让同一个模型对同一道题生成多份回答,分别评分,用这些回答的平均得分作为比较基准。

例如,同一道题生成了 4 份回答,其中 3 份答对、1 份答错。我们可以提高答对回答的生成概率,降低答错回答的生成概率,而不必额外训练一个 Critic 预测这道题能得多少分。

这就是 GRPO(Group Relative Policy Optimization,组相对策略优化) 的核心思路:使用同组回答的奖励构造优势,继续通过 PPO 式的裁剪目标更新策略。GRPO 最初由 DeepSeekMath 论文第 4.1 节提出。

PPO 通过价值预测和 GAE 计算优势,GRPO 通过同题多份回答的组内奖励计算优势

图 1:优势的来源发生了变化,策略仍然通过概率比和 clip 更新。图中的 KL 是语言模型训练中相对于参考模型的约束。

PPO 的 Critic 在大语言模型训练中可能带来较大的参数、梯度和优化器状态开销。GRPO 省去了这部分,但需要为每道题生成多份回答。因此,它减少了价值模型的训练负担,实际总成本仍然取决于模型大小、生成长度和组大小。

下面讨论每份完整回答只得到一个最终分数的 GRPO,也就是 outcome supervision。这个范围很重要:如果每个推理步骤都有独立评分,优势的分配方式也会变化。

2. 语言模型中的状态、动作和 reward

前面的 PPO 使用 CartPole:状态是位置、速度等数值,动作是向左或向右。语言模型也能放进相同的框架,只是动作变成了 token。

设问题为 \(q\),一份回答为:

\[ o=(o_1,o_2,\ldots,o_T) \]

生成第 \(t\) 个 token 时:

\[ s_t=(q,o_{<t}),\qquad a_t=o_t \]

\(o_{<t}\) 表示已经生成的前缀。模型读取“问题 + 已有回答”,输出下一个 token 的概率分布:

\[ \pi_\theta(o_t\mid q,o_{<t}) \]

强化学习概念 语言模型中的对应内容
状态 \(s_t\) 问题和当前已生成的回答前缀
动作 \(a_t\) 本次实际采样出的 token
策略 \(\pi_\theta\) 语言模型输出的下一个 token 分布
一条 trajectory 从回答开始到结束的生成过程
最终 reward \(R\) 评分规则或奖励模型给完整回答的分数

例如,问题是“\(3\times4\) 等于多少?”。模型可能生成“因为 \(3+3+3+3=12\),所以答案是 12”,也可能生成错误答案。为了突出训练过程,这里假设评分规则只检查最后的数值:答对得 1,答错得 0。

reward 不一定来自另一个神经网络。数学题可以比较最终答案,代码题可以运行测试;开放式任务则可能使用奖励模型。这些方式都在回答“这份输出得多少分”。DeepSeek-R1 论文第 2.2.2 节给出了准确性与格式规则奖励的例子。

为了与前面逐步产生的 \(r_t\) 区分,本文用大写 \(R_i\) 表示第 \(i\) 份回答的最终得分。在只给终点奖励、折扣因子取 1 的简化设置下,同一条回答中各时间步的未折扣回报都是 \(R_i\)。

评分器可以使用标准答案,但训练时模型并没有被逐 token 告知“接下来必须输出什么”。它先生成自己的回答,再根据整份回答的分数调整生成概率。

3. 不用 Critic,优势从哪里来?

3.1 同一道题生成一组回答

对同一个问题 \(q\),使用更新前的策略 \(\pi_{\theta_{\mathrm{old}}}\) 采样 \(G\) 份回答:

\[ o_1,o_2,\ldots,o_G \sim\pi_{\theta_{\mathrm{old}}}(\cdot\mid q) \]

分别评分,得到:

\[ \mathbf R=(R_1,R_2,\ldots,R_G) \]

这里的 group 是同一个问题对应的多份回答。如果一个 batch 有 \(B\) 道题,每道题生成 \(G\) 份回答,就会有 \(B\) 个独立的组,而不是把 \(B\times G\) 个分数混在一起计算基准。

同题比较使得基准与当前问题有关。比如一道难题的平均分为 0.2,一道简单题的平均分为 0.9;模型需要知道某份回答相对于它自己那道题的其他回答表现如何。

3.2 计算组内均值和标准差

本文采用总体标准差,分母为 \(G\),与后面代码中的 std(unbiased=False) 一致:

\[ \mu_q=\frac{1}{G}\sum_{j=1}^G R_j, \qquad \sigma_q=\sqrt{\frac{1}{G}\sum_{j=1}^G(R_j-\mu_q)^2} \]

然后构造第 \(i\) 份回答的相对优势:

核心公式:组相对优势

\[ \hat A_i=\frac{R_i-\mu_q}{\sigma_q+\varepsilon_{\mathrm{std}}} \]

\(\varepsilon_{\mathrm{std}}\) 是防止除零的小常数,代码中取 \(10^{-8}\)。它与后面用于裁剪概率比的 \(\epsilon_{\mathrm{clip}}\) 是两个不同的参数。不同实现对标准差的约定可能不同,手算时需要与代码保持一致。

减去均值,决定这份回答比同组平均水平好还是差;除以标准差,则调整组内分数的尺度。

这里的 \(\hat A_i\) 是一个根据采样结果构造的相对训练权重,不是精确的 \(Q_\pi(s_t,a_t)-V_\pi(s_t)\)。它也没有预测每个回答前缀的状态价值。因此,不能把 GRPO 理解为“已经准确算出了 PPO 的 Critic,只是省略了网络”。

3.3 手算一组优势

仍然使用“\(3\times4\)”这道题。假设 4 份回答的最终答案分别为 12、10、12、12,得到:

\[ \mathbf R=[1,0,1,1] \]

均值和标准差为:

\[ \begin{aligned} \mu_q&=\frac{1+0+1+1}{4}=0.75 \\ \sigma_q&=\sqrt{\frac{0.25^2+(-0.75)^2+0.25^2+0.25^2}{4}} =\sqrt{0.1875}\approx0.4330 \end{aligned} \]

忽略只用于数值稳定的小常数,各回答的优势为:

回答 最终答案 \(R_i\) \(R_i-\mu_q\) \(\hat A_i\)
\(o_1\) 12 1 0.25 0.5774
\(o_2\) 10 0 -0.75 -1.7321
\(o_3\) 12 1 0.25 0.5774
\(o_4\) 12 1 0.25 0.5774

3 份正确回答各得到一个正优势,错误回答得到一个负优势。负优势的绝对值较大,是这组奖励标准化的结果:错误回答比组内均值低得更多。

优势正负取决于组内比较。如果奖励可以取连续值,那么一份得分大于 0 的回答,也可能因为低于组内均值而得到负优势。

3.4 一份回答的分数,怎样分配给 token?

在本文的最终结果评分设置中,同一份回答的所有生成 token 使用相同优势:

\[ \hat A_{i,t}=\hat A_i,\qquad t=1,\ldots,T_i \]

\(T_i\) 是第 \(i\) 份回答的有效 token 数。正确回答的整段生成过程获得正权重,错误回答的整段生成过程获得负权重。

奖励 1、0、1、1 经组内标准化后得到 0.5774、-1.7321、0.5774、0.5774,同一回答中的 token 共享优势

图 2:先对回答评分,再按组计算优势,最后将优势分配给回答 token。方块只示意 token 位置,不代表真实 tokenizer 的切分。

这不表示每个 token 都独立得到了正确性验证。某份回答可能前面推理正确、最后算错,但结果评分仍会给整份回答负权重。GRPO 的这种训练信号比较粗,无法直接指出到底是哪一步导致失败。

此外,相同优势也不意味着参数更新完全相同:不同位置的上下文、token 概率和梯度都不同。

4. 从组相对优势到 GRPO 的 loss

现在已经有了回答和优势,接下来要把它们变成可以执行 loss.backward() 的损失。

4.1 先区分三个策略

策略 作用 什么时候变化
当前策略 \(\pi_\theta\) 计算当前 token 概率,接受梯度更新 每次优化器更新后变化
旧策略 \(\pi_{\theta_{\mathrm{old}}}\) 生成这一批回答,作为概率比的分母 下一批 rollout 开始时刷新
参考策略 \(\pi_{\mathrm{ref}}\) 提供 KL 约束的参照 本文整个训练阶段固定

旧策略负责回答“与采样时相比,概率改了多少”,参考策略负责回答“与训练阶段的参照模型相比,分布偏离了多少”。两者可能在训练开始时相同,但承担的角色不同。

和 PPO 一样,不一定要始终在显存中保留一份独立的旧模型。生成 rollout 时缓存旧 log probability,就可以用于这批数据后续的优化。参考策略的 log probability 也可以提前缓存。更复杂的分阶段训练可以刷新参考模型,本文不涉及这种设置。

4.2 按 token 计算新旧概率比

对于已采样回答 \(o_i\) 的第 \(t\) 个 token,固定其问题、前缀和 token 本身,计算:

\[ \rho_{i,t}(\theta) =\frac{\pi_\theta(o_{i,t}\mid q,o_{i,<t})} {\pi_{\theta_{\mathrm{old}}}(o_{i,t}\mid q,o_{i,<t})} \]

代码中使用 log probability 相减后取指数:

\[ \rho_{i,t} =\exp\left(\log\pi_\theta(o_{i,t}\mid q,o_{i,<t}) -\log\pi_{\theta_{\mathrm{old}}}(o_{i,t}\mid q,o_{i,<t})\right) \]

例如,某个已采样 token 的旧概率为 0.25、新概率为 0.30,那么 \(\rho_{i,t}=1.2\),表示该 token 在相同前缀下的概率提高了 20%。

本文采用逐 token 的概率比。 不能先把整份回答的 token 概率连乘,再用一个整句概率比替换它;那会改变裁剪目标,也会让概率比更容易随回答长度出现大幅波动。

4.3 clip 保留了 PPO 的更新规则

先暂时不看 KL。对每个有效 token,构造:

\[ C_{i,t}(\theta) =\min\left( \rho_{i,t}\hat A_i, \operatorname{clip}(\rho_{i,t},1-\epsilon_{\mathrm{clip}},1+\epsilon_{\mathrm{clip}})\hat A_i \right) \]

\(C_{i,t}\) 是希望最大化的策略目标。令 \(\epsilon_{\mathrm{clip}}=0.2\),用前面的优势计算:

情况 \(\hat A_i\) \(\rho_{i,t}\) 未裁剪项 裁剪项 最终取最小值
好回答的概率已经增加很多 0.5774 1.4 0.8083 0.6928 0.6928
差回答的概率已经降低很多 -1.7321 0.6 -1.0392 -1.3856 -1.3856
差回答的概率反而提高 -1.7321 1.4 -2.4249 -2.0785 -2.4249

表中的计算使用未舍入的优势,结果保留四位小数。

第一行说明:好回答的 token 概率超过旧概率的 1.2 倍后,这个样本的裁剪目标不再鼓励继续增加。第二行说明:差回答的 token 概率低于旧概率的 0.8 倍后,不再鼓励继续降低。

第三行则是策略朝错误方向变化,未裁剪项仍然提供纠正信号。因此,clip 不是将网络输出的概率比强制锁在 \([0.8,1.2]\) 中。

4.4 为什么还有参考模型的 KL 约束?

clip 只比较当前策略与这一批 rollout 的旧策略。每次重新采样,旧策略都会刷新;连续很多轮以后,模型仍可能逐渐偏离训练开始时的行为。

如果评分规则只检查最后的答案,模型可能通过一些评分器没有充分约束的行为获得高分。参考策略提供另一个参照,用于惩罚过大的分布偏移,但它本身不能保证回答正确或消除评分漏洞。

固定上下文 \(h=(q,o_{i,<t})\),完整 token 分布上的 KL 散度为:

\[ D_{\mathrm{KL}}\bigl(\pi_\theta(\cdot\mid h)\|\pi_{\mathrm{ref}}(\cdot\mid h)\bigr) =\sum_v\pi_\theta(v\mid h) \log\frac{\pi_\theta(v\mid h)}{\pi_{\mathrm{ref}}(v\mid h)} \]

\(v\) 遍历词表中的 token。GRPO 的常见写法使用已采样 token 上的量:

\[ \begin{aligned} \Delta_{i,t} &=\log\pi_{\mathrm{ref}}(o_{i,t}\mid h)-\log\pi_\theta(o_{i,t}\mid h) \\ k_{i,t}(\theta) &=\exp(\Delta_{i,t})-\Delta_{i,t}-1 \end{aligned} \]

由于 \(e^x\geq1+x\),\(k_{i,t}\) 非负;当采样 token 在两个模型下的概率相等时,这个样本上的值为 0。但单个样本上的 \(k_{i,t}=0\),不能说明整个词表分布完全相同。

例如,当前概率为 0.30,参考概率为 0.20:

\[ k_{i,t} =\frac{0.20}{0.30}-\log\frac{0.20}{0.30}-1 \approx0.0721 \]

这个数衡量的是相对于参考模型的偏移,与刚才使用旧概率 0.25 算出的 \(\rho=1.2\) 不同。

这里还需要区分样本值和期望:固定上下文,并且 token 真正按当前策略采样时,\(k\) 的期望等于上述方向的 KL。本文的 rollout 来自旧策略,多轮更新后旧策略与当前策略不同,因此这里使用的是旧样本上的 KL 近似正则项,不能把它在任意更新时刻都当成精确 KL;这个数值期望关系也不等于对固定样本直接反传就得到了完整 KL 的精确梯度。

4.5 合并成最终损失

对一道题的 \(G\) 份回答,GRPO 的经验目标写成:

核心公式:GRPO 目标与训练损失

\[ J_q(\theta) =\frac{1}{G}\sum_{i=1}^G\frac{1}{T_i} \sum_{t=1}^{T_i} \left[C_{i,t}(\theta)-\beta k_{i,t}(\theta)\right] \]

\[ L(\theta)=-\frac{1}{B}\sum_{b=1}^B J_{q_b}(\theta) \]

\(B\) 是问题数量,\(\beta\) 是 KL 系数。目标希望策略获得较大的裁剪收益和较小的 KL;优化器执行最小化,所以 loss 中是“负的策略目标 + 正的 KL 惩罚”。

这里先对每份回答的有效 token 求平均,再对回答和问题求平均。这意味着每份回答在外层具有相同权重,而不是让 token 更多的回答天然占据更多总权重。它同时会让较短回答中每个 token 的权重更大,因此也并非完全没有长度相关的影响。

本文沿用原始 GRPO 的这套归一化方式。训练库还可能提供按 batch 有效 token 总数归一化、改变奖励标准化方式等变体;使用现成工具时,应核对配置对应的公式。TRL 的 GRPO 文档列出了相关区别。

与前面的 PPO 代码比较,这里没有 Critic 的 value loss,也不需要构造 \(V^{\mathrm{target}}\)。KL 单独进入 loss,不参与本文的组内 reward 标准化。

5. 一次训练怎样执行?

把前面的公式按数据流连接起来:

取 B 道问题,每道问题采样 G 份回答
                  ↓
保存回答 token、有效位置、旧策略 log probability
                  ↓
给完整回答评分,按问题计算组相对优势
                  ↓
参考模型计算这些回答上的 log probability
                  ↓
当前模型重新计算同一批回答上的 log probability
                  ↓
计算逐 token 概率比、裁剪目标和 KL,更新当前策略
                  ↓
同一批数据可优化若干轮,然后重新采样

5.1 哪些量固定,哪些量参与反向传播?

数据 常见形状 这批数据优化期间是否固定
回答 token \([B,G,T]\) 固定
回答奖励 \([B,G]\) 固定
组相对优势 \([B,G]\) 固定
旧策略、参考策略的 log probability \([B,G,T]\) 固定
当前策略的 log probability \([B,G,T]\) 每轮重新计算,保留梯度
有效 token mask \([B,G,T]\) 固定

\(T\) 是为了组成张量而使用的最大回答长度,实际第 \(i\) 份回答可能只有 \(T_i\) 个有效 token。组内优势通过 unsqueeze(-1) 扩展为 \([B,G,1]\),然后广播到回答中的各个位置。

不需要对“采样出哪个 token”或评分器反向传播。token 和分数都是已经收集的数据;梯度通过当前模型计算这些 token 的 log probability,进入策略参数。

5.2 重新计算概率,不是重新生成回答

更新时,把 rollout 中已有的回答作为上下文送入模型,读取每个实际生成 token 对应的 log probability。它与 teacher forcing 的前向计算相似,但 loss 使用的是组相对优势和概率比。

例如已有回答为 \([o_1,o_2,o_3]\),需要取出的是:

\[ \log\pi_\theta(o_1\mid q),\quad \log\pi_\theta(o_2\mid q,o_1),\quad \log\pi_\theta(o_3\mid q,o_1,o_2) \]

在真实 causal LM 中,要把 logits 与“下一个 token”对齐,不能让模型看到目标 token 后再计算该 token 的概率。prompt 位置和 padding 不进入回答的 loss;实际生成的 EOS 通常属于有效回答 token。生成长度上限导致的截断还需要单独决定如何评分和屏蔽。

采样策略也必须与保存的旧概率一致。本文代码直接从模型的分类分布采样;如果加入 temperature、top-p 等改变采样分布的操作,就需要明确概率计算与采样分布的对应关系。

5.3 为什么开始时 loss 可能为 0?

如果当前策略尚未更新,\(\rho_{i,t}=1\);如果当前策略也与参考策略相同,那么 KL 项为 0。组内优势的和又为 0,因此按本文的回答平均方式计算,初始 loss 可能非常接近 0。

但这不表示梯度为 0。在旧策略处:

\[ \left.\nabla_\theta\rho_{i,t}\right|_{\theta=\theta_{\mathrm{old}}} =\nabla_\theta\log\pi_\theta(o_{i,t}\mid q,o_{i,<t}) \]

不同回答、不同 token 的 log probability 梯度并不相同,即使优势数值相加为 0,它们加权后的梯度也通常不会相互抵消。观察训练是否有效,应结合奖励和任务成功率,不能只看 loss 是否下降。

6. 用一个小实验跑通 GRPO

为了直接看到训练过程,下面不下载大语言模型,而是训练一个很小的自回归策略。它接收目标数 \(q\in\{2,3,4,5,6\}\),依次生成两个数字,每个数字都在 \(0\sim4\) 中选择。

奖励规则为:

\[ R(q,o)=\mathbf 1[o_1+o_2=q] \]

例如,\(q=4\) 时,回答 \([1,3]\)、\([2,2]\)、\([4,0]\) 都能获得奖励 1,\([1,2]\) 得到奖励 0。训练并不指定唯一的正确回答,只根据模型自己生成的结果评分。

第一步输入目标数和 BOS,生成第一个数字;第二步输入目标数和第一个数字,再生成第二个数字。这个两步任务保留了自回归采样、同题分组和逐 token 更新,便于检查算法中的每一个量。

6.1 实验配置和实际结果

配置 数值
随机种子 0
每批问题数 \(B\) 5
每题回答数 \(G\) 16
每条回答长度 \(T\) 2
每批 rollout 优化轮数 2
学习率 0.01
裁剪系数 \(\epsilon_{\mathrm{clip}}\) 0.2
KL 系数 \(\beta\) 0.02
rollout 批次数 120

每道题只有 \(5\times5=25\) 种回答,因此可以直接枚举所有回答,计算当前模型的准确成功概率:

\[ P_\theta(\mathrm{success}\mid q) =\sum_{a=0}^4\sum_{b=0}^4 \pi_\theta(a\mid q)\pi_\theta(b\mid q,a) \mathbf 1[a+b=q] \]

再对 5 道题平均,就得到下表中的数值。它不是单个 rollout 恰好答对的比例,也不是抽取最大概率 token 后的贪心准确率。

下面是在 CPU、PyTorch 2.4.1 上实际执行本文代码得到的结果:

完成的 rollout 批次 平均成功概率
0 0.1649
1 0.1928
10 0.9005
30 0.9915
60 0.9944
120 0.9929
两步数字生成实验中,平均成功概率从约 0.165 上升到约 0.993,后期有小幅波动

图 3:固定种子的一次实际运行,纵轴通过枚举所有回答计算。这 5 道题同时用于训练与评估,曲线只验证训练机制,不代表未见问题上的泛化能力。

成功概率没有严格单调增加。每轮采样的回答不同,组相对优势也随之变化;KL 项还在约束模型相对于参考策略的偏移。不同依赖版本可能产生略有不同的数值。

6.2 完整代码

下面代码只依赖 PyTorch,限制为单线程 CPU,不需要 GPU 或预训练模型。可以直接下载 grpo_toy.py。

from copy import deepcopy

import torch
import torch.nn as nn
from torch.distributions import Categorical


def group_advantages(rewards):
    # rewards: [B, G],每道题单独计算均值和总体标准差
    centered = rewards - rewards.mean(dim=1, keepdim=True)
    std = rewards.std(dim=1, keepdim=True, unbiased=False)
    return (centered / (std + 1e-8)).detach()


def grpo_loss(new_logp, old_logp, ref_logp, advantages, mask,
              clip_epsilon=0.2, beta=0.02):
    # logp、mask: [B, G, T];advantages: [B, G]
    # 先清除无效位置,避免 padding 处的数值进入 exp。
    valid = mask.bool()
    log_ratio = torch.where(valid, new_logp - old_logp.detach(), 0.0)
    ratio = log_ratio.exp()
    advantage = advantages.detach().unsqueeze(-1)
    unclipped = ratio * advantage
    clipped = ratio.clamp(1 - clip_epsilon, 1 + clip_epsilon) * advantage
    policy_loss = -torch.minimum(unclipped, clipped)

    log_ref_ratio = torch.where(valid, ref_logp.detach() - new_logp, 0.0)
    kl_estimate = torch.expm1(log_ref_ratio) - log_ref_ratio
    token_loss = policy_loss + beta * kl_estimate

    # 先在每条回答内部平均,再对回答和问题平均。
    lengths = mask.sum(dim=-1).clamp_min(1)
    return ((token_loss * mask).sum(dim=-1) / lengths).mean()


class TinyPolicy(nn.Module):
    def __init__(self):
        super().__init__()
        self.question = nn.Embedding(7, 16)
        self.previous = nn.Embedding(6, 16)  # 0..4 是数字,5 是 BOS
        self.head = nn.Sequential(
            nn.Linear(32, 32), nn.Tanh(), nn.Linear(32, 5)
        )

    def forward(self, questions, previous_tokens):
        # questions: [N];previous_tokens: [N, T]
        q = self.question(questions).unsqueeze(1)
        q = q.expand(-1, previous_tokens.shape[1], -1)
        previous = self.previous(previous_tokens)
        return self.head(torch.cat([q, previous], dim=-1))


def token_log_probs(model, questions, previous_tokens, answers):
    logits = model(questions, previous_tokens)
    return logits.log_softmax(dim=-1).gather(
        -1, answers.unsqueeze(-1)
    ).squeeze(-1)


@torch.no_grad()
def collect_rollout(policy, reference, questions, group_size):
    batch_size = len(questions)
    repeated_questions = questions.repeat_interleave(group_size)
    previous = torch.full((len(repeated_questions), 1), 5, dtype=torch.long)
    inputs, actions = [], []
    for _ in range(2):
        inputs.append(previous)
        distribution = Categorical(logits=policy(repeated_questions, previous))
        action = distribution.sample()
        actions.append(action)
        previous = action

    previous_tokens = torch.cat(inputs, dim=1)
    answers = torch.cat(actions, dim=1)
    old_logp = token_log_probs(policy, repeated_questions, previous_tokens, answers)
    ref_logp = token_log_probs(reference, repeated_questions, previous_tokens, answers)
    rewards = (answers.sum(dim=1) == repeated_questions).float()
    shape = (batch_size, group_size, 2)
    return (repeated_questions, previous_tokens, answers,
            old_logp.reshape(shape), ref_logp.reshape(shape),
            rewards.reshape(batch_size, group_size))


@torch.no_grad()
def exact_success_rate(policy, questions):
    # 枚举 5 × 5 种回答,计算模型答对的概率,无需再采样。
    rates = []
    for question in questions.tolist():
        q = torch.tensor([question])
        first_probs = policy(q, torch.tensor([[5]])).softmax(-1)[0, 0]
        success = 0.0
        for first in range(5):
            second = question - first
            if 0 <= second < 5:
                second_probs = policy(q, torch.tensor([[first]])).softmax(-1)[0, 0]
                success += float(first_probs[first] * second_probs[second])
        rates.append(success)
    return sum(rates) / len(rates)


def main():
    torch.manual_seed(0)
    torch.set_num_threads(1)
    policy = TinyPolicy()
    reference = deepcopy(policy).eval()
    reference.requires_grad_(False)
    optimizer = torch.optim.Adam(policy.parameters(), lr=0.01)
    questions = torch.arange(2, 7)
    group_size = 16
    history = [(0, exact_success_rate(policy, questions))]
    print(f"Update   0 | Exact success {history[-1][1]:.4f}")

    for update in range(1, 121):
        q, previous, answers, old_logp, ref_logp, rewards = collect_rollout(
            policy, reference, questions, group_size
        )
        advantages = group_advantages(rewards)
        mask = torch.ones_like(old_logp)  # 本例每条回答恰好有 2 个 token

        for _ in range(2):
            new_logp = token_log_probs(policy, q, previous, answers)
            new_logp = new_logp.reshape_as(old_logp)
            loss = grpo_loss(new_logp, old_logp, ref_logp, advantages, mask)
            optimizer.zero_grad()
            loss.backward()
            torch.nn.utils.clip_grad_norm_(policy.parameters(), 1.0)
            optimizer.step()

        history.append((update, exact_success_rate(policy, questions)))
        if update in (1, 10, 30, 60, 120):
            print(f"Update {update:3d} | Exact success {history[-1][1]:.4f}")
    return history


if __name__ == "__main__":
    main()

6.3 代码和公式如何对应?

collect_rollout 在 no_grad() 下采样并保存旧概率。对每个问题连续排列 16 份回答,所以将奖励恢复为 \([B,G]\) 后,dim=1 正好是同一问题的组内维度。

group_advantages 只根据这组奖励计算优势;优化的 2 轮中,它与 old_logp、ref_logp 都保持不变。每轮只有 new_logp 重新前向计算并参与反向传播。

grpo_loss 先计算逐 token 概率比和裁剪项,再加入 KL。代码中的 expm1(x) 等价于 \(e^x-1\),在 \(x\) 接近 0 时通常比直接相减更适合数值计算。

最后先沿 token 维度求和,再除以该回答的有效长度,之后对问题和回答求平均。真实回答长短不一时,需要传入正确的 mask,并在进入 loss 前排除没有有效 token 的回答;这里每份回答都恰好有两个 token,mask 全为 1。

这个实验只让策略学习两步数字组合,没有自然语言 tokenizer、长上下文或真实推理过程。它用于验证 GRPO 的数据流和更新机制,不能据此判断大语言模型训练的算力需求或推理能力。

7. GRPO 的训练信号有什么限制?

7.1 全对或全错的组,没有相对差异

如果同一组奖励为 \([1,1,1,1]\) 或 \([0,0,0,0]\),那么所有 \(R_i-\mu_q=0\),加上防除零常数以后,各回答的优势仍然都是 0。

这时该组的策略奖励项没有更新信号;如果当前策略与参考策略不同,KL 项仍可能产生梯度。\(G=1\) 时每个组都退化成这种情况,因此本文的组相对优势需要至少两个回答才可能提供非零信号。

可以用一个简单计算理解为什么太难、太简单的问题都可能缺少信号。假设每份回答独立、答对概率均为 \(p\),奖励只有 0 和 1,那么一组内同时出现正确与错误回答的概率为:

\[ P(\text{组内有差异})=1-p^G-(1-p)^G \]

当 \(p=0.5,G=4\) 时,这个概率是 \(0.875\);当 \(p=0.01,G=4\) 时,只有约 \(0.0394\)。增加 \(G\) 能提高观察到差异的机会,但也会增加生成成本;如果模型根本无法产生非零奖励,单纯增加采样次数也无法凭空提供好答案。

7.2 奖励标准化会影响不同问题的权重

对于二元奖励,设一组中正确回答占比为 \(p\),且 \(0<p<1\)。忽略稳定常数:

\[ \hat A_{\mathrm{correct}}=\sqrt{\frac{1-p}{p}}, \qquad \hat A_{\mathrm{wrong}}=-\sqrt{\frac{p}{1-p}} \]

这直接来自 \(\mu=p\) 和 \(\sigma=\sqrt{p(1-p)}\)。组内正确回答稀少时,每份正确回答的正优势较大;错误回答稀少时,每份错误回答的负优势绝对值较大。

因此,除以标准差会改变样本的相对权重,并非只是一项完全不影响优化方向的数值处理。分析训练曲线时,需要同时看原始 reward、组内差异和标准化后的优势。

7.3 去掉 Critic,不等于去掉评分问题

GRPO 仍然依赖奖励的质量。如果评分只奖励格式,模型可能学会格式却没有学会解决问题;如果最终答案判定存在漏洞,模型也可能沿着漏洞提高得分。组内比较只是加工已有的评分,不能替代一个可靠的评分规则。

另外,一份回答共享一个优势,意味着它缺少细粒度的步骤归因。把最终答案评分改成过程评分,需要重新设计优势与 token 的对应关系,不能直接沿用本文“所有 token 共享同一优势”的假设。

把本文和前面的 PPO 放在一起,可以看到两者主要区别:

比较项 前文的 PPO 本文的 GRPO
优势来源 reward、Critic 价值预测与 GAE 同题多份回答的组相对奖励
是否训练 Critic 是 否
不同时间步的优势 通常不同 同一回答内共享一个优势
策略更新 新旧概率比与 clip 逐 token 新旧概率比与 clip
额外损失 value loss、熵奖励 相对于参考策略的 KL 项
数据使用 当前 rollout 优化后重新采集 当前回答组优化后重新生成

表中的额外损失对应这两篇文章具体采用的设置,不是两种算法不可改变的边界。例如,语言模型的 PPO 训练也可以加入参考策略的 KL 约束。