《AI Agent 技术原理与架构·决策、记忆与学习》12.2 RLHF/DPO:偏好与拒绝

偏好对齐不学“好答案”,只学“更受欢迎”的相对顺序。本节用五个有固定真实效用的候选答案建模标注噪声,用 MM 算法拟合 Bradley-Terry 分数。实验展示噪声抬高 0.35 后排序翻转、比较次数只压方差不压偏差,说明偏好数据要区分噪声与数据量。

以下数字为教学示例,不构成对任何真实系统或供应商的承诺。

SFT 教 Agent"照着专家做",偏好对齐教 Agent"做大家更喜欢的那一个"。它的输入不是绝对评分,而是两两比较:标注者看两个答案,说哪个更好。RLHF 用这个信号训奖励模型,DPO 用这个信号直接调策略。两者的共同地基是偏好模型——本节用 Bradley-Terry 排序的最小模型,把"偏好数据里什么是可修复的、什么是修不掉的"讲清楚。

模型:五个候选与两两比较

五个候选答案有固定的真实效用:

标签真实效用
A0.90
B0.78
C0.62
D0.45
E0.30

真值排序 A>B>C>D>E。标注者两两比较,以概率 noise 翻转标签——它该选更优的那个,但有 noise 的概率选反。实验用 MM 算法从胜场矩阵拟合 Bradley-Terry 分数,再看拟合排序与真值排序的差距。

噪声扫描:什么时候开始排错

实验先固定每个比较重复 20 次,扫描噪声从 0.00 到 0.50:

# file: agp_lab/preference_learning.py | write
# tier: 3
# verify: python3 -m unittest tests.test_preference_learning
"""RLHF/DPO 的偏好数据:标注噪声对 Bradley-Terry 排序的影响。

五个候选答案有固定的真实效用。标注者两两比较,以概率 noise 翻转
标签;用 MM 算法拟合 Bradley-Terry 分数,再看排序质量。实验区分两
件事:增加比较次数只能压低方差,标注噪声带来的是偏差,不会因为数
据变多而自动消失。
"""
from __future__ import annotations

import math
import random

LABELS = ("A", "B", "C", "D", "E")
TRUE_UTILITY = (0.90, 0.78, 0.62, 0.45, 0.30)
DEFAULT_SEED = 7


def make_wins(reps: int, noise: float, seed: int = DEFAULT_SEED) -> list[list[int]]:
    """每一对候选比较 reps 次,返回 wins[i][j] = i 胜过 j 的次数。"""
    if reps <= 0:
        raise ValueError("reps 必须为正")
    if not 0.0 <= noise <= 0.5:
        raise ValueError("noise 必须在 [0, 0.5] 内")
    rng = random.Random(seed)
    count = len(TRUE_UTILITY)
    wins = [[0] * count for _ in range(count)]
    for left in range(count):
        for right in range(left + 1, count):
            better, worse = (
                (left, right) if TRUE_UTILITY[left] > TRUE_UTILITY[right] else (right, left)
            )
            for _ in range(reps):
                if rng.random() < noise:
                    wins[worse][better] += 1
                else:
                    wins[better][worse] += 1
    return wins


def fit_bt(wins: list[list[int]], iterations: int = 400) -> list[float]:
    """Bradley-Terry 的 MM 更新:theta_i = W_i / sum_j n_ij/(theta_i+theta_j)。"""
    count = len(wins)
    if count == 0:
        raise ValueError("候选不能为空")
    if any(len(row) != count for row in wins):
        raise ValueError("wins 必须是方阵")
    theta = [1.0] * count
    for _ in range(iterations):
        updated = [0.0] * count
        for left in range(count):
            numerator = sum(wins[left])
            denominator = 0.0
            for right in range(count):
                if left == right:
                    continue
                pairs = wins[left][right] + wins[right][left]
                if pairs:
                    denominator += pairs / (theta[left] + theta[right])
            updated[left] = numerator / denominator if denominator else 1e-12
        scale = math.exp(sum(math.log(max(value, 1e-12)) for value in updated) / count)
        theta = [value / scale for value in updated]
    return theta


def ordering(theta: list[float]) -> tuple[int, ...]:
    return tuple(sorted(range(len(theta)), key=lambda index: (-theta[index], index)))


def top1_accuracy(theta: list[float], truth: tuple[float, ...] = TRUE_UTILITY) -> bool:
    return ordering(theta)[0] == max(range(len(truth)), key=lambda index: truth[index])


def kendall_tau(theta: list[float], truth: tuple[float, ...] = TRUE_UTILITY) -> float:
    predicted = ordering(theta)
    count = len(predicted)
    concordant = 0
    discordant = 0
    for left in range(count):
        for right in range(left + 1, count):
            first, second = predicted[left], predicted[right]
            if truth[first] > truth[second]:
                concordant += 1
            elif truth[first] < truth[second]:
                discordant += 1
    return (concordant - discordant) / (count * (count - 1) / 2)


def _order_text(theta: list[float]) -> str:
    return ">".join(LABELS[index] for index in ordering(theta))


def _print_noise_sweep() -> None:
    print(f"{'noise':>6}{'top1':>7}{'tau':>7}  order")
    for noise in (0.0, 0.10, 0.20, 0.35, 0.50):
        theta = fit_bt(make_wins(20, noise))
        print(
            f"{noise:>6.2f}{int(top1_accuracy(theta)):>7d}"
            f"{kendall_tau(theta):>7.2f}  {_order_text(theta)}"
        )


def _print_sample_sweep() -> None:
    print(f"{'reps':>6}{'tau':>7}  order")
    for reps in (1, 5, 20, 100):
        theta = fit_bt(make_wins(reps, 0.20))
        print(f"{reps:>6}{kendall_tau(theta):>7.2f}  {_order_text(theta)}")


if __name__ == "__main__":
    _print_noise_sweep()
    print()
    _print_sample_sweep()

运行:

cd private/labs/agp-lab
python3 -m agp_lab.preference_learning

输出:

 noise   top1    tau  order
  0.00      1   1.00  A>B>C>D>E
  0.10      1   1.00  A>B>C>D>E
  0.20      1   1.00  A>B>C>D>E
  0.35      1   0.80  A>C>B>D>E
  0.50      0  -0.40  C>E>D>A>B

这张表揭示了偏好的三层抵抗能力。

噪声 0.20 以内,排序纹丝不动。 从 0.00 到 0.20,top1 都是 1,tau 都是 1.00,顺序都是 A>B>C>D>E。真实效用差距是 0.12 到 0.18 的梯度,20% 的翻转噪声不足以颠倒任意一对的顺序。偏好数据对温和噪声有天然的鲁棒性——这是 RLHF 在实践里能用的前提。

噪声 0.35 开始扭曲相邻排序。 tau 掉到 0.80,顺序变成 A>C>B>D>E——B 和 C 互换了位置。这对应的正是效用靠得最近的一对(B 0.78 vs C 0.62):噪声把这对的相对顺序翻了过来,但全局还能保持 A 第一、E 最后。最先垮的总是效用最接近的相邻对。

噪声 0.50 是彻底的排列崩溃。 top1 变成 0,tau 变成 -0.40,顺序 C>E>D>A>B——这已经和真值负相关。0.50 的翻转等于掷硬币决定每对谁赢,Bradley-Terry 拟合出来的"分数"只是噪声的投影,它还把正确答案 A 排在倒数第二。标签完全随机时,偏好数据不提供任何信号,拟合出来的排序连随机都不如。

样本量扫描:为什么数据变多修不掉噪声

第二个直觉是"比较次数多一点就稳了"。下面固定噪声 0.20,把每对重复比较次数从 1 扫到 100:

  reps    tau  order
     1   0.20  E>A>B>C>D
     5   0.60  C>A>B>D>E
    20   1.00  A>B>C>D>E
   100   1.00  A>B>C>D>E

三行之间藏着"方差 vs 偏差"的分工。

reps=1 的排序是噪声主导。 每个比较只有一次,单次翻转直接改变胜场矩阵,拟合出来的顺序 E>A>B>C>D——tau 只有 0.20,几乎随机。少量比较下,方差(单次噪声的随机性)是主导误差。

reps=20 以后收敛到正确排序。 从 20 到 100,tau 都是 1.00、顺序都是 A>B>C>D>E。对 0.20 的噪声,20 次重复已经把每对的胜率磨成了真实比例的估计,排序稳定下来。比较次数压掉的是方差:单次翻转被平均掉,估计趋于稳定。

但注意:这只有在噪声 0.20 时成立。 回看第一张表,噪声 0.35 时即使每对比较 20 次,B/C 还是错的;噪声 0.50 时比较再多也是 -0.40。数据变多修不掉的是偏差——噪声是"系统性翻对错",平均多少次都不会把它翻转回来。这就是和 11.3 完全同构的结构:样本量消方差,不消偏差。

偏好数据的三个诚实认知

第一,偏好教的是"相对",不是"绝对"。 模型学到 A 比 B 受欢迎、C 比 D 受欢迎,它没有学到"A 的绝对质量是 0.90"。所以偏好对齐擅长调整顺序,不擅长建立绝对标准。要求 Agent"这件事必须做到某个绝对水平",偏好数据给不了,要可验证奖励(见 12.3)。

第二,标注者差异是天然噪声。 有人喜欢简洁、有人喜欢详尽,同一个 A/B 比较在不同标注者那里方向不同。这不算 bug,是偏好数据的固有属性——它带来偏差而不是方差,加标注量救不回来,只能接受"排序里有分歧"。

第三,DPO 与 RLHF 的数据问题同源。 DPO 把 RLHF 的奖励建模省掉了,直接从偏好直接调策略,但输入还是同样的两两比较。本节所有噪声结论对 DPO 同样成立:偏好数据质量差,DPO 和 RLHF 一起翻车。

偏好对齐的判据

判据合格的样子不合格的样子
噪声有数标注噪声有量化估计标签质量黑盒
排序可测用排序指标(tau)评测只看"标注者满意率"
数据量定位明确比较次数压方差以为加数据能修偏差
相对口径清楚学的是相对顺序误当绝对质量
标注分歧可见分歧是报告的一部分分歧被平均掩盖

“只看标注者满意率"是偏好对齐评测的常见陷阱:满意率衡量的是"标注者认可哪个”,而偏好对齐真正要的是"排序是否反映真值"。两者混在一起,系统会在标注者的系统偏好上越走越远。

架构含义

偏好对齐对架构有三个直接约束:

  1. 偏好与可验证奖励分层。 偏好负责"哪种风格更受欢迎",可验证奖励负责"任务做没做成",两层不混。
  2. 标注噪声入报告。 每次偏好数据版本带上噪声估计,排序质量跌破阈值要停。
  3. 比较次数按噪声定。 噪声高则增加每对重复次数压方差,但要知道偏差修不掉。

第 1 条是 RLHF/DPO 在生产里最容易乱的一层:把"用户更喜欢"和"任务做对了"混成一个信号,Agent 会学会讨好而非正确。分层是架构底线。

与三条工作负载的关系

  • W1 检索问答:偏好对齐适合"回答风格"(详细 vs 简洁),不适合"检索准不准"——后者要用可验证命中率。
  • W2 代码修复:风格偏好(注释多少、命名习惯)可对齐;修复正确性必须可验证奖励,不能交给偏好。
  • W3 运维处置:偏好数据最危险——用户"看起来喜欢"的处置未必安全;W3 只认可验证的处置结果。

W3 的教训极端:运维处置里"用户对某操作的偏好"可能与安全直接冲突。W3 应当禁用偏好对齐做处置决策,只允许偏好影响表达层(报告的详细程度、措辞),处置本身走可验证奖励。

小结

  • 偏好数据输入是两两比较,不是绝对评分。
  • 噪声 0.20 内排序纹丝不动,0.35 时相邻对先垮,0.50 时彻底崩溃。
  • 比较次数压方差:reps 从 1 到 20,tau 从 0.20 收敛到 1.00。
  • 数据变多修不掉偏差:噪声 0.50 时比较再多也是 -0.40。
  • 偏好教相对不教绝对,DPO 与 RLHF 数据问题同源。
  • 偏好负责风格、可验证奖励负责正确性,两层分层是架构底线。

阅读导航:上一节:12.1 SFT:行为克隆与轨迹数据 · 下一节:12.3 Agentic RL:可验证奖励、GRPO 与探索 。

常见错误与边界

  1. 把偏好当绝对质量。 相对顺序学不到绝对标准,“必须达到某水平"要可验证奖励。
  2. 只用满意率评测。 排序与真值的差距才是偏好对齐的指标,满意率会掩盖系统偏差。
  3. 加数据修噪声。 比较次数压方差,标注噪声是偏差,加量修不掉。
  4. 忽略标注分歧。 分歧是天然噪声,被平均掩盖后会变成隐藏的系统偏差。
  5. 偏好与正确性混一个信号。 Agent 学会讨好而非正确,W3 场景直接禁用偏好做处置。
  6. 噪声黑盒。 不量化标签噪声,排序质量跌破阈值也发现不了。

继续阅读

探索更多技术文章

浏览归档,发现更多关于系统设计、工具链和工程实践的内容。

全部文章 返回首页

「books」更多文章

  1. 《大规模分布式计算深入解析》15.3 落地:从 Neo4j 到自研图引擎
  2. 《大规模分布式计算深入解析·图计算与图数据库内核》 · 目录与学习路径(45 篇)
  3. 《大规模分布式计算深入解析》15.2 十一卷主线:从切分到图