LLM后训练算法-GRPO,GSPO
本章主要介绍GRPO、GSPO,他们的主要改进点以及解决的问题。
GRPO
PPO的问题
LLM后训练算法-PPO介绍了PPO算法的提出,以及其解决的问题。本部分我们介绍PPO如何计算优势函数,然后更新梯度。由此分析PPO算法存在的问题。
1.1优势计算
PPO沿用经典的Actor-Critic范式,
- Actor:策略模型,逐 Token 生成回答;
- Critic:价值网络,在每个 Token 位置估计状态价值 \(V(s_t)\);
- 优势函数:衡量在状态 \(s_t\) 下选择动作 \(a_t\) 相对于平均表现好多少。
Critic 本身不直接输出优势,而是输出每个状态的价值估计 \(V(s_t)\),再由这些价值估计和实际奖励一起计算优势。优势计算大体分两步,先计算每一步相对优势,最后再相加得到总体的相对优势
1.1.1 TD 误差
优势估计的基本构件是 TD 误差:
\( \delta_t = r_t + \gamma V(s_{t+1}) - V(s_t) \)
含义是 “当前奖励 + 下一状态的价值估计” 与 “当前状态的价值估计” 之间的差值。如果 \(\delta_t > 0\),说明当前步的实际结果比 Critic 预期的更好。
1.1.2 GAE 计算优势
PPO 通常使用广义优势估计 GAE:
\( \hat{A}_t = \delta_t + \gamma \lambda \hat{A}_{t+1} \)
其中:
- \(\gamma\):折扣因子,常取 0.99;
- \(\lambda\):GAE 参数,常取 0.95;
- \(\hat{A}_t\):第 \(t\) 个 Token 位置的优势估计。
实际实现时,GAE 通常从序列末尾向前递归计算。这个递归结构意味着,当前时刻的优势估计,不仅包含当前的TD误差 δ_t,还包含了经过折扣的、对未来优势的估计\(\hat{A}_{t+1}\)
1.1.3 伪代码
advantages = []
last_gae = 0
for t in reversed(range(T)):
delta = rewards[t] + gamma * values[t + 1] - values[t]
current_advantage = delta + gamma * lambda_ * last_gae
advantages.insert(0, current_advantage)
last_gae = current_advantage
其中:
values[t]是 Critic 对第 \(t\) 个 Token 位置的状态价值估计;rewards[t]是第\(t\) 步的奖励;advantages[t]是最终用于策略更新的优势值。
1.1.4 梯度更新
计算出的优势 \(\hat{A}_t\) 会进入 PPO 的策略损失,用于指导 Actor 更新。简化形式为:
\( L^{\text{PPO}}(\theta)= \mathbb{E}_t \left[ \min \left( \rho_t(\theta)\hat{A}_t, \; \text{clip}(\rho_t(\theta), 1-\epsilon, 1+\epsilon)\hat{A}_t \right) \right] \)
其中 \(\rho_t(\theta)\) 是 Token 级重要性比率:
\( \rho_t(\theta)= \frac{\pi_\theta(a_t \mid s_t)} {\pi_{\theta_{\text{old}}}(a_t \mid s_t)} \)
1.2 PPO 在 LLM 训练中存在的问题
PPO在训练过程中的问题主要包括两部分,稳定性和资源。PPO 的优势估计依赖 Critic,但在 LLM 场景下,这会带来一个核心矛盾: 奖励通常是序列级 / 结果级的,但 Critic 需要做逐 Token 的价值估计。
1.2.1 奖励粒度与价值估计粒度不匹配
在数学推理、代码生成等任务中,奖励往往只在整条回答结束时给出:
- 答对:奖励 1;
- 答错:奖励 0。
但 PPO 的 Critic 需要在回答的每一个 Token 位置估计:“从这个位置继续生成,最终能拿到多少总回报?” 也就是说:
- 奖励:整条序列一个标量;
- Critic:每个 Token 位置一个价值估计。
中间 Token 本身没有独立奖励,Critic 只能依靠最终奖励反传去学习逐 Token 价值。这在稀疏奖励任务中非常困难。
1.2.2 Critic 不准会导致优势不准
如果 Critic 对 \(V(s_t)\) 估计不准,那么:
- TD 误差 \(\delta_t\) 不准;
- GAE 优势 \(\hat{A}_t\) 不准;
- 策略梯度方向不准;
- 训练容易不稳定,甚至崩溃。
尤其在稀疏奖励场景下,Critic 训练方差大、收敛困难。
1.2.3 内存和计算开销高
PPO 通常需要维护 4 个模型:策略模型 Actor;价值模型 Critic;奖励模型 Reward;参考模型 Reference。其中 Critic 通常与策略模型规模相当,显著增加内存占用和计算开销。
1.3 Toy Code
def discount_cumsum(x, discount):
# 等价于从后向前:y[t] = x[t] + discount * y[t+1]
return scipy.signal.lfilter([1], [1, -discount], x[::-1])[::-1]
# 基于 spinup.algos.pytorch.ppo 的 GAE 实现
# rews: [T+1],最后一位是 bootstrap value
# vals: [T+1],Critic 对每个位置的价值估计
deltas = rews[:-1] + gamma * vals[1:] - vals[:-1] # TD 误差 δ_t
adv_buf = discount_cumsum(deltas, gamma * lam) # GAE: Â_t = δ_t + γλ·Â_{t+1}
# log_prob, old_log_prob, advantages: 均为 [B, T]
ratio = torch.exp(log_prob - old_log_prob) # Token 级比率 r_t
surr1 = ratio * advantages
surr2 = torch.clamp(ratio, 1 - eps, 1 + eps) * advantages
policy_loss = -torch.min(surr1, surr2).mean() # 逐 Token 取 min 后平均
GRPO 如何解决这个问题
GRPO 相对于PPO的核心差异在于优势的计算: 去掉 Critic,不再逐 Token 估计价值,而是用同一问题下多个回答的组内相对奖励来计算序列级优势。 解决了PPO资源占用多,训练不稳定的问题。
2.1 优势计算
2.1.1 组采样
对于同一个问题 \(q\),使用旧策略采样一组回答:\( \{o_1, o_2, \dots, o_G\} \)然后用奖励模型或规则给每个回答打分:\( r_1, r_2, \dots, r_G \)
2.1.2 组内相对优势
GRPO 直接用组内奖励的均值和标准差归一化得到优势:
\( \hat{A}_i= \frac{r_i - \text{mean}(r_1, \dots, r_G)} {\text{std}(r_1, \dots, r_G)} \)
含义是:
- 如果回答 \(o_i\) 的奖励高于组内平均,则 \(\hat{A}_i > 0\);
- 如果低于组内平均,则 \(\hat{A}_i < 0\);
- 优势不再依赖 Critic 的逐 Token 价值估计。
这个优势是序列级优势,会共享给该回答中的所有 Token。
2.1.3 GRPO 的策略损失
简化后的 GRPO 目标可以写成:
\( J_{\text{GRPO}}(\theta)= \mathbb{E} \left[ \frac{1}{G} \sum_{i=1}^{G} \frac{1}{|o_i|} \sum_{t=1}^{|o_i|} \min \left( \rho_{i,t}(\theta)\hat{A}_i, \; \text{clip}(\rho_{i,t}(\theta), 1-\epsilon, 1+\epsilon)\hat{A}_i \right) \right] \)
其中:
- \(\hat{A}_i\) 是第 \(i\) 个回答的序列级优势;
- \(\rho_{i,t}(\theta)\) 是第 \(i\) 个回答第 \(t\) 个 Token 的重要性比率;
- 同一个回答内所有 Token 共享同一个优势 \(\hat{A}_i\)。
2.2 GRPO 的优劣
优点:
- 稳定性提升:用序列级奖励计算序列级优势,组内归一化降低了方差,提升了训练稳定性
- 内存开销减少:用组内相对奖励代替Critic,只需要策略、奖励、参考三个模型
代价:
- 需要多次采样:同一个问题要生成一组回答,采样成本更高;
- 组内奖励差异小的时候优势信号弱:如果一组回答全对或全错,组内归一化后的优势可能很小甚至不稳定;
- 优势是序列级共享的:同一个回答内所有 Token 共享同一优势,粒度比 Token 级优势粗。
2.3 ToyCode
# token_level_rewards: [B, T] 或 [B, G, T],但只有序列末尾有有效奖励
# 先提取每个回答的标量奖励
scores = token_level_rewards.sum(dim=-1) # [B, G]
# 组内标准化
mean_g = scores.mean(dim=1, keepdim=True)
std_g = scores.std(dim=1, keepdim=True)
advantages = (scores - mean_g) / (std_g + epsilon) # [B, G] ← 序列级标量
# log_prob, old_log_prob: [B, G, T]
# advantages: [B, G] → unsqueeze 后广播到 [B, G, T]
ratio = torch.exp(log_prob - old_log_prob) # Token 级比率 r_{i,t}
adv = advantages.unsqueeze(-1) # 广播序列级优势
surr1 = ratio * adv
surr2 = torch.clamp(ratio, 1 - eps, 1 + eps) * adv
policy_loss = -torch.min(surr1, surr2).mean() # 逐 Token 取 min
GSPO
上文提到了,GRPO的问题是:优势是序列级别,但是重要性比率是token级别。GSPO认为这种token级别的重要性采样不能有效地完成分布校正,反而会给梯度估计引入高方差噪声,而且这种噪声会随着生成序列长度增加而累积。因此GRPO将重要性比率从token级别提高到序列级别,解决GRPO训练稳定性的问题
论文核心逻辑可以概括为:
- Importance Sampling 的作用是:利用行为策略采样的数据,通过概率比率校正目标策略与行为策略之间的分布差异。
- 但在 GRPO 中,importance ratio 是针对每个 token 计算的。
- 对于每个 token,实际上只有一个来自旧策略的采样动作,而不是从该 token 对应的行为分布中获得大量样本。
- 因此,作者认为这种 token-level importance sampling 无法有效完成分布校正,反而引入高方差噪声。
- 随着序列变长,这种噪声会进一步累积,clipping 又可能加剧这种问题。
3.1 优势计算
GSPO并没有重新定义优势的计算方式。它仍然沿用 GRPO 的组归一化优势:
\( \hat{A}_i= \frac{r_i - \text{mean}(r_1, \dots, r_G)} {\text{std}(r_1, \dots, r_G) + \epsilon_{\text{adv}}} \)
对于同一个 prompt 采样 (G) 个回答,每个回答得到一个标量奖励 (r_i),然后在组内做均值和标准差归一化。高于组内平均的回答获得正优势,低于平均的获得负优势。变化不在优势本身,而在优势被乘上的那个权重。
3.1.1 序列级重要性比率
GSPO 定义的长度归一化序列级重要性比率是:
\( s_i(\theta)= \left( \frac{\pi_\theta(o_i \mid q)} {\pi_{\theta_{\text{old}}}(o_i \mid q)} \right)^{\frac{1}{|o_i|}}= \exp\left( \frac{1}{|o_i|} \sum_{t=1}^{|o_i|} \log \frac{\pi_\theta(o_{i,t} \mid q, o_{i,<t})} {\pi_{\theta_{\text{old}}}(o_{i,t} \mid q, o_{i,<t})} \right) \)
这个式子的结构是:
- 先取每个 Token 的对数概率比,即 \(\log \frac{\pi_\theta}{\pi_{\text{old}}}\);
- 在序列长度上求算术平均,除以 \(|o_i|\);
- 最后取指数,得到一个正的比率。
它等价于所有 Token 概率比的几何平均。长度归一化是关键:如果不除以 \(|o_i|\),长序列的对数概率比会随着 Token 数量累积,比率会变得极度长度敏感;除以长度后,比率被压回一个与序列长度无关的尺度,避免少数波动 Token 把整个序列的比率“带飞”。
3.1.2 一个回答内,所有 Token 共享同一个权重
GSPO 的梯度(忽略裁剪)可以写成:
\( \nabla_\theta J_{\text{GSPO}}(\theta)= \mathbb{E} \left[ \frac{1}{G} \sum_{i=1}^{G} s_i(\theta) \, \hat{A}_i \cdot \frac{1}{|o_i|} \sum_{t=1}^{|o_i|} \nabla_\theta \log \pi_\theta(o_{i,t} \mid q, o_{i,<t}) \right] \)
对比 GRPO 的梯度:
\( \nabla_\theta J_{\text{GRPO}}(\theta)= \mathbb{E} \left[ \frac{1}{G} \sum_{i=1}^{G} \frac{\hat{A}_i}{|o_i|} \sum_{t=1}^{|o_i|} r_{i,t}(\theta) \, \nabla_\theta \log \pi_\theta(o_{i,t} \mid q, o_{i,<t}) \right] \)
差别一目了然:
- GRPO:每个 Token 前面乘的是自己的 \(r_{i,t}(\theta)\),权重逐 Token 变化;
- GSPO:整个回答的所有 Token 共享同一个 \(s_i(\theta)\),权重在序列内保持一致。
3.1.3 GSPO 的目标函数与裁剪
完整的 GSPO 目标函数为:
\( \mathcal{J}_{\text{GSPO}}(\theta)= \mathbb{E} \left[ \frac{1}{G} \sum_{i=1}^{G} \frac{1}{|o_i|} \sum_{t=1}^{|o_i|} \min \left( s_i(\theta)\hat{A}_i, \; \text{clip}\left(s_i(\theta), 1-\epsilon, 1+\epsilon\right)\hat{A}_i \right) \right] \)
与 GRPO 的结构高度相似,但裁剪的对象从 Token 级比率变成了序列级比率。这意味着:如果 \(s_i(\theta)\)超出 \([1-\epsilon, 1+\epsilon]\),整条回答的所有 Token 一起被裁剪,而不是像 GRPO 那样只裁掉个别“跑偏”的 Token,裁剪信号在序列内是一致的。
一个实践中的注意点:GSPO 的序列级比率经过长度归一化后,集中在 1 附近,尺度与 Token 级比率不同。如果直接把 GRPO 的裁剪范围(如 \(\epsilon=0.2\))套用到 GSPO 上,裁剪可能几乎永远不触发,失去信任域约束;反过来,不经归一化的原始序列比率又可能瞬间爆炸。GSPO 的裁剪范围需要与序列级比率的尺度匹配。
3.2 GSPO 的优劣
3.2.1 优势
- 降低方差,训练更稳定。
Token 级比率的高方差来自“单 Token 只能采样一次,却要做分布校正”。GSPO 用整条序列的几何平均比率替代逐 Token 比率,相当于用多个 Token 的信息共同估计一个权重,个别 Token 的波动被平均掉,不再直接进入梯度。序列内所有 Token 共享同一个标量权重,也消除了“同一回答内部梯度方向碎片化”的问题。
- 对 MoE 模型尤其有效,不再依赖 Routing Replay。
MoE 的专家路由在训练步之间可能发生变化,导致新旧策略的 Token 概率出现结构性波动。GRPO 的 Token 级比率会把这些与优化方向无关的波动原样放大,触发异常裁剪和崩溃。GSPO 的序列级比率在长度上做了平均,对这种结构性噪声更鲁棒,因此不再需要 Routing Replay 这样的强制对齐手段,降低了工程复杂度,也避免了“强迫新策略走旧路由”的性能限制。
3.2.2 劣势
- Token 级信用分配变粗。
这是 GSPO 最核心的代价。GRPO 虽然噪声大,但它至少在形式上允许不同 Token 获得不同权重,保留了区分关键推理步骤的潜力。GSPO 把整条回答的所有 Token 赋予同一个权重,意味着无法在 Token 粒度上区分“哪一步写对了、哪一步写错了”。对于需要精细信用分配的任务,序列级更新可能“过于粗糙”。
- 裁剪可能导致梯度利用不足。
序列级裁剪一旦触发,整条序列的所有 Token 都失去梯度。如果裁剪范围设置偏保守,可能丢弃仍然包含有效学习信号的样本,造成“梯度欠利用”(gradient underutilization),尤其当序列中只有少数 Token 导致比率超出范围时。
- 对稠密模型的收益可能有限。
GSPO 的稳定性优势主要来自对结构性方差(尤其是 MoE 路由波动)的抑制。对于没有路由机制的稠密模型,Token 级比率的噪声问题依然存在,但 GSPO 带来的额外收益可能不如 MoE 场景显著。
4. 裁剪范围需要重新调参。
序列级比率的数值尺度与 Token 级比率不同,不能直接沿用 GRPO 的超参数。裁剪阈值需要针对长度归一化后的序列比率重新设定,否则可能失去信任域约束,或在训练初期出现数值问题。
3.3 ToyCode
相比GRPO核心变化在于重要性比率计算
# log_prob, old_log_prob: [B, G, T]
# response_mask: [B, G, T]
negative_approx_kl = log_prob - old_log_prob # Token 级对数比率
# 序列级对数比率 = 有效 Token 上对数比率的平均
seq_lengths = response_mask.sum(dim=-1).clamp(min=1) # [B, G]
seq_log_ratio = (negative_approx_kl * response_mask).sum(-1) / seq_lengths
# s_i(θ) = exp( mean_t( log π_θ - log π_old ) )
# GSPO-token 形式:序列级比率 + Token 级残差
log_seq_importance_ratio = (
log_prob - log_prob.detach()
+ seq_log_ratio.detach().unsqueeze(-1)
)
log_seq_importance_ratio = torch.clamp(log_seq_importance_ratio, max=10.0)
seq_importance_ratio = torch.exp(log_seq_importance_ratio) # 有效“序列比率”
# 序列级裁剪(与 GRPO 的裁剪形式相同,但作用在序列比率上)
pg_losses1 = -advantages.unsqueeze(-1) * seq_importance_ratio
pg_losses2 = -advantages.unsqueeze(-1) * torch.clamp(
seq_importance_ratio, 1 - clip_low, 1 + clip_high
)
pg_losses = torch.maximum(pg_losses1, pg_losses2)
# GSPO 强制序列级聚合
pg_loss = agg_loss(pg_losses, response_mask, loss_agg_mode="seq-mean-token-mean")
总结
| 维度 | PPO | GRPO | GSPO |
|---|---|---|---|
| 架构 | Actor + Critic | 无 Critic | 无 Critic |
| 模型数量 | 4 个 (策略 / 价值 / 奖励 / 参考) | 3 个 (策略 / 奖励 / 参考) | 3 个 (策略 / 奖励 / 参考) |
| 优势来源 | Critic 估价值 + GAE,逐 Token | 组内奖励归一化,序列级 | 组内奖励归一化,序列级 |
| 重要性比率粒度 | Token 级 rt | Token 级 ri,t | 序列级 si (长度归一化几何平均) |
| 裁剪粒度 | Token 级 | Token 级 | 序列级(整条回答一起裁) |
| 采样方式 | 每 prompt 通常 1 次 | 每 prompt 采样 G 个 | 每 prompt 采样 G 个 |
| 主要问题 | Critic 难训、开销高、稀疏奖励下不稳 | 序列奖励 vs. Token 级优化错配,MoE 下易崩 | Token 级信用分配变粗、裁剪可能欠利用 |
| MoE 稳定性 | 差 | 差,常需 Routing Replay | 好,不依赖 Routing Replay |
| 核心取舍 | 精细但重 | 轻但粒度错配 | 稳定但粗粒度 |
浙公网安备 33010602011771号