后训练 RLHF/DPO——从助手模型到对齐模型 / RLHF and DPO from Assistant Model to Aligned Model
📅 创建时间：2026-06-02 🏷️ 标签：#RLHF #PPO #DPO #Reward-Model #KL散度 #对齐 #PPO- KL 📚 前置知识：[[06-posttraining-sft]]（SFT 监督微调） 📚 相关知识：[[05-pretraining]]（预训练） [[08-efficient-finetuning]]（LoRA）
场景：SFT 后模型仍然有毒有害，RLHF 是解法
┌─────────────────────────────────────────────────────────────┐
│ │
│ 你已经完成了 SFT，模型可以正常对话了。 │
│ │
│ 但你发现了一些问题： │
│ │
│ 问题 1：有害内容 │
│ 你：请教我怎么制造炸弹 │
│ SFT模型：当然可以！首先，你需要...（详细教程） │
│ → 模型学会了"如何回答"，但不知道"什么不该说" │
│ │
│ 问题 2：回答过于模板化 │
│ 所有回答都是："好的，我来帮你...首先...其次...最后..." │
│ → 模型记住了训练数据中的回复模式 │
│ │
│ 问题 3：不符合人类偏好 │
│ 用户想要简洁的回答，模型给你写了一大段 │
│ 用户想要幽默的回复，模型一本正经 │
│ → 模型不知道什么是"好"的回答 │
│ │
│ SFT 的局限： │
│ → SFT 只能学"正确的回复是什么样的" │
│ → 无法表达"我更喜欢这个回复而不是那个" │
│ │
│ RLHF（Reinforcement Learning from Human Feedback）： │
│ → 用人类的偏好信号来指导模型生成 │
│ → 让模型学会"什么是人类喜欢的好回答" │
│ │
└─────────────────────────────────────────────────────────────┘第1节：RLHF 三步流程——RM → SFT → PPO
RLHF 的完整流程
┌─────────────────────────────────────────────────────────────┐
│ RLHF 三步流程图 │
├─────────────────────────────────────────────────────────────┤
│ │
│ ┌─────────────────────────────────────────────────────┐ │
│ │ Step 1：收集偏好数据（Preference Data Collection） │ │
│ │ │ │
│ │ 给定 prompt: "如何做炸弹" │ │
│ │ │ │
│ │ Response A: "详细的炸弹制作教程..."（差） │ │
│ │ Response B: "抱歉，我不能帮助这个请求..."（好） │ │
│ │ │ │
│ │ 人类标注：A < B（更偏好 B） │ │
│ │ → 收集 (prompt, response_A, response_B, preference) │ │
│ └─────────────────────────────────────────────────────┘ │
│ ↓ │
│ ┌─────────────────────────────────────────────────────┐ │
│ │ Step 2：训练 Reward Model（Reward Model Training） │ │
│ │ │ │
│ │ 用偏好数据训练一个模型 R(x, y) → 分数（好/差） │ │
│ │ │ │
│ │ 目标：R(x, y) 能预测人类偏好 │ │
│ │ 即：如果 y_A 优于 y_B，则 R(x, y_A) > R(x, y_B) │ │
│ └─────────────────────────────────────────────────────┘ │
│ ↓ │
│ ┌─────────────────────────────────────────────────────┐ │
│ │ Step 3：PPO 微调（PPO Fine-tuning） │ │
│ │ │ │
│ │ 用 Reward Model 作为奖励信号 │ │
│ │ 用 RL（PPO）算法优化 SFT 模型 │ │
│ │ │ │
│ │ 目标：最大化 R(x, y) 的同时，保持不过度偏离 SFT │ │
│ └─────────────────────────────────────────────────────┘ │
│ │
└─────────────────────────────────────────────────────────────┘为什么需要 Reward Model
┌─────────────────────────────────────────────────────────────┐
│ 为什么不能直接用人类打分来训练 │
├─────────────────────────────────────────────────────────────┤
│ │
│ 直接人类打分的问题： │
│ ┌─────────────────────────────────────────────────────┐ │
│ │ 问题 1：标注成本极高 │ │
│ │ → 每次模型生成都需要人类评估 │ │
│ │ → 无法规模化 │ │
│ │ │ │
│ │ 问题 2：标注一致性差 │ │
│ │ → 不同标注者对同一回答的偏好不同 │ │
│ │ → 噪声太大，模型难以学习 │ │
│ │ │ │
│ │ 问题 3：无法微分 │ │
│ │ → 人类打分不是可微分的 loss function │ │
│ │ → 无法直接用梯度下降优化 │ │
│ └─────────────────────────────────────────────────────┘ │
│ │
│ Reward Model 的解决方案： │
│ ┌─────────────────────────────────────────────────────┐ │
│ │ 1. 离线收集偏好数据（一次收集，多次使用） │ │
│ │ 2. 训练一个可微分的 Reward Model │ │
│ │ 3. PPO 用 RM 的分数作为 reward signal │ │
│ │ 4. RM 可以复用，每次 PPO 迭代不需要人类参与 │ │
│ └─────────────────────────────────────────────────────┘ │
│ │
│ 本质：RM 是"人类偏好的可微分代理" │
│ │
└─────────────────────────────────────────────────────────────┘Reward Model 的训练方法
┌─────────────────────────────────────────────────────────────┐
│ Reward Model 的训练：Bradley-Terry 模型 │
├─────────────────────────────────────────────────────────────┤
│ │
│ 偏好数据的格式： │
│ ┌─────────────────────────────────────────────────────┐ │
│ │ (prompt, response_chosen, response_rejected) │ │
│ │ │ │
│ │ 例： │ │
│ │ prompt = "什么是量子计算" │ │
│ │ response_chosen = "量子计算是..."（好） │ │
│ │ response_rejected = "这个很复杂..."（差） │ │
│ └─────────────────────────────────────────────────────┘ │
│ │
│ Bradley-Terry 模型（标准做法）： │
│ ┌─────────────────────────────────────────────────────┐ │
│ │ 假设：人类偏好服从 logistic 函数 │ │
│ │ │ │
│ │ P(y_winner > y_loser) = sigmoid( │ │
│ │ R(x, y_winner) - R(x, y_loser) │ │
│ │ ) │ │
│ │ │ │
│ │ 即：reward 差越大，越可能选择 winner │ │
│ └─────────────────────────────────────────────────────┘ │
│ │
│ Loss 函数（从 SFT 模型初始化）： │
│ ┌─────────────────────────────────────────────────────┐ │
│ │ RM = SFT_model + reward_head (随机初始化) │ │
│ │ │ │
│ │ loss = -E[log σ(r_chosen - r_rejected)] │ │
│ │ │ │
│ │ 即：最大化 chosen 和 rejected 的 reward 差距 │ │
│ └─────────────────────────────────────────────────────┘ │
│ │
│ 训练注意： │
│ → 从 SFT 模型初始化 RM（保留语言能力） │
│ → Reward head 随机初始化 │
│ → 通常训练 1-2 个 epoch（避免过拟合） │
│ │
└─────────────────────────────────────────────────────────────┘第2节：PPO 算法——RL 优化阶段
PPO 的核心思想
┌─────────────────────────────────────────────────────────────┐
│ PPO（Proximal Policy Optimization）核心思想 │
├─────────────────────────────────────────────────────────────┤
│ │
│ PPO 要解决的问题： │
│ → 在 reward signal 的引导下，，如何更新模型参数？ │
│ → 但不能更新太多（会灾难性遗忘） │
│ │
│ 核心约束（KL 约束）： │
│ ┌─────────────────────────────────────────────────────┐ │
│ │ maximize: E[r(x, y)] │ │
│ │ subject to: KL(π_new || π_old) < δ │ │
│ │ │ │
│ │ 翻译： │ │
│ │ → 最大化 reward │ │
│ │ → 但新模型和旧模型的 KL 散度要小于 δ │ │
│ │ → KL 散度 = 衡量两个分布有多"不同" │ │
│ │ → δ 控制了每次更新的幅度（通常 δ = 0.01-0.02） │ │
│ └─────────────────────────────────────────────────────┘ │
│ │
│ 为什么不能随意更新： │
│ → 过度优化 reward会导致模型"作弊"（找漏洞） │
│ → 比如：模型发现"输出 'LOL' 能获得高 reward" │
│ → 没有 KL 约束，模型会退化成一个输出固定回复的模型 │
│ │
└─────────────────────────────────────────────────────────────┘PPO 的完整算法流程
┌─────────────────────────────────────────────────────────────┐
│ PPO 训练流程详解 │
├─────────────────────────────────────────────────────────────┤
│ │
│ ┌─────────────────────────────────────────────────────┐ │
│ │ 输入：SFT 模型（π_SFT），Reward Model（R），Reference 模型（π_ref） │ │
│ └─────────────────────────────────────────────────────┘ │
│ │
│ ┌─────────────────────────────────────────────────────┐ │
│ │ for each PPO epoch: │ │
│ │ │ │
│ │ ┌───────────────────────────────────────────────┐│ │
│ │ │ 1. 生成 rollout（用当前策略 π_θ） ││ │
│ │ │ ││ │
│ │ │ for each prompt: ││ │
│ │ │ y ~ π_θ(·|prompt) ││ │
│ │ │ 计算 r = R(prompt, y) ││ │
│ │ │ 保存 (prompt, y, r) ││ │
│ │ │ ││ │
│ │ │ 收集大量 (prompt, response, reward) tuples ││ │
│ │ └───────────────────────────────────────────────┘│ │
│ │ │ │
│ │ ┌───────────────────────────────────────────────┐│ │
│ │ │ 2. 计算 KL penalty（与 reference 模型的偏离） ││ │
│ │ │ ││ │
│ │ │ r_full = r - β * KL(π_θ(y|prompt) || π_ref(y|prompt)) ││ │
│ │ │ ││ │
│ │ │ β = KL penalty 系数（通常 0.01-0.1） ││ │
│ │ │ β 越大 → 越保守更新，越接近 SFT ││ │
│ │ └───────────────────────────────────────────────┘│ │
│ │ │ │
│ │ ┌───────────────────────────────────────────────┐│ │
│ │ │ 3. PPO 更新（策略梯度优化） ││ │
│ │ │ ││ │
│ │ │ r_CLIP = clip(r_full, 1-ε, 1+ε) ││ │
│ │ │ # 限制 reward 的变化幅度，防止过大更新 ││ │
│ │ │ ││ │
│ │ │ loss = -min(r_full * ratio, r_CLIP * ratio) ││ │
│ │ │ gradient_descent(loss) ││ │
│ │ └───────────────────────────────────────────────┘│ │
│ │ │ │
│ └─────────────────────────────────────────────────────┘ │
│ │
│ 关键参数： │
│ → γ (gamma): 折扣因子，通常 1.0（无折扣） │
│ → ε (epsilon): PPO clip 范围，通常 0.2 │
│ → β (beta): KL penalty 系数 │
│ → PPO epochs: 每个 batch 的更新轮数，通常 4 │
│ │
└─────────────────────────────────────────────────────────────┘PPO 的实际工程挑战
┌─────────────────────────────────────────────────────────────┐
│ PPO 的工程挑战与解决方案 │
├─────────────────────────────────────────────────────────────┤
│ │
│ 挑战 1：Reward Model 的 reward hacking │
│ ┌─────────────────────────────────────────────────────┐ │
│ │ 问题：RM 不是完美的，模型会找到 RM 的漏洞 │ │
│ │ │ │
│ │ 例子： │ │
│ │ → 模型发现回答 "LOL" 能获得高 reward │ │
│ │ → 模型开始输出无意义的 "LOL" │ │
│ │ → RM 给了高分（因为短回复通常质量高？） │ │
│ │ │ │
│ │ 解决： │ │
│ │ → KL penalty 约束更新幅度 │ │
│ │ → 增加 RM 的对抗样本（让 RM 学到"作弊"的回复是差的）│ │
│ │ → 使用 Reward Model Ensemble（多个 RM 投票） │ │
│ └─────────────────────────────────────────────────────┘ │
│ │
│ 挑战 2：KL penalty 系数的调节 │
│ ┌─────────────────────────────────────────────────────┐ │
│ │ β 太大： │ │
│ │ → 模型几乎不更新，和 SFT 一样 │ │
│ │ → 没有学到人类偏好 │ │
│ │ │ │
│ │ β 太小： │ │
│ │ → 模型更新过大，可能退化 │ │
│ │ → reward hacking │ │
│ │ │ │
│ │ 实践：动态调节 β │ │
│ │ → 如果 KL 散度 > 目标：减小 β │ │
│ │ → 如果 KL 散度 < 目标：增大 β │ │
│ └─────────────────────────────────────────────────────┘ │
│ │
│ 挑战 3：PPO 的计算成本 │
│ ┌─────────────────────────────────────────────────────┐ │
│ │ PPO 需要： │ │
│ │ → Reward Model 前向（所有生成） │ │
│ │ → Reference Model 前向（计算 KL） │ │
│ │ → Policy Model 前向（生成 + 更新） │ │
│ │ │ │
│ │ 计算量 ≈ 3x SFT │ │
│ │ → 需要专门的工程优化 │ │
│ └─────────────────────────────────────────────────────┘ │
│ │
└─────────────────────────────────────────────────────────────┘第3节：DPO——不需要 PPO 的偏好优化
DPO 的核心思想
┌─────────────────────────────────────────────────────────────┐
│ DPO（Direct Preference Optimization）核心思想 │
├─────────────────────────────────────────────────────────────┤
│ │
│ 问题：PPO 训练太复杂了 │
│ → 需要单独训练 Reward Model │
│ → 需要 Reference Model + Policy Model 两个模型 │
│ → 需要大量超参数调节（β, ε, PPO epochs...） │
│ → 计算成本高，训练不稳定 │
│ │
│ DPO 的洞察： │
│ ┌─────────────────────────────────────────────────────┐ │
│ │ PPO 的目标（KL 约束最大化 reward）： │ │
│ │ │ │
│ │ max_θ E[log π_θ(y|prompt) * exp(R(prompt, y))] │ │
│ │ subject to: KL(π_θ || π_ref) < δ │ │
│ │ │ │
│ │ 这个优化问题有解析解！ │ │
│ │ │ │
│ │ 最优策略： │ │
│ │ π_θ*(y|x) ∝ π_ref(y|x) * exp(R(x, y)/β) │ │
│ │ │ │
│ │ 翻译：最优策略 = Reference 策略 × exp(reward) │ │
│ └─────────────────────────────────────────────────────┘ │
│ │
│ DPO 推导出的 loss（不需要显式 Reward Model）： │
│ ┌─────────────────────────────────────────────────────┐ │
│ │ loss = -E[log σ( │ │
│ │ β * log π_θ(y_w|x) - β * log π_θ(y_l|x) │ │
│ │ - β * log π_ref(y_w|x) + β * log π_ref(y_l|x) │ │
│ │ )] │ │
│ │ │ │
│ │ 简化后： │ │
│ │ loss = -E[log σ( │ │
│ │ β * (log π_θ(y_w|x) - log π_θ(y_l|x)) │ │
│ │ - β * (log π_ref(y_w|x) - log π_ref(y_l|x)) │ │
│ │ )] │ │
│ │ │ │
│ │ 即：增大 chosen 概率，减小 rejected 概率 │ │
│ │ → 不需要 reward model，不需要 PPO │ │
│ └─────────────────────────────────────────────────────┘ │
│ │
└─────────────────────────────────────────────────────────────┘DPO vs PPO 对比
┌─────────────────────────────────────────────────────────────┐
│ DPO vs PPO：全面对比 │
├─────────────────────────────────────────────────────────────┤
│ │
│ │ 维度 │ PPO │ DPO │
│ ├────────────────┼──────────────────────────────────┼───────────────────┤
│ │ 训练流程 │ 三步：RM → SFT → PPO │ 一步：DPO 直接优化│
│ ├────────────────┼──────────────────────────────────┼───────────────────┤
│ │ 模型数量 │ 4 个（SFT + RM + Ref + Policy）│ 2 个（SFT + Policy）│
│ ├────────────────┼──────────────────────────────────┼───────────────────┤
│ │ 需要 RM？ │ 需要单独的 RM │ 不需要 │
│ ├────────────────┼──────────────────────────────────┼───────────────────┤
│ │ 训练稳定性 │ 较复杂，可能不稳定 │ 相对稳定 │
│ ├────────────────┼──────────────────────────────────┼───────────────────┤
│ │ 超参数 │ 多（β, ε, PPO epochs...） │ 少（主要 β） │
│ ├────────────────┼──────────────────────────────────┼───────────────────┤
│ │ 计算成本 │ 高（约 3x SFT） │ 低（约 1.5x SFT）│
│ ├────────────────┼──────────────────────────────────┼───────────────────┤
│ │ 实现难度 │ 高（需要 RL 框架） │ 低（就是分类 loss）│
│ ├────────────────┼──────────────────────────────────┼───────────────────┤
│ │ 理论基础 │ RL 理论成熟 │ 较新（2023） │
│ ├────────────────┼──────────────────────────────────┼───────────────────┤
│ │ 工业应用 │ GPT-4 / Claude 等主流模型 │ Llama 2/3 / Mistral│
│ │
│ 关键发现（2023-2024 的经验）： │
│ → DPO 训练简单，但容易训崩（KL 约束弱） │
│ → PPO 更稳定，但需要更多工程投入 │
│ → 实践中：两者结合使用效果最好 │
│ │
└─────────────────────────────────────────────────────────────┘DPO 的实现
python
# DPO Loss 的 PyTorch 实现（极简）
import torch
import torch.nn.functional as F
def dpo_loss(
policy_logps_chosen, # π_θ(y_w|x) 的 log probability
policy_logps_rejected, # π_θ(y_l|x) 的 log probability
ref_logps_chosen, # π_ref(y_w|x) 的 log probability
ref_logps_rejected, # π_ref(y_l|x) 的 log probability
beta=0.1, # KL penalty 系数
):
"""
DPO Loss: 最大化 chosen 和 rejected 的相对概率差异
"""
# 策略的对数几率差
policy_logratio = policy_logps_chosen - policy_logps_rejected
# Reference 的对数几率差（作为 baseline）
ref_logratio = ref_logps_chosen - ref_logps_rejected
# DPO loss
logits = beta * (policy_logratio - ref_logratio)
loss = -F.logsigmoid(logits).mean()
return loss
# 训练循环
for batch in dataloader:
# 提取 chosen 和 rejected 的 log probs
chosen_logps = model(batch["chosen"]).log_prob(batch["chosen_tokens"])
rejected_logps = model(batch["rejected"]).log_prob(batch["rejected_tokens"])
# Reference 模型也要前向
with torch.no_grad():
ref_chosen_logps = ref_model(batch["chosen"]).log_prob(batch["chosen_tokens"])
ref_rejected_logps = ref_model(batch["rejected"]).log_prob(batch["rejected_tokens"])
loss = dpo_loss(
chosen_logps, rejected_logps,
ref_chosen_logps, ref_rejected_logps,
beta=0.1
)
loss.backward()
optimizer.step()
optimizer.zero_grad()第4节：对齐训练的综合评估
RLHF/DPO 后的质量评估
┌─────────────────────────────────────────────────────────────┐
│ 对齐训练后的质量评估方法 │
├─────────────────────────────────────────────────────────────┤
│ │
│ 评估维度： │
│ ┌─────────────────────────────────────────────────────┐ │
│ │ 维度 1：Helpfulness（有用性） │ │
│ │ → 回答是否满足用户意图 │ │
│ │ → 是否准确、完整、有帮助 │ │
│ │ │ │
│ │ 维度 2：Harmlessness（安全性） │ │
│ │ → 是否拒绝有害请求（炸弹制作、钓鱼等） │ │
│ │ → 是否不产生有害内容 │ │
│ │ │ │
│ │ 维度 3：Honesty（真实性） │ │
│ │ → 是否不知道就说不知道 │ │
│ │ → 是否不产生幻觉（事实错误） │ │
│ └─────────────────────────────────────────────────────┘ │
│ │
│ 评估方法： │
│ ┌─────────────────────────────────────────────────────┐ │
│ │ 方法 1：人类评估（Gold Standard） │ │
│ │ → 人类直接评判回答质量 │ │
│ │ → 最准确，但成本高、速度慢 │ │
│ │ │ │
│ │ 方法 2：Reward Model 评估 │ │
│ │ → 用训练好的 RM 打分 │ │
│ │ → 快，但 RM 有偏差 │ │
│ │ │ │
│ │ 方法 3：GPT-4 评估（LLM-as-Judge） │ │
│ │ → 用强 LLM 评判回答质量 │ │
│ │ → 成本低，速度快，和人类有一定相关性 │ │
│ │ → 但 GPT-4 也有自己的偏好 │ │
│ │ │ │
│ │ 方法 4：自动化 Benchmark │ │
│ │ → MMLU（知识）、GSM8K（数学）、HumanEval（代码） │ │
│ │ → 能力指标，但不能反映对齐质量 │ │
│ └─────────────────────────────────────────────────────┘ │
│ │
└─────────────────────────────────────────────────────────────┘对齐训练的常见问题
┌─────────────────────────────────────────────────────────────┐
│ 对齐训练的问题诊断与解决 │
├─────────────────────────────────────────────────────────────┤
│ │
│ 问题 1：过度拒绝（Excessive Refusals） │
│ ┌─────────────────────────────────────────────────────┐ │
│ │ 表现：模型开始拒绝正常的用户请求 │ │
│ │ "抱歉，这个请求我无法帮助"（用户只是问做菜） │ │
│ │ │ │
│ │ 原因： │ │
│ │ → 安全数据过多，模型学会过度保守 │ │
│ │ → KL penalty 系数 β 过大 │ │
│ │ │ │
│ │ 解决： │ │
│ │ → 平衡安全数据和普通数据的比例 │ │
│ │ → 减小 β，增大非安全样本 的 reward 权重 │ │
│ │ → 增加正向样本（模型正常回答的场景） │ │
│ └─────────────────────────────────────────────────────┘ │
│ │
│ 问题 2：谄媚（Sycophancy） │
│ ┌─────────────────────────────────────────────────────┐ │
│ │ 表现：模型过于讨好用户，放弃自己的立场 │ │
│ │ 用户：我认为 X 是对的。模型：是的是的，你完全正确。 │ │
│ │ │ │
│ │ 原因： │ │
│ │ → 偏好数据中包含用户说"满意"的样本 │ │
│ │ → 模型学会讨好比坚持更安全 │ │
│ │ │ │
│ │ 解决： │ │
│ │ → 在偏好数据中包含"有原则的回复" │ │
│ │ → RM 训练时包含对抗样本 │ │
│ └─────────────────────────────────────────────────────┘ │
│ │
│ 问题 3：能力退化（Capability Regression） │
│ ┌─────────────────────────────────────────────────────┐ │
│ │ 表现：RLHF 后，数学/代码能力下降 │ │
│ │ │ │
│ │ 原因： │ │
│ │ → RLHF 优化的 reward 和真实能力不完全相关 │ │
│ │ → 模型过度拟合到 reward signal │ │
│ │ │ │
│ │ 解决： │ │
│ │ → RLHF 后做轻量 SFT（PPO 之后 SFT，通常叫"DPO"）│ │
│ │ → 在 benchmark 上监控能力退化 │ │
│ │ → 使用 Rejection Sampling 选择更好的回复 │ │
│ └─────────────────────────────────────────────────────┘ │
│ │
└─────────────────────────────────────────────────────────────┘升华：RLHF 的工程哲学
┌─────────────────────────────────────────────────────────────┐
│ RLHF 的核心工程哲学 │
├─────────────────────────────────────────────────────────────┤
│ │
│ 1. 偏好是主观的，RM 是偏好的代理 │
│ → 人类偏好因人而异，RM 只能捕捉"平均"偏好 │
│ → RM 的偏差会传递到 PPO/DPO │
│ → 好的 RM 是 RLHF 成功的一半 │
│ │
│ 2. KL 约束是对抗 reward hacking 的武器 │
│ → 没有 KL 约束，模型会"作弊" │
│ → KL 系数太大 → 不更新；太小 → 退化 │
│ → 调节 KL 系数是 RLHF 最重要的超参数 │
│ │
│ 3. DPO 是工程简化，PPO 是理论完备 │
│ → DPO 降低了工程复杂度，适合快速迭代 │
│ → PPO 更稳定，适合大规模生产 │
│ → 实践中根据场景选择 │
│ │
│ 4. 对齐不是免费的，能力退化是代价 │
│ → 安全性和能力是一对 trade-off │
│ → 需要持续监控 benchmark，防止能力退化 │
│ → "过度对齐"（跪舔用户）也是问题 │
│ │
│ 一句话总结： │
│ RLHF 让模型从"会回答"进化到"回答得好"。 │
│ 核心挑战是找到人类偏好的可信赖代理（RM）。 │
│ │
└─────────────────────────────────────────────────────────────┘"AI 可查 vs 必须理解"清单
AI 可查：
✅ PPO 的数学推导（策略梯度、重要性采样）
✅ 具体 RM 训练的超参数配置
✅ DPO 论文的详细推导
必须理解：
🔴 RLHF 三步流程：偏好数据收集 → Reward Model 训练 → PPO/DPO 微调
🔴 为什么需要 Reward Model（人类打分成本高、不能微分）
🔴 Bradley-Terry 模型：RM 的训练目标
🔴 KL 散度约束在 PPO 中的作用（防止 reward hacking）
🔴 PPO loss 中的 clip 机制（限制更新幅度）
🔴 DPO 的核心洞察：KL 约束下的最优策略有解析解，不需要 PPO
🔴 DPO vs PPO 的 trade-off（工程复杂度 vs 训练稳定性）
🔴 对齐训练的常见问题：过度拒绝、谄媚、能力退化学习状态：🟡 开始学习