1.1 标准 RLHF 流程#

标准 RLHF 存在以下问题：

1. 奖励模型训练不稳定：需要大量偏好数据，且奖励模型可能存在 reward hacking
2. PPO 超参数敏感：需要精心调参，训练过程容易出现梯度爆炸或策略崩塌
3. 计算开销大：需要同时加载参考模型、训练模型、奖励模型和 value head，显存占用极大
4. 奖励作弊（Reward Hacking）：策略模型可能找到奖励模型的高分漏洞，而非真正对齐人类偏好

1.2 关键洞察#

DPO 的核心洞察来自对语言模型的重新理解：

语言模型实际上是隐式的奖励模型！

KL 散度约束下的最优策略满足： $\pi_r(y|x) \propto \pi_{ref}(y|x) \exp\left(\frac{1}{\beta} r(x, y)\right)$

其中 $\beta$ 是 KL 约束系数。这意味着可以通过分析语言模型本身来直接优化偏好！

2.1 偏好概率建模#

DPO 基于 Bradley-Terry 模型建模偏好概率。Bradley-Terry 模型最初用于竞赛排名（如体育赛事），其核心思想是：每个参赛者都有一个潜在的实力分数，两两对决时实力更高的一方获胜概率更大。

在偏好建模场景中，给定提示 $x$ 和两个响应 $y_1, y_2$，人类偏好 $y_1$ 的概率为：

$P(y_1 \succ y_2 | x) = \sigma\left(r(x, y_1) - r(x, y_2)\right) = \frac{\exp(r(x, y_1))}{\exp(r(x, y_1)) + \exp(r(x, y_2))}$

其中 $\sigma$ 是 sigmoid 函数，$r(x, y)$ 是隐式奖励函数。

2.2 从偏好到奖励#

如果我们有偏好数据 $\mathcal{D} = \{(x, y_w, y_l)\}$，其中 $y_w$ 是被偏好的响应（winner），$y_l$ 是不被偏好的响应（loser）。

Bradley-Terry 模型下的最大似然估计目标为：

$\mathcal{L}_R = \mathbb{E}_{(x, y_w, y_l) \sim \mathcal{D}} \left[\log \sigma\left(r(x, y_w) - r(x, y_l)\right)\right]$

直觉上，这个目标要求奖励模型给 $y_w$ 打分高于 $y_l$，且差距越大，loss 越小。当 $r(x, y_w) \gg r(x, y_l)$ 时，$\sigma(\cdot) \to 1$，$\log\sigma(\cdot) \to 0$。

2.3 Plackett-Luce 推广#

Bradley-Terry 模型是 Plackett-Luce 模型的二选一特例。对于 $K$ 个候选响应的排序 $(y_{(1)} \succ y_{(2)} \succ \cdots \succ y_{(K)})$，Plackett-Luce 模型的概率为：

$P(y_{(1)} \succ \cdots \succ y_{(K)} | x) = \prod_{k=1}^{K} \frac{\exp(r(x, y_{(k)}))}{\sum_{j=k}^{K} \exp(r(x, y_{(j)}))}$

当 $K=2$ 时，上式退化为 Bradley-Terry 模型。DPO 论文主要关注 $K=2$ 的配对比较场景，但这一框架可以自然扩展到更一般的排序设定。

3.1 起点：KL 约束的奖励最大化#

RLHF 的核心优化目标是 KL 正则化的奖励最大化：

$\max_{\pi_\theta} \mathbb{E}_{x \sim \mathcal{D}, y \sim \pi_\theta(\cdot|x)} \left[r(x, y)\right] - \beta \cdot \mathbb{D}_{KL}\left[\pi_\theta(\cdot|x) \| \pi_{ref}(\cdot|x)\right]$

其中 $\beta$ 控制 KL 惩罚强度。这个目标在奖励最大化和保持与参考模型接近之间做权衡。

3.2 闭式最优解#

上述优化问题有闭式解。将其改写为：

$\max_{\pi_\theta} \mathbb{E}_{x, y} \left[\log \pi_\theta(y|x) - \log \pi_{ref}(y|x) + \frac{1}{\beta} r(x, y)\right]$

通过变分法求解，最优策略为：

$\pi^*(y|x) = \frac{1}{Z(x)} \pi_{ref}(y|x) \exp\left(\frac{1}{\beta} r(x, y)\right)$

其中配分函数 $Z(x) = \sum_y \pi_{ref}(y|x) \exp\left(\frac{1}{\beta} r(x, y)\right)$ 仅与 $x$ 有关，与 $y$ 无关。

3.3 从奖励函数到策略的映射#

对最优策略等式两边取对数并重新排列：

$r(x, y) = \beta \log \frac{\pi^*(y|x)}{\pi_{ref}(y|x)} + \beta \log Z(x)$

注意 $\beta \log Z(x)$ 仅依赖于 $x$，对任意给定的 $x$ 是一个常数。在 Bradley-Terry 模型中计算偏好概率时：

$P(y_w \succ y_l | x) = \sigma\left(r(x, y_w) - r(x, y_l)\right)$

常数 $\beta \log Z(x)$ 在做差时被消去！因此可以定义隐式奖励：

$\hat{r}(x, y) = \beta \log \frac{\pi_\theta(y|x)}{\pi_{ref}(y|x)}$

3.4 DPO 目标函数的最终形式#

将隐式奖励代入 Bradley-Terry 最大似然目标，得到 DPO 的损失函数：

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

其中 $\beta$ 是温度参数，控制相对于参考模型的偏离程度。上式可以用对数概率比简化为：

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

3.5 直观理解#

DPO 的巧妙之处：

• 同时增加偏好响应概率和降低不偏好响应概率
• 通过 KL 散度约束防止模型过度偏离原始分布
• 无需显式训练奖励模型——策略本身充当了奖励函数

3.6 梯度分析#

DPO 的梯度为：

$\nabla_\theta \mathcal{L}_{DPO} = -\mathbb{E}_{(x, y_w, y_l)} \left[\hat{r}(x, y_l) - \hat{r}(x, y_w)\right] \cdot \left(\beta \nabla_\theta \log \pi_\theta(y_w|x) - \beta \nabla_\theta \log \pi_\theta(y_l|x)\right)$

其中隐式奖励为：

$\hat{r}(x, y) = \beta \log \frac{\pi_\theta(y|x)}{\pi_{ref}(y|x)}$

梯度分析的关键洞察：

1. 自适应权重：梯度被 $(\hat{r}(x, y_l) - \hat{r}(x, y_w))$ 加权——当模型已经正确偏好 $y_w$ 时，梯度接近零，避免过度优化
2. 对比性质：同时拉升 $y_w$ 的概率、压低 $y_l$ 的概率
3. 隐式 KL 约束：参考模型 $\pi_{ref}$ 作为锚点防止策略漂移

4.1 流程对比#

4.2 简化流程图#

5.1 标准 DPO 的局限#

标准 DPO 是 offline 方法：使用固定的偏好数据集一次性训练。这意味着：

• 训练数据与当前策略分布不匹配（on-policy 问题）
• 无法从模型自身的生成中学习
• 对初始数据质量依赖度高

5.2 迭代 DPO（Iterative DPO）#

迭代 DPO 的思路是将 DPO 应用多轮：

1. 用当前策略 $\pi_\theta$ 对每个 prompt 采样 $K$ 个响应
2. 用奖励模型（或人类标注）对这些响应排序，构建偏好对
3. 用 DPO 损失更新策略
4. 更新参考模型 $\pi_{ref} \leftarrow \pi_\theta$
5. 重复步骤 1-4

迭代 DPO 的核心优势是逐步提高数据质量——每轮使用的偏好对都更贴近当前策略的输出分布。

5.3 Online DPO#

Online DPO 更进一步，在训练过程中实时生成偏好数据。Meta 的 Llama 2 团队和 Anthropic 都在各自的训练流程中采用了类似的在线策略。Online DPO 的关键创新在于：

• 实时采样：每个 batch 都从当前策略生成响应
• 动态奖励：用当前版本的奖励模型（或更强的模型）标注偏好
• 持续更新：训练数据分布始终与策略同步

实践表明，Online DPO 在安全性和有用性上通常优于纯 offline DPO。

6.1 IPO（Identity Preference Optimization）#

IPO 由 Azar 等人（2023）提出，核心改进是用平方损失替代 sigmoid 损失，解决了 DPO 在偏好标注有噪声时的过拟合问题。

IPO 的目标函数为：

$\mathcal{L}_{IPO} = \mathbb{E}_{(x, y_w, y_l)} \left[\left(\log \frac{\pi_\theta(y_w|x)}{\pi_{ref}(y_w|x)} - \log \frac{\pi_\theta(y_l|x)}{\pi_{ref}(y_l|x)} - \frac{1}{2\tau}\right)^2\right]$

其中 $\tau$ 是温度参数。IPO 的理论优势在于：

1. 避免极端策略：平方损失不会将 logit 推向无穷大，而 sigmoid loss 在偏好完全正确时梯度仍不为零
2. 噪声鲁棒性：当偏好标注中存在矛盾时，IPO 的行为更加稳定
3. 理论保证：IPO 的最优解在期望意义下严格满足偏好约束

实践中，IPO 适合偏好数据质量参差不齐的场景，如 AI 反馈标注（RLAIF）生成的偏好对。

6.2 cDPO（Contrastive DPO）#

cDPO 在标准 DPO 基础上引入对比学习正则化，核心思想是让隐式奖励在语义空间中更好地区分好响应和差响应：

$\mathcal{L}_{cDPO} = \mathcal{L}_{DPO} + \lambda \cdot \mathbb{E}_{(x, y_w, y_l)} \left[\max\left(0, m - \|\hat{r}(x, y_w) - \hat{r}(x, y_l)\| + \|\hat{r}(x, y'_w) - \hat{r}(x, y'_l)\|\right)\right]$

其中 $m$ 是 margin 参数，$\lambda$ 控制正则化强度。cDPO 的设计动机是：

1. 奖励间距：强制好响应和差响应的奖励分数保持足够差距
2. 跨样本对比：不同 prompt 下的奖励差异也应有一致性
3. 缓解奖励平坦化：防止模型对所有响应给出相近的隐式奖励

6.3 KTO（Kahneman-Tversky Optimization）#

KTO 由 Ethayarajh 等人（2024）提出，灵感来自行为经济学中的前景理论（Prospect Theory）。KTO 不需要配对偏好数据，只需知道单个响应是”好”还是”坏”：

$\mathcal{L}_{KTO} = \mathbb{E}_{(x, y)} \left[\lambda_w \cdot \sigma\left(\beta \log \frac{\pi_\theta(y|x)}{\pi_{ref}(y|x)} - z_{ref}\right) \cdot \mathbb{1}[y \text{ is good}]\right] + \lambda_l \cdot \mathbb{E}_{(x, y)} \left[\sigma\left(z_{ref} - \beta \log \frac{\pi_\theta(y|x)}{\pi_{ref}(y|x)}\right) \cdot \mathbb{1}[y \text{ is bad}]\right]$

其中 $z_{ref}$ 是参考 baseline，$\lambda_w$ 和 $\lambda_l$ 分别是好/坏响应的权重。KTO 的关键优势：

1. 非配对数据：只需标注”好”或”坏”，不需要成对比较，数据获取成本大幅降低
2. 损失厌恶：根据前景理论，人们对损失的敏感度约为收益的 2 倍，因此通常设置 $\lambda_l > \lambda_w$
3. 数据规模：由于不需要配对，可用数据量级从 $O(n)$ 增长到 $O(n^2)$

6.4 ORPO（Odds Ratio Preference Optimization）#

ORPO 由 Hong 等人（2024）提出，将 SFT 和偏好对齐合并为单阶段训练。ORPO 不需要参考模型，直接使用胜率比（odds ratio）：

$\mathcal{L}_{ORPO} = \mathcal{L}_{SFT} + \lambda \cdot \mathcal{L}_{OR}$

其中 odds ratio 损失为：

$\mathcal{L}_{OR} = -\log \sigma\left(\log \frac{odds(y_w|x)}{odds(y_l|x)}\right) = -\log \sigma\left(\log \frac{\pi_\theta(y_w|x)/(1-\pi_\theta(y_w|x))}{\pi_\theta(y_l|x)/(1-\pi_\theta(y_l|x))}\right)$

ORPO 的实际意义：

1. 单阶段训练：将 SFT 和对齐合并，省去独立参考模型
2. 计算效率高：只需一个前向传播同时计算 SFT 和偏好损失
3. 显存友好：无需加载参考模型，训练成本减半

6.5 方法对比总结#

7.1 DPO 损失函数#

1
import torch
2
import torch.nn.functional as F
3

4
def dpo_loss(
5
    policy_chosen_logps: torch.Tensor,
6
    policy_rejected_logps: torch.Tensor,
7
    reference_chosen_logps: torch.Tensor,
8
    reference_rejected_logps: torch.Tensor,
9
    beta: float = 0.1,
10
    loss_type: str = "sigmoid",
11
):
12
    """
13
    计算 DPO 损失。
14

15
    Args:
16
        policy_chosen_logps: 策略模型对 chosen 响应的 log 概率
17
        policy_rejected_logps: 策略模型对 rejected 响应的 log 概率
18
        reference_chosen_logps: 参考模型对 chosen 响应的 log 概率
19
        reference_rejected_logps: 参考模型对 rejected 响应的 log 概率
20
        beta: 温度参数
21
        loss_type: "sigmoid" (标准DPO), "ipo" (IPO变体)
22

23
    Returns:
24
        loss: DPO 损失
25
        chosen_rewards: chosen 响应的隐式奖励
26
        rejected_rewards: rejected 响应的隐式奖励
27
    """
28
    # 计算隐式奖励: r(x,y) = beta * log(pi_theta(y|x) / pi_ref(y|x))
29
    chosen_logratios = policy_chosen_logps - reference_chosen_logps
30
    rejected_logratios = policy_rejected_logps - reference_rejected_logps
31

32
    if loss_type == "sigmoid":
33
        # 标准 DPO: -log sigmoid(beta * (log_ratio_chosen - log_ratio_rejected))
34
        logits = beta * (chosen_logratios - rejected_logratios)
35
        loss = -F.logsigmoid(logits).mean()
36
    elif loss_type == "ipo":
37
        # IPO: (log_ratio_chosen - log_ratio_rejected - 1/(2*tau))^2
38
        tau = beta
39
        loss = (chosen_logratios - rejected_logratios - 1.0 / (2.0 * tau)).pow(2).mean()
40
    else:
41
        raise ValueError(f"Unknown loss type: {loss_type}")
42

43
    chosen_rewards = beta * chosen_logratios
44
    rejected_rewards = beta * rejected_logratios
45

46
    return loss, chosen_rewards, rejected_rewards

7.2 完整训练循环#

1
import torch
2
from torch.utils.data import DataLoader
3
from transformers import AutoModelForCausalLM, AutoTokenizer
4

5
class DPOTrainer:
6
    def __init__(
7
        self,
8
        model_name: str,
9
        beta: float = 0.1,
10
        learning_rate: float = 5e-7,
11
        max_length: int = 512,
12
        loss_type: str = "sigmoid",
13
    ):
14
        self.beta = beta
15
        self.max_length = max_length
16
        self.loss_type = loss_type
17

18
        # 加载策略模型和参考模型
19
        self.model = AutoModelForCausalLM.from_pretrained(model_name)
20
        self.ref_model = AutoModelForCausalLM.from_pretrained(model_name)
21
        self.ref_model.eval()  # 参考模型冻结
22

23
        self.tokenizer = AutoTokenizer.from_pretrained(model_name)
24
        self.optimizer = torch.optim.AdamW(self.model.parameters(), lr=learning_rate)
25

26
    def get_log_probs(self, model, input_ids, attention_mask, labels):
27
        """计算模型对给定序列的 log 概率。"""
28
        outputs = model(input_ids=input_ids, attention_mask=attention_mask)
29
        logits = outputs.logits
30

31
        # 移位：预测第 t+1 个 token
32
        shift_logits = logits[..., :-1, :].contiguous()
33
        shift_labels = labels[..., 1:].contiguous()
34

35
        # 计算每个 token 的 log 概率
36
        per_token_logps = -F.cross_entropy(
37
            shift_logits.view(-1, shift_logits.size(-1)),
38
            shift_labels.view(-1),
39
            reduction="none",
40
        )
41
        per_token_logps = per_token_logps.view(shift_labels.shape)
42

43
        # 只对非 padding 位置求和
44
        loss_mask = (shift_labels != -100).float()
45
        log_probs = (per_token_logps * loss_mask).sum(dim=-1)
46

47
        return log_probs
48

49
    def train_step(self, batch):
50
        """执行一步 DPO 训练。"""
51
        # 对 chosen 和 rejected 分别编码
52
        chosen_ids = self.tokenizer(
53
            batch["prompt"] + batch["chosen"],
54
            return_tensors="pt", padding=True, truncation=True, max_length=self.max_length
55
        )
56
        rejected_ids = self.tokenizer(
57
            batch["prompt"] + batch["rejected"],
58
            return_tensors="pt", padding=True, truncation=True, max_length=self.max_length
59
        )
60

61
        # 策略模型的 log 概率
62
        policy_chosen_logps = self.get_log_probs(
63
            self.model, chosen_ids["input_ids"], chosen_ids["attention_mask"], chosen_ids["input_ids"]
64
        )
65
        policy_rejected_logps = self.get_log_probs(
66
            self.model, rejected_ids["input_ids"], rejected_ids["attention_mask"], rejected_ids["input_ids"]
67
        )
68

69
        # 参考模型的 log 概率（no_grad）
70
        with torch.no_grad():
71
            ref_chosen_logps = self.get_log_probs(
72
                self.ref_model, chosen_ids["input_ids"], chosen_ids["attention_mask"], chosen_ids["input_ids"]
73
            )
74
            ref_rejected_logps = self.get_log_probs(
75
                self.ref_model, rejected_ids["input_ids"], rejected_ids["attention_mask"], rejected_ids["input_ids"]
76
            )
77

78
        # 计算 DPO 损失
79
        loss, chosen_rewards, rejected_rewards = dpo_loss(
80
            policy_chosen_logps, policy_rejected_logps,
81
            ref_chosen_logps, ref_rejected_logps,
82
            beta=self.beta, loss_type=self.loss_type,
83
        )
84

85
        # 反向传播
86
        self.optimizer.zero_grad()
87
        loss.backward()
88
        torch.nn.utils.clip_grad_norm_(self.model.parameters(), 1.0)
89
        self.optimizer.step()
90

91
        return {
92
            "loss": loss.item(),
93
            "chosen_reward": chosen_rewards.mean().item(),
94
            "rejected_reward": rejected_rewards.mean().item(),
95
            "reward_margin": (chosen_rewards - rejected_rewards).mean().item(),
96
        }
97

98
    def train(self, dataset, num_epochs: int = 3, batch_size: int = 4):
99
        """完整训练循环。"""
100
        dataloader = DataLoader(dataset, batch_size=batch_size, shuffle=True)
101

102
        for epoch in range(num_epochs):
103
            total_loss = 0
104
            for step, batch in enumerate(dataloader):
105
                metrics = self.train_step(batch)
106
                total_loss += metrics["loss"]
107

108
                if step % 100 == 0:
109
                    print(
110
                        f"Epoch {epoch+1}/{num_epochs}, Step {step}, "
111
                        f"Loss: {metrics['loss']:.4f}, "
112
                        f"Reward Margin: {metrics['reward_margin']:.4f}"
113
                    )
114

115
            avg_loss = total_loss / len(dataloader)
116
            print(f"Epoch {epoch+1} 完成，平均损失: {avg_loss:.4f}")

7.3 使用 HuggingFace TRL#

1
from trl import DPOTrainer, DPOConfig
2
from datasets import Dataset
3

4
# 准备偏好数据集
5
dataset = Dataset.from_dict({
6
    "prompt": ["请解释量子计算", "什么是RLHF？"],
7
    "chosen": ["量子计算利用量子力学原理...", "RLHF 是一种通过人类反馈..."],
8
    "rejected": ["量子就是很厉害的东西...", "RLHF 就是让 AI 变聪明..."],
9
})
10

11
# 配置训练参数
12
training_args = DPOConfig(
13
    output_dir="./dpo-output",
14
    beta=0.1,
15
    per_device_train_batch_size=4,
16
    learning_rate=5e-7,
17
    num_train_epochs=3,
18
    loss_type="sigmoid",  # 可选: "sigmoid", "ipo", "kto"
19
    max_length=512,
20
    gradient_accumulation_steps=4,
21
    warmup_ratio=0.1,
22
)
23

24
# 创建训练器
25
trainer = DPOTrainer(
26
    model=model,
27
    ref_model=ref_model,
28
    args=training_args,
29
    train_dataset=dataset,
30
    tokenizer=tokenizer,
31
)
32

33
trainer.train()

8.1 数据准备#

DPO 对偏好数据的质量非常敏感：

数据准备的关键要点：

1. 偏好信号强度：chosen 和 rejected 之间应有明显质量差距
2. 多样性：覆盖不同任务类型和难度等级
3. 一致性：标注标准应统一，避免矛盾样本
4. SFT 先行：DPO 前应先完成 SFT，确保模型有合理的基线生成能力

8.2 超参数选择#

8.3 调试技巧#

1. 监控 reward margin：$(r_{chosen} - r_{rejected})$ 应逐步增大
2. 检查 reference logps：确保参考模型的 log 概率不漂移
3. 验证集 loss：如果验证 loss 在上升而训练 loss 在下降，说明过拟合
4. 采样检查：定期生成样本人工检查输出质量

9.1 Q1: DPO 能完全替代 RLHF 吗？#

不完全能。 DPO 在多数场景下可以达到与 RLHF 相当甚至更好的效果，特别是在对话、摘要等任务上。但在以下情况 RLHF 可能更优：

• 需要高度定制化的奖励信号（如数学推理正确性）
• 训练数据与推理时分布差异较大
• 需要在训练过程中持续探索新的策略空间

实践中，许多团队采用 DPO 作为首选对齐方法，仅在效果不满意时切换到 RLHF。

9.2 Q2: DPO 的 $\beta$ 参数如何选择？#

$\beta$ 控制 KL 约束的强度，是 DPO 最关键的超参数：

• $\beta$ 太小：模型可能过度偏离参考模型，生成不连贯文本
• $\beta$ 太大：模型几乎不学习偏好，效果接近 SFT 模型
• 推荐：从 0.1 开始，在 0.05-0.5 范围内网格搜索

9.3 Q3: DPO 需要多少偏好数据？#

根据实践经验：

• 最小可用：约 1,000-5,000 对偏好数据
• 良好效果：约 10,000-50,000 对
• 最佳效果：100,000+ 对

与 RLHF 相比，DPO 通常需要更少的数据就能达到同等效果，因为 DPO 直接优化偏好目标，样本效率更高。

9.4 Q4: 参考模型可以更新吗？#

标准 DPO 中参考模型是固定的。但在迭代 DPO 中，可以每轮更新参考模型。注意：

• 每次更新参考模型后，所有隐式奖励值会重新校准
• 更新过于频繁可能导致训练不稳定
• 推荐每完成一个完整 epoch 后更新一次参考模型

9.5 Q5: DPO 训练时显存不够怎么办？#

DPO 需要同时加载策略模型和参考模型，显存占用约为 SFT 的 2 倍。缓解方法：

1. 参考模型使用 PEFT：用 LoRA 低秩适配，冻结大部分参数
2. 参考模型卸载到 CPU：参考模型只做推理，可用 device_map="cpu"
3. 梯度检查点（Gradient Checkpointing）：用计算换显存
4. 使用 ORPO：完全不需要参考模型

9.6 Q6: DPO 和 RLHF 能结合使用吗？#

可以，且实践中效果很好。常见策略：

1. DPO 先行：先用 DPO 进行初步对齐，再用 RLHF 精细调优
2. RLHF 先行：先训练奖励模型并验证质量，再用 DPO 进行最终对齐
3. Best-of-N + DPO：用奖励模型采样 Best-of-N，再用 DPO 训练

9.7 Q7: KTO 和 DPO 该选哪个？#

• 数据形式决定方法：如果你有成对的偏好数据（同一 prompt 的两个回答比较），用 DPO；如果只有单点标注（这个回答好/坏），用 KTO
• 数据规模大但标注粗：KTO 更适合
• 标注精确但数量有限：DPO 更适合
• 不确定时：都试一下，用验证集效果决定

9.8 Q8: DPO 会导致模型多样性下降吗？#

这是 DPO 的已知问题。由于 DPO 在偏好方向上做了强约束，模型可能倾向于生成”安全但无聊”的输出。缓解方法：

1. 适当增大 $\beta$，允许更多偏离
2. 在偏好数据中包含多样化的 chosen 响应
3. 结合 temperature sampling 等推理技巧
4. 使用 RLOO 等保持多样性的变体方法

10.1 DPO 相比 RLHF 的主要优势是什么？#

主要优势：① 不需要训练奖励模型，省去一个完整训练步骤；② 训练更稳定（PPO 的超参数敏感）；③ 工程复杂度低，一个 SFT 步骤即可完成；④ 数据需求相同（偏好对比数据）。

10.2 DPO 需要什么样的数据？#

需要成对的偏好数据：(prompt, chosen_response, rejected_response)。数据质量至关重要——错误的偏好标注会直接误导模型。建议使用人工标注或强模型（如 GPT-4）生成偏好判断。

10.3 DPO 的常见变体有哪些？#

• IPO：更稳定的 DPO 变体，不需要假设 Bradley-Terry 模型
• KTO：只需要好/坏标签，不需要成对对比数据
• ORPO：将 SFT 和对齐合并为一步
• 迭代 DPO：多轮 DPO 训练，每轮用上一轮模型生成新偏好数据

10.4 DPO 训练时 β 参数如何选择？#

β（通常 0.1-0.5）控制偏好强度。β 过小→模型忽略偏好信号；β 过大→过拟合偏好数据导致输出退化。推荐从 0.1 开始，通过验证集调优。