[LLM 4/10] DPO：当语言模型成为它自己的奖励模型

上一章我们用 PPO 做了 RLHF，你应该已经看到它有多少零件—— 要单独训练一个奖励模型，要同时把 4 个模型塞进显存， 还要调十几个 PPO 超参数；而一旦奖励模型跑偏，模型就会找到刷分的捷径。 这一章我们要用一个普通的 supervised 训练循环做同样的事——没有奖励模型，也没有 RL。 更关键的是，这并不是一种近似：我们会用代数证明那两块东西是真的互相抵消掉了。

1. 问题（Problem statement）​

假设你希望自己的 AI 助手"永远用泰语回答"——听起来很简单。 但你试着把它写成一个 loss function 看看，你会发现根本写不出来。

这就是 alignment 的核心难题：回答的质量没法写成公式。 "更礼貌""更自然""不要中途滑回英语"——这些都不存在唯一正确的标准答案， 有的只是比较：让人看两个回答，然后说更喜欢哪一个。 于是得到的数据长成三元组：prompt $x$、被选中的回答 $y_w$（chosen）、被拒绝的回答 $y_l$（rejected）。

PPO 版本的 RLHF 用两步绕路来解决这个问题：

1. 训练一个奖励模型 $r_\phi(x,y)$ 去模仿人类的偏好
2. 用 RL 把策略推向该奖励模型给分高的方向

这条绕路是有代价的：

所以这一章的问题只有一句话：我们能不能把第 1 步和第 2 步直接跳过？

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

答案是能，而且理由非常漂亮。

出发点是这样一个观察：带 KL 约束的 RLHF objective 存在闭式解（closed form）。 我们其实早就知道最优策略长什么样，一个 RL step 都不用跑。 既然如此，我们就把公式反过来写——与其问"这个 reward 对应什么策略"， 不如问"这个策略意味着多少 reward"。

这就是 DPO（Direct Preference Optimization），由 Rafailov 等人在 2023 年提出。 名字里的 "Direct" 指的是我们直接在偏好数据上做优化，中间不经过任何代理。

3. 公式（Equation）​

3.1 先摆出题目：RLHF objective​

用人话读一遍："把 reward 拿到最高，但不许离初始模型太远。"

• $\pi$ = 策略，也就是我们正在训练的模型
• $\pi_{\text{ref}}$ = 参考策略，也就是初始模型（本章指第 2 章 SFT 之后的模型）
• $r(x,y)$ = 回答 $y$ 对 prompt $x$ 的 reward
• $\beta$ = 这根牵引绳的紧度，越大就把模型往 $\pi_{\text{ref}}$ 拉得越狠

KL 那一项不是装饰。没有它，模型会跑向 reward 很高但语言已经崩坏的地方。

3.2 第一步——闭式解​

上面这道题可以手推出来（本质是在求一个相对目标分布 KL 最小的分布），结果是

• $Z(x) = \sum_{y}\pi_{\text{ref}}(y|x)\exp\!\big(r(x,y)/\beta\big)$ 就是 partition function，负责把总和归一到 1 的分母
• 注意 $Z(x)$ 只依赖 $x$，不依赖 $y$——把这句话记牢，它待会儿是主角

直觉上的含义是：最优策略就是原模型，按 $\exp(r/\beta)$ 重新加权。 reward 高的回答概率被放大，reward 低的被压低，但一切始终是从 $\pi_{\text{ref}}$ 原本的形状出发的。

实际上我们算不出 $Z(x)$，因为那要把全宇宙所有可能的回答都加起来。 这正是大家不得不用 RL 的原因——也正是 DPO 不需要用 RL 的原因。

3.3 第二步——把公式反解出 reward​

两边取 log 再移项，得到

这一行就是关键：任何 reward 函数都可以改写成"最优策略与初始策略"的形式。 也就是说，只要手上有两个模型，我们立刻就能算出它隐含的 reward，完全不必训练任何奖励模型。

3.4 第三步——代入 Bradley-Terry，$Z(x)$ 抵消​

偏好的标准建模方式是 Bradley-Terry：人类选择 $y_w$ 而非 $y_l$ 的概率为

其中 $\sigma$ 是 sigmoid。注意在这个式子里，reward 只以差值的形式出现。 把 3.3 代进去——$\beta\log Z(x)$ 在两边完全相等，因为 $x$ 是同一个——于是它直接抵消掉了。

3.5 梯度——直觉所在之处​

其中 $\hat r = \beta\log\big(\pi_\theta/\pi_{\text{ref}}\big)$ 被称为隐式奖励（implicit reward）。

一块一块地读：

• 右边的括号 = 方向：同时把 $y_w$ 的 log-prob 推上去、把 $y_l$ 的 log-prob 压下来
• $\sigma(\hat r_l - \hat r_w)$ = 权重，也就是"模型把这一对排错得有多离谱"

这个权重是全章最重要的教学点。如果模型本来就把这一对排对了（$\hat r_w$ 明显大于 $\hat r_l$）， 那么 $\sigma(\hat r_l - \hat r_w)$ 会趋近于零，这一对几乎不贡献任何梯度。 于是 DPO 会自动把注意力集中在自己犯的错上，不需要任何人替它筛数据。

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

Bradley-Terry：从 reward 差值到概率​

差值为零的那一点恰好给出概率 0.5，也就是"模型没有意见"。 又因为整条曲线只看差值，给两边的 reward 同时加上一个常数不会改变任何东西。 这就是 $Z(x)$ 能被抵消掉的几何解释。

Loss 与梯度权重​

令 $\Delta = \log\frac{\pi_\theta(y_w|x)}{\pi_{\text{ref}}(y_w|x)} - \log\frac{\pi_\theta(y_l|x)}{\pi_{\text{ref}}(y_l|x)}$， 则 loss 为 $-\log\sigma(\beta\Delta)$，梯度权重为 $\sigma(-\beta\Delta)$。

右边这一面板要仔细看：当 margin 很正的时候，权重会收敛到零——这一对"已经毕业了"。 而 $\beta$ 越大，曲线越陡，也就是学得越快、"退学"也越早。 在 $\beta = 1.0$ 时，margin 超过 4 的样本对几乎不剩任何梯度。 而在 $\beta = 0.1$ 时曲线平缓得多，模型会持续从每一对里都收一点梯度——更慢，但更稳。

$\beta$ 决定模型能离初始状态多远​

这张图从右往左读：在 $\beta = 0.1$ 时，几乎全部概率质量都塌到了 reward 最高的 $y_5$ 上。 这就是 mode collapse——分数好看了，多样性却荡然无存。 而在 $\beta = 10$ 时，柱子几乎贴着虚线，等于什么都没学到。 $\beta$ 不是那种"调到 loss 最低"的超参数，它是一个在服从偏好与保住自我之间选择交易点的旋钮。

自己拖动一下参数，看看 loss 和梯度的形状会怎么变：

5. 准备环境（Environment）​

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

torch_dtype=torch.float16      # 不是 bfloat16
attn_implementation="sdpa"     # 不是 flash_attention_2
fp16=True                      # 在 DPOConfig 里（不是 bf16=True）

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 也算上了！）

一个完全不额外占显存的 reference model​

DPO 需要同时用到 $\pi_\theta$ 和 $\pi_{\text{ref}}$，听上去像是要加载两个模型。 但我们是在第 2 章的 LoRA adapter 基础上继续做的，因此两者共享同一份底座权重。

from peft import PeftModel

base = AutoModelForCausalLM.from_pretrained(
    "Qwen/Qwen3-0.6B",
    torch_dtype=torch.float16,
    attn_implementation="sdpa",
).cuda()

policy = PeftModel.from_pretrained(base, "kobkrit/qwen3-0.6b-th-sft-lora", is_trainable=True)

policy 就是 base + adapter，而 $\pi_{\text{ref}}$ 就是同一个 base，只不过把 adapter 关掉。 直接用 context manager policy.disable_adapter() 就行，不需要额外加载任何东西。

6. 准备数据（Data）​

DPO 的数据只需要 3 列：prompt、chosen、rejected。

数据集 1 —— iapp/dpo_thai_tutorial（100 对，Apache-2.0） 这是我为这个系列亲手做的数据集，以 Apache-2.0 发布，欢迎拿去继续用。 它是人工挑选的泰语偏好对，重点关注礼貌程度和语言的自然度。

数据集 2 —— 自己造大约 400 对，源自 airesearch/wangchanx-seed-free-synthetic-instruct-thai-120k。 造法非常直白：

• chosen = 数据集自带的泰语参考答案
• rejected = 基座模型自己用 greedy decoding 生成的回答

def build_rejected(prompt):
    with torch.no_grad(), policy.disable_adapter():
        out = policy.generate(**tok(prompt, return_tensors="pt").to("cuda"),
                              max_new_tokens=192, do_sample=False)
    return tok.decode(out[0], skip_special_tokens=True)[len(prompt):]

合起来大约 500 对，留出 15% 作为 held-out 用于评测，训练期间绝不碰。

7. 核心代码（Main code）​

这一节的重点不是怎么调库，而是亲手把 DPO loss 写出来， 然后证明它和真家伙一模一样。如果第 3 节的推导还没让你完全信服，这段代码会让你信。

7.1 手写 25 行​

import torch, torch.nn.functional as F

def seq_logp(model, input_ids, attention_mask, labels):
    """'仅回答部分'的 log-prob 之和（prompt 的 token 已被 mask 成 -100）"""
    logits = model(input_ids=input_ids, attention_mask=attention_mask).logits
    logits = logits[:, :-1, :]                   # 位置 t 预测的是第 t+1 个 token
    target = labels[:, 1:]                       # 所以目标要往后移一位
    mask = target.ne(-100)                       # 只统计回答部分的 token
    target = target.masked_fill(~mask, 0)        # 避免 gather 在 -100 处出错
    logp = torch.log_softmax(logits.float(), dim=-1)
    tokp = logp.gather(-1, target.unsqueeze(-1)).squeeze(-1)
    return (tokp * mask).sum(-1)                 # [B] —— 是求和，不是求平均

def dpo_loss(policy, batch, beta=0.1):
    pi_w = seq_logp(policy, batch["chosen_ids"],   batch["chosen_mask"],   batch["chosen_labels"])
    pi_l = seq_logp(policy, batch["rejected_ids"], batch["rejected_mask"], batch["rejected_labels"])

    with torch.no_grad(), policy.disable_adapter():        # reference: 关掉 adapter + 不要梯度
        ref_w = seq_logp(policy, batch["chosen_ids"],   batch["chosen_mask"],   batch["chosen_labels"])
        ref_l = seq_logp(policy, batch["rejected_ids"], batch["rejected_mask"], batch["rejected_labels"])

    delta = (pi_w - ref_w) - (pi_l - ref_l)                # 第 4 节里的 Δ
    loss = -F.logsigmoid(beta * delta).mean()              # 就是公式 3.4 本身

    r_w = beta * (pi_w - ref_w).detach()                   # chosen 的隐式奖励
    r_l = beta * (pi_l - ref_l).detach()                   # rejected 的隐式奖励
    return loss, r_w, r_l

整个 DPO 就全在这里了，没有任何其他藏起来的东西。 delta 那一行是公式 3.4 一对一翻译成的代码，而 -F.logsigmoid(beta * delta) 就是完整的 loss。

7.2 证明它和 TRL 一致​

from trl import DPOTrainer, DPOConfig

cfg = DPOConfig(
    output_dir="dpo-out",
    beta=0.1,
    loss_type="sigmoid",              # 必须与我们手写的公式一致
    label_smoothing=0.0,              # 一旦不为零，公式就不再是 3.4 了
    per_device_train_batch_size=2,
    gradient_accumulation_steps=8,    # effective batch = 16
    num_train_epochs=2,
    learning_rate=5e-6,               # 远低于 SFT —— 见下方警告
    lr_scheduler_type="cosine",
    warmup_ratio=0.1,
    max_length=768,
    max_prompt_length=256,
    fp16=True,                        # T4 没有 bf16
    logging_steps=5,
)

trainer = DPOTrainer(model=policy, args=cfg, train_dataset=train_ds, processing_class=tok)

# 关键：刚创建的 LoRA 中 lora_B = 0，此时 policy 与 reference 完全相同，
# 差值为零，两种实现都会返回 ln 2 —— 即使公式写错了也一样。
# 必须先扰动权重，这个 assert 才是真正的检验。
with torch.no_grad():
    for name, p in policy.named_parameters():
        if "lora_B" in name:
            p.add_(torch.randn_like(p) * 0.01)

loss_manual, _, _ = dpo_loss(policy, batch, beta=0.1)
loss_trl = trainer.compute_loss(policy, trl_batch)

assert torch.allclose(loss_manual, loss_trl, atol=1e-4)
print("一致:", loss_manual.item(), loss_trl.item())

在 T4 上，500 对数据训练 2 个 epoch 总共约 9 分钟。

8. 结果（Results）​

notebook 会测三项指标并写入 results.json：

1. Held-out preference accuracy —— chosen 的隐式奖励高于 rejected 的样本对占比，附 Wilson 95% CI
2. 隐式奖励 margin 的分布（$\hat r_w - \hat r_l$）——看整个分布，而不只是平均值
3. th_ratio —— 模型生成回答中泰文字符所占的比例。泰语有自己的一套字母，和拉丁字母毫不重叠， 所以只要数一下字符就能可靠地判断模型有没有偷偷滑回英语。这是本系列专门用来抓这种"静默语言漂移"的指标。

第一次看 log 时会吓你一跳的事​

训练过程中，你会在 TRL 的 log 里看到 rewards/chosen 和 rewards/rejected。 而几乎每次都会发生的情况是：这两个值一起往负数方向掉，同时 rewards/margins 却越拉越宽。

9. 对比（Comparison）​

下一章： GRPO——当"给现成的东西排序"不再够用时， 我们会让模型采样出自己的多个回答，彼此互相比较，而且不需要 PPO 那样的 value function。

参考文献（References）​

1. Rafailov et al. (2023). Direct Preference Optimization: Your Language Model is Secretly a Reward Model — DPO 原始论文——第 3 节推导的出处
2. Bradley & Terry (1952). Rank Analysis of Incomplete Block Designs: I. The Method of Paired Comparisons — 所有奖励模型赖以成立的 Bradley-Terry 模型
3. Azar et al. (2023). A General Theoretical Paradigm to Understand Learning from Human Preferences — IPO：指出 DPO 对偏好过拟合的弱点
4. Ethayarajh et al. (2024). KTO: Model Alignment as Prospect Theoretic Optimization — KTO：无需 chosen/rejected 成对数据的替代方案
5. Park et al. (2024). Disentangling Length from Quality in Direct Preference Optimization — 第 9 节所警告的 DPO 长度偏置
6. Tang et al. (2024). Understanding the performance gap between online and offline alignment algorithms — 离线（DPO）为何落后于在线（PPO/GRPO）
7. Ouyang et al. (2022). Training language models to follow instructions with human feedback — InstructGPT：整条 SFT -> RM -> PPO 流水线的源头

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