【NLP 技术专栏 · 第四篇】从 SFT 到 RLHF：让大模型真正“听话“的核心技术

找。不。到。路。了。呢。

426人浏览 · 2026-04-11 18:29:11

找。不。到。路。了。呢。 · 2026-04-11 18:29:11 发布

NLP 技术专栏 · 第四篇
前三篇我们理解了 Transformer 的架构、三种分支、以及注意力优化。但一个关键问题还没回答：为什么 ChatGPT 比 GPT-3 强这么多？ 答案不在于更大的模型或更多的数据，而在于对齐（Alignment）技术。这一篇拆解 SFT、RLHF、DPO 等核心技术。

一、预训练模型的困境：会写但不会"听话"

1.1 一个真实场景

假设你问 GPT-3（纯预训练模型）：

用户: 请帮我写一段 Python 代码，计算前 n 个斐波那契数

GPT-3 (纯预训练) 可能的回复:

  "以下是计算前 n 个斐波那契数的代码：
   def fibonacci(n):
       ...
   
   希望对你有帮助。另外，如果你对数学感兴趣，
   可以看看《数学之美》这本书，作者是吴军博士，
   这本书从概率统计的角度介绍了自然语言处理..."
   
   ↑ 开头正确，但突然开始推荐书籍，偏离了用户的需求

1.2 问题的根源

预训练的目标是预测下一个词（Next Token Prediction），模型学到的是：

给定前文 → 预测最可能的下一个词

但"最可能的下一个词" ≠ "最有帮助的回复"

预训练语料中包含了：
  - 对话片段 → 模型学会了一点对话模式
  - 代码片段 → 模型学会了写代码
  - 闲聊、广告、噪声 → 模型也学会了这些
  - 矛盾的信息 → 模型不知道该信哪个

模型的"能力"已经有了（见过足够多的文本）
但模型的"行为"还不受控（不知道该做什么、不该做什么）

1.3 对齐（Alignment）的目标

对齐要解决的三个维度:

1. 有帮助 (Helpful)
   用户问什么就答什么，不跑题，不废话
   
2. 诚实 (Honest)
   不知道的就说不知道，不编造事实
   
3. 无害 (Harmless)
   不生成有害、歧视、违法的内容

   ┌─────────────────────────────────────┐
   │  预训练模型（能力的源泉）               │
   │  "我什么都会，但不知道该展示什么"        │
   └──────────────┬──────────────────────┘
                  │ 对齐技术
                  ▼
   ┌─────────────────────────────────────┐
   │  对齐后的模型（能力 + 行为）            │
   │  "我会的都展示，该说的说，不该说的不说"   │
   └─────────────────────────────────────┘

二、第一步：Supervised Fine-Tuning（SFT）

2.1 最直觉的方法

既然预训练模型的行为不可控，最直觉的想法就是：

用高质量的人工示范数据，手把手教模型该怎么做。

预训练:  海量无标注文本 → 学习语言能力
SFT:     少量高质量 (指令, 回复) 对 → 学习如何响应指令

示例数据:
┌────────────────────────────────────┬────────────────────────────────────┐
│ 指令 (Prompt)                       │ 期望回复 (Completion)               │
├────────────────────────────────────┼────────────────────────────────────┤
│ 请翻译以下英文为中文：                 │                                    │
│ "The weather is nice today."       │ "今天天气很好。"                     │
├────────────────────────────────────┼────────────────────────────────────┤
│ 解释什么是机器学习                    │ 机器学习是人工智能的一个分支，          │
│                                    │ 它使计算机能够从数据中学习...          │
├────────────────────────────────────┼────────────────────────────────────┤
│ 写一首关于春天的五言绝句               │ 春风拂柳绿，                        │
│                                    │ 细雨润花红。                        │
│                                    │ 燕子归来早，                        │
│                                    │ 田间麦苗青。                        │
└────────────────────────────────────┴────────────────────────────────────┘

2.2 SFT 的训练过程

# SFT 本质上就是标准的语言模型微调
# 只是在精心构造的指令-回复数据上训练

# 数据格式
prompt = "请解释什么是 Transformer"
completion = "Transformer 是一种基于注意力机制的神经网络架构..."

# 训练时只在 completion 部分计算 loss
# （prompt 部分不计算 loss，模型不应该"预测"用户的问题）

input_ids = tokenize(prompt + completion)
labels = [-100] * len(tokenize(prompt)) + tokenize(completion)
#                     ↑ prompt 部分的 label 设为 -100，不参与 loss 计算

loss = CrossEntropyLoss(model(input_ids), labels)

2.3 SFT 的效果

SFT 前后对比:

SFT 前 (纯预训练):
  Q: "什么是深度学习？"
  A: "深度学习是近年来非常热门的技术。在2012年ImageNet比赛中，
      AlexNet取得了突破性成绩。深度学习的应用场景包括图像识别、
      语音识别等。如果你感兴趣，可以去Coursera上Andrew Ng的课程..."
      ↑ 虽然内容相关，但更像是语料续写，不是在"回答问题"

SFT 后:
  Q: "什么是深度学习？"
  A: "深度学习是机器学习的一个子领域，使用多层神经网络从数据中
      学习表示。其核心思想是通过逐层抽象，从原始数据中自动提取
      高层特征。主要特点包括：
      1. 使用深层网络结构
      2. 端到端学习
      3. 自动特征提取..."
      ↑ 结构清晰，直接回答问题

2.4 SFT 的局限

SFT 虽然有效，但有两个根本性问题：

问题 1: 数据瓶颈

  高质量的人工标注数据非常昂贵
  InstructGPT 用了 ~13000 条 SFT 样本
  这些样本需要人工逐一撰写，成本高、速度慢

问题 2: 对齐税（Alignment Tax）

  SFT 只告诉模型"什么是好的"
  但没有告诉模型"什么是不好的"
  
  模型可能学到: "看起来像好回复的格式" 而非 "真正好的回复"
  即模仿了形式，没有学到本质

  更关键的是: 模型可能的回复千千万万
  SFT 只给了少数几种"正确答案"
  模型不知道其他几百种可能的回复哪些好、哪些差

三、RLHF：用人类偏好训练奖励模型

3.1 核心洞察

RLHF 的发明基于一个重要洞察：

让人类判断"哪个回复更好"，比让人类"写出完美回复"容易得多。

SFT 需要: 人类写出一个好回复（创造，难）
RLHF 需要: 人类从 2-4 个回复中选一个最好的（比较，容易）

这就像:
  写一篇满分作文（难） vs 给两篇作文打分哪个更好（容易）
  
  数据效率提升巨大: 同样的时间，人类可以做 10 倍以上的比较

3.2 RLHF 的三步流程

Step 1: SFT（已经讲过）
  用指令-回复数据微调，得到 SFT 模型

Step 2: 训练奖励模型（Reward Model, RM）
  让 SFT 模型对同一个 prompt 生成多个回复
  让人类标注员对这些回复排序
  用排序数据训练一个奖励模型

Step 3: PPO 强化学习优化
  用奖励模型给 SFT 模型的回复打分
  用 PPO 算法优化 SFT 模型，让它的回复获得更高分

完整流程图:

  ┌──────────────┐
  │   预训练模型： │ 
  └──────┬───────┘
         │
         ▼
  ┌──────────────┐     人工撰写
  │ Step 1: SFT  │ ← ─ ─ ─ (指令, 回复) 对
  └──────┬───────┘
         │
         ▼
  ┌──────────────┐     同一 prompt 生成多个回复
  │   SFT 模型：  │ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ┐
  └──────┬───────┘                           │
         │                                   ▼
         │                          ┌────────────────┐
         │                          │ 回复 A: [排名2] │
         │                          │ 回复 B: [排名1] │  ← 人类排序
         │                          │ 回复 C: [排名3] │
         │                          └────────┬───────┘
         │                                   │
         │                                   ▼
         │                          ┌────────────────┐
         │                          │ Step 2: 训练 RM │
         │                          │ 学习人类偏好     │
         │                          └────────┬───────┘
         │                                   │
         │                          奖励模型 R(x, y)
         │                                   │
         ▼                                   │
  ┌──────────────┐                           │
  │ Step 3: PPO  │ ← ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ┘
  │              │     奖励模型打分 + KL 惩罚
  │ SFT 模型优化  │
  └──────┬───────┘
         │
         ▼
  ┌──────────────┐
  │ 对齐后的模型   │  (如 ChatGPT, InstructGPT)
  └──────────────┘

3.3 Step 2：训练奖励模型（RM）

奖励模型的训练数据:

Prompt: "写一首关于春天的诗"

回复 A: "春天来了，花儿开了，鸟儿叫了，真好啊。"      ← 排名 3
回复 B: "东风吹绿江南岸，细雨润开万树花。            ← 排名 1
         燕子归来寻旧巢，春光满院映朝霞。"
回复 C: "春风吹拂大地，万物复苏。"                  ← 排名 2

人类标注的偏好: B > C > A

训练数据格式（成对比较）:
  (prompt, B, A)  →  B 优于 A
  (prompt, B, C)  →  B 优于 C
  (prompt, C, A)  →  C 优于 A

奖励模型的结构

奖励模型的结构:

  ┌──────────────┐
  │ SFT 模型     │  ← 复用 SFT 模型的全部参数
  │ (冻结或微调)  │
  └──────┬───────┘
         │
         │ 取最后一个 token 的隐状态
         ▼
  ┌──────────────┐
  │ Linear 层    │  ← 唯一新增的参数
  │ 隐状态 → 标量  │     输出一个分数
  └──────┬───────┘
         │
         ▼
    奖励分数 r(x, y)

损失函数：Bradley-Terry 模型

# 奖励模型的损失函数
def reward_model_loss(r_chosen, r_rejected):
    """
    r_chosen: 人类更偏好的回复的奖励分数
    r_rejected: 人类不偏好的回复的奖励分数
    
    目标: 让 P(chosen > rejected) 尽可能大
    """
    # Bradley-Terry 模型
    # P(chosen > rejected) = sigmoid(r_chosen - r_rejected)
    loss = -torch.log(torch.sigmoid(r_chosen - r_rejected))
    return loss.mean()

# 直觉:
# 如果 r_chosen=3.0, r_rejected=1.0 → sigmoid(2) ≈ 0.88 → loss ≈ 0.13 (好)
# 如果 r_chosen=1.0, r_rejected=3.0 → sigmoid(-2) ≈ 0.12 → loss ≈ 2.12 (差，会大幅更新)

3.4 Step 3：PPO 强化学习优化

这一步是最复杂的。核心思想：

把语言模型当作一个"策略"，每生成一个 token 就是一个"动作"，奖励模型的打分就是"奖励"。用 PPO 算法优化这个策略。

PPO 的核心循环:

  1. 采样: 用当前模型对 prompt 生成回复
  2. 评分: 用奖励模型给回复打分
  3. 优化: 调整模型参数，让高分回复更可能被生成
  4. 约束: 加 KL 散度惩罚，防止模型偏离原始 SFT 模型太远

为什么要 KL 惩罚？

  没有约束的话，模型可能学会"骗"奖励模型：
  - 生成一堆看起来像高分回复但实际无意义的文本
  - 或者退化成只生成少数几种高分模板
  - 或者为了拿高分输出越来越长的内容
  
  KL 惩罚 = "你可以改进，但别跑太远"

PPO 的四个模型

PPO 阶段同时需要四个模型实例:

┌──────────────┐
│ 策略模型      │  被优化的模型，生成回复
│ (Policy)     │  参数不断更新
├──────────────┤
│ 参考模型      │  SFT 模型的副本
│ (Reference)  │  参数冻结，用于计算 KL 惩罚
├──────────────┤
│ 奖励模型      │  Step 2 训练好的
│ (Reward)     │  参数冻结，给回复打分
├──────────────┤
│ 价值模型      │  估计每个状态的"预期总奖励"
│(Value/Critic)│  和策略模型一起训练
└──────────────┘

这就是为什么 RLHF 的显存占用非常大:
  需要同时在 GPU 上跑 4 个模型！
  7B 模型 → 需要 ~4×28GB ≈ 112GB 显存（至少需要 4×A100）

PPO 的优化目标

# PPO 的损失函数（简化版）
def ppo_loss(
    log_probs_new,      # 新策略下生成回复的 log 概率
    log_probs_old,      # 旧策略下生成回复的 log 概率
    log_probs_ref,      # 参考模型（SFT）的 log 概率
    rewards,            # 奖励模型的打分
    values,             # 价值模型的估计
    advantages,         # 优势函数
    kl_coeff=0.1,       # KL 惩罚系数
    clip_eps=0.2,       # PPO 裁剪范围
):
    # 1. 策略比率
    ratio = torch.exp(log_probs_new - log_probs_old)
    
    # 2. PPO 裁剪（防止策略更新过大）
    clipped_ratio = torch.clamp(ratio, 1 - clip_eps, 1 + clip_eps)
    policy_loss = -torch.min(ratio * advantages, clipped_ratio * advantages)
    
    # 3. KL 惩罚（防止偏离参考模型太远）
    kl_penalty = kl_coeff * (log_probs_new - log_probs_ref)
    
    # 4. 价值损失（训练价值模型）
    value_loss = F.mse_loss(values, rewards)
    
    return policy_loss.mean() + kl_penalty.mean() + value_loss.mean()

3.5 RLHF 的效果

InstructGPT (1.3B, RLHF) vs GPT-3 (175B, 无对齐):

  参数量: 1.3B vs 175B (小了 100 多倍)
  但人类标注员偏好: InstructGPT 胜出！

  这说明:
  - 对齐技术的价值 >> 增加模型规模
  - 一个好的 1.3B 对齐模型，比一个没对齐的 175B 模型更好用
  - 这就是 ChatGPT 比 GPT-3 "强"的本质原因

3.6 RLHF 的问题

问题 1: 训练复杂度极高
  - 需要同时维护 4 个模型
  - PPO 训练不稳定，超参敏感
  - 显存占用巨大

问题 2: 奖励模型的上限
  - RM 只是一个近似，可能被"欺骗"
  - RM 的训练数据有限，覆盖不全
  - "Reward Hacking"：模型学会拿高分而非真正有帮助

问题 3: 标注一致性
  - 不同标注员的偏好不同
  - 标注质量难以保证
  - 需要大量标注员培训和一致性校验

四、DPO：绕过奖励模型的简洁方案

4.1 核心洞察

RLHF 的复杂性主要来自 Step 3（PPO）。DPO 的洞察是：

奖励模型和 PPO 都不是必须的。我们可以直接从偏好数据中优化语言模型。

RLHF:  偏好数据 → 训练 RM → PPO 优化  (三步，复杂)
DPO:   偏好数据 → 直接优化 LM          (一步，简洁)

4.2 DPO 的数学原理

DPO 的关键推导：证明了最优策略可以用奖励函数和参考策略解析表示。

DPO 的损失函数:

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

  其中 y_w 是人类偏好的回复，y_l 是不偏好的回复

直觉理解：

DPO 的损失函数想做什么:

  让 π(y_w|x) 相对 π_ref(y_w|x) 增大    ← 偏好回复的概率提升
  让 π(y_l|x) 相对 π_ref(y_l|x) 减小     ← 不偏好回复的概率降低

  β 控制更新幅度: β 越大，越保守（不偏离参考模型太远）

4.3 DPO 的代码实现

import torch
import torch.nn.functional as F

def dpo_loss(
    model,              # 当前语言模型
    ref_model,          # 参考模型（冻结）
    prompt_ids,         # prompt 的 token ids
    chosen_ids,         # 偏好回复的 token ids
    rejected_ids,       # 不偏好回复的 token ids
    beta=0.1,           # 温度参数
):
    # 拼接 prompt + completion
    chosen_input = torch.cat([prompt_ids, chosen_ids], dim=1)
    rejected_input = torch.cat([prompt_ids, rejected_ids], dim=1)
    
    # 当前模型的 log 概率
    chosen_logprobs = get_logprobs(model, chosen_input, prompt_ids.size(1))
    rejected_logprobs = get_logprobs(model, rejected_input, prompt_ids.size(1))
    
    # 参考模型的 log 概率（不需要梯度）
    with torch.no_grad():
        ref_chosen_logprobs = get_logprobs(ref_model, chosen_input, prompt_ids.size(1))
        ref_rejected_logprobs = get_logprobs(ref_model, rejected_input, prompt_ids.size(1))
    
    # DPO 损失
    chosen_rewards = beta * (chosen_logprobs - ref_chosen_logprobs)
    rejected_rewards = beta * (rejected_logprobs - ref_rejected_logprobs)
    
    loss = -F.logsigmoid(chosen_rewards - rejected_rewards).mean()
    
    return loss

def get_logprobs(model, input_ids, prompt_len):
    """计算 completion 部分的 log 概率"""
    logits = model(input_ids).logits  # (batch, seq, vocab)
    logprobs = F.log_softmax(logits, dim=-1)
    
    # 取 completion 部分每个位置对应 token 的 log prob
    # 对齐: logits[i] 预测的是 input_ids[i+1]
    completion_logprobs = logprobs[:, prompt_len-1:-1].gather(
        dim=-1, index=input_ids[:, prompt_len:].unsqueeze(-1)
    ).squeeze(-1)
    
    return completion_logprobs.sum(dim=-1)  # 整个 completion 的总 log prob

4.4 DPO vs RLHF

┌─────────────────┬──────────────────┬──────────────────┐
│                 │ RLHF (PPO)       │ DPO              │
├─────────────────┼──────────────────┼──────────────────┤
│ 需要的模型        │ 4 个模型          │ 2 个模型          │
│                 │(策略/RM/参考/价值) │ (策略/参考)       │
├─────────────────┼──────────────────┼──────────────────┤
│ 训练稳定性        │ 不稳定            │ 稳定              │
│ 超参敏感度        │ 高               │ 低                │
├─────────────────┼──────────────────┼──────────────────┤
│ 实现复杂度        │ 高               │ 低                │
│ 显存占用          │ 非常大           │ 中等              │
├─────────────────┼──────────────────┼──────────────────┤
│ 效果             │ 上限更高          │ 接近 RLHF         │
│                 │ (更灵活的探索)     │ (有时略差)        │
├─────────────────┼──────────────────┼──────────────────┤
│ 适用场景         │ 大厂，资源充足      │ 大多数团队        │
└─────────────────┴──────────────────┴──────────────────┘

五、RLHF/DPO 之外：更多对齐技术

5.1 Constitutional AI (CAI) / RLAIF

Anthropic 的方法：用 AI 自己来生成偏好标注，减少人工标注需求。

传统 RLHF: 人类标注偏好
CAI/RLAIF: AI 标注偏好（根据一套"宪法"原则）

流程:
  1. 模型生成回复
  2. 用另一个模型（或同一个模型）根据"宪法原则"评判回复
  3. 用 AI 的评判代替人类排序来训练 RM
  4. 后续仍可用少量人类标注来修正偏差

宪法原则示例:
  "请选择更无害的回复"
  "请选择更诚实、不编造事实的回复"
  "请选择更直接回答用户问题的回复"

5.2 KTO (Kahneman-Tversky Optimization)

DPO 需要: 成对数据 (chosen, rejected) — 两个回复的比较
KTO 只需要: 单条数据 (回复 + 好/坏标签) — 更容易收集

  DPO 数据: (prompt, 回复A, 回复B, 哪个好)
  KTO 数据: (prompt, 回复A, 好), (prompt, 回复B, 坏)

  实践中，收集"这个回复好不好"比"这两个哪个更好"更高效

5.3 ORPO (Odds Ratio Preference Optimization)

DPO 需要: 两步（先 SFT，再 DPO）
ORPO 只需要: 一步（SFT + 对齐同时做）

  把偏好信号直接加入 SFT 的损失函数
  不需要单独的参考模型
  训练流程最简洁

5.4 各种方法的演进脉络

2017 ─── RLHF 的早期探索 (Deep RL from Human Preferences)
  │
2020 ─── Anthropic 提出用 RLHF 做对齐
  │
2022 ─── InstructGPT / ChatGPT: RLHF (PPO) 大获成功
  │      证明对齐 >> 增大规模
  │
2023 ─── DPO: 大幅简化 RLHF
  │      取消 RM + PPO，直接优化
  │      ├── SimPO: DPO 的简化版（去掉参考模型）
  │      ├── KTO: 不需要成对数据
  │      ├── IPO: 改进 DPO 的过拟合问题
  │      └── RLAIF/CAI: 用 AI 标注代替人类标注
  │
2024 ─── ORPO: SFT + 对齐一步完成
  │      趋势: 越来越简洁，越来越高效
  │
2025 ─── 持续演进...

六、为什么对齐技术让 Decoder-Only 发扬光大？

6.1 对齐技术天然适配 Decoder-Only

对齐的核心是: "什么该说，什么不该说"

  Decoder-Only (自回归):
    每一步都在做"选择"——从词表中选一个 token
    对齐 = 调整每一步的选择概率
    天然适配

  Encoder-Only (BERT):
    输出是分类/标注，没有"生成"过程
    没有逐步选择的机制，不适合 RLHF 的 token 级优化
  
  Encoder-Decoder:
    可以做 RLHF（如 T5 的对齐版本）
    但模型更复杂，4 个模型实例的开销更大

6.2 Scaling Law × 对齐 = 能力涌现

单独 scaling (增大模型/数据):
  能力线性增长，但行为不可控
  "会但不听话"

单独对齐 (RLHF/DPO):
  行为受控，但没有足够的能力支撑
  "听话但不太会"

Scaling + 对齐:
  模型有足够的能力 + 知道该展示哪些能力
  = 真正有用的 AI 助手
  
GPT-3 (175B, 无对齐) < InstructGPT (1.3B, 有对齐)
 → 对齐的价值 > 100× 规模

6.3 Decoder-Only 的生态系统飞轮

RLHF/DPO 的成功 → 更多人选择 Decoder-Only
  → 更多工程优化（Flash Attention、GQA、vLLM）针对 Decoder-Only
  → Decoder-Only 推理更快、更省
  → 更多人选择 Decoder-Only
  → 形成正向飞轮

  现在的状态:
  - 所有主流推理框架（vLLM、TGI、TensorRT-LLM）都针对 Decoder-Only 优化
  - 所有对齐工具（TRL、OpenRLHF）都基于 Decoder-Only
  - 所有开源模型（LLaMa、Mistral、Qwen）都是 Decoder-Only
  
  Encoder-Only 和 Encoder-Decoder 并没有消失，
  但在"大语言模型"这个赛道上，Decoder-Only 已经赢了。

七、InstructGPT / ChatGPT 的完整训练流程

把所有技术串起来，看看 ChatGPT 是怎么训练的：

Stage 0: 预训练
  数据: 大规模互联网文本 (~TB 级)
  目标: Next Token Prediction
  结果: 一个有强大语言能力但行为不可控的基础模型 (GPT-3)

Stage 1: SFT
  数据: ~13,000 条人工编写的 (指令, 回复) 对
  目标: 教模型如何遵循指令
  结果: SFT 模型（已经能用，但质量参差不齐）

Stage 2: 训练奖励模型 (RM)
  数据: ~33,000 条人类比较数据（对同一个 prompt 的多个回复排序）
  方法: 用 SFT 模型生成回复，人类排序，训练 RM
  结果: 奖励模型（能预测人类对回复的偏好）

Stage 3: PPO 优化
  方法: 用 RM 打分 + KL 惩罚 + PPO 算法优化 SFT 模型
  结果: 对齐后的最终模型 (ChatGPT)

八、总结

8.1 要点回顾

┌─────────────────┬──────────────────────────────────────────────────┐
│ 技术            │ 核心贡献                                           │
├─────────────────┼──────────────────────────────────────────────────┤
│ SFT             │ 用人工示范教模型如何响应指令                          │
│                 │ 解决"会但不会听话"的问题                             │
├─────────────────┼──────────────────────────────────────────────────┤
│ RM (奖励模型)   │ 学习人类偏好评判标准                                  │
│                 │ 从"写出好回复"到"判断好坏"                           │
├─────────────────┼──────────────────────────────────────────────────┤
│ RLHF (PPO)      │ 用强化学习优化模型，让回复获得更高奖励                 │
│                 │ 效果最强，但实现复杂                                │
├─────────────────┼──────────────────────────────────────────────────┤
│ DPO             │ 绕过 RM 和 PPO，直接从偏好数据优化                   │
│                 │ 效果接近 RLHF，实现大幅简化                          │
├─────────────────┼──────────────────────────────────────────────────┤
│ RLAIF/CAI       │ 用 AI 代替人类做偏好标注                            │
│                 │ 降低标注成本                                       │
├─────────────────┼──────────────────────────────────────────────────┤
│ KTO/ORPO        │ 进一步简化数据需求和训练流程                          │
│                 │ 对齐技术的持续演进                                  │
└─────────────────┴──────────────────────────────────────────────────┘

8.2 核心结论

大模型的突破 = Scaling（能力的源泉）+ 对齐（行为的引导）

预训练让模型有了"会什么"的能力
对齐技术让模型学会了"该做什么"
Decoder-Only 的自回归目标天然适配对齐技术
对齐的价值在某些场景下超过 100 倍的规模增长

参考文献

Ouyang, L., et al. (2022). Training language models to follow instructions with human feedback. (InstructGPT)

Christiano, P., et al. (2017). Deep reinforcement learning from human preferences.

Rafailov, R., et al. (2023). Direct Preference Optimization: Your Language Model is Secretly a Reward Model. (DPO)

Bai, Y., et al. (2022). Training a Helpful and Harmless Assistant with RLHF. (Anthropic)

Ethayarajh, K., et al. (2024). KTO: Model Alignment as Prospect Theoretic Optimization.

Hong, J., et al. (2024). ORPO: Monolithic Preference Optimization without Reference Model.