LLM 中的强化学习：从零开始完全图解

LLM 的强化学习对齐，就是在回答这个问题：「模型已经很能说话了，但怎么让它说『好话』？」

RLHF = 雇人类裁判打分，让模型慢慢向高分方向进化； PPO = 让模型每次只改一点点，防止进化出奇怪东西； DPO = 不要裁判了，直接让模型从"这个好/那个差"的对比中学习； GRPO = 让模型多写几个答案，自己和自己比，好的留下坏的丢掉； RLAIF = 裁判不用人了，换成另一个 AI 来打分。

1.1 预训练到底在做什么——"下一词预测游戏"

在理解为什么需要强化学习之前，我们先弄清楚 GPT 这类大模型是怎么被训练出来的。

预训练的任务极其简单，叫做「下一个词预测（Next Token Prediction）」：

1.2 预训练 vs 我们真正想要的——巨大的鸿沟

让我们用一个具体例子感受这个问题：

这个差距不是因为对齐后的模型更"聪明"或知识更多——两个模型的知识量是一样的。区别在于：预训练模型在续写"互联网文本"，而对齐后的模型在"回答用户的真实需求"。

更具体地说，预训练模型在以下方面存在严重缺陷：

2.1 用打游戏理解强化学习

强化学习（Reinforcement Learning，RL）是机器学习的一个分支，核心思想极其简单：

强化学习里有几个核心概念，我们一一解释：

2.2 LLM 里的 RL 是什么样的——万词游戏

现在我们把游戏的类比换成 LLM 的实际情况：

跟马里奥游戏相比，LLM 的 RL 有几个独特的难点：

2.3 KL 惩罚：防止模型"走火入魔"

在 LLM 的 RL 训练中，有一个几乎所有方法都会用到的技巧：KL 散度惩罚。理解它非常重要。

KL 散度是衡量两个概率分布"有多不同"的数学工具。在 LLM RL 中：

RLHF = Reinforcement Learning from Human Feedback，基于人类反馈的强化学习。这是 InstructGPT（ChatGPT 的前身）的核心训练方法，也是 LLM 对齐领域的奠基性工作。

3.1 第一阶段：SFT 监督微调——给模型"打个样"

SFT = Supervised Fine-Tuning（监督微调）。

在这个阶段，OpenAI 雇了一批专业标注员，让他们：

1. 看到一个用户 prompt（比如"写一首关于秋天的诗"）
2. 自己手写一个"理想回答"
3. 用这些 (prompt, 理想回答) 对来微调预训练模型

经过 SFT 之后，模型从"网络文章续写机器"变成了"勉强可以回答问题的助手"——但还不够好，主要原因是 SFT 数据量太少（只有几万条），覆盖不了所有情况。

3.2 第二阶段：训练奖励模型——教会"评分机器"

这是 RLHF 中最关键、也最昂贵的步骤。我们需要训练一个奖励模型（Reward Model，RM），它的作用是：给任意一对 (prompt, 回答) 打一个实数分数，分数越高代表回答越好。

有了这个奖励模型，我们就可以在第三阶段用它来"自动化"评分，不再需要人类实时打分。

奖励模型的训练数据是怎么收集的？

对于同一个 prompt，让 SFT 后的模型生成 4–9 个不同的回答，然后让标注员对这些回答从好到坏排序：

奖励模型的训练目标（Bradley-Terry 模型）

奖励模型 $r_\phi$ 接受一对 (prompt $x$，回答 $y$)，输出一个实数分数。训练目标是：

3.3 第三阶段：PPO 强化学习训练

有了奖励模型，我们现在用 PPO（Proximal Policy Optimization）算法来训练语言模型。

整个训练循环如下：

PPO（Proximal Policy Optimization，近端策略优化）是 RLHF 第三阶段使用的 RL 算法。要理解 PPO，我们先要理解：为什么不能用最简单的方法？

4.1 朴素策略梯度的崩溃——开车猛打方向盘的下场

最简单的强化学习更新方法叫做策略梯度（Policy Gradient），思路是：

1. 让模型生成一个回答
2. 如果奖励高（好回答），就增大这个回答里每个词的生成概率
3. 如果奖励低（差回答），就减小每个词的生成概率
4. 每次按梯度方向更新一步

4.2 PPO 的裁剪魔法——给更新幅度加限速器

PPO 的核心创新是引入了裁剪（Clipping）机制。先看公式，然后我们逐步解释：

我们来分情况理解这个公式（$\varepsilon = 0.2$）：

4.3 优势函数：判断每个词的"功劳"

PPO 中最难理解的部分是：如何判断"生成第 237 个词的这个选择，对最终回答质量贡献了多少"？这就是优势函数 $\hat{A}_t$ 要解决的问题。

实践中，PPO 用广义优势估计（GAE，Generalized Advantage Estimation）来计算：

4.4 PPO 的工程现实：4 个模型同时运行

这是 PPO 在实践中让很多工程师头疼的地方——完整的 PPO 训练需要同时维护 4 个不同的神经网络：

DPO（Direct Preference Optimization，直接偏好优化）由 Stanford 的 Rafailov 等人在 2023 年提出。它的核心问题是：

5.1 核心洞察：语言模型本身就是一个隐式的奖励模型

DPO 的数学推导比较复杂，但直觉是这样的：

5.2 DPO 损失函数（直觉版推导）

可以从数学上证明，在 KL 约束下的最优策略 $\pi^*$ 满足：

这告诉我们：奖励函数可以直接用语言模型的概率来表示！把这个关系代入 Bradley-Terry 偏好模型（§3.2 里的奖励模型训练目标），化简后得到 DPO 的损失函数：

5.3 DPO vs PPO：什么时候用哪个？

GRPO（Group Relative Policy Optimization，组相对策略优化）来自 DeepSeek 团队，是 DeepSeek-R1 能在数学推理上超越 GPT-4o 的核心技术。

6.1 GRPO 的算法细节

对每个 prompt $x$，让当前模型生成 $G$ 个（通常 8–16 个）不同的输出 $\{y_1, y_2, \ldots, y_G\}$，得到各自的奖励分数 $\{r_1, r_2, \ldots, r_G\}$。

然后，用组内 z-score 归一化来计算每个输出的优势：

然后用类似 PPO 的裁剪目标来更新策略：

6.2 为什么数学/代码特别适合 GRPO？

RLAIF（Reinforcement Learning from AI Feedback）是 RLHF 的变体，用 AI 的反馈代替人类标注员的反馈。Anthropic 的 Constitutional AI（CAI）是这个方向的代表性工作。

为什么要用 AI 打分？

人工标注是 RLHF 最大的成本和瓶颈：

• GPT-4 的人工标注费用估计超过 1 亿美元
• 标注员之间存在不一致（不同人对"好回答"的标准不同）
• 规模难以扩大（标注员数量有上限，收集速度慢）
• 某些领域（专业医学、法律）需要昂贵的专家标注

Constitutional AI（CAI）：原则驱动的 AI 自我改进

Anthropic 的方案叫 Constitutional AI（宪法 AI），由两个子阶段组成：

演化路径：从复杂到简单

九个核心概念的直觉总结

一个统一的视角：所有方法都在解决同一件事

所有这些方法，本质都是在回答：「怎么给语言模型一个学习信号，让它向'更符合人类偏好'的方向移动，同时不把已有能力弄坏？」

区别只在于：谁来提供学习信号（人类/AI/规则程序）？学习信号以什么形式出现（打分/排名/对比/答案正误）？语言模型如何利用这个信号（PPO 更新/DPO 对比/GRPO 组内归一）？每种选择都有它的成本-效果权衡。

下一步学习路线建议

下面的代码是教学向的简化版 RLHF，不依赖任何框架，只用 PyTorch 基础 API，帮助理解每个阶段"在做什么"。每一行都有注释，先看注释理解意图，再看代码理解实现。

Phase 1：SFT 监督微调——模仿"好例子"

# ─────────────────────────────────────────────────────
# Phase 1: SFT —— 给模型看"好回答"示范，让它学习模仿
# ─────────────────────────────────────────────────────
import torch
import torch.nn as nn
import torch.nn.functional as F

# 极简"语言模型"：输入一个 prompt 向量，输出两个动作的 log 概率
# 动作 0 = "说有帮助的话"，动作 1 = "说无关的话"
class TinyLM(nn.Module):
    def __init__(self):
        super().__init__()
        self.net = nn.Sequential(nn.Linear(4, 8), nn.ReLU(), nn.Linear(8, 2))

    def forward(self, prompt):
        return F.log_softmax(self.net(prompt), dim=-1)  # 输出 log 概率

policy = TinyLM()                          # 这是我们要训练的策略模型
ref_policy = TinyLM()                      # 参考模型（SFT后冻结，用于计算KL）
optimizer_sft = torch.optim.Adam(policy.parameters(), lr=1e-3)

# SFT 数据：(prompt 向量, 正确动作) 对
# 含义：当 prompt 为 [1,0,0,0] 时，正确动作是 0（"说有帮助的话"）
sft_data = [
    (torch.tensor([1.,0.,0.,0.]), 0),   # 问题A → 应该回答有帮助的内容
    (torch.tensor([0.,1.,0.,0.]), 0),   # 问题B → 应该回答有帮助的内容
    (torch.tensor([0.,0.,1.,0.]), 0),   # 问题C → 应该回答有帮助的内容
]

# SFT 训练：标准的交叉熵损失，让模型模仿标注员的回答
for epoch in range(100):
    for prompt, correct_action in sft_data:
        log_probs = policy(prompt)               # 模型输出动作的 log 概率
        loss = -log_probs[correct_action]        # 负对数似然：让正确动作概率最大
        optimizer_sft.zero_grad()
        loss.backward()
        optimizer_sft.step()

# SFT 完成后，把模型参数复制给参考模型（ref_policy 从此冻结，不再更新）
ref_policy.load_state_dict(policy.state_dict())
for p in ref_policy.parameters(): p.requires_grad = False
print("Phase 1 完成：SFT 模型已训练，参考模型已冻结")

Phase 2：训练奖励模型——学会"打分"

# ─────────────────────────────────────────────────────
# Phase 2: 训练奖励模型 —— 从人类排序中学会打分
# ─────────────────────────────────────────────────────

# 奖励模型：输入 (prompt, 动作)，输出一个实数分数
class RewardModel(nn.Module):
    def __init__(self):
        super().__init__()
        # 输入 = prompt(4维) 拼上动作的 one-hot(2维) = 6维
        self.net = nn.Sequential(nn.Linear(6, 8), nn.ReLU(), nn.Linear(8, 1))

    def score(self, prompt, action):
        action_onehot = torch.zeros(2)
        action_onehot[action] = 1.0
        x = torch.cat([prompt, action_onehot])   # 拼接输入
        return self.net(x).squeeze()              # 输出标量分数

reward_model = RewardModel()
optimizer_rm = torch.optim.Adam(reward_model.parameters(), lr=1e-3)

# 人类标注的偏好数据：(prompt, 好动作 y_w, 差动作 y_l)
# 含义：对于这个 prompt，动作 0 比动作 1 更好
preference_data = [
    (torch.tensor([1.,0.,0.,0.]), 0, 1),   # 对问题A：动作0 > 动作1
    (torch.tensor([0.,1.,0.,0.]), 0, 1),   # 对问题B：动作0 > 动作1
    (torch.tensor([0.,0.,1.,0.]), 0, 1),   # 对问题C：动作0 > 动作1
]

# BT（Bradley-Terry）损失：让好动作的分数 > 差动作的分数
for epoch in range(200):
    for prompt, y_w, y_l in preference_data:
        score_winner = reward_model.score(prompt, y_w)  # 好回答的分
        score_loser  = reward_model.score(prompt, y_l)  # 差回答的分
        # 损失：-log sigmoid(好分 - 差分)，让差值尽量大
        loss = -F.logsigmoid(score_winner - score_loser)
        optimizer_rm.zero_grad()
        loss.backward()
        optimizer_rm.step()

print("Phase 2 完成：奖励模型已训练")
# 验证：问题A 下，动作0 的分数应该高于动作1
p = torch.tensor([1.,0.,0.,0.])
print(f"  动作0（好回答）得分: {reward_model.score(p,0):.3f}")
print(f"  动作1（差回答）得分: {reward_model.score(p,1):.3f}")

Phase 3：PPO 强化学习——按照"打分机"的标准进化

# ─────────────────────────────────────────────────────
# Phase 3: PPO 强化学习 —— 用奖励模型当"裁判"优化策略
# ─────────────────────────────────────────────────────

optimizer_ppo = torch.optim.Adam(policy.parameters(), lr=1e-4)
beta = 0.1    # KL 惩罚系数：越大越不允许偏离参考模型
eps  = 0.2    # PPO 裁剪范围：概率比最多允许 [0.8, 1.2]

prompts = [torch.tensor([1.,0.,0.,0.]),   # 问题 A
           torch.tensor([0.,1.,0.,0.]),   # 问题 B
           torch.tensor([0.,0.,1.,0.])]  # 问题 C

for step in range(300):
    total_loss = 0.0

    for prompt in prompts:

        # ── Step A：让当前策略采样一个动作 ──────────────────
        log_probs_now = policy(prompt)                     # 当前策略的 log 概率
        probs_now     = log_probs_now.exp()                # 转为概率
        action = torch.multinomial(probs_now, 1).item()    # 按概率采样一个动作

        # ── Step B：用奖励模型打分（代替人类实时打分）──────
        reward = reward_model.score(prompt, action).detach()  # 不对 RM 求梯度

        # ── Step C：计算 KL 惩罚（防止偏离参考模型太远）──
        with torch.no_grad():
            log_probs_ref = ref_policy(prompt)             # 参考模型（冻结）的 log 概率
        # KL(current || ref) ≈ sum(p * (log_p - log_q))
        kl_penalty = (probs_now * (log_probs_now - log_probs_ref)).sum()

        # 最终奖励 = RM 奖励 - β × KL（KL 越大，扣分越多）
        advantage = reward - beta * kl_penalty.detach()

        # ── Step D：PPO 裁剪目标 ──────────────────────────────
        with torch.no_grad():
            old_log_prob = log_probs_now[action].clone()   # 旧策略的 log 概率（固定）

        new_log_prob = policy(prompt)[action]              # 重新前向，当前策略的 log 概率
        ratio = (new_log_prob - old_log_prob).exp()        # ρ = π_new / π_old（概率比）

        # PPO 核心：取「不裁剪目标」和「裁剪目标」的最小值
        obj_unclipped = ratio * advantage                  # 不裁剪：直接 ρ × A
        obj_clipped   = ratio.clamp(1-eps, 1+eps) * advantage  # 裁剪：ρ 限制在[0.8,1.2]
        ppo_loss      = -torch.min(obj_unclipped, obj_clipped)  # 取 min 再取负（最小化损失）

        total_loss += ppo_loss

    # 对所有 prompt 的 loss 求均值，反向传播更新策略
    optimizer_ppo.zero_grad()
    (total_loss / len(prompts)).backward()
    optimizer_ppo.step()

    # 每 100 步打印一次，观察策略进化情况
    if step % 100 == 0:
        p = prompts[0]
        probs = policy(p).exp().detach()
        print(f"step {step:3d} | 动作0(好话)概率={probs[0]:.3f}  动作1(废话)概率={probs[1]:.3f}")

print("\nPhase 3 完成！最终策略：")
for i, p in enumerate(prompts):
    probs = policy(p).exp().detach()
    print(f"  问题{i+1}：说好话概率={probs[0]:.3f}，说废话概率={probs[1]:.3f}")

Phase 1 完成：SFT 模型已训练，参考模型已冻结
Phase 2 完成：奖励模型已训练
  动作0（好回答）得分: 1.247
  动作1（差回答）得分: -0.983
step   0 | 动作0(好话)概率=0.531  动作1(废话)概率=0.469
step 100 | 动作0(好话)概率=0.713  动作1(废话)概率=0.287
step 200 | 动作0(好话)概率=0.856  动作1(废话)概率=0.144
Phase 3 完成！最终策略：
  问题1：说好话概率=0.891，说废话概率=0.109
  问题2：说好话概率=0.876，说废话概率=0.124
  问题3：说好话概率=0.883，说废话概率=0.117

代码结构对应真实 RLHF 的哪些部分？