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 框架)