【NLP 技术专栏 · 第六篇】大模型的强化学习：从 PPO 到 GRPO 的技术演进
·
NLP 技术专栏 · 第六篇
第四篇我们讲了 RLHF 和 DPO 等对齐技术。这一篇往更深处走——强化学习在大模型中的角色远不止对齐，它正在成为大模型训练的核心范式。从 InstructGPT 的 PPO 到 DeepSeek 的 GRPO，我们来完整梳理这条技术线。
一、为什么大模型需要强化学习？
1.1 预训练的本质局限
预训练的目标: Next Token Prediction
给定 x₁, x₂, ..., xₙ → 预测 xₙ₊₁
它教会模型的: "语料中最可能出现的下一个词是什么"
它没有教的: "对于当前用户的问题，最好的回答是什么"
举例:
问题: "请用 Python 写一个快速排序"
预训练模型的"最优"策略:
→ 预测语料中最常见的续写方式
→ 可能是: "快速排序是一种分治算法，以下是它的原理..." (先解释)
→ 也可能续写其他代码片段、学术论文段落等
我们期望的:
→ 直接给出清晰、正确的代码实现
差距: 预训练是"模仿语料"，我们想要的是"解决问题"
1.2 监督学习为什么不够？
监督学习（SFT）的信号:
只有"正确答案"，没有"错误答案"的反馈
模型学到: 这个方向是对的
模型没学: 其他几百种可能的回复，哪些比这个更好，哪些更差
强化学习的信号:
不仅有"这个回复得了多少分"
还有"比那个回复高/低了多少分"
信号密度更高，模型能学到更精细的偏好
1.3 强化学习在大模型中的三个战场
战场 1: 对齐 (Alignment)
目标: 让模型"听话"
方法: RLHF, DPO, GRPO
奖励来源: 人类偏好 / 奖励模型
战场 2: 推理 (Reasoning)
目标: 让模型学会复杂推理
方法: RLVR (Reinforcement Learning with Verifiable Rewards)
奖励来源: 答案对错（可验证的奖励）
战场 3: Agent / 工具使用
目标: 让模型学会使用工具、完成多步任务
方法: 强化学习 + 环境交互
奖励来源: 任务完成度
本篇重点: 战场 1 和战场 2，以及从 PPO 到 GRPO 的完整演进。
二、强化学习基础速览
在进入大模型的 RL 之前，快速回顾几个关键概念。
2.1 核心要素
┌─────────────────────────────────────────────────────────────┐
│ 强化学习的核心五要素 │
├─────────────────────────────────────────────────────────────┤
│ │
│ 智能体 (Agent) → 语言模型 │
│ 环境 (Environment) → 用户 / 奖励模型 / 验证器 │
│ 状态 (State) → 当前的 prompt + 已生成的 token │
│ 动作 (Action) → 选择下一个 token │
│ 奖励 (Reward) → 回复质量的打分 / 答案对错 │
│ │
└─────────────────────────────────────────────────────────────┘
用大模型的语言翻译:
语言模型 = 策略 π(a|s)
状态 s = prompt + 已经生成的前缀
动作 a = 从词表中选一个 token
奖励 R = 最终整个回复的质量评分
目标: 最大化期望奖励
max_π E[R(prompt, response)]
2.2 策略梯度（Policy Gradient）
策略梯度定理: 通过调整策略 π 的参数，让高奖励的动作更可能被选择
直觉:
如果某个动作（token 选择）带来了高奖励
→ 增大这个动作的概率
如果带来了低奖励
→ 减小这个动作的概率
问题: 方差极大
单次采样的奖励可能噪声很大
需要引入 baseline 来降低方差
2.3 优势函数（Advantage Function）
Advantage: A(s, a) = Q(s, a) - V(s)
Q(s, a): 在状态 s 做动作 a 后能得到的期望总奖励
V(s): 在状态 s 的期望总奖励（不管做什么动作）
A(s, a): 做动作 a 比"平均"好多少
A > 0: 这个动作比平均好 → 应该增加概率
A < 0: 这个动作比平均差 → 应该减少概率
A = 0: 这个动作和平均一样 → 不需要调整
用优势函数替代原始奖励，方差大幅降低，训练更稳定
三、PPO：InstructGPT 时代的标准方案
3.1 回顾：PPO 在 RLHF 中的角色
第四篇讲过，PPO 是 InstructGPT/ChatGPT 使用的 RL 算法。这里补充更多细节。
3.2 PPO 的关键设计
PPO = Policy Gradient + 三个关键改进
改进 1: 重要性采样 (Importance Sampling)
用旧策略收集数据，但用新策略计算梯度
不用每次更新策略后都重新收集数据
大幅提高数据效率
改进 2: 裁剪 (Clipping)
限制策略更新的幅度
防止一次更新导致策略剧变
ratio = π_new(a|s) / π_old(a|s)
L = -min(ratio · A, clip(ratio, 1-ε, 1+ε) · A)
如果 ratio 太大（策略变化太剧烈）→ 裁剪掉
ε = 0.1 或 0.2
改进 3: 多目标联合优化
L_total = L_PPO + c₁ · L_value + c₂ · L_entropy
L_PPO: 策略损失
L_value: 价值函数损失（训练 Critic）
L_entropy: 熵奖励（鼓励探索）
3.3 PPO 在大模型 RLHF 中的完整流程
# PPO 训练循环（大模型场景，伪代码）
def ppo_training_loop(prompt, sft_model, reward_model, num_epochs):
# 初始化四个模型
policy = sft_model.copy() # 策略模型（被优化）
ref_model = sft_model.copy().freeze() # 参考模型（冻结）
reward_fn = reward_model # 奖励模型（冻结）
value_fn = ValueHead(sft_model) # 价值模型（一起训练）
for epoch in range(num_epochs):
# Phase 1: 生成回复（Rollout）
responses = policy.generate(prompt, max_length=512)
# Phase 2: 计算奖励
rewards = reward_fn(prompt, responses) # 最终奖励
# Phase 3: 计算优势（使用 GAE）
values = value_fn(prompt, responses) # 每步的价值估计
advantages = compute_gae(rewards, values) # 广义优势估计
# Phase 4: PPO 更新（多个 epoch）
for _ in range(ppo_epochs):
# 计算策略比率
log_probs_new = policy.log_prob(prompt, responses)
log_probs_old = old_policy.log_prob(prompt, responses) # 保存旧的概率
log_probs_ref = ref_model.log_prob(prompt, responses)
ratio = torch.exp(log_probs_new - log_probs_old)
# PPO 裁剪
clipped_ratio = torch.clamp(ratio, 1 - clip_eps, 1 + clip_eps)
policy_loss = -torch.min(ratio * advantages, clipped_ratio * advantages)
# KL 惩罚（防止偏离参考模型太远）
kl_penalty = kl_coeff * (log_probs_new - log_probs_ref)
# 价值损失
value_loss = F.mse_loss(values, rewards)
# 总损失
total_loss = policy_loss + kl_penalty + c * value_loss
total_loss.backward()
optimizer.step()
3.4 PPO 的痛点
痛点 1: 需要同时维护 4 个模型
┌──────────────────────────────┐
│ 策略模型 (Policy) │ 需要梯度 ~28 GB (7B模型)
│ 参考模型 (Reference) │ 不要梯度 ~28 GB
│ 奖励模型 (Reward) │ 不要梯度 ~28 GB
│ 价值模型 (Value/Critic) │ 需要梯度 ~28 GB
│ │
│ 总计: ~112 GB 显存
│ 至少需要 4 × A100 (80GB) │
└──────────────────────────────┘
痛点 2: PPO 训练不稳定
- 超参敏感: clip_eps, kl_coeff, lr, GAE λ
- 不同 prompt 可能需要不同的超参
- 经常出现 reward hacking（模型学会骗 RM）
痛点 3: 实现复杂
- 需要正确处理序列级和 token 级的奖励
- 需要 GAE（广义优势估计）
- 需要正确处理 log 概率的计算
- 调试困难
四、DPO 之后：简化 RL 的尝试
4.1 DPO 的局限
第四篇详细讲了 DPO，但 DPO 也有问题：
DPO 的问题 1: 离线学习
DPO 用的是固定的偏好数据集
模型不能在线探索新的回复方式
不能发现"数据集中没有的好回复"
DPO 的问题 2: 分布偏移 (Distribution Shift)
训练数据来自 SFT 模型或参考模型的输出
但训练过程中，模型的输出分布会变化
导致"训练数据和模型当前行为对不上"
DPO 的问题 3: 隐式奖励不易解释
DPO 的"奖励"是隐式的：β · log(π/π_ref)
不像显式奖励模型那样可以单独检查和调试
4.2 DPO 之后的改进方向
方向 1: 在线 DPO (Online DPO / Self-Play DPO)
不用固定数据集，而是让当前模型生成回复
用奖励模型或 AI 评判来排序
在线更新
方向 2: 去掉参考模型 (SimPO, ORPO)
减少一个模型，节省显存
通过其他方式控制更新幅度
方向 3: 重新设计 RL 算法 (GRPO, REINFORCE++)
保留在线学习的优势
但大幅简化实现复杂度和显存占用
这是当前最热的方向
五、GRPO：DeepSeek 的突破
5.1 GRPO 的核心洞察
GRPO = Group Relative Policy Optimization
DeepSeek-V2/DeepSeek-R1 使用的核心 RL 算法。核心洞察：
不需要单独训练价值模型（Critic），用同组内多个回复的相对奖励作为基线。
PPO 的做法:
对一个 prompt，生成 1 个回复
需要价值模型估计 V(s) 作为基线
优势 A = R - V(s)
GRPO 的做法:
对一个 prompt，生成 G 个回复（比如 G=64）
用这 G 个回复的平均奖励作为基线
优势 A_i = (R_i - mean(R)) / std(R)
→ 不需要价值模型！
→ 省掉一个 ~28 GB 的模型
→ 实现更简单，训练更稳定
5.2 详细对比：PPO vs GRPO
对同一个 prompt "什么是机器学习？":
PPO:
生成 1 个回复 → 得分 R = 0.7
需要价值模型: V(prompt) = 0.5
优势 A = 0.7 - 0.5 = 0.2
依赖价值模型的准确性
GRPO:
生成 4 个回复:
回复 1: 得分 R₁ = 0.8
回复 2: 得分 R₂ = 0.6
回复 3: 得分 R₃ = 0.9
回复 4: 得分 R₄ = 0.5
mean = 0.7, std = 0.17
优势 A₁ = (0.8 - 0.7) / 0.17 = +0.59 (好)
优势 A₂ = (0.6 - 0.7) / 0.17 = -0.59 (差)
优势 A₃ = (0.9 - 0.7) / 0.17 = +1.18 (很好)
优势 A₄ = (0.5 - 0.7) / 0.17 = -1.18 (很差)
不需要价值模型，组内相对比较即可
5.3 GRPO 的损失函数
def grpo_loss(policy, ref_policy, prompts, responses, rewards, beta=0.01, eps=0.2):
"""
GRPO 损失函数
policy: 当前策略模型
ref_policy: 参考模型（冻结）
prompts: 输入 prompt
responses: 每个 prompt 对应 G 个回复 (shape: batch × G × seq_len)
rewards: 每个回复的奖励 (shape: batch × G)
beta: KL 惩罚系数
eps: PPO 裁剪范围
"""
batch_size, G = rewards.shape
# 1. 计算组内相对优势
mean_rewards = rewards.mean(dim=-1, keepdim=True) # (batch, 1)
std_rewards = rewards.std(dim=-1, keepdim=True) + 1e-8
advantages = (rewards - mean_rewards) / std_rewards # (batch, G)
# 2. 计算 log 概率
log_probs = policy.log_prob(prompts, responses) # (batch, G, seq_len)
log_probs_ref = ref_policy.log_prob(prompts, responses) # 不需要梯度
# 3. 序列级概率（每个回复一个 log prob）
seq_log_probs = log_probs.sum(dim=-1) # (batch, G)
seq_log_probs_ref = log_probs_ref.sum(dim=-1) # (batch, G)
# 4. KL 惩罚（逐 token）
kl_penalty = (log_probs - log_probs_ref).sum(dim=-1) # (batch, G)
# 5. GRPO 损失（PPO 风格的裁剪）
ratio = torch.exp(seq_log_probs - seq_log_probs.detach()) # 用 detach 防止梯度通过 ratio
surr1 = ratio * advantages
surr2 = torch.clamp(ratio, 1 - eps, 1 + eps) * advantages
policy_loss = -torch.min(surr1, surr2).mean()
kl_loss = beta * kl_penalty.mean()
return policy_loss + kl_loss
5.4 GRPO vs PPO vs DPO
┌──────────────┬──────────────┬──────────────┬──────────────┐
│ │ PPO │ DPO │ GRPO │
├──────────────┼──────────────┼──────────────┼──────────────┤
│ 需要的模型 │ 4 个 │ 2 个 │ 2 个 │
│ (策略/RM/ │ │ (策略/参考) │ (策略/参考) │
│ 参考/价值) │ │ │ + 奖励函数 │
├──────────────┼──────────────┼──────────────┼──────────────┤
│ 学习方式 │ 在线 │ 离线 │ 在线 │
│ (生成新数据) │ │ (固定数据集) │ │
├──────────────┼──────────────┼──────────────┼──────────────┤
│ 优势估计 │ GAE + Critic │ 隐式 │ 组内相对 │
├──────────────┼──────────────┼──────────────┼──────────────┤
│ 显存占用 │ 非常大 │ 中等 │ 中等 │
├──────────────┼──────────────┼──────────────┼──────────────┤
│ 训练稳定性 │ 低 │ 高 │ 高 │
├──────────────┼──────────────┼──────────────┼──────────────┤
│ 效果上限 │ 高 │ 中 │ 高 │
├──────────────┼──────────────┼──────────────┼──────────────┤
│ 实现复杂度 │ 高 │ 低 │ 中 │
└──────────────┴──────────────┴──────────────┴──────────────┘
六、REINFORCE++：更简洁的在线 RL
6.1 从 REINFORCE 到 REINFORCE++
REINFORCE 是最原始的策略梯度算法，直接用奖励作为信号。问题是什么？
原始 REINFORCE:
∇J = E[R · ∇log π(a|s)]
问题: 方差太大
单次采样的 R 可能很不准确
导致梯度估计噪声大，训练不稳定
REINFORCE++（OpenAI 内部使用的方法之一）的核心改进：
改进 1: 用组内归一化降低方差（类似 GRPO）
同一个 prompt 生成 G 个回复
用组内均值和标准差归一化奖励
改进 2: KL 惩罚（防止策略跑飞）
和 GRPO 一样加 KL 惩罚
改进 3: 简单实现
不需要 GAE
不需要价值模型
代码量只有 PPO 的 1/3
def reinforce_plus_plus_loss(policy, ref_policy, prompt, responses, rewards, beta=0.01):
"""REINFORCE++ 损失函数"""
# 组内归一化
advantages = (rewards - rewards.mean()) / (rewards.std() + 1e-8)
# 策略梯度
log_probs = policy.log_prob(prompt, responses).sum(dim=-1)
policy_loss = -(advantages.detach() * log_probs).mean()
# KL 惩罚
log_probs_ref = ref_policy.log_prob(prompt, responses).sum(dim=-1)
kl_penalty = beta * (log_probs - log_probs_ref).mean()
return policy_loss + kl_penalty
6.2 GRPO vs REINFORCE++
两者非常相似，核心区别:
GRPO:
- 使用 PPO 风格的裁剪（clipping）
- 限制策略更新的幅度
- 更保守，更稳定
REINFORCE++:
- 不裁剪，直接用归一化后的优势
- 更简单，更直接
- 在大规模训练中效果接近
实践中的选择:
- DeepSeek 用 GRPO（需要更稳定的训练）
- 很多团队用 REINFORCE++（实现更简单）
- 两者效果差距不大，都远好于原始 PPO
七、RLVR：强化学习 × 可验证奖励
7.1 从主观奖励到客观奖励
前面的 RLHF/DPO/GRPO 都依赖人类偏好或奖励模型作为奖励信号。但这些信号都是主观的、近似的。
RLVR = Reinforcement Learning with Verifiable Rewards 改变了这个范式：
用客观可验证的结果作为奖励——答案对了就是对，错了就是错，不需要训练奖励模型。
传统 RLHF:
prompt → 模型生成回复 → 奖励模型打分 → 优化
问题: 奖励模型可能被骗，打分不准确
RLVR:
prompt → 模型生成回复 → 和标准答案比对 → 0/1 奖励
优势: 奖励信号完全可靠，不存在 hacking
适用场景:
✓ 数学题（答案可以验证对错）
✓ 代码题（可以跑测试用例）
✓ 逻辑推理题（有标准答案）
✗ 开放式问答（没有标准答案）
✗ 创意写作（主观评判）
7.2 DeepSeek-R1 的训练流程
DeepSeek-R1 是 RLVR + GRPO 的集大成者：
DeepSeek-R1 的训练流程:
Stage 0: 基座模型
DeepSeek-V3 (预训练的 MoE 模型)
Stage 1: Cold Start SFT
少量高质量的推理数据（带 Chain-of-Thought）
教模型基本的推理格式
Stage 2: RLVR (推理导向的 RL)
用 GRPO 算法
奖励 = 答案是否正确（数学题、代码题）
不需要人类标注！
数据: 数学题 + 代码题 (有标准答案)
奖励函数:
if answer_correct: R = 1.0
else: R = 0.0
效果: 模型学会在推理时"想更久"（生成更长的思考链）
Stage 3: Rejection Sampling + SFT
从 Stage 2 的模型采样高质量推理样本
筛选正确答案，用于进一步 SFT
Stage 4: 最终 RL (对齐)
用 GRPO + 奖励模型
兼顾推理能力和对话友好性
┌──────────┐ SFT ┌──────────┐ RLVR ┌──────────┐
│ V3 基座 │ ──────────→ │ Cold Start│ ─────────→ │ RL 推理 │
└──────────┘ └──────────┘ (答案对错) └────┬─────┘
│
┌──────────┐ RL 对齐 │
│ R1 最终 │ ←─────────────┘
└──────────┘ (奖励模型)
7.3 RLVR 的关键：奖励函数设计
# DeepSeek-R1 风格的奖励函数
def math_reward_fn(prompt, response):
"""数学题的奖励函数"""
# 从 response 中提取答案
predicted_answer = extract_answer(response) # 从 \boxed{} 或最后的数字中提取
ground_truth = get_ground_truth(prompt)
# 精确匹配
if normalize(predicted_answer) == normalize(ground_truth):
return 1.0
else:
return 0.0
def code_reward_fn(prompt, response, test_cases):
"""代码题的奖励函数"""
code = extract_code(response)
# 运行测试用例
passed = 0
for input_case, expected_output in test_cases:
try:
actual_output = execute_code(code, input_case)
if actual_output == expected_output:
passed += 1
except Exception:
pass # 代码运行出错，不加分
return passed / len(test_cases) # 通过率作为奖励
# 组合奖励
def combined_reward(prompt, response, test_cases=None):
rewards = []
# 格式奖励（鼓励正确的推理格式）
format_reward = check_format(response) # 检查 <think>...</think> 格式
rewards.append(0.1 * format_reward)
# 答案奖励
if "math" in prompt.metadata:
rewards.append(0.9 * math_reward_fn(prompt, response))
elif "code" in prompt.metadata:
rewards.append(0.9 * code_reward_fn(prompt, response, test_cases))
return sum(rewards)
7.4 RLVR 为什么有效？——涌现的"顿悟时刻"
DeepSeek-R1 论文中的发现:
训练初期:
模型的回答简短，错误率高
"答案是 42"（不管对不对，快速给出答案）
训练中期:
模型开始自发表现出"Chain-of-Thought"
"让我一步步思考这个问题..."（没人教它这么做！）
训练后期:
模型出现了 "Aha Moment"（顿悟时刻）
"等等，我刚才的方法不对。让我重新用另一种方法..."
模型学会了:
- 自我验证（检查自己的答案）
- 回溯（发现错误后重新推理）
- 多方法尝试（一种方法不通就换另一种）
为什么会出现这些行为?
RL 优化的是"最终答对"这个目标
模型发现"仔细思考后答对的概率更高"
所以自发地学会了更长的推理链
这是纯 SFT 做不到的——SFT 只能模仿已有数据的模式
RL 让模型自己"发现"好的推理策略
八、PPO → GRPO → RLVR 的演进脉络
8.1 三代 RL 方法
第一代: PPO + 人类偏好 (2022)
├── InstructGPT / ChatGPT
├── 奖励来自人类标注
├── 需要 4 个模型，实现复杂
├── 主要目标: 对齐（让模型听话）
└── 局限: 标注成本高，奖励模型有上限
第二代: DPO / GRPO (2023-2024)
├── DPO: 去掉 RM 和 PPO，大幅简化
├── GRPO: 去掉价值模型，在线学习
├── 奖励来自人类偏好 / 奖励模型
├── 主要目标: 对齐（更高效的方法）
└── 改进: 更简洁，更稳定，但奖励来源不变
第三代: RLVR + GRPO (2024-2025)
├── DeepSeek-R1 / o1 / o3
├── 奖励来自客观验证（答案对错）
├── 不需要人类标注！
├── 主要目标: 推理能力（让模型学会"思考"）
└── 突破: 涌现的推理能力，自我验证，回溯
8.2 奖励来源的演变
奖励来源的变化:
人类标注 (2022) → 奖励模型 (2023) → 客观验证 (2024)
手动排序 学习人类偏好 答案对错、测试用例
成本极高 成本中等 成本极低
覆盖面有限 有上限，可被 hack 完全可靠
↓ 从主观走向客观
↓ 从人工走向自动化
↓ 从"听话"走向"思考"
8.3 从对齐到推理：范式转移
2022-2023 的核心问题: "如何让模型听话？"
→ RLHF, DPO, 对齐
2024-2025 的核心问题: "如何让模型学会思考？"
→ RLVR, 推理模型
这是一个范式转移:
对齐: 改变模型的输出风格（怎么说话）
推理: 改变模型的内部策略（怎么思考）
o1/o3 的 "Thinking" = 模型学会了推理时自动生成更长的思考链
DeepSeek-R1 = 模型学会了自我验证和回溯
这些都不是人工设计的，是 RL 优化出来的
九、关键工程挑战
9.1 在线采样的效率
GRPO 需要对每个 prompt 生成 G 个回复
G 通常 = 16 到 64
这意味着:
采样阶段的计算量 = G × 单次生成的计算量
如果 G = 64, 训练数据有 10000 个 prompt
需要生成 640,000 个回复！
采样和训练交替进行:
┌─────────────────────────────┐
│ 采样阶段 (大量生成) │
│ ↓ │
│ 计算奖励 (批量评估) │
│ ↓ │
│ 梯度更新 (多次 mini-batch) │
│ ↓ │
│ 重复... │
└─────────────────────────────┘
优化方法:
- vLLM: 高效推理引擎，支持 PagedAttention
- 异步采样: 采样和训练并行
- 推测解码: 加速采样过程
9.2 奖励 hacking
什么是奖励 hacking?
模型学会了"骗"奖励函数，而非真正完成任务
示例:
奖励函数: 回复越长奖励越高（某些场景下的简单设计）
模型学会: 生成非常冗长但无意义的回复
奖励函数: 包含关键词 "好的" 得高分
模型学会: 每句话都以 "好的" 开头
防御方法:
1. 多维度奖励（不只看一个指标）
2. KL 惩罚（防止偏离太远）
3. 定期更新奖励模型（不能被一个版本的模型 hack）
4. 用可验证的奖励（RLVR 的思路）
9.3 训练不稳定性
RL 训练的常见崩溃模式:
模式 1: 策略坍缩
模型退化为只输出少数几种回复
多样性急剧下降
→ 用 KL 惩罚 + 熵奖励防止
模式 2: 奖励爆炸
奖励值持续增大，模型过度优化
→ 奖励归一化 + 裁剪
模式 3: 训练发散
梯度过大，模型参数剧变
→ 学习率 warmup + 梯度裁剪
经验法则:
- KL 惩罚系数从大到小（先保守，后放开）
- 定期检查回复质量（不只是看 loss 曲线）
- 保留一个回滚点（训练崩了可以恢复）
十、总结
要点回顾
┌──────────────────┬────────────────────────────────────────────┐
│ 算法 │ 核心特点 │
├──────────────────┼────────────────────────────────────────────┤
│ PPO │ 经典在线 RL, 需要 4 模型, InstructGPT 使用 │
│ │ 实现复杂, 显存大, 但效果成熟 │
├──────────────────┼────────────────────────────────────────────┤
│ DPO │ 离线学习, 2 模型, 直接从偏好优化 │
│ │ 最简洁, 但有分布偏移问题 │
├──────────────────┼────────────────────────────────────────────┤
│ GRPO │ 在线学习, 2 模型, 组内相对优势 │
│ │ 去掉价值模型, DeepSeek-R1 使用 │
├──────────────────┼────────────────────────────────────────────┤
│ REINFORCE++ │ 在线学习, 最简单实现, 效果接近 GRPO │
│ │ 不裁剪, 直接策略梯度 │
├──────────────────┼────────────────────────────────────────────┤
│ RLVR │ 不是具体算法, 而是奖励设计范式 │
│ │ 用客观验证代替主观打分, 推理能力的关键 │
└──────────────────┴────────────────────────────────────────────┘
参考文献
- Schulman, J., et al. (2017). Proximal Policy Optimization Algorithms. (PPO)
- Ouyang, L., et al. (2022). Training language models to follow instructions with human feedback. (InstructGPT)
- Rafailov, R., et al. (2023). Direct Preference Optimization. (DPO)
- Shao, Z., et al. (2024). DeepSeekMath: Pushing the Limits of Mathematical Reasoning. (GRPO)
- DeepSeek-AI. (2025). DeepSeek-R1: Incentivizing Reasoning Capability in LLMs via Reinforcement Learning.
- Lambert, N., et al. (2024). TRL: Transformer Reinforcement Learning. (开源 RLHF 框架)
AtomGit 是由开放原子开源基金会联合 CSDN 等生态伙伴共同推出的新一代开源与人工智能协作平台。平台坚持“开放、中立、公益”的理念，把代码托管、模型共享、数据集托管、智能体开发体验和算力服务整合在一起，为开发者提供从开发、训练到部署的一站式体验。
更多推荐
6
0- 0
已为社区贡献2条内容
所有评论(0)