偏好对齐全链路：RLHF → DPO → SimPO → GRPO

更新日期：2026-04-26

---

一、对齐方法演进

flowchart LR
    sft["SFT<br/>(监督模仿)"]
    rlhf["RLHF<br/>2022<br/>policy+ref+RM+value"]
    rlaif["RLAIF<br/>2022<br/>AI 标注"]
    dpo["DPO<br/>2023<br/>2-model 闭式"]
    ipo["IPO<br/>2023<br/>正则"]
    kto["KTO<br/>2024<br/>二元标签"]
    simpo["SimPO<br/>2024<br/>无 ref_model"]
    orpo["ORPO<br/>2024<br/>SFT+pref 一阶段"]
    grpo["GRPO<br/>2024<br/>在线 + 组归一"]
    rlvr["RLVR<br/>2025<br/>验证器 reward"]

    sft --> rlhf --> dpo
    rlhf --> rlaif
    dpo --> ipo
    dpo --> kto
    dpo --> simpo
    dpo --> orpo
    rlhf --> grpo --> rlvr

    classDef stage fill:#fff,stroke:#cc785c,color:#1a1a1a;
    class sft,rlhf,rlaif,dpo,ipo,kto,simpo,orpo,grpo,rlvr stage

方法	年份	核心改进	为什么需要	实践建议	论文
RLHF	2022	人类偏好 → RM → PPO	SFT 只能模仿数据分布，无法学"好坏"偏好	仍是理论基线；除非有丰富 RL 工程经验 + 大量 GPU，否则优先 DPO	InstructGPT
RLAIF	2022	AI 反馈替代人类反馈	人类标注成本高（$1-3/条）、慢、一致性差；AI judge 成本降低 10-100×	Claude / GPT-4 级模型做标注时，详细 rubric + 5% 人工抽检	Constitutional AI
DPO	2023	直接从偏好优化，跳过 RM	RLHF 需 4 模型（policy/ref/RM/value），显存 4× SFT；DPO 只 2 模型	小团队首选；β=0.1 稳健起点；ref_model 必须冻结	DPO
IPO	2023	解决 DPO 过拟合	DPO 在偏好数据少 / 噪声大时把 chosen 概率推到极端	数据 <2K 对或标注质量差时优先 IPO；τ 从 0.1 起调	IPO
KTO	2024	只需二元标签（好 / 坏）	实际业务难收成对偏好，但"这个回答好不好"的二元标注容易	用户点赞 / 点踩日志；正负样本 1:1 - 1:3	KTO
ORPO	2024	统一 SFT + 偏好	传统两阶段（SFT → 偏好）流程复杂，SFT 阶段可能学坏习惯	数据有限 + 简化 pipeline 时；β 从 0.1 起调	ORPO
SimPO	2024	无需参考模型	DPO 的 ref_model 占一半显存（7B → 14GB）	显存紧；β=2.0、γ=1.0；缺 KL，建议早停	SimPO
GRPO	2024	组内相对优化	DPO 离线受静态数据集限制，无法探索新策略	DeepSeek-R1 核心；G=64 常用；需可验证 reward	GRPO
RLVR	2025	可验证奖励（数学/代码）	传统 RM 是"学出来的评分器"有误差且易 hack；数学/代码答案可精确验证	2026 主流；适用于有确定性验证器的领域	DeepSeek-R1

---

二、RLHF 完整流程

2.1 三阶段

flowchart LR
    base["Pretrained LM"]
    sft["Stage 1<br/>SFT<br/>demo data"]
    rm["Stage 2<br/>RM training<br/>preference pairs"]
    ppo["Stage 3<br/>PPO<br/>policy + ref + RM + value"]
    final["Aligned model"]

    base --> sft --> rm --> ppo --> final

    classDef stage fill:#fff,stroke:#cc785c,color:#1a1a1a;
    classDef io fill:#f5f3eb,stroke:#bdb9ab,color:#1a1a1a;
    class base,final io
    class sft,rm,ppo stage

四个模型同时驻留显存：

模型	是否更新	用途
Policy π_θ	✅ 更新	当前训练的模型
Reference π_ref	❌ 冻结	KL 约束基线，防偏离 SFT
Reward Model RM	❌ 冻结（Stage 3）	给 (prompt, response) 打分
Value V_φ	✅ 更新	PPO advantage baseline

7B model RLHF 显存 ≈ 4 × SFT，所以 RLHF 的硬件成本一直是 frontier lab 才能负担。

2.2 Reward Model 训练

class RewardModel:
    def __init__(self, base_model):
        self.backbone = base_model    # 从 SFT 模型初始化
        self.reward_head = Linear(d_model, 1)  # 替换 LM head 为标量

    def forward(self, prompt, response):
        hidden = self.backbone(prompt + response)
        # 用最后一个 token 的 hidden state
        return self.reward_head(hidden[:, -1]).squeeze()

# 训练: Bradley-Terry 模型
def train_rm(rm, preference_pairs):
    for prompt, chosen, rejected in preference_pairs:
        r_chosen = rm(prompt, chosen)
        r_rejected = rm(prompt, rejected)
        # 好的回答得分更高
        loss = -log(sigmoid(r_chosen - r_rejected))
        loss.backward()

2.3 PPO 阶段

def ppo_step(policy, ref_policy, reward_model, prompts, beta=0.1, eps=0.2):
    for prompt in prompts:
        # 1. Rollout
        response = policy.generate(prompt)
        # 2. raw reward
        raw_reward = reward_model(prompt, response)
        # 3. KL 惩罚
        log_ratio = log_prob(policy, response) - log_prob(ref_policy, response)
        kl_penalty = beta * log_ratio
        # 4. 最终奖励
        total_reward = raw_reward - kl_penalty
        # 5. GAE advantage
        advantages = compute_gae(total_reward, values)
        # 6. PPO clip
        ratio = exp(log_prob_new - log_prob_old)
        clipped = clip(ratio, 1 - eps, 1 + eps)
        policy_loss = -min(ratio * advantages, clipped * advantages)
        policy_loss.backward()

工程挑战：4 模型 + GAE + clip + KL，每个超参都得调。这是为什么 DPO 系列 2023 年一出来就横扫小团队。

---

三、DPO 深入推导

3.1 DPO 的数学原理

DPO 的关键洞察：最优策略的闭式解可以直接从偏好数据优化，不需要显式 RM。参考 DPO Paper (Rafailov et al., 2023)。

RLHF 的目标:
  max_π E[r(x,y)] - β KL(π || π_ref)

闭式解:
  π*(y|x) = (1/Z(x)) · π_ref(y|x) · exp(r(x,y) / β)

从这个解, 可以推出 reward 和策略的关系:
  r(x,y) = β · log(π*(y|x) / π_ref(y|x)) + β · log Z(x)

代入 Bradley-Terry 偏好模型:
  P(y_w > y_l | x) = σ(r(x, y_w) - r(x, y_l))
                   = σ(β · log(π(y_w|x)/π_ref(y_w|x))
                     - β · log(π(y_l|x)/π_ref(y_l|x)))

DPO loss:
  L_DPO = -E[log σ(β · (log(π(y_w|x)/π_ref(y_w|x))
                       - log(π(y_l|x)/π_ref(y_l|x))))]

3.2 DPO 实现

def dpo_loss(policy, ref_policy, prompt, chosen, rejected, beta=0.1):
    log_pi_chosen   = log_prob(policy, chosen, prompt)
    log_pi_rejected = log_prob(policy, rejected, prompt)
    log_ref_chosen   = log_prob(ref_policy, chosen, prompt)
    log_ref_rejected = log_prob(ref_policy, rejected, prompt)

    # 隐式 reward
    r_chosen   = log_pi_chosen   - log_ref_chosen
    r_rejected = log_pi_rejected - log_ref_rejected

    # Bradley-Terry loss
    loss = -log(sigmoid(beta * (r_chosen - r_rejected)))
    return loss.mean()

for prompt, chosen, rejected in preference_data:
    loss = dpo_loss(model, ref_model, prompt, chosen, rejected)
    loss.backward()
    optimizer.step()

3.3 DPO vs RLHF 对比

维度	RLHF (PPO)	DPO
模型数	4（policy + ref + RM + value）	2（policy + ref）
显存	4× SFT	2× SFT
训练阶段	3（SFT → RM → PPO）	2（SFT → DPO）
在线/离线	在线 rollout	离线（预收集偏好对）
探索新策略	✅ 能（PPO 在线）	❌ 受限于数据集
Reward hacking	RM 有，能 game	无显式 RM，间接 hack
调参难度	高（PPO 多 hyperparam）	低（β + LR）
训练稳定性	中（PPO 易崩）	高
适合	大团队 / 探索性任务	小中团队 / 标准对齐

---

四、DPO 变体

4.1 SimPO：无需参考模型

def simpo_loss(policy, prompt, chosen, rejected, beta=2.0, gamma=1.0):
    # 创新: 不需要 ref_model
    # 用长度归一化的 log 概率作为隐式 reward
    log_pi_chosen   = log_prob(policy, chosen, prompt) / len(chosen)
    log_pi_rejected = log_prob(policy, rejected, prompt) / len(rejected)
    # 加 margin γ: 好回答应至少高 γ
    loss = -log(sigmoid(beta * (log_pi_chosen - log_pi_rejected) - gamma))
    return loss.mean()

# 优势:
#   1. 内存减半（不需要 ref_model）
#   2. 长度归一化防止"写长回答"
# 劣势:
#   1. 没有 KL 约束，可能偏离 SFT 太远 → 需早停

4.2 KTO：只需二元标签

def kto_loss(policy, ref_policy, prompt, response, is_good, beta=0.1):
    log_ratio = log_prob(policy, response, prompt) - log_prob(ref_policy, response, prompt)
    r = beta * log_ratio
    z_ref = estimate_reference_reward()  # 基线

    if is_good:
        loss = -sigmoid(r - z_ref)  # 推高好回答
    else:
        loss = -sigmoid(z_ref - r)  # 推低坏回答
    return loss.mean()

# 优势:
#   - 标注更容易（不需要成对比较）
#   - 对标注噪声更鲁棒

4.3 ORPO：SFT + 偏好同时优化

def orpo_loss(policy, prompt, chosen, rejected, beta=0.1):
    # SFT loss on chosen
    sft_loss = -log_prob(policy, chosen, prompt)

    # Odds ratio preference
    log_odds_chosen   = log(sigmoid(log_prob(policy, chosen, prompt)))
    log_odds_rejected = log(sigmoid(log_prob(policy, rejected, prompt)))
    pref_loss = -log(sigmoid(log_odds_chosen - log_odds_rejected))

    return sft_loss + beta * pref_loss

# 优势: 一阶段同时学 SFT + 偏好

---

五、GRPO：在线 RL 的重生

# GRPO vs DPO 的本质区别:
#   DPO: 离线，用预先收集的偏好数据
#   GRPO: 在线，训练中动态采样

def grpo_step(policy, ref_policy, prompts, verifier, group_size=64, beta=0.04, eps=0.2):
    for prompt in prompts:
        # 1. 同 prompt 采样 G 个回答
        responses = [policy.generate(prompt) for _ in range(group_size)]
        # 2. 验证器评分
        rewards = torch.tensor([verifier(r, prompt) for r in responses])
        # 3. 组内归一化（替代 PPO 的 value baseline）
        advantages = (rewards - rewards.mean()) / (rewards.std() + 1e-8)
        # 4. 策略更新
        for resp, adv in zip(responses, advantages):
            log_ratio = log_prob(policy, resp, prompt) - log_prob(ref_policy, resp, prompt)
            ratio = exp(log_ratio)
            clipped = clip(ratio, 1 - eps, 1 + eps)
            policy_loss = -min(ratio * adv, clipped * adv)
            kl = log_ratio
            total_loss = policy_loss + beta * kl
            total_loss.backward()

GRPO 的工程节省：

• 砍掉 value network → 显存少 ¼
• 砍掉 RM → 显存少 ¼（reward 是 verifier 函数，无参数）
• 用 group baseline 替代 GAE → 实现简化

代价：方差比 PPO 大（无 value baseline），需要更大 G 来平均（典型 G=8-64）。

参考 E3-E6 文档深入各 RL 方向。

---

六、方法选型决策

flowchart TB
    start["有偏好对齐需求"]
    q1{"团队规模<br/>+ 算力"}
    q2{"任务类型"}

    start --> q1

    q1 -->|"小团队<br/>单机"| simpo["SimPO<br/>显存最小"]
    q1 -->|"中团队<br/>多卡"| dpo["DPO<br/>稳定基线"]
    q1 -->|"大团队<br/>千卡"| q2

    q2 -->|"标准对齐"| rlhf["RLHF / DPO 混合"]
    q2 -->|"推理 / 数学 / 代码"| grpo["RLVR / GRPO<br/>R1 路线"]
    q2 -->|"宪法 + 安全"| cai["CAI + RLAIF<br/>Anthropic 路线"]

    classDef stage fill:#fff,stroke:#cc785c,color:#1a1a1a;
    classDef decision fill:#f5f3eb,stroke:#bdb9ab,color:#1a1a1a;
    class start,simpo,dpo,rlhf,grpo,cai stage
    class q1,q2 decision

2026 年的工程选择建议：

• 小团队 / 快速迭代：DPO（简单稳定）或 SimPO（最简单）
• 中等团队：DPO + GRPO 组合（DPO 学格式，GRPO 学推理）
• 大团队 / SOTA 模型：Cold Start SFT → 大规模 GRPO / RLVR（DeepSeek-R1 路线）
• 需要安全 / 宪法对齐：加 CAI 自评层（见 Anthropic alignment）

---

参考文献

1. Ouyang et al. InstructGPT (RLHF). NeurIPS 2022. arXiv:2203.02155
2. Rafailov et al. DPO: Direct Preference Optimization. NeurIPS 2023. arXiv:2305.18290
3. Meng et al. SimPO. 2024. arXiv:2405.14734
4. Ethayarajh et al. KTO. 2024. arXiv:2402.01306
5. Hong et al. ORPO. 2024. arXiv:2403.07691
6. Azar et al. IPO. 2023. arXiv:2310.12036
7. Shao et al. DeepSeekMath (GRPO). 2024. arXiv:2402.03300
8. DeepSeek-AI. DeepSeek-R1. 2025. arXiv:2501.12948
9. Bai et al. Constitutional AI. 2022. arXiv:2212.08073

---

↑ 上级 · E. 后训练与对齐