从 RLHF 到 GRPO：大模型对齐训练技术演进与实战
· 阅读需 9 分钟
为什么又聊对齐训练
DeepSeek-R1 发布后，GRPO（Group Relative Policy Optimization）成了对齐训练领域最火的关键词。但如果你只看了 PR 通稿，大概率会以为 GRPO 是 DeepSeek 发明的全新算法——实际上它是 DPO 和 PPO 的自然演化，核心思想早就有迹可循。
这篇文章从工程落地的角度，把 RLHF → DPO → GRPO 这条线讲清楚。有代码、有坑、有 benchmark。
RLHF 的工程痛点
RLHF（Reinforcement Learning from Human Feedback）的标准流程：
- SFT：监督微调基座模型
- Reward Model：训练一个评分模型
- PPO：用 PPO 优化策略模型，reward model 打分
┌─────────┐ ┌──────────┐ ┌──────────┐
│ SFT │───▶│ Reward │───▶│ PPO │
│ Model │ │ Model │ │ Update │
└─────────┘ └──────────┘ └──────────┘
工程上维护这个流程的痛点：
- Reward Model 需要单独训练和部署：一个 7B 的策略模型，reward model 通常也得 7B，显存翻倍
- Reward Hacking：策略模型学会钻评分的空子，生成高分但无意义的回复
- PPO 训练不稳定：四个模型同时加载（policy、reference、reward、value），显存爆炸；KL 散度约束调参玄学
DPO 的出现解决了 reward model 的问题，但引入了新问题。
DPO：优雅但有天花板
DPO（Direct Preference Optimization） 的核心洞察：PPO 的优化目标可以重参数化，直接消掉 reward model。
DPO 的 loss：
def dpo_loss(
policy_chosen_logp, # π_θ(y_w|x)
policy_rejected_logp, # π_θ(y_l|x)
ref_chosen_logp, # π_ref(y_w|x)
ref_rejected_logp, # π_ref(y_l|x)
beta=0.1, # temperature
):
"""
DPO loss: maximize the gap between chosen and rejected responses.
β controls how far the policy can deviate from the reference.
"""
import torch
policy_log_ratio = policy_chosen_logp - policy_rejected_logp
ref_log_ratio = ref_chosen_logp - ref_rejected_logp
logits = policy_log_ratio - ref_log_ratio
loss = -torch.nn.functional.logsigmoid(beta * logits)
return loss.mean()
不需要 reward model，只需要偏好对 (chosen, rejected)。训练速度比 RLHF 快 2-4 倍。
但 DPO 的硬伤：
- 离线偏好数据依赖：训练数据和策略模型分布不匹配时会退化。你用的偏好对是 Llama-3 生成的，但你训练的是 Qwen——分布漂移导致效果打折
- 缺少 exploration：不像 PPO 有在线采样过程，DPO 只能"学习已有的偏好"，无法发现新的更好的响应
- reward 信号稀疏：每对数据只有一个 chosen/rejected 标签，没有中间状态的信息
这就是为什么 2024 年底开始，工业界开始探索 在线对齐 方案。
GRPO：去掉 Critic，保留 Online
GRPO 是 DeepSeek 在 DeepSeekMath 论文中提出的，后来被 DeepSeek-R1 采用。
核心思想
传统 PPO 需要四个模型：
PPO: Policy + Reference + Reward + Value (4 个模型)
GRPO: Policy + Reference + Reward (3 个模型)
GRPO 去掉了 Value 模型（critic），用组内相对比较替代 advantage 估计：
对每个 prompt x，采样 G 个响应 {y1, y2, ..., yG}
→ 用 reward model 打分得到 {r1, r2, ..., rG}
→ 组内归一化：advantage_i = (ri - mean(r)) / std(r)
→ 只更新使 advantage > 0 的 token
Loss 函数详解
def grpo_loss(
policy_model,
reference_model,
prompts, # batch of prompts
reward_func, # callable: (prompt, response) -> float
group_size=4, # G: responses per prompt
beta=0.04, # KL penalty coefficient
epsilon=0.2, # clipping parameter
):
"""
GRPO loss as used in DeepSeek-R1.
Key difference from PPO:
- No critic/value model
- Advantage computed via group normalization
- Clipping on both sides like PPO
"""
import torch
import torch.nn.functional as F
total_loss = []
total_kl = []
for prompt in prompts:
# Step 1: Sample G responses from current policy
responses = []
rewards = []
with torch.no_grad():
for _ in range(group_size):
resp_ids, logps = policy_model.generate(
prompt, return_logprobs=True, do_sample=True
)
responses.append((resp_ids, logps))
# Get reward (rule-based or model-based)
resp_text = policy_model.tokenizer.decode(resp_ids[0])
r = reward_func(prompt, resp_text)
rewards.append(r)
rewards = torch.tensor(rewards)
# Step 2: Group normalization for advantage
advantages = (rewards - rewards.mean()) / (rewards.std() + 1e-8)
# Step 3: Compute loss for each positive-advantage response
for i, (resp_ids, old_logps) in enumerate(responses):
if advantages[i] <= 0:
continue
# Current policy logprobs
new_logps = policy_model.get_logprobs(prompt, resp_ids)
# PPO-style ratio
ratio = torch.exp(new_logps - old_logps)
# Clipped objective
clipped_ratio = torch.clamp(
ratio, 1 - epsilon, 1 + epsilon
)
policy_loss = -torch.min(
ratio * advantages[i],
clipped_ratio * advantages[i]
).mean()
# KL penalty to reference model
ref_logps = reference_model.get_logprobs(prompt, resp_ids)
kl = (new_logps - ref_logps).mean()
loss = policy_loss + beta * kl
total_loss.append(loss)
total_kl.append(kl.item())
if total_loss:
return torch.stack(total_loss).mean(), sum(total_kl) / len(total_kl)
return torch.tensor(0.0), 0.0
为什么 GRPO 更好
| 维度 | PPO | DPO | GRPO |
|---|---|---|---|
| 在线采样 | ✅ | ❌ | ✅ |
| 需要 Value Model | ✅ | N/A | ❌ |
| 需要 Reward Model | ✅ | ❌ | ✅ |
| 偏好数据需求 | 低 | 高 | 低 |
| 显存占用 | 高 | 中 | 中 |
| 训练稳定性 | 低 | 高 | 中 |
Benchmark 数据（来自 DeepSeekMath 论文）：
| 方法 | MATH 500 | GSM8K | HumanEval |
|---|---|---|---|
| Base (DeepSeek-Coder 7B) | 51.7% | 78.2% | 48.2% |
| + SFT | 56.2% | 82.4% | 52.4% |
| + DPO | 58.4% | 83.1% | 54.3% |
| + GRPO | 64.2% | 86.7% | 58.5% |
GRPO 在数学和代码推理任务上比 DPO 显著提升，尤其在 MATH 上差了近 6 个点。
实战：用 TRL 跑 GRPO
截至 2026 年 8 月，TRL（Transformer Reinforcement Learning）已原生支持 GRPO：
from datasets import load_dataset
from trl import GRPOConfig, GRPOTrainer
from transformers import AutoModelForCausalLM, AutoTokenizer
# 1. 加载模型
model_name = "Qwen/Qwen2.5-7B-Instruct"
model = AutoModelForCausalLM.from_pretrained(
model_name,
torch_dtype="auto",
device_map="auto",
attn_implementation="flash_attention_2",
)
tokenizer = AutoTokenizer.from_pretrained(model_name)
tokenizer.pad_token = tokenizer.eos_token
# 2. 准备数据集（只需要 prompts）
dataset = load_dataset("openai/gsm8k", "main", split="train[:2000]")
def format_prompt(example):
return {
"prompt": f"Question: {example['question']}\nAnswer: "
}
dataset = dataset.map(format_prompt)
# 3. 定义 reward function
def math_reward(prompt, completion):
"""
Rule-based reward for math reasoning.
简单粗暴：提取 \boxed{} 中的答案，跟标准答案比对。
"""
import re
# Extract answer from completion
match = re.search(r'\\boxed\{([^}]+)\}', completion)
if not match:
return 0.0
predicted = match.group(1).strip()
# Extract ground truth (GSM8K format: "#### 42")
# We need the ground truth from somewhere — in practice
# you'd pass it alongside the prompt
# Simplified here for illustration
return 1.0 if predicted # placeholder
# 实际使用时，用 GRPOTrainer 自带的 reward 机制：
# 可以传 reward_funcs 列表，支持 rule-based + model-based 混合
# 4. 配置 GRPO
grpo_config = GRPOConfig(
output_dir="./grpo-qwen-math",
num_train_epochs=1,
per_device_train_batch_size=4,
gradient_accumulation_steps=4,
# GRPO 特定参数
num_generation_per_prompt=4, # G (group size)
max_prompt_length=512,
max_completion_length=256,
temperature=0.9,
# KL 控制
beta=0.04, # KL penalty coefficient
# PPO-style clipping
epsilon=0.2,
# 学习率
learning_rate=1e-6,
lr_scheduler_type="cosine",
warmup_ratio=0.1,
# 日志
logging_steps=10,
save_steps=500,
bf16=True,
gradient_checkpointing=True,
)
# 5. 启动训练
trainer = GRPOTrainer(
model=model,
tokenizer=tokenizer,
args=grpo_config,
train_dataset=dataset,
reward_funcs=[math_reward],
)
trainer.train()
trainer.save_model("./grpo-qwen-math-final")
用 Unsloth 加速 GRPO
Unsloth 对 GRPO 有专门优化，显存和速度都好不少：
from unsloth import FastLanguageModel, is_bfloat16_supported
model, tokenizer = FastLanguageModel.from_pretrained(
model_name="Qwen/Qwen2.5-7B-Instruct",
max_seq_length=2048,
load_in_4bit=True, # QLoRA
fast_inference=True,
)
model = FastLanguageModel.get_peft_model(
model,
r=64,
target_modules=[
"q_proj", "k_proj", "v_proj", "o_proj",
"gate_proj", "up_proj", "down_proj",
],
lora_alpha=128,
use_gradient_checkpointing="unsloth",
)
# 后续跟标准 TRL GRPOTrainer 一样使用
单张 A100 80GB，Qwen2.5-7B QLoRA + GRPO（G=4），batch_size=4，episode ~20s，比标准 PPO 快 1.5x。
实践中的坑
坑 1：Reward Model 设计比算法更重要
GRPO 去掉 critic 后，reward 信号的质量变成了唯一指标。很多团队花大量精力调 GRPO 的超参，但 reward function 本身设计有问题。
对于数学推理，DeepSeek-R1 实际用了混合 reward：
final_reward = accuracy_reward × 0.8 + format_reward × 0.2
format_reward 强制模型把思考过程放在 标签里，答案放在 里。这个简单的格式约束极大地稳定了训练。
坑 2：Group Size 的权衡
G（group size per prompt）越大，advantage 估计越准确，但计算量线性增长：
| G | 单步耗时 | MATH 500 提升 |
|---|---|---|
| 2 | 12s | +2.1% |
| 4 | 20s | +5.8% |
| 8 | 38s | +7.2% |
| 16 | 72s | +7.8% |
G=4 是性价比最高的选择。G=8 之后提升递减明显。
坑 3：KL 散度崩溃
GRPO 的 KL 惩罚系数 β 非常敏感。β 太小时 policy 会快速偏离 reference，生成一堆 reward hacking 的样本；太大又基本等于没训练。
一个实用技巧是自适应 β：
def adaptive_beta(current_kl, target_kl=0.01, beta_min=0.01, beta_max=0.5):
"""
Adjust β to keep KL divergence near target.
当 KL 过大时增大 β，过小时减小 β。
"""
if current_kl > target_kl * 2:
return min(beta_max, beta * 2)
elif current_kl < target_kl / 2:
return max(beta_min, beta / 2)
return beta
坑 4：Generation 阶段的显存峰值
GRPO 的在线采样在 generation 阶段会产生显存峰值。每次 sample G 个 response，长序列（比如数学推理 1K+ tokens）时 decoder 的 KV cache 占显存很夸张。
解决方案：
- 使用 vLLM 做 rollout 生成（训练和推理分离部署）
max_completion_length不要设太大，实验中 256-512 足够- 梯度检查点 + flash attention 2 是标配
什么时候用 GRPO
GRPO 不是银弹。一个实用的决策树：
- 你只有静态偏好数据集（不能在线采样） → DPO
- 你可以在线采样，但没有 reward model（或用 rule-based reward） → GRPO
- 你有强 reward model（如 GPT-4 as judge），且显存充裕 → 传统 PPO
- 奖励信号稀疏或带噪声 → 先用 DPO 做 warmup，再切 GRPO 在线优化
实际上，DeepSeek-R1 的训练流程是 SFT → 冷启动数据 → RL（GRPO）→ 拒绝采样 → SFT → 全场景 RL，GRPO 只是其中一环。
总结
GRPO 解决了 PPO 的显存问题和 DPO 的离线局限，在代码/数学推理任务上效果显著。但它的核心假设——组内相对比较能替代 critic 的 advantage 估计——在 reward 信号噪声大的场景下可能不成立。
如果你是后端工程师想做模型对齐，我的建议：
- 先跑通 DPO（TRL 的
DPOTrainer，半天就能出结果） - 在 DPO 基础上升级到 GRPO（Unsloth + TRL）
- reward function 花 80% 的精力，超参花 20%