RLHF 深度解析：从人类反馈到 PPO/GRPO/DPO 的对齐革命

1. 引言：为什么需要”对齐”？#

1.1 从 SFT 到 RLHF 的进化#

如果说预训练给学生灌输了整个互联网的知识，SFT 教会学生”听人话做事”，那么RLHF 就是让学生学会**“做正确的事”**——不仅按指令，还要符合人类的价值观、偏好与安全约束。

1
训练范式的演进：
2

3
预训练 (Pre-training)
4
  ↓ 学习"语言 + 世界知识"
5
  ↓ 能力：续写、模仿
6

7
SFT (Supervised Fine-Tuning)
8
  ↓ 学习"指令 → 回答"
9
  ↓ 能力：助手、对话
10

11
RLHF (Reinforcement Learning from Human Feedback)
12
  ↓ 学习"偏好 + 价值观"
13
  ↓ 能力：有用 (Helpful) + 无害 (Harmless) + 诚实 (Honest)

1.2 SFT 解决不了的问题#

即使做完 SFT，模型仍会表现出：

问题	表现	例子
胡编乱造	一本正经说错信息	编造不存在的论文
有害输出	教用户做危险的事	制造武器、绕过安全
过度冗长	不必要的客套话	”作为 AI 助手…”
风格不适配	不符合期望语气	客服场景过于正式
幻觉 + 自信	错误但充满信心	错误医学建议

这些问题是主观偏好与价值观判断，无法用”标准答案”完全标注——SFT 的最大似然损失没有偏好信号。

一个关键洞见

SFT 优化的是 $p(\text{answer} | \text{question})$ ，但 RLHF 优化的是 $p(\text{answer} | \text{question}, \text{preference})$ 。后者编码了”哪一个更好”这一隐性知识。

1.3 RLHF 的核心思想#

两阶段训练：

奖励建模（Reward Modeling）：学习一个人类偏好的”打分器”
策略优化（Policy Optimization）：用 RL 让 LLM 生成高分回答

1
┌──────────────────────────────────────────────────────────────┐
2
│                        RLHF 流程总览                          │
3
├──────────────────────────────────────────────────────────────┤
4
│                                                              │
5
│  ① 收集偏好数据                                              │
6
│     prompt + response_A + response_B + 人类标注 A>B          │
7
│                          ↓                                   │
8
│  ② 训练奖励模型 RM(y|x)                                      │
9
│     loss = -log σ( RM(y_w|x) - RM(y_l|x) )                  │
10
│                          ↓                                   │
11
│  ③ 用 PPO 优化 SFT 模型                                      │
12
│     reward = RM(y|x) - β·KL(π_θ || π_ref)                   │
13
│                                                              │
14
└──────────────────────────────────────────────────────────────┘

2. 偏好数据：从反馈到标注#

2.1 数据形式#

每个偏好样本是一个三元组或四元组：

(x,\ y_w,\ y_l)

其中：

$x$ ：提示（prompt）
$y_w$ ：被人类标注为”更好”的回答（winner）
$y_l$ ：被人类标注为”更差”的回答（loser）

2.2 数据来源#

1
preference_data_sources = {
2
    # 1. 人类标注
3
    "human_annotation": "标注员对同一 prompt 的多个回答进行排序",
4

5
    # 2. AI 反馈（RLAIF / Constitutional AI）
6
    "ai_feedback": "用强模型按宪法原则评判弱模型回答",
7

8
    # 3. 用户隐式反馈
9
    "implicit_feedback": "点赞、采纳、停留时间、复制按钮",
10

11
    # 4. 合成数据
12
    "synthetic": "用 prompt 模板生成 y_w, 再故意制造 y_l 错误",
13
}

2.3 数据质量的关键#

维度	影响	工程经验
标注一致性	RM 学到正确偏好	多标注员 + Krippendorff α
多样性	RM 不偏科	跨领域、跨任务、跨长度
边界 case	RM 鲁棒性	故意加入对抗样本
失败模式覆盖	知道”哪里不好”	红队测试数据

数据陷阱

标注员有风格偏好（偏好长回答），导致 RM 学会”越长越好”。解决：在 prompt 中明确告知”长度不是评判标准”。

3. 奖励模型（Reward Model）#

3.1 Bradley-Terry 模型#

假设人类偏好遵循 Bradley-Terry 模型：

P(y_w \succ y_l \mid x) = \frac{\exp(R(x, y_w))}{\exp(R(x, y_w)) + \exp(R(x, y_l))} = \sigma\big(R(x, y_w) - R(x, y_l)\big)

其中 $R(x, y)$ 是真实的”人类偏好分数”。我们用一个神经网络 $R_\theta$ 来近似它。

3.2 损失函数#

对数似然：

\mathcal{L}_{\text{RM}} = -\mathbb{E}_{(x,y_w,y_l)\sim D}\Big[\log \sigma\big(R_\theta(x,y_w) - R_\theta(x,y_l)\big)\Big]

直觉：拉大 winner 和 loser 的分数差。

3.3 实现#

1
import torch
2
import torch.nn as nn
3
from transformers import AutoModelForCausalLM
4

5
class RewardModel(nn.Module):
6
    """
7
    基于 LLM 的奖励模型。
8
    通常是一个 LLM + 一个标量回归头，预测回答的"人类偏好分数"。
9
    """
10
    def __init__(self, base_model_path: str, cache_dir: str = None):
11
        super().__init__()
12
        # 加载与 SFT 相同架构的 LLM
13
        self.backbone = AutoModelForCausalLM.from_pretrained(
14
            base_model_path, cache_dir=cache_dir, torch_dtype=torch.bfloat16
15
        )
16
        hidden_size = self.backbone.config.hidden_size
17
        # 标量奖励头
18
        self.score_head = nn.Linear(hidden_size, 1, bias=False)
19
        # 初始化为接近 0（让初始分数居中）
20
        nn.init.zeros_(self.score_head.weight)
21

22
    def forward(self, input_ids: torch.Tensor, attention_mask: torch.Tensor):
23
        """
24
        输入: 拼接 [prompt; response]
25
        输出: 最后一个 token 的标量分数
26
        """
27
        outputs = self.backbone(
28
            input_ids=input_ids,
29
            attention_mask=attention_mask,
30
            output_hidden_states=True,
31
        )
32
        # 取每个序列最后一个有效 token 的隐藏状态
33
        last_hidden = outputs.hidden_states[-1]  # (B, L, H)
34
        sequence_lengths = attention_mask.sum(dim=1) - 1
35
        batch_idx = torch.arange(last_hidden.size(0), device=last_hidden.device)
36
        last_token_hidden = last_hidden[batch_idx, sequence_lengths]
37
        score = self.score_head(last_token_hidden).squeeze(-1)
38
        return score
39

40
class RewardModelLoss(nn.Module):
41
    """Bradley-Terry 偏好损失"""
42
    def forward(self, score_w: torch.Tensor, score_l: torch.Tensor) -> torch.Tensor:
43
        return -torch.nn.functional.logsigmoid(score_w - score_l).mean()

3.4 训练实践#

1
def train_reward_model(model, dataset, optimizer, epochs=2, batch_size=4):
2
    for epoch in range(epochs):
3
        for batch in dataset:
4
            # batch 包含 (x, y_w, y_l) 三组 tokenized 输入
5
            score_w = model(batch["input_ids_w"], batch["attention_mask_w"])
6
            score_l = model(batch["input_ids_l"], batch["attention_mask_l"])
7
            loss = -torch.nn.functional.logsigmoid(score_w - score_l).mean()
8

9
            optimizer.zero_grad()
10
            loss.backward()
11
            optimizer.step()

3.5 评估 RM 的方法#

1
def evaluate_rm(model, eval_pairs):
2
    """
3
    评估 RM 的"判别准确率"：
4
    在测试集上，正确判定 y_w > y_l 的比例。
5
    """
6
    correct = 0
7
    for pair in eval_pairs:
8
        score_w = model(pair["x_w"])
9
        score_l = model(pair["x_l"])
10
        if score_w > score_l:
11
            correct += 1
12
    return correct / len(eval_pairs)

4. PPO：经典的策略优化算法#

4.1 为什么不用 SFT 直接拟合 RM？#

直觉：用 RM 给回答打分，然后 SFT 用 $\text{reward} \cdot p(y|x)$ 加权拟合。问题：

分布偏移：RM 只在 SFT 数据上学过，对”模型自己生成的分布”外推差
Reward hacking：模型学会 RM 的盲点（比如生成”看起来很好但其实乱码”的回答）
无约束：可能偏离原始 SFT 模型，丧失能力

4.2 RL 基础#

把 LLM 视为一个自回归策略 $\pi_\theta(y|x)$ ：

\pi_\theta(y|x) = \prod_{t=1}^{|y|} \pi_\theta(y_t | x, y_{<t})

目标是最大化期望奖励：

J(\theta) = \mathbb{E}_{y\sim\pi_\theta}\big[R(x,y)\big]

4.3 KL 约束：锚定参考策略#

为防止 $\pi_\theta$ 偏离太远，加入 KL 惩罚：

J_{\text{RLHF}}(\theta) = \mathbb{E}_{y\sim\pi_\theta}\Big[R(x,y) - \beta\,\text{KL}\big(\pi_\theta(\cdot|x)\,\|\,\pi_{\text{ref}}(\cdot|x)\big)\Big]

其中 $\pi_{\text{ref}}$ 是 SFT 模型（参数冻结）， $\beta$ 控制约束强度。

直觉

KL 项相当于”不许忘本”。模型可以优化 RM，但不能变成另一个完全不同的模型。

4.4 PPO 目标函数#

PPO 是信赖域优化的实用版本：

\mathcal{L}_{\text{PPO}}(\theta) = -\mathbb{E}_t\Big[\min\big(r_t(\theta)\,A_t,\ \text{clip}(r_t(\theta), 1-\epsilon, 1+\epsilon)\,A_t\big)\Big]

其中：

重要性比率： $r_t(\theta) = \frac{\pi_\theta(a_t|s_t)}{\pi_{\theta_{\text{old}}}(a_t|s_t)}$
优势函数： $A_t$ （用 GAE 或 critic 估计）
$\epsilon$ 通常为 0.2

clip 机制：限制新旧策略的比率不超出 $[1-\epsilon, 1+\epsilon]$ ，避免一次更新步子过大。

4.5 RM + KL 的奖励设计#

PPO 中每个 token 的”奖励”：

r_t = \begin{cases} R(x, y) - \beta\,\big(\log \pi_\theta(y_t|\cdot) - \log \pi_{\text{ref}}(y_t|\cdot)\big) & t = T \\ -\beta\,\big(\log \pi_\theta(y_t|\cdot) - \log \pi_{\text{ref}}(y_t|\cdot)\big) & t < T \end{cases}

只有最后一个 token获得真实 RM 分数，前面所有 token 的”奖励”只是负的 KL 惩罚——鼓励每个位置的策略不偏离参考。

4.6 PPO for LLM 的完整实现#

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

4
def compute_gae(rewards, values, dones, gamma=0.99, lam=0.95):
5
    """广义优势估计 GAE"""
6
    advantages = torch.zeros_like(rewards)
7
    last_adv = 0
8
    T = rewards.size(1)
9
    for t in reversed(range(T)):
10
        if t == T - 1:
11
            next_value = 0
12
        else:
13
            next_value = values[:, t + 1]
14
        nonterminal = 1.0 - dones[:, t]
15
        delta = rewards[:, t] + gamma * next_value * nonterminal - values[:, t]
16
        last_adv = delta + gamma * lam * nonterminal * last_adv
17
        advantages[:, t] = last_adv
18
    returns = advantages + values
19
    return advantages, returns
20

21
def ppo_loss(
22
    log_probs_new,      # 新策略对每个 token 的 log prob: (B, T)
23
    log_probs_old,      # 旧策略（rollout 时）的 log prob
24
    advantages,         # GAE 优势
25
    clip_ratio=0.2,
26
):
27
    """PPO clipped surrogate loss"""
28
    ratio = torch.exp(log_probs_new - log_probs_old)
29
    surr1 = ratio * advantages
30
    surr2 = torch.clamp(ratio, 1 - clip_ratio, 1 + clip_ratio) * advantages
31
    policy_loss = -torch.min(surr1, surr2).mean()
32
    return policy_loss
33

34
def rlhf_train_step(
35
    policy_model,        # π_θ，待优化
36
    ref_model,           # π_ref，冻结
37
    reward_model,        # R(x,y)
38
    critic,              # 价值网络 V(s)
39
    batch,               # prompt 列表
40
    beta=0.1,            # KL 系数
41
    clip_ratio=0.2,
42
):
43
    """
44
    RLHF 单步训练流程（简化的 PPO）：
45
    1. 用当前 policy 生成回答（rollout）
46
    2. 用 RM 评分
47
    3. 计算 KL 惩罚
48
    4. 用 GAE 计算优势
49
    5. PPO 更新 policy 与 critic
50
    """
51
    prompts = batch["prompts"]
52

53
    # === 1. Rollout：用当前策略生成回答 ===
54
    with torch.no_grad():
55
        responses, response_mask = policy_model.generate(
56
            prompts, max_new_tokens=256, do_sample=True, temperature=1.0
57
        )
58

59
    # === 2. 计算旧策略的 log prob（用于重要性采样） ===
60
    with torch.no_grad():
61
        log_probs_old = compute_log_probs(policy_model, responses)
62

63
    # === 3. 用奖励模型打分 ===
64
    with torch.no_grad():
65
        rewards = reward_model(prompts + responses)
66

67
    # === 4. 计算 KL 惩罚（per token） ===
68
    with torch.no_grad():
69
        log_probs_ref = compute_log_probs(ref_model, responses)
70
    kl_per_token = log_probs_old - log_probs_ref  # = log(π_θ / π_ref)
71

72
    # 最后一个 token 获得 RM 分数；其余 token 仅 KL 惩罚
73
    T = responses.size(1)
74
    token_rewards = -beta * kl_per_token
75
    token_rewards[:, -1] += rewards
76

77
    # === 5. GAE 计算优势 ===
78
    with torch.no_grad():
79
        values = critic(responses)
80
    dones = torch.zeros_like(token_rewards)
81
    dones[:, -1] = 1.0  # 序列结束
82
    advantages, returns = compute_gae(token_rewards, values, dones)
83
    advantages = (advantages - advantages.mean()) / (advantages.std() + 1e-8)
84

85
    # === 6. PPO 更新（通常做 K_mini_epochs 次） ===
86
    for _ in range(4):
87
        log_probs_new = compute_log_probs(policy_model, responses)
88
        policy_loss = ppo_loss(log_probs_new, log_probs_old, advantages, clip_ratio)
89

90
        value_pred = critic(responses)
91
        value_loss = F.mse_loss(value_pred, returns)
92

93
        loss = policy_loss + 0.5 * value_loss
94
        loss.backward()
95
        # ... optimizer.step()

4.7 PPO 的工程痛点#

痛点	原因	缓解
显存爆炸	同时持有 policy、ref、RM、critic	LoRA + 共享参数
训练不稳定	大 reward 方差	Reward 归一化、KL warmup
Reward hacking	模型找到 RM 漏洞	多 RM ensemble
慢	每步 4 模型前向	vLLM rollout
崩溃	极端 KL 时崩	早停 + checkpoint rollback

经典教训

InstructGPT 论文报告：RLHF 训练中，约 10-30% 的训练会因奖励坍缩或 KL 爆炸而中断。需要持续监控。

5. GRPO：DeepSeek 提出的高效替代#

5.1 动机#

PPO 的最大开销：

一个额外的 critic 网络（与 policy 同尺寸）
每个 prompt 一次采样 → GAE 优势估计
4 个模型同时在显存

5.2 GRPO 核心思想#

**GRPO（Group Relative Policy Optimization）**由 DeepSeek 提出：

不需要 critic，对同一 prompt 采样一组回答，用组内相对排名作为优势。

5.3 算法流程#

1
对每个 prompt x：
2
  1. 用 π_θ 采样 G 个回答 {y_1, y_2, ..., y_G}
3
  2. 用 RM 给每个回答打分 {r_1, r_2, ..., r_G}
4
  3. 组内归一化得到优势：
5
     A_i = (r_i - mean(r)) / std(r)
6
  4. 用优势做 PPO 风格更新

5.4 优势计算#

A_i = \frac{r_i - \text{mean}(\mathbf{r})}{\text{std}(\mathbf{r})}, \quad i = 1,\ldots,G

直觉：比平均好的回答获得正优势，比平均差的获得负优势。无需 critic，无需 GAE。

5.5 完整损失#

\mathcal{L}_{\text{GRPO}}(\theta) = -\mathbb{E}\Big[\frac{1}{G}\sum_{i=1}^{G}\big(\min(r_i A_i, \text{clip}(r_i, 1-\epsilon, 1+\epsilon) A_i) - \beta\,\text{KL}(\pi_\theta \| \pi_{\text{ref}})\big)\Big]

其中重要性比率：

r_i(\theta) = \frac{\pi_\theta(y_i|x)}{\pi_{\theta_{\text{old}}}(y_i|x)}

5.6 GRPO 实现#

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

4
def grpo_loss(
5
    log_probs_new,       # (B, G, T) — B 个 prompt，每个 G 个回答
6
    log_probs_old,       # 同上
7
    rewards_group,       # (B, G) — 组内每个回答的 RM 分数
8
    ref_log_probs,       # (B, G, T)
9
    beta=0.04,
10
    clip_ratio=0.2,
11
):
12
    """
13
    GRPO 损失（DeepSeek-R1 风格）。
14
    log_probs_new, log_probs_old, ref_log_probs 形状: (B, G, T)
15
    rewards_group 形状: (B, G)
16
    """
17
    # === 组内归一化得到优势 ===
18
    mean_r = rewards_group.mean(dim=-1, keepdim=True)
19
    std_r = rewards_group.std(dim=-1, keepdim=True) + 1e-8
20
    advantages = (rewards_group - mean_r) / std_r  # (B, G)
21

22
    # === 重要性比率 ===
23
    # 这里我们用平均 log prob（per sequence）作为比率
24
    ratio = torch.exp(
25
        (log_probs_new - log_probs_old).sum(dim=-1)
26
    )  # (B, G)
27

28
    # === PPO-style clipped surrogate ===
29
    surr1 = ratio * advantages
30
    surr2 = torch.clamp(ratio, 1 - clip_ratio, 1 + clip_ratio) * advantages
31
    policy_loss = -torch.min(surr1, surr2).mean()
32

33
    # === KL 惩罚 ===
34
    kl = (log_probs_new - ref_log_probs).sum(dim=-1).mean()
35
    kl_loss = beta * kl
36

37
    total_loss = policy_loss + kl_loss
38
    return total_loss, {"policy_loss": policy_loss.item(), "kl": kl.item()}

5.7 PPO vs GRPO 对比#

维度	PPO	GRPO
Critic	需要	不需要
优势估计	GAE + Value Net	组内排名
显存	4 模型	2 模型 (policy + ref)
采样数	1/G	G（按 prompt）
训练稳定	较稳定	需要足够大的 G
代表工作	InstructGPT, ChatGPT	DeepSeek-R1

6. DPO：免强化学习的对齐#

6.1 核心洞见#

DPO（Direct Preference Optimization）由 Stanford 在 2023 年提出，关键问题是：

能不能绕过 RM 和 RL，直接用偏好数据训练 LLM？

答案是：可以。RLHF 的目标函数有一个闭式解。

6.2 推导：从 RLHF 到 DPO#

RLHF 目标：

\max_\pi \mathbb{E}_{x,y\sim\pi}\Big[R(x,y)\Big] - \beta\,\text{KL}\big(\pi(\cdot|x)\,\|\,\pi_{\text{ref}}(\cdot|x)\big)

其最优解为：

\pi^*(y|x) = \frac{1}{Z(x)}\pi_{\text{ref}}(y|x)\exp\!\Big(\frac{1}{\beta}R(x,y)\Big)

其中 $Z(x) = \sum_y \pi_{\text{ref}}(y|x)\exp(R(x,y)/\beta)$ 是归一化常数。

反解出 RM：

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

代入 Bradley-Terry 偏好模型（ $Z(x)$ 抵消）：

P(y_w \succ y_l | x) = \sigma\Big(\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)}\Big)

这就是 DPO 损失！

6.3 DPO 损失#

\mathcal{L}_{\text{DPO}}(\theta) = -\mathbb{E}_{(x,y_w,y_l)}\Big[\log\sigma\big(\beta\,\Delta_\theta(x,y_w,y_l)\big)\Big]

其中：

\Delta_\theta = \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)}

6.4 关键优势#

1
RLHF 流程：
2
  偏好数据 → 训练 RM → PPO 优化 policy
3
  (3 个阶段，复杂)
4

5
DPO 流程：
6
  偏好数据 → 直接训练 policy
7
  (1 个阶段，简单)

维度	RLHF/PPO	DPO
训练阶段	3（RM、critic、policy）	1（policy）
显存	4 模型	2 模型
超参	$\beta$ + clip + GAE + KL	只需 $\beta$
在线采样	需要	不需要（offline）
稳定性	易崩	稳定
性能	略好（一般）	与 PPO 相当
代表模型	GPT-4, Claude 2	Llama 3 Instruct, Mistral

6.5 DPO 实现#

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

4
def compute_log_probs(model, input_ids, attention_mask, response_mask):
5
    """计算回答部分的 log π(y|x) 之和"""
6
    outputs = model(input_ids=input_ids, attention_mask=attention_mask)
7
    logits = outputs.logits[:, :-1, :]  # 预测下一个 token
8
    labels = input_ids[:, 1:]
9
    log_probs = F.log_softmax(logits, dim=-1)
10
    # 取出真实 token 的 log prob
11
    token_log_probs = log_probs.gather(2, labels.unsqueeze(-1)).squeeze(-1)
12
    # 只对 response 部分求和（mask 掉 prompt）
13
    response_token_log_probs = token_log_probs * response_mask[:, 1:]
14
    return response_token_log_probs.sum(dim=-1)
15

16
def dpo_loss(
17
    policy_chosen_logps,    # π_θ(y_w|x) 对数和
18
    policy_rejected_logps,
19
    ref_chosen_logps,       # π_ref(y_w|x) 对数和
20
    ref_rejected_logps,
21
    beta=0.1,
22
):
23
    """
24
    DPO 损失。
25
    policy_chosen_logps: (B,)
26
    policy_rejected_logps: (B,)
27
    ref_chosen_logps: (B,)
28
    ref_rejected_logps: (B,)
29
    """
30
    # log π_θ(y|x) - log π_ref(y|x)
31
    policy_logratios = policy_chosen_logps - policy_rejected_logps
32
    ref_logratios = ref_chosen_logps - ref_rejected_logps
33

34
    # DPO 目标：β * (Δ_θ - Δ_ref)
35
    logits = beta * (policy_logratios - ref_logratios)
36

37
    # 偏好损失
38
    loss = -F.logsigmoid(logits).mean()
39

40
    # 额外监控：chosen reward margin
41
    chosen_rewards = beta * (policy_chosen_logps - ref_chosen_logps).detach()
42
    rejected_rewards = beta * (policy_rejected_logps - ref_rejected_logps).detach()
43

44
    return loss, {
45
        "chosen_rewards": chosen_rewards.mean().item(),
46
        "rejected_rewards": rejected_rewards.mean().item(),
47
        "accuracy": (chosen_rewards > rejected_rewards).float().mean().item(),
48
    }

6.6 DPO 训练循环#

1
from torch.optim import AdamW
2

3
def train_dpo(policy_model, ref_model, dataloader, beta=0.1, lr=1e-6, epochs=1):
4
    optimizer = AdamW(policy_model.parameters(), lr=lr)
5
    ref_model.eval()  # 冻结
6
    for epoch in range(epochs):
7
        for batch in dataloader:
8
            # batch: {chosen: input_ids, mask, response_mask, rejected: ...}
9

10
            # Policy 对 chosen 和 rejected 的 log prob
11
            policy_chosen_logps = compute_log_probs(
12
                policy_model, batch["chosen_input_ids"],
13
                batch["chosen_attention_mask"], batch["chosen_response_mask"]
14
            )
15
            policy_rejected_logps = compute_log_probs(
16
                policy_model, batch["rejected_input_ids"],
17
                batch["rejected_attention_mask"], batch["rejected_response_mask"]
18
            )
19

20
            # Ref（不计算梯度）
21
            with torch.no_grad():
22
                ref_chosen_logps = compute_log_probs(
23
                    ref_model, batch["chosen_input_ids"],
24
                    batch["chosen_attention_mask"], batch["chosen_response_mask"]
25
                )
26
                ref_rejected_logps = compute_log_probs(
27
                    ref_model, batch["rejected_input_ids"],
28
                    batch["rejected_attention_mask"], batch["rejected_response_mask"]
29
                )
30

31
            loss, metrics = dpo_loss(
32
                policy_chosen_logps, policy_rejected_logps,
33
                ref_chosen_logps, ref_rejected_logps,
34
                beta=beta,
35
            )
36

37
            optimizer.zero_grad()
38
            loss.backward()
39
            torch.nn.utils.clip_grad_norm_(policy_model.parameters(), 1.0)
40
            optimizer.step()
41

42
            print(f"loss={loss.item():.4f}  "
43
                  f"acc={metrics['accuracy']:.2f}  "
44
                  f"chosen_r={metrics['chosen_rewards']:.2f}  "
45
                  f"rejected_r={metrics['rejected_rewards']:.2f}")

6.7 DPO 的局限与变体#

DPO 偏差

DPO 容易过拟合到偏好数据，并出现”verbosity bias”——偏好变长但不一定变好。

主要变体：

算法	改进点	公式
IPO	防止过拟合	$\mathcal{L} = (\log\frac{\pi_\theta(y_w)}{\pi_{\text{ref}}(y_w)} - \log\frac{\pi_\theta(y_l)}{\pi_{\text{ref}}(y_l)} - \frac{1}{2\beta})^2$
KTO	不需要成对偏好（单回答 + 标签）	Kahneman-Tversky 前景理论
SimPO	移除 reference model	$\mathcal{L} = -\log\sigma(\frac{\\|y_w\\|}{\\|y_w\\|}R(y_w) - \frac{\\|y_l\\|}{\\|y_l\\|}R(y_l) - \gamma)$
ORPO	SFT + DPO 联合	联合 SFT 与 odds ratio 损失
CPO	SFT + DPO 简化	加 SFT 正则项

7. 进阶：从 RLHF 到 RLAIF / Constitutional AI#

7.1 RLAIF (RL from AI Feedback)#

动机：人类标注慢、贵、不一致。用强模型替代人类打标。

1
传统 RLHF:
2
  人类对 (y_A, y_B) 排序 → RM → PPO
3

4
RLAIF:
5
  GPT-4 对 (y_A, y_B) 按"宪法原则"排序 → RM → PPO

7.2 Constitutional AI (CAI)#

Anthropic 提出，两阶段：

阶段 1：监督式（SL-CAI）

1
1. 模型生成回答 y
2
2. 模型基于"宪法原则"（如"不要有害"）批评 y
3
3. 模型根据批评改写 y'
4
4. 用 (prompt, y') 做监督微调

阶段 2：RL-CAI

1
1. 模型生成回答 y_A, y_B
2
2. 模型按宪法原则判断哪个更好
3
3. 用这些 AI 偏好训练 RM
4
4. PPO 训练

宪法原则示例：

1
## 宪法（Constitution）
2

3
1. 请选择更**有帮助**的回答。
4
2. 请选择更**诚实**的回答。
5
3. 请选择更**无害**的回答，不应协助暴力、欺骗。
6
4. 请避免**歧视性**内容。
7
5. 请避免**违反隐私**的回答。

7.3 自我奖励语言模型（Meta，2024）#

1
迭代过程：
2
1. 用 CAI 生成偏好数据
3
2. 训练 RM
4
3. 用 DPO 训练 LLM
5
4. 重复：用更强的 LLM 重新打标
6
→ 模型自己当老师

8. 实战：完整 RLHF 训练流水线#

8.1 三阶段流水线#

1
┌──────────────────────────────────────────────────────────────┐
2
│                  完整 RLHF 训练流水线                          │
3
├──────────────────────────────────────────────────────────────┤
4
│                                                              │
5
│  Stage 0: Base Model (预训练 LLM)                            │
6
│     ↓                                                        │
7
│  Stage 1: SFT (监督微调)                                     │
8
│     ↓  用高质量指令数据训练 π_SFT                              │
9
│  Stage 2: Reward Model Training                              │
10
│     ↓  用偏好数据训练 R_θ                                     │
11
│  Stage 3: RL Fine-tuning (PPO / GRPO / DPO)                  │
12
│     ↓                                                        │
13
│  Final: Aligned Model                                        │
14
│                                                              │
15
└──────────────────────────────────────────────────────────────┘

8.2 推荐训练顺序（基于 Llama 2/3 论文经验）#

1
1. 预训练（基模型） ............................. 1-3 月，~1万 GPU·小时
2
2. SFT（指令微调） ............................... 数小时
3
3. RLHF 阶段 A：采样 + RM 训练 .................. 数小时
4
4. RLHF 阶段 B：PPO/DPO ......................... 数十小时
5
5. 安全对齐（可选的第二轮 RLHF） ............... 数小时

8.3 关键超参表#

超参	推荐值	备注
学习率（policy）	1e-6 ~ 5e-6	比 SFT 小一个数量级
学习率（RM）	1e-5 ~ 5e-5	RM 可以稍大
$\beta$ （KL 系数）	0.04 ~ 0.2	DPO 论文用 0.1
PPO clip $\epsilon$	0.2	标准值
Rollout 采样数 $G$	4 ~ 16	GRPO 用更大
Mini-batch 大小	1 ~ 4	受显存限制
GAE $\lambda$	0.95
折扣 $\gamma$	1.0	序列级任务

8.4 监控指标#

1
metrics_to_log = {
2
    # === RM 训练 ===
3
    "rm/loss": "RM Bradley-Terry 损失",
4
    "rm/accuracy": "RM 在测试集上判别准确率",
5
    "rm/score_margin": "winner - loser 平均分数差",
6

7
    # === PPO/DPO 训练 ===
8
    "policy/kl": "π_θ 与 π_ref 的 KL",
9
    "policy/reward": "RM 给当前生成回答的平均分",
10
    "policy/reward_std": "RM 分数方差",
11
    "policy/clip_fraction": "被 clip 的 token 比例",
12
    "policy/advantages": "优势均值",
13

14
    # === 任务指标 ===
15
    "eval/helpfulness": "GPT-4 评分（1-10）",
16
    "eval/harmlessness": "安全率",
17
    "eval/win_rate": "相对基模型的胜率",
18
}

8.5 常见 Failure Mode#

1
┌────────────────────────┬──────────────────────────────────┐
2
│ 现象                    │ 原因 / 解决                       │
3
├────────────────────────┼──────────────────────────────────┤
4
│ KL 爆炸               │ β 太小 / LR 太大 → 增大 β、降低 LR │
5
│ Reward 坍缩到 0        │ RM 过拟合 → 加正则、做 ensemble    │
6
│ 模型输出变成乱码        │ Reward hacking → 多 RM、加规则   │
7
│ 模型变得太保守（拒绝一切）│ RM 偏负样本 → 重新平衡数据         │
8
│ 偏好过拟合（DPO）       │ 学习率太大 / epoch 多 → 减小       │
9
│ Verbosity bias（越长越好）│ RM 没控制长度 → 加长度归一化       │
10
└────────────────────────┴──────────────────────────────────┘

9. 算法全景对比#

9.1 主流对齐方法#

1
┌─────────────────────────────────────────────────────────────┐
2
│                    对齐方法谱系                                │
3
├─────────────────────────────────────────────────────────────┤
4
│                                                              │
5
│  RL-based:                                                   │
6
│    ├── PPO (2017)         ──  经典，4 模型，复杂             │
7
│    ├── GRPO (2024)        ──  DeepSeek-R1，无 critic         │
8
│    ├── REINFORCE          ──  最简，公式简洁                  │
9
│    └── A2C / A3C          ──  通用 RL，LLM 中较少用          │
10
│                                                              │
11
│  RL-free (Direct Preference):                                │
12
│    ├── DPO (2023)         ──  开山之作，1 阶段               │
13
│    ├── IPO (2023)         ──  防过拟合                        │
14
│    ├── KTO (2024)         ──  不需成对偏好                    │
15
│    ├── SimPO (2024)       ──  无参考模型                      │
16
│    ├── ORPO (2024)        ──  SFT + DPO 联合                 │
17
│    └── CPO (2024)         ──  SFT + DPO 正则                  │
18
│                                                              │
19
│  Self-Play / Iterative:                                      │
20
│    ├── Constitutional AI  ──  AI 当标注员                     │
21
│    ├── Self-Rewarding LM  ──  自我奖励迭代                    │
22
│    └── SPIN / Iterative DPO── 多轮迭代偏好对齐                │
23
│                                                              │
24
└─────────────────────────────────────────────────────────────┘

9.2 决策树#

1
需要对齐 LLM
2
  │
3
  ├── 你有多少 GPU？多少数据？
4
  │     │
5
  │     ├── 资源受限（< 8 卡 A100）
6
  │     │     └── ✅ DPO / SimPO（最便宜、最稳）
7
  │     │
8
  │     ├── 中等资源（8-32 卡）
9
  │     │     ├── 数据多 + 想追最强性能 → ✅ GRPO
10
  │     │     └── 数据少 + 想稳定 → ✅ DPO
11
  │     │
12
  │     └── 大量资源（> 64 卡）
13
  │           └── ✅ PPO + 大 RM ensemble
14
  │
15
  ├── 你能采集偏好数据吗？
16
  │     │
17
  │     ├── 可以（人工标注）
18
  │     │     └── ✅ PPO / DPO
19
  │     │
20
  │     ├── 不能人工，但有强模型
21
  │     │     └── ✅ RLAIF + PPO / DPO
22
  │     │
23
  │     └── 都没有
24
  │           └── ✅ KTO（只需要"好/坏"标签）
25
  │
26
  └── 是否需要在线探索？
27
        │
28
        ├── 是 → ✅ PPO / GRPO
29
        └── 否 → ✅ DPO（offline）

9.3 性能 vs 复杂度矩阵#

算法	实现复杂度	显存	性能	稳定性	推荐场景
PPO	高	高	★★★★★	★★	大厂、追 SOTA
GRPO	中	中	★★★★★	★★★	DeepSeek 复现
DPO	低	低	★★★★	★★★★★	快速迭代、初创
IPO	低	低	★★★★	★★★★	DPO 过拟合时
KTO	低	低	★★★	★★★★	只有二值标签
SimPO	低	最低	★★★★	★★★★	显存紧张

10. 核心数学公式汇总#

10.1 Bradley-Terry 偏好模型#

P(y_w \succ y_l | x) = \sigma\big(R(x,y_w) - R(x,y_l)\big)

10.2 RM 损失#

\mathcal{L}_{\text{RM}} = -\mathbb{E}\Big[\log\sigma\big(R_\theta(x,y_w) - R_\theta(x,y_l)\big)\Big]

10.3 RLHF 目标#

J(\pi_\theta) = \mathbb{E}\Big[R(x,y)\Big] - \beta\,\text{KL}\big(\pi_\theta(\cdot|x)\,\|\,\pi_{\text{ref}}(\cdot|x)\big)

10.4 PPO Clipped Surrogate#

\mathcal{L}^{\text{CLIP}} = -\mathbb{E}_t\Big[\min\big(r_t A_t,\ \text{clip}(r_t, 1-\epsilon, 1+\epsilon)\,A_t\big)\Big]

10.5 GRPO 组内归一化#

A_i = \frac{r_i - \text{mean}(\mathbf{r})}{\text{std}(\mathbf{r})}

10.6 DPO 损失#

\mathcal{L}_{\text{DPO}} = -\mathbb{E}\Big[\log\sigma\big(\beta\,\Delta_\theta\big)\Big], \quad \Delta_\theta = \log\frac{\pi_\theta(y_w)}{\pi_{\text{ref}}(y_w)} - \log\frac{\pi_\theta(y_l)}{\pi_{\text{ref}}(y_l)}

10.7 IPO 损失#

\mathcal{L}_{\text{IPO}} = \mathbb{E}\Big[\big(\log\frac{\pi_\theta(y_w)}{\pi_{\text{ref}}(y_w)} - \log\frac{\pi_\theta(y_l)}{\pi_{\text{ref}}(y_l)} - \frac{1}{2\beta}\big)^2\Big]

11. 总结#

11.1 对齐范式的演进#

1
阶段 1: SFT only
2
  → 学会"按指令回答"
3
  → 无法处理偏好、价值观
4

5
阶段 2: RLHF (InstructGPT, ChatGPT)
6
  → 引入 RM + PPO
7
  → 性能强但训练复杂
8

9
阶段 3: Direct Preference (DPO)
10
  → 闭式解，无需 RL
11
  → 工程简单，性能相当
12

13
阶段 4: Self-Improvement (RLAIF, Self-Rewarding)
14
  → AI 替代人类标注
15
  → 持续自我改进

11.2 选择建议#

1
项目初期 / 资源受限:
2
  → DPO 是最好的起点。简单、稳定、性能强。
3

4
追求 SOTA:
5
  → PPO + 大 RM（如果算力足够）
6
  → 或 GRPO（DeepSeek 路径）
7

8
数据形式特殊:
9
  → 只有"好/坏"标签 → KTO
10
  → 没有 reference model → SimPO
11

12
长期迭代:
13
  → Constitutional AI + 自我奖励
14
  → SPIN / Iterative DPO

11.3 未解决的问题#

超人类反馈：模型比人类专家更强时，谁来评判？
多目标对齐：Helpful + Harmless + Honest 之间的权衡
奖励模型的鲁棒性：对抗样本、分布外泛化
对齐税（Alignment Tax）：对齐带来的能力损失如何最小化
可解释对齐：能否理解模型为什么”对齐”了

进阶阅读

推荐按以下顺序阅读论文：

InstructGPT（2022）—— RLHF 经典
DPO（2023）—— 直接偏好优化
Constitutional AI（2022）—— RLAIF 思想
DeepSeek-R1（2024）—— GRPO 与推理 RL
SimPO（2024）—— 简洁的现代变体

参考资料#

Ouyang, L., et al. (2022). “Training language models to follow instructions with human feedback.” NeurIPS.
Christiano, P., et al. (2017). “Deep reinforcement learning from human preferences.” NeurIPS.
Schulman, J., et al. (2017). “Proximal Policy Optimization Algorithms.” arXiv.
Rafailov, R., et al. (2023). “Direct Preference Optimization: Your Language Model is Secretly a Reward Model.” NeurIPS.
Azar, M., et al. (2023). “A General Theoretical Paradigm to Understand Learning from Human Feedback.” AISTATS (IPO).
Ethayarajh, K., et al. (2024). “KTO: Model Alignment as Prospect Theoretic Optimization.” ICML.
Meng, Y., et al. (2024). “SimPO: Simple Preference Optimization with a Reference-Free Reward.” arXiv.
Shao, Z., et al. (2024). “DeepSeekMath: Pushing the Limits of Mathematical Reasoning in Open Language Models.” arXiv (GRPO).
Bai, Y., et al. (2022). “Constitutional AI: Harmlessness from AI Feedback.” arXiv.
Touvron, H., et al. (2023). “LLaMA 2: Open Foundation and Fine-Tuned Chat Models.” arXiv.
Guo, D., et al. (2025). “DeepSeek-R1: Incentivizing Reasoning Capability in LLMs via Reinforcement Learning.” arXiv.
Lambert, N., et al. (2024). “RewardBench: Evaluating Reward Models for Language Modeling.” arXiv.

Federico

RLHF 深度解析：从人类反馈到 PPO/GRPO/DPO 的对齐革命

1. 引言：为什么需要”对齐”？#

1.1 从 SFT 到 RLHF 的进化#

1.2 SFT 解决不了的问题#

1.3 RLHF 的核心思想#

2. 偏好数据：从反馈到标注#

2.1 数据形式#

2.2 数据来源#

2.3 数据质量的关键#

3. 奖励模型（Reward Model）#

3.1 Bradley-Terry 模型#

3.2 损失函数#

3.3 实现#

3.4 训练实践#

3.5 评估 RM 的方法#

4. PPO：经典的策略优化算法#

4.1 为什么不用 SFT 直接拟合 RM？#

4.2 RL 基础#

4.3 KL 约束：锚定参考策略#

4.4 PPO 目标函数#

4.5 RM + KL 的奖励设计#

4.6 PPO for LLM 的完整实现#

4.7 PPO 的工程痛点#

5. GRPO：DeepSeek 提出的高效替代#

5.1 动机#

5.2 GRPO 核心思想#

5.3 算法流程#

5.4 优势计算#

5.5 完整损失#

5.6 GRPO 实现#

5.7 PPO vs GRPO 对比#

6. DPO：免强化学习的对齐#

6.1 核心洞见#

6.2 推导：从 RLHF 到 DPO#

6.3 DPO 损失#

6.4 关键优势#

6.5 DPO 实现#

6.6 DPO 训练循环#

6.7 DPO 的局限与变体#

7. 进阶：从 RLHF 到 RLAIF / Constitutional AI#

7.1 RLAIF (RL from AI Feedback)#

7.2 Constitutional AI (CAI)#

7.3 自我奖励语言模型（Meta，2024）#

8. 实战：完整 RLHF 训练流水线#

8.1 三阶段流水线#

8.2 推荐训练顺序（基于 Llama 2/3 论文经验）#

8.3 关键超参表#

8.4 监控指标#

8.5 常见 Failure Mode#

9. 算法全景对比#

9.1 主流对齐方法#

9.2 决策树#

9.3 性能 vs 复杂度矩阵#

10. 核心数学公式汇总#

10.1 Bradley-Terry 偏好模型#

10.2 RM 损失#

10.3 RLHF 目标#

10.4 PPO Clipped Surrogate#

10.5 GRPO 组内归一化#

10.6 DPO 损失#

10.7 IPO 损失#

11. 总结#

11.1 对齐范式的演进#

11.2 选择建议#

11.3 未解决的问题#

参考资料#

文章分享

Federico