[LLM 3/10] RLHF 与 PPO：用一个无法求导的奖励去训练模型

第 2 章我们靠"逐 token 模仿标准答案"来教模型。但真正让 AI 助手可用的那些性质—— 答得对、有礼貌、不胡编、不滑回英语——既没有标准答案可模仿，也写不成一个直接的 loss function。 这一章是那个问题最正统的答案：RLHF（Reinforcement Learning from Human Feedback）配 PPO。 我们会从泰语偏好对训练一个真正的 reward model，然后从零手写约 120 行 PPO 循环， 最后做一个我在整个系列里最喜欢的实验：解开 KL 牵引绳，现场看模型作弊刷分。 这是全系列刻意安排的最重的一章，因为第 4 章（DPO）和第 5 章（GRPO） 都是从本章的公式出发，各自选择"删掉"其中一块零件。

1. 问题（Problem statement）​

第 2 章的 SFT 藏着一个前提假设：必须有标准答案可以模仿。 但想想我们真正想要的东西，比如"把数学题做对，并用读得通的泰语解释清楚"—— 这句话没有唯一答案，好的回答可以有一百种写法，而"读得通"三个字根本写不成公式。

一旦试图直接 optimize 这些目标，我们总会撞上两堵墙：

第一堵墙——质量写不成 loss。 "更好"无法定义成函数，但人类比较的能力极强： 给两个回答让人指出更喜欢哪个，立刻能答，而且相互间还算一致。 所以现实中能收集到的数据是三样东西：prompt $x$、被选中的回答 $y_w$、被拒绝的回答 $y_l$。

第二堵墙——就算有了分数，也无法 backprop。 假设存在一个魔法函数 $r(x,y)$ 能给每个回答打分，你依然没法做 supervised 训练： 因为回答 $y$ 是一个 token 一个 token 采样出来的，分数在采样结束之后才到， 而导数无法逆着采样往回走——从 $r$ 回到权重 $\theta$ 的路径恰好在那里断掉了。

这就是本章标题的由来：我们要 optimize 的是一个无法求导的奖励。 能做到这件事的工具，名叫 reinforcement learning。

2. 我们要做什么（Solution）​

RLHF 用两步走同时拆掉两堵墙：

• Stage A——Reward Model： 训练一个模型 $r_\phi(x,y)$ 去模仿人类在偏好对上的比较（拆第一堵墙，并顶替打分打不过来的人类）
• Stage B——PPO： 用 policy-gradient RL 把 policy 推向 $r_\phi$ 的高分方向，全程不需要对采样求导（拆第二堵墙），同时系上KL 牵引绳，不让它跑离初始模型

付出的代价是复杂度：训练期间有四个模型同时待在显存里—— policy $\pi_\theta$（被训练的那个）、reference $\pi_{\text{ref}}$（被冻结的初始模型）、 reward model $r_\phi$，以及一个还没登场的 value network（价值网络）$V_\psi$（3.4 节见）。

还有一句话请揣在兜里带完全系列：本章的 objective 是整个系列后半程的母公式。 第 4 章（DPO）把它解成闭式，让 reward model 和 RL 循环相互抵消。 第 5 章（GRPO）换掉 advantage（优势）的估计方式，让价值网络消失。 把这一章弄懂，后面两章就成了一眼能读懂的"零件删减"。

3. 公式（Equation）​

3.1 Reward model：Bradley–Terry​

Stage A 用一个短短的 loss 训练 $r_\phi$：

• $r_\phi(x,y)$ = 每段文本一个标量分数——实践中就是把语言模型的头换成单层 linear（num_labels=1）
• $\sigma$ = sigmoid，把分数差变成人类会选 $y_w$ 的概率（Bradley–Terry 模型）
• 差值 $r_\phi(x,y_w) - r_\phi(x,y_l)$ 拉得越开，loss 越低

一个常被忽视、事后吃亏的点：这个 loss 只看得见分数的差值。 把 $r_\phi$ 换成 $r_\phi + c$（$c$ 是任意常数）——loss 纹丝不动。 也就是说 reward model 的绝对尺度没有意义，也不被训练所确定。 跑两次可能得到平均分 3.7 和 −12.4，排序却完全一致。 这就是进 PPO 之前必须先 standardize reward（减 mean 除 std）的原因——记住这一点，它会在第 7 节和第 9 节回来。

3.2 母公式：RLHF objective​

如果全系列只背一个公式，就背这个：

用人话读一遍："把 reward 分数拿到最多，但每离初始模型远一步，都要交罚款。"

• $\pi_\theta$ = policy，正在训练的模型——注意 $y$ 是从 $\pi_\theta$ 自己采样出来的，这是它与从静态文件学习的 SFT 之间的结构性区别
• $\pi_{\text{ref}}$ = reference，初始模型（第 2 章 SFT 之后的模型），训练全程冻结
• $\beta$ = 每偏离一个 nat 的价格——牵引绳的紧度
• $\mathbb{D}_{\text{KL}}$ = policy 与 reference 之间的分布距离

3.3 PPO 裁剪代理目标：Stage B 的发动机​

原始的 policy gradient（REINFORCE）一批 rollout 只能更新一次就得扔，非常昂贵——因为 generate 才是瓶颈。 PPO 想把同一批 rollout 榨上好几个 epoch，就需要一个校正系数（importance sampling ratio）：

• $s_t$ = 位置 $t$ 的状态，即 prompt 加上已经采样出的全部 token
• $a_t$ = "动作"，即 rollout 时已经采样出的下一个 token
• $\pi_{\theta_{\text{old}}}$ = rollout 那一刻的 policy snapshot——只算一次，然后冻结

再用 clip 把 $\rho_t$ 夹住：

• $\hat A_t$ = 优势（advantage），"这个 token 比预期好多少"（下一小节定义）
• $\epsilon$ = trust region 的宽度（标准值 0.2）

核心在于 min + clip 合起来构成一种刻意的悲观： 如果 $\hat A_t$ 为正（好 token），把 $\rho_t$ 往上推的收益被封顶在 $1+\epsilon$——推过头没有任何额外收益，梯度为零。 但如果 $\hat A_t$ 为负（坏 token），min 永远会选更差的那一支——罚款没有上限。 一句话总结：收益有限，损失无限。policy 因此只会在原地附近迈小步。

3.4 GAE：怎么算 advantage 才不会淹死在噪声里​

advantage 由价值网络 $V_\psi$ 的 TD error 构建：

• $V_\psi(s_t)$ = 价值网络，预测"从这里走到结束，还能收多少 reward"——这就是第四个模型
• $r_t$ = 每个 token 的 reward（在我们的任务里：每个位置的 KL 罚款，外加最后一个 token 上的任务得分）
• $\gamma$ = discount factor（LLM 任务通常取 1.0）
• $\lambda$ = bias–variance 旋钮：$\lambda = 0$ 全盘信任 $V_\psi$（$V_\psi$ 预测跑偏时 bias 大），$\lambda = 1$ 完全不信、等着看真实结局（背上整条链的噪声，variance 大），常用值 0.95

3.5 PPO 的完整 loss：三项，两个模型​

把所有零件拼成 optimizer 真正看到的那一个 loss（按 minimize 的写法）：

• 第一项 = 3.3 节的裁剪代理目标（加负号，因为我们要 maximize）
• 第二项 = value loss，教 $V_\psi$ 贴近真实 return $\hat R_t$，$c_1$ 通常取 0.5
• 第三项 = entropy bonus $\mathcal{H}$，防止分布过早塌缩，$c_2$ 通常取 0.01
• 至于公式 3.2 的 KL 牵引绳，实践中习惯把它塞进逐 token 的 reward：$r_t \leftarrow r_t - \beta\,(\log\pi_\theta - \log\pi_{\text{ref}})$——第 7 节用的正是这个写法

数一数需要调的玩具：4 个模型，加上 $\epsilon, \beta, \gamma, \lambda, c_1, c_2$，再加两套 learning rate。 这就是 PPO "换个 seed 跑两遍，结果完全两回事"名声的来源， 也是第 4 章整章存在的理由。

4. 把公式画出来（Visualize）​

Bradley–Terry：梯度堆在还排错的那些对上​

在下面的工具里选择 Bradley-Terry 模式，然后拖动 margin 看看： reward model 已经自信排对的对（margin 很正）几乎不剩任何梯度—— Stage A 的训练预算会自动流向它还排错的那些对。

如果这张图让你想起第 4 章 DPO 的梯度——不是巧合。 DPO 把这个 Bradley–Terry 模型整个搬了过去，只是换了"由谁来充当 reward"。

看得见的 trust region：min + clip​

请仔细看那份不对称——它就是 PPO 的全部性格： 朝好的方向挪，每次最多赚 20%；但一旦给坏 token 的概率多了，就会被全力拽回来。 图中的"平坦区"正是 trust region，它让 PPO 可以把旧 rollout 反复用上好几个 epoch 而不爆炸。

GAE 的 bias–variance 旋钮​

从底部那条线往上读：$\lambda = 0$（绿）时 advantage 几乎全程贴零—— 结尾的分数传不到前面的 token，因为一切都要经过预测跑偏的 $V_\psi$ 过滤。 $\lambda = 1$（红）时每个 token 都从结尾拿到全额 credit，但也背上了整条链累积的噪声。 $\lambda = 0.95$（蓝）是全行业选中的中间点——信号走得远，噪声被压住。

继续之前，先亲手建立 advantage——"比预期好多少"——的直觉： 下面的工具用组内平均代替 $V_\psi$ 当 baseline（这是对第 5 章的全剧透）。 按下 All correct 那组，看看当所有回答拿到相同 reward 时会发生什么：

全组 advantage 为零 = 没有任何可学的信号——把这个感觉记住，读第 9 节时会用到。

KL 牵引绳：把公式 3.2 画出来​

绿线停下来的那个点不是猜的——它就是公式 3.2 的数学结论： 优化会恰好停在"每多偏离一个 nat 所换来的 reward 正好等于 β"的位置，再往前走就是亏本。 当 $\beta = 0$ 时，这个停止条件根本不存在——只要多偏离一点点还能换到哪怕一丁点 reward，那就算"赚"。 于是模型会一路远离自然语言，只要 reward 的数字还在往上跳。

5. 准备环境（Environment）​

打开 Colab，选择 Runtime → Change runtime type → T4 GPU（免费额度够用）。

torch_dtype=torch.float16      # 不是 bfloat16
attn_implementation="sdpa"     # 不是 flash_attention_2

cap = torch.cuda.get_device_capability(0)
print("compute capability:", cap)                    # T4 = (7, 5)
print("native bf16:", cap[0] >= 8)                   # T4 -> False
print("torch says   :", torch.cuda.is_bf16_supported())  # T4 -> True（把 emulation 也算上了！）

为什么 RLHF 昂贵：一张图说完​

图中的数字只是权重——还没算 activation、generate 时的 KV cache、gradient 和 optimizer state。 在 0.6B 上一切都显得小巧，但那个 ×4 的乘数在放大时哪儿也不去：到 7B 就是 56 GB，什么都还没开始做。

6. 准备数据（Data）​

Stage A——给 reward model 的偏好对​

使用 iapp/dpo_thai_tutorial（100 对，Apache-2.0）—— 我为这个系列亲手制作并开放使用的泰语偏好数据集。 每行有人工挑选的 prompt、chosen、rejected，重点关注礼貌程度和语言的自然度。

按 80/20 切分：80 对训练，20 对留作 held-out，训练期间绝不碰。 Stage A 的及格线是：在留出的 20 对上的 pairwise ranking accuracy，其 Wilson 95% CI 不跨 0.5 ——只要"显著好于抛硬币"就算机制验证成功，因为 20 对实在做不出更窄的 CI。

Stage B——能用规则批改的题目​

PPO 循环用的是 VISAI-AI/gsm8k-thai（GSM8K 的泰语翻译版）里的 64 道数学题， 并用可核查的规则打分，而不是用 Stage A 的 reward model：

import re

def rule_reward(response: str, gold: int) -> float:
    """回答中最后一个整数正确得 +1.0，真的用泰语回答再得 +0.2"""
    nums = re.findall(r"-?\d+", response.replace(",", ""))
    correct = 1.0 if nums and int(nums[-1]) == gold else 0.0
    thai = sum("ก" <= ch <= "๛" for ch in response)
    thai_bonus = 0.2 if thai / max(len(response), 1) >= 0.5 else 0.0
    return correct + thai_bonus

7. 核心代码（Main code）​

7.1 Stage A——训练一个真正的 reward model（约 6 分钟）​

把语言模型改造成打分机：LM 头被换成返回单个标量的单层 linear。

import torch, torch.nn.functional as F
from transformers import AutoModelForSequenceClassification, AutoTokenizer
from peft import LoraConfig, get_peft_model

tok = AutoTokenizer.from_pretrained("Qwen/Qwen3-0.6B")
rm = AutoModelForSequenceClassification.from_pretrained(
    "Qwen/Qwen3-0.6B",
    num_labels=1,                          # 标量头：每段文本一个分数
    torch_dtype=torch.float16,             # T4 没有 bf16
    attn_implementation="sdpa",
).cuda()
rm.config.pad_token_id = tok.pad_token_id

rm = get_peft_model(rm, LoraConfig(
    task_type="SEQ_CLS", r=8, lora_alpha=16,
    target_modules=["q_proj", "k_proj", "v_proj", "o_proj"],
    modules_to_save=["score"],             # 打分头是随机初始化的，必须全量训练
))
for p in rm.parameters():
    if p.requires_grad:
        p.data = p.data.float()            # 第 1 章的 fp16 教训：在 fp32 中训练

def rm_loss(chosen, rejected):
    s_w = rm(**chosen).logits.squeeze(-1)     # r_φ(x, y_w)
    s_l = rm(**rejected).logits.squeeze(-1)   # r_φ(x, y_l)
    return -F.logsigmoid(s_w - s_l).mean()    # 就是公式 3.1 本身

在 80 对上训 3 个 epoch，然后在留出的 20 对上测 pairwise accuracy，附 Wilson CI。 如果 CI 不跨 0.5——你刚刚用 80 行数据，成功训出了人生第一个 reward model。

7.2 Stage B——从零手写 PPO，约 120 行（约 10 分钟）​

我们不用 TRL 的 PPOTrainer，而这是一个刻意的决定，不是犟： TRL 已把 PPOTrainer 移入 trl.experimental，并宣布计划在 0.29.0 移除—— 用这个库教的代码，再过几个月就跑不起来了。 而自己写的约 120 行 PPO 循环，只要 PyTorch 还在就能跑。 更重要的是：亲手写过，你才知道每一行在做什么——和第 4 章那 25 行 DPO loss 是同一个道理。

棋盘上的棋子：policy = base + LoRA adapter（来自第 2 章，is_trainable=True）， reference = 同一个 base 关掉 adapter，value head 是插在最后一层 hidden state 上的两层 MLP：

value_head = torch.nn.Sequential(
    torch.nn.Linear(1024, 1024), torch.nn.Tanh(),
    torch.nn.Linear(1024, 1),
).float().cuda()                           # ~1M 参数 —— 和另外三个比起来微不足道

rollout：每次对 8 个 prompt 采样回答（max_new_tokens=200、do_sample=True）， 用 rule_reward 打分，在 batch 内 standardize 分数，并当场把 rollout 时的 log-prob detach 存下来。 然后进入这个 update 循环——全章的心脏，40 行（完整循环在 notebook 里）：

def compute_gae(rewards, values, gamma=1.0, lam=0.95):
    """rewards: 单条 response 的 [T]，values: [T+1]（最后一格 = 结束后为 0）"""
    adv, acc = torch.zeros_like(rewards), 0.0
    for t in reversed(range(rewards.shape[0])):
        delta = rewards[t] + gamma * values[t + 1] - values[t]   # 公式 3.4
        acc = delta + gamma * lam * acc                          # Â_t = δ_t + γλ Â_{t+1}
        adv[t] = acc
    return adv

def ppo_update(rollout, eps=0.2, beta=0.05):
    out = policy(rollout.ids, output_hidden_states=True)         # 一次 forward 拿两样东西
    logp = gather_logprobs(out.logits, rollout.ids)              # [B, T] 带梯度
    with torch.no_grad(), policy.disable_adapter():
        logp_ref = gather_logprobs(policy(rollout.ids).logits, rollout.ids)

    # 逐 token 的 reward = 每个位置的 KL 罚款 + 最后一个 token 上的任务得分（公式 3.2）
    rew = -beta * (logp.detach() - logp_ref)
    rew[:, -1] += rollout.scores_std                 # standardize 过的 rule 得分

    hidden = out.hidden_states[-1].detach().float()  # detach = 切断流向主干的梯度
    values = value_head(hidden).squeeze(-1)
    adv = torch.stack([compute_gae(r, F.pad(v, (0, 1))) for r, v in zip(rew, values)])
    adv = (adv - adv.mean()) / (adv.std() + 1e-8)    # 再 standardize 一层 advantage

    log_ratio = (logp - rollout.logp_old).clamp(-10, 10)   # 防 fp16 overflow！
    ratio = log_ratio.exp()                                # ρ_t（公式 3.3）
    surr = torch.min(ratio * adv.detach(),
                     ratio.clamp(1 - eps, 1 + eps) * adv.detach())

    returns = (adv + values).detach()                # value head 的学习目标
    m = rollout.resp_mask                            # 只统计 response 的 token
    loss = (-(surr * m).sum() + 0.5 * ((values - returns).pow(2) * m).sum()) / m.sum()
    return loss                                      # （entropy 项在 notebook 里）

配置：$\epsilon = 0.2$、$\beta = 0.05$、$\gamma = 1.0$、$\lambda = 0.95$， 同一批 rollout 训 4 个 epoch，共 64 个 prompt，adapter 的 LR 为 1e-5、value head 为 1e-4。 在 T4 上一次运行约 10 分钟（notebook 会跑两次：$\beta = 0.05$ 和 $\beta = 0$）。

8. 结果（Results）​

notebook 每个 update 同时量三条曲线，并写入 results.json：

1. 每个 rollout 的平均 reward——应当爬升（这是我们买到的东西）
2. 相对 $\pi_{\text{ref}}$ 的逐 token KL——应当上升然后在 $\beta$ 划定的天花板下饱和（这是付出的价格）
3. 平均回答长度——病症探测器：长度异常暴涨或跳水，是 policy 开始跑偏的第一信号

当场抓获 reward hacking​

notebook 的第二次运行设定 $\beta = 0$，其他一个字都不动——没有牵引绳。 预期会看到的模式：reward 爬得一样快或更快，但 KL 没有天花板地飞升， 回答开始退化——车轱辘话、异常地短，或者变成句尾塞个数字的固定套路。 因为 rule_reward 只看得见最后的数字和泰文字符占比——它看不见的一切，都是模型可以白扔的东西。

$\beta = 0$ 运行中退化回答的实例，会由 notebook 的最后一个 cell 打印出来：

[这一格只能由 notebook 的真实运行结果来填 —— 我不会自己编造 degenerate 的例子，
 因为整个系列立足的规矩就是：没有任何数字或 output 是 invent 出来的。
 跑完 notebook，"hacking exhibits" 那个 cell 会展示 2-3 条真实回答和它们的 KL]

9. 对比（Comparison）​

notebook 用同一套 held-out 泰语数学题（TH-MATH）测量三个系统：

下一章： DPO——DPO 用纯代数，从你刚背下的母公式 3.2 出发，把 reward model 和 RL 循环双双删掉。

参考文献（References）​

1. Schulman et al. (2017). Proximal Policy Optimization Algorithms — PPO 原始论文：第 3 节的裁剪代理目标
2. Schulman et al. (2015). High-Dimensional Continuous Control Using Generalized Advantage Estimation — GAE：PPO 所用的优势估计
3. Christiano et al. (2017). Deep reinforcement learning from human preferences — 开启"从人类偏好做 RL"的工作
4. Stiennon et al. (2020). Learning to summarize from human feedback — 首次在摘要任务上真正跑通的 RLHF
5. Ouyang et al. (2022). Training language models to follow instructions with human feedback — InstructGPT：整条 SFT -> RM -> PPO 流水线的源头
6. Bai et al. (2022). Training a Helpful and Harmless Assistant with Reinforcement Learning from Human Feedback — helpful/harmless 数据集及关于 KL 的经验
7. Zheng et al. (2023). Secrets of RLHF in Large Language Models Part I: PPO — 其他论文略去的 PPO 工程细节
8. Bradley & Terry (1952). Rank Analysis of Incomplete Block Designs: I. The Method of Paired Comparisons — 所有奖励模型赖以成立的 Bradley-Terry 模型

本系列的文章、代码与 notebook 均以 CC BY-NC-SA 4.0 授权 —— 可自由使用与改编，须署名、限非商业用途，并以相同方式共享。文中引用的第三方模型与数据集仍适用各自的许可证。