$$ L_{DPO}(\pi_{\theta}; \pi_{\text{ref}}) = -\mathbb{E}_{(x, y_w, y_l) \sim D} \left[ \log \sigma \left( \beta \log \frac{\pi_{\theta}(y_w|x)}{\pi_{\text{ref}}(y_w|x)} - \beta \log \frac{\pi_{\theta}(y_l|x)}{\pi_{\text{ref}}(y_l|x)} \right) \right] $$

我们用白话把这个公式“翻译”一遍：

我们手头有什么：提示 $x$，人类更喜欢的回复 $y_w$（winner），不太喜欢的回复 $y_l$（loser）。
我们想要什么：模型 $\pi_{\theta}$ 对 $y_w$ 的打分要比对 $y_l$ 的打分高得多。这里巧妙地将模型生成一个回复的概率视为“模型对该回复的隐式打分”。
怎么评判分数：我们把获胜回复和失败回复分别代入公式，计算它们的一个“得分”差异。这个差异越大，说明模型越能区分好坏。
$\beta$ 是控制杆：它决定了模型能多大程度地偏离它最初的“参考模型” $\pi_{\text{ref}}$。因为 $\pi_{\text{ref}}$ 也出现在了公式的分母里，它起到了一个“锚点”和“约束”的作用，防止模型为了单纯优化偏好而“忘记”自己原来会说的话，出现严重的灾难性遗忘。
$\sigma$ 的作用：sigmoid 函数将得分差转化为一个 0 到 1 之间的概率，然后用对数损失来优化。

更直白的直觉理解：

DPO 的损失函数就是在做一件事：它拼命地让 $\frac{\pi_{\theta}(y_w|x)}{\pi_{\text{ref}}(y_w|x)}$ 这个比值远大于 $\frac{\pi_{\theta}(y_l|x)}{\pi_{\text{ref}}(y_l|x)}$。也就是说，经过训练后，模型 $\pi_{\theta}$ 相对于原始模型 $\pi_{\text{ref}}$，要极大地提升好回复的生成概率，同时极大地降低差回复的生成概率。

3、动手实践：从零实现一个 DPO 训练器

理论弄明白了，代码实现其实出奇地简洁。我们来搭建一个可以实际跑通的 DPO 训练器。

1、导入必要的库并定义一个玩具数据集

我们先用一个极其简化的场景来演示：让模型学会更倾向于“积极”的回复。

import torch
import torch.nn.functional as F
from torch.utils.data import Dataset, DataLoader
from transformers import AutoModelForCausalLM, AutoTokenizer

# 定义一个超小的偏好数据集
# 每个样本包含：提示(prompt)，好的回复(chosen)，差的回复(rejected)
toy_dataset = [
    {
        "prompt": "今天天气真好，我感觉",
        "chosen": "心情非常舒畅，充满了活力！",
        "rejected": "也就那样吧，没什么特别的。"
    },
    {
        "prompt": "我刚收到一份礼物，",
        "chosen": "真是太开心了，拆礼物的感觉真好！",
        "rejected": "不知道是谁送的，有点烦。"
    },
    {
        "prompt": "关于人工智能的未来，",
        "chosen": "我充满希望，它将帮助我们解决许多难题。",
        "rejected": "我担心它会失控，带来很多灾难。"
    }
]

2、最核心的部分：DPO 损失函数

这里就是公式的代码化身。我们会逐行解释。

def dpo_loss(policy_chosen_logps, policy_rejected_logps,
             ref_chosen_logps, ref_rejected_logps, beta=0.1):
    """
    计算 DPO 损失。

    参数:
        policy_chosen_logps: 策略模型对好回复生成的对数概率
        policy_rejected_logps: 策略模型对差回复生成的对数概率
        ref_chosen_logps: 参考模型对好回复生成的对数概率
        ref_rejected_logps: 参考模型对差回复生成的对数概率
        beta: 控制与参考模型偏离程度的超参数
    """
    # 1. 计算策略模型和参考模型之间的相对概率比的对数
    policy_log_ratio = policy_chosen_logps - policy_rejected_logps
    ref_log_ratio = ref_chosen_logps - ref_rejected_logps

    # 2. 计算最终的隐式奖励差距，并乘以 beta
    # 这就是公式里面 sigmoid 函数里的那一大串
    logits = beta * (policy_log_ratio - ref_log_ratio)

    # 3. 计算损失。F.logsigmoid 等价于 log(sigmoid(x))
    # 由于我们想让 chosen 打败 rejected，所以用负号来最小化损失
    loss = -F.logsigmoid(logits)

    return loss.mean()

policy_log_ratio 就是 $\log \frac{\pi_\theta(y_w|x)}{\pi_\theta(y_l|x)}$。
ref_log_ratio 就是 $\log \frac{\pi_{\text{ref}}(y_w|x)}{\pi_{\text{ref}}(y_l|x)}$。
两者相减，再乘以 $\beta$，就得到了公式里完整的内部项。
-F.logsigmoid(...) 是对 $\log \sigma(\cdot)$ 的损失计算，完全吻合公式。

3、构建一个完整的训练循环框架

这提供了一个可扩展的蓝图。

def train_dpo(model, ref_model, tokenizer, dataset, optimizer, beta=0.1, epochs=100):
    """一个简化的 DPO 训练循环示例"""
    model.train()
    ref_model.eval() # 参考模型冻结，不更新参数

    for epoch in range(epochs):
        total_loss = 0
        for batch in dataset:
            prompt = batch["prompt"]
            chosen = batch["chosen"]
            rejected = batch["rejected"]

            # ----- 1. 组装文本并分词 -----
            # 为了方便，这里把 prompt + response 拼在一起
            chosen_text = [p + c for p, c in zip(prompt, chosen)]
            rejected_text = [p + r for p, r in zip(prompt, rejected)]

            # 这里简化了：实际应用中需要更精细的掩码控制
            chosen_tokens = tokenizer(chosen_text, return_tensors="pt", padding=True, truncation=True)
            rejected_tokens = tokenizer(rejected_text, return_tensors="pt", padding=True, truncation=True)

            # ----- 2. 计算所有需要的对数概率 -----
            with torch.no_grad(): # 参考模型的输出不需要梯度
                ref_chosen_logps = get_log_probs(ref_model, **chosen_tokens)
                ref_rejected_logps = get_log_probs(ref_model, **rejected_tokens)

            policy_chosen_logps = get_log_probs(model, **chosen_tokens)
            policy_rejected_logps = get_log_probs(model, **rejected_tokens)

            # ----- 3. 计算损失并更新模型 -----
            loss = dpo_loss(policy_chosen_logps, policy_rejected_logps,
                           ref_chosen_logps, ref_rejected_logps, beta)

            optimizer.zero_grad()
            loss.backward()
            optimizer.step()

            total_loss += loss.item()

        if (epoch + 1) % 20 == 0:
            print(f"Epoch {epoch+1}/{epochs}, Average Loss: {total_loss/len(dataset):.4f}")

def get_log_probs(model, input_ids, attention_mask):
    """辅助函数：获取模型对输入序列的平均对数概率"""
    outputs = model(input_ids=input_ids, attention_mask=attention_mask)
    logits = outputs.logits # 形状: [batch, seq_len, vocab_size]

    log_probs = F.log_softmax(logits, dim=-1)
    # 获取每个位置真实 token 的对数概率
    # 将 input_ids 移位一位，以便 log_probs[:, :-1, :] 能预测 input_ids[:, 1:]
    target_log_probs = torch.gather(log_probs[:, :-1, :], dim=-1, index=input_ids[:, 1:].unsqueeze(-1)).squeeze(-1)

    # 计算序列的平均对数概率（这里简化了，只对非填充部分取平均）
    mask = attention_mask[:, 1:].float()
    avg_log_probs = (target_log_probs * mask).sum(dim=1) / mask.sum(dim=1)
    return avg_log_probs

4、总结：DPO 的优势与思考

到这里，DPO的整个图景应该很清晰了。最后我们梳理一下它的核心优势与局限。

优势

简洁稳定：无需训练和维护独立的奖励模型，直接优化策略，流程简洁，训练稳定。

计算高效：显存占用和计算开销显著降低，让偏好对齐不再是大厂的专利。

理论优雅：不基于采样和近似（PPO），而是直接在偏好数据上定义损失，优化目标明确。

局限与思考

数据就是一切：DPO的性能极度依赖偏好数据的质量和分布。如果数据有偏差，模型会直接学到这些偏差。

分布外泛化：当训练好的模型面对与训练时完全不同的新提示时，其性能可能变得难以预测。

并非万能钥匙：DPO适合让“好”与“更好”的模型对齐，但如果基础模型能力本身就弱，DPO也无能为力。

DPO 不仅是工程上的简化，更代表了从“奖励建模”到“直接偏好”的范式转变。希望这个章节能让大家对这项技术有一个扎实且清晰的理解。

_{本教程共55节，当前为第42节!}
_{本教程最新修订时间为：2026-08-17 09:09:33}

✨ 复制成功！

以文会友，打造好学人设！

直接偏好优化算法介绍

1、从 RLHF 说起：为什么需要更好的方法？

2、深度解析 DPO：数学原理之美

更直白的直觉理解：

3、动手实践：从零实现一个 DPO 训练器

4、总结：DPO 的优势与思考