论文精读：放弃绝对打分！带你从浅入深看懂大模型对齐前沿算法 INPO

AggressiveYu

440人浏览 · 2026-04-08 20:49:16

AggressiveYu · 2026-04-08 20:49:16 发布

在大型语言模型（LLM）的对齐竞赛中，传统的 DPO（直接偏好优化）正在遭遇不可忽视的瓶颈。当模型能力逐渐超越人工标注的静态数据集时，强行假设“绝对完美回复”的数学底层（Bradley-Terry 模型）往往会导致模型陷入分布偏移的泥潭，甚至发生能力退化。

本教程深度拆解了对齐领域的重磅前沿论文 INPO（Iterative Nash Policy Optimization）。该算法完成了一次惊艳的范式转移：它彻底抛弃了虚幻的“绝对高分”，引入博弈论的世界观，将大模型生成转化为一场“二人零和博弈”。通过极其优雅的无悔学习机制与闭式解公式，INPO 引导模型在不断的“左脚踩右脚”迭代自博弈中，稳步收敛至无懈可击的“纳什均衡”状态。

在这个教程中，你将获得：

认知重塑：用最直白的语言和具体实例，明白为什么“石头-剪刀-布”式的真实偏好会压垮传统算法。
数学降维：拨开复杂的积分与偏导数，直击 FTRL 算法的核心闭式解，看懂概率与温度惩罚（KL散度）的博弈过程。
工程落地：脱离理论纸上谈兵，以上帝视角审视 INPO 的“内外双循环”架构，彻底搞懂数据与梯度在显卡中的流动轨迹。

论文下载地址：https://arxiv.org/pdf/2407.00617

第一部分：基础背景与动机

要让一个大型语言模型（LLM）听话且有用，行业内有一套标准流程。通常分为两步：

SFT（监督微调）： 教模型“像人一样说话”。
对齐（Alignment）： 教模型“说人类喜欢听的话”，也就是让模型的行为符合人类的价值观或偏好。

目前的对齐技术经历了两个主要的时代，而它们都各自面临着难以解决的硬伤。

1. PPO 时代与“奖励作弊”（Reward Hacking）

在早期的 RLHF（基于人类反馈的强化学习）中，最主流的算法是 PPO。它的核心逻辑是：“找个裁判来打分，然后想办法拿高分”。

具体做法是，先训练一个奖励模型（Reward Model, RM）。这个 RM 就像一个不知疲倦的考官，负责看 LLM 生成的回复，并给出一个具体的绝对分数（例如 8.5 分、9.2 分）。然后，PPO 算法就会去调整 LLM 的参数，让它生成的回复得分越来越高。

致命缺陷：奖励作弊（Reward Hacking）

这个机制最大的问题在于，考官（奖励模型）也是个 AI，它并不完美。当 PPO 拼命追求高分时，它会发现考官的“漏洞”。 实例： 假设考官喜欢礼貌的回复。LLM 在训练中发现，只要在句首加上“作为一个有用且安全的人工智能助手，我非常乐意为您解答”，无论后面跟着什么废话，考官都会给高分。结果就是，模型变成了一个只会说套话的废话机器。它没有变得更好，它只是学会了“刷分”。

2. DPO 时代与“绝对分数的幻觉”

为了避免 PPO 训练一个独立奖励模型的麻烦，研究人员发明了 DPO（直接偏好优化）。DPO 的理念是：“我们不要打绝对分了，我们直接对比”。 给定两个回复 A 和 B，人类只需要说“我更喜欢 A”，DPO 就能直接用这个数据来更新模型。

这听起来很完美，对吧？但 DPO 底层依赖一个数学假设——Bradley-Terry (BT) 模型。

BT 模型强制假设：如果人类认为 A 比 B 好，那一定是因为在宇宙中存在一个关于 A 的“绝对质量得分” $S_A$ ，和一个关于 B 的得分 $S_B$ ，且 $S_A > S_B$ 。

致命缺陷：偏好的不可传递性（Intransitivity）

现实中，人类的偏好往往不是一条直线，而是像“石头、剪刀、布”一样的循环。

实例： 假设有三个回复：

回复 A： 详细但冗长（石头）

回复 B： 简短但生硬（剪刀）

回复 C： 幽默但细节略少（布）

在特定情境下，用户觉得 A 比 B 好（详细胜过生硬），B 比 C 好（简短直接胜过抖机灵），但同时又觉得 C 比 A 好（幽默胜过冗长无聊）。

这时，BT 模型的逻辑崩溃了：它试图证明 $S_A > S_B > S_C > S_A$ 。这在数学上是不可能的，因为你找不到三个数字能满足这个条件。这就导致 DPO 在面对复杂人类偏好时，往往会感到困惑，最终给出一个平庸的折中方案。

3. INPO 的核心动机：从“拿高分”到“不被打败”

既然“给回复打绝对分”（PPO）和“假设存在绝对好坏”（DPO）都走不通，INPO 就提出了一个全新的世界观：

不要去追求那个虚无缥缈的“绝对最优回复”，因为在复杂的偏好网络中，它根本不存在。我们要追求的是一个“不败策略”。

INPO 把生成对话变成了一场博弈：我不求我的回复能拿 100 分，我只求无论你（或其他模型）拿出什么样的回复，我的回复在人类眼中，都不比你的差。这种状态，在博弈论中就被称为纳什均衡

第二部分：核心概念引入（博弈论与纳什均衡）

1. 新的计分板：偏好矩阵（Preference Matrix）

既然放弃了打绝对分，我们如何记录人类的偏好呢？答案是：成对比较概率（Pairwise Preference Probability）。

在 INPO 的设定中，对于同一个提示词（Prompt） $x$ ，模型生成了两个回复 $y$ 和 $y'$ 。我们不再问“ $y$ 得多少分”，而是问：“在人类眼中， $y$ 击败 $y'$ 的概率是多少？”

我们将这个概率记为： $P(y \succ y' | x)$

实例说明：

假设提示词 $x$ 是“请解释什么是黑洞”。

回复 $y$ 是一段通俗易懂的白话。

回复 $y'$ 是一段包含复杂公式的物理学定义。

在给 100 个普通人看了这两个回复后，有 80 个人觉得 $y$ 更好。那么：

$P(y \succ y' | x) = 0.8$

相应的， $y'$ 击败 $y$ 的概率就是 $1 - 0.8 = 0.2$ 。

如果我们把模型能生成的所有可能回复列成行和列，把它们两两比较的胜率填进去，就得到了一个庞大的偏好矩阵。这个矩阵记录了真实世界中错综复杂的人类偏好，哪怕它是“石头-剪刀-布”那样的循环偏好，也能被完美记录下来，而不会像 DPO 那样崩溃。

2. 核心机制：将 LLM 生成视为“二人零和博弈”

有了偏好矩阵，INPO 是如何训练模型的呢？它设计了一场二人零和博弈（Two-player Zero-sum Game）。

在这个博弈中，有两个玩家：

玩家一（你正在训练的当前模型）： 它的策略用 $\pi$ 表示。它的目标是生成一个回复 $y$ 。
玩家二（对手/环境）： 它的策略用 $\mu$ 表示。它也会生成一个回复 $y'$ 。

游戏规则（零和）：

两人同时亮出回复，然后查阅“偏好矩阵”。

如果 $y$ 赢了，玩家一得 1 分，玩家二扣 1 分。

如果 $y'$ 赢了，玩家二得 1 分，玩家一扣 1 分。

实例说明：

这就像两个学生同时交卷。老师（人类偏好）不打分，只看谁写得更好。

如果你的模型生成的回复比对手好，你的模型就“赢”了一次。为了让你训练的模型赢，你要调整模型的参数（权重），让它以后更倾向于生成能赢的回复。

3. 终极目标：寻找“纳什均衡”（Nash Equilibrium）

在传统的 PPO 中，模型的终极目标是“拿满分”。但在 INPO 的零和博弈中，不存在绝对的满分。那么，训练的终点在哪里？

答案是：纳什均衡策略（Nash Equilibrium Policy）。

在博弈论中，纳什均衡是一种“最稳健”的状态。对于我们的语言模型来说，如果一个模型策略 $\pi^*$ 达到了纳什均衡，它意味着：

无论对手（其他任何模型，或任何挑剔的人类）使用什么策略，我的模型 $\pi^*$ 的期望胜率，都绝对不会低于 50%。

这在物理意义上是一个巨大的范式转变：

传统模型： 追求生成某一种特定风格的“完美回复”（容易陷入只会说套话的 Reward Hacking）。
INPO 纳什模型： 追求一种“不败的回复分布”。它可能有时详细，有时简短，但它的整体策略分布是没有漏洞的。无论对手怎么针对你，你都不会吃亏。

第三部分：INPO 算法机制

在上一部分，我们确立了 INPO 的终极目标：找到一个在博弈中不败的纳什均衡策略。但拥有几十亿、上百亿参数的大型语言模型（LLM）极其复杂，我们不可能像解数学方程那样一步算出完美答案。

那么，我们该如何引导庞大的 LLM 走向这个均衡点呢？INPO 给出的答案是一套“无悔学习的自我博弈”（No-Regret Self-Play）机制。我们分三个核心步骤来拆解它。

1. 核心引擎：无悔学习（No-Regret Learning）

想象你在玩一个无尽版的“石头-剪刀-布”游戏。如果你一直出“石头”，对手很快就会发现并一直出“布”来赢你。这时候，你会为你之前僵化的策略感到后悔。

无悔学习（具体在 INPO 中使用的是在线镜像下降，Online Mirror Descent）的逻辑是：不断动态调整策略，使得在经历了一长串博弈之后，你的总收益不比任何一种固定的“死策略”差。

对于 LLM 来说，这意味着它在训练中绝不能把自己局限在某一种单一的回复风格里（因为总有被克制的时候）。通过无悔学习算法，模型会自动让自己的回复风格多样化且稳健，最终逼近那个“无懈可击”的纳什均衡点。

2. 左脚踩右脚的攀登：迭代过程（Iterative Process）

要把无悔学习应用在 LLM 上，INPO 设计了一个迭代自我博弈（Iterative Self-Play）的循环。它不是让模型直接和人类对战，而是让“今天的模型”和“昨天的模型”对战。

这个过程分为三个步骤（假设当前是第 $t$ 轮）：

Step 1（生成）： 使用前一轮的模型（我们称之为 $\pi_t$ ）针对各种 Prompt 生成大量的回复数据。
Step 2（比较）： 让当前正在训练的模型 $\pi$ 生成回复，并与 $\pi_t$ 的回复进行对比，通过偏好打分系统（或人类标注）得出谁更好的概率。
Step 3（更新）： 调整当前模型 $\pi$ 的参数，让它只求击败前一轮的自己（ $\pi_t$ ）。
Step 4（迭代）： 成功击败后，当前模型就晋升为新的 $\pi_{t+1}$ ，循环重新开始。

为什么要这么麻烦？因为直接对齐复杂的绝对偏好太难了。INPO 把一个巨大的难题拆解成了无数个“只要比昨天的我好一点点就行”的小目标。这也是为什么它的名字里有 Iterative（迭代的）。

3. 约束与平衡：INPO 的损失函数（Loss Function）

模型在不断打败过去自己的过程中，会不会为了赢而不择手段，最后变成了只会说乱码的疯子？为了防止这种情况，我们需要在数学上给它套上缰绳。

这就引出了 INPO 的优化目标（概念公式化简）：

$\min_{\pi} \left[ - \mathbb{E}_{y \sim \pi, y' \sim \pi_t} [ P(y \succ y') ] + \tau \text{KL}(\pi || \pi_{\text{ref}}) \right]$

这个损失函数包含两个相互拉扯的力量：

左侧（追求胜率）： 负的期望胜率（ $-P$ ）。模型要尽可能降低这个值，也就是拼命提高自己（ $y$ ）打败昨天自己（ $y'$ ）的概率。
右侧（保持人性）： KL 散度（ $\text{KL}$ ）惩罚项。 $\pi_{\text{ref}}$ 是最开始经过 SFT（监督微调）的基础模型。这一项强制要求：你再怎么变，也不能和最开始那个会说人话的基座模型偏离太远。 $\tau$ 就是控制这个缰绳松紧的系数。

正是通过这个精妙的损失函数，INPO 直接在偏好数据集上优化策略，完美避开了传统方法中“评估单一绝对分数”的高昂成本和不准确性。

第四部分：深入底层逻辑与数学推导

1. 算法引擎：FTRL（Follow-The-Regularized-Leader）

在第三部分我们提到，INPO 使用了“无悔学习”。在数学上，INPO 具体采用的是无悔学习家族中非常著名的一个算法：FTRL（正则化跟随领导者算法）。

为了理解 FTRL，我们先定义一下，在第 $t$ 轮迭代时，一个回复 $y$ 的“瞬时奖励”（ $R_t(y)$ ）是什么：

$R_t(y) = \mathbb{E}_{y' \sim \pi_t} [P(y \succ y')]$

这句话的物理意义是：回复 $y$ 在面对“昨天的模型（ $\pi_t$ ）”生成的所有可能回复时，它的平均胜率

FTRL 的核心思想是：“我要找到一个新的策略 $\pi$ ，它不仅要在当前轮次收益最高，还要尽可能不要偏离我的初始状态。” 因此，INPO 在第 $t+1$ 轮的优化目标（Objective Function）可以用以下公式严格表示：

$\max_{\pi} \mathbb{E}_{y \sim \pi} [R_t(y)] - \tau \text{KL}(\pi || \pi_{\text{ref}})$

左半边 $\mathbb{E}_{y \sim \pi} [R_t(y)]$ ： 追求胜率最大化。让模型多生成那些能打败昨天自己的回复。
右半边 $-\tau \text{KL}(\pi || \pi_{\text{ref}})$ ： KL 散度正则项。约束当前策略 $\pi$ 不能偏离基座模型 $\pi_{\text{ref}}$ （SFT 模型）太远。 $\tau$ 是温度系数。

2. 见证奇迹：闭式解（Closed-Form Solution）

上面的优化公式看起来很复杂，需要用梯度下降一步步慢慢算吗？

不需要！ 这个公式在数学上非常优美，它存在一个闭式解（Closed-form Solution）。也就是说，我们可以直接用一个等式把完美答案写出来！

通过拉格朗日乘数法（Lagrange Multiplier）对上述公式求导并令导数为 0，我们可以推导出 INPO 第 $t+1$ 轮的最优策略：

$\pi_{t+1}(y|x) = \frac{1}{Z(x)} \pi_{\text{ref}}(y|x) \exp \left( \frac{R_t(y)}{\tau} \right)$

我们把它翻译成人类语言： 新的生成概率 = 初始生成概率 X 胜率指数放大器

$\pi_{\text{ref}}(y|x)$ ：这是模型在微调（SFT）后，天生生成这个回复的概率。
$\exp( R_t(y) / \tau )$ ：这是一个乘法增益（Multiplier）。如果这个回复打败昨天模型的胜率 $R_t(y)$ 很高，指数函数会把它急剧放大；如果胜率低，就会缩小。
$Z(x)$ ：配分函数（Partition Function），仅仅是为了把所有概率加起来等于 100% 而做的一个归一化除法。

实例运算推演：

假设面对一个问题，基座模型原本生成 A、B 两个回复的概率都是 50%（ $\pi_{\text{ref}} = 0.5$ ）。

回复 A（平庸）： 胜率 $R_t(A) = 0.1$
回复 B（优秀）： 胜率 $R_t(B) = 0.9$
假设温度 $\tau = 0.5$ 。

计算 A 的放大倍数： $\exp(0.1 / 0.5) = \exp(0.2) \approx 1.22$

计算 B 的放大倍数： $\exp(0.9 / 0.5) = \exp(1.8) \approx 6.05$

更新后的相对权重：

A 的权重 = $0.5 \times 1.22 = 0.61$

B 的权重 = $0.5 \times 6.05 = 3.025$

归一化后（新的概率）：

$\pi_{t+1}(A) = 0.61 / (0.61 + 3.025) \approx 16.8\%$

$\pi_{t+1}(B) = 3.025 / (0.61 + 3.025) \approx 83.2\%$

结论： 仅仅经过一轮迭代，模型生成优秀回复 B 的概率就从 50% 飙升到了 83.2%！这就是 INPO 闭式解的威力。

3. 为什么 INPO 比 Iterative DPO 更强？

目前市面上也有其他的迭代算法，比如 Iterative DPO（迭代直接偏好优化）。INPO 和它们在数学本质上有什么区别？

Iterative DPO 的困境： DPO 的底层仍然死死绑定着 Bradley-Terry (BT) 模型（即必须假设每个回复存在一个“绝对分数”）。当进入迭代博弈时，如果数据里出现了第一部分我们说的“石头-剪刀-布”循环，DPO 的损失函数就会在数学上产生矛盾，梯度方向会相互打架，导致模型原地踏步或者崩溃。
INPO 的降维打击： 你看上面推导出的 INPO 公式，里面没有任何关于“绝对分数”的假设。它直接拿“真实世界的经验胜率矩阵 $P(y \succ y')$ ” 作为计算的原材料。因此，INPO 对数据分布的偏移（Distribution Shift）和偏好的不一致性有着极强的鲁棒性。

第五部分：实战逻辑与代码级实现思路

1. 数据构造：偏好概率是怎么算出来的？

在前面的数学推导中，我们一直假设有一个现成的“偏好概率” $P(y \succ y')$ 供我们使用。但在写代码时，这个概率从哪来？

在实际工程中，通常有两种做法：

方法 A（AI 裁判 / LLM-as-a-Judge）： 让 GPT-4 或其他更强大的模型做裁判。输入 Prompt 和两个回复，让它输出一个倾向性概率。
方法 B（奖励模型代理）： 训练一个传统的奖励模型（RM），让它给回复 A 打分 R(A)，给回复 B 打分 R(B)。然后用 Sigmoid 函数把分差转化为概率：

$P(A \succ B) = \sigma(R(A) - R(B))$

关键区别： 虽然这里用到了奖励模型打分，但 INPO 只在生成训练数据时使用它来计算相对胜率。在实际训练大模型的反向传播（Backward Pass）中，大模型根本不看绝对分数，只看计算出来的胜率矩阵。这就切断了“模型去钻裁判漏洞（Reward Hacking）”的路径。

2. 训练大架构：内外双循环（The Dual-Loop Architecture）

INPO 的代码实现是一个典型的“双循环架构”。它不能像 SFT 那样一次性把数据集跑到底，而是需要走走停停。

外层循环（Outer Loop / Data Generation）： 负责“打怪爆装备”。当前的参考模型（Reference Model, $\pi_t$ ）根据各种提示词生成海量的回复对，并交给裁判打分，构建出本轮的经验偏好数据集。
内层循环（Inner Loop / Policy Update）： 负责“闭关修炼”。用外层循环生成的数据，利用我们上一节推导出的 INPO 目标函数，进行多步梯度下降（Gradient Descent），更新模型权重。

修炼完成后，把新的模型提拔为下一轮的参考模型（ $\pi_{t+1}$ ），开启新的外层循环。

3. 核心代码逻辑（PyTorch 伪代码解析）

为了让你看清底层，下面是 INPO 内层循环（模型更新）的最核心代码逻辑（已极度简化，仅保留数学骨架）：

import torch
import torch.nn.functional as F

def inpo_loss(policy_model, ref_model, batch_data, tau=0.5):
    """
    INPO 核心损失函数计算
    batch_data 包含: prompts, response_A, response_B, win_rate_A (A击败B的概率)
    """
    prompts, resp_A, resp_B, win_rate_A = batch_data
    
    # 1. 计算当前模型（正在训练的模型）生成 A 和 B 的对数概率
    log_prob_A = policy_model(prompts, resp_A)
    log_prob_B = policy_model(prompts, resp_B)
    
    # 2. 计算参考模型（昨天的模型）生成 A 和 B 的对数概率 (不需要计算梯度)
    with torch.no_grad():
        ref_log_prob_A = ref_model(prompts, resp_A)
        ref_log_prob_B = ref_model(prompts, resp_B)
        
    # 3. 计算 KL 惩罚项 (当前模型与参考模型的差异)
    kl_penalty_A = log_prob_A - ref_log_prob_A
    kl_penalty_B = log_prob_B - ref_log_prob_B
    
    # 4. 构建 INPO 的对齐目标 (根据闭式解推导出的损失函数)
    # 我们希望增大胜率高的一方的概率，同时减去 KL 惩罚
    # 这里用一种简化的对比损失形式来体现 FTRL 的更新逻辑
    
    # 胜率优势差
    advantage = win_rate_A - (1 - win_rate_A) 
    
    # INPO 对数比率损失 (类似 DPO，但目标是真实概率而非绝对分数假设)
    loss = - F.logsigmoid( (log_prob_A - log_prob_B) - (ref_log_prob_A - ref_log_prob_B) ) * advantage
    
    # 加上 KL 正则化
    total_loss = loss.mean() + tau * (kl_penalty_A.mean() + kl_penalty_B.mean())
    
    return total_loss

# --- 训练主循环 ---
# for epoch in range(num_epochs):
#     optimizer.zero_grad()
#     loss = inpo_loss(policy_model, ref_model, batch)
#     loss.backward()  # 反向传播，计算梯度
#     optimizer.step() # 更新模型权重

在原论文中，研究团队基于 LLaMA-3-8B（一个相对较小的 80 亿参数模型）进行了实验。INPO 的最终效果可以用三个词来概括：全面碾压、拒绝作弊、稳如老狗。

具体来说，INPO 取得了以下三大核心战果：

1. 榜单跑分全面碾压

在业界公认的两个最难对齐评测榜单上，INPO 的成绩大幅甩开了传统的 DPO 甚至其他迭代版本的 DPO（如 Iterative DPO）：

AlpacaEval 2.0： INPO 拿下了 42.6% 的胜率（作为对比，当时的迭代 DPO 只有约 29%）。
Arena-Hard v0.1： INPO 拿下了 37.8% 的胜率（同样远超对比基线）。
这意味着，一个经过 INPO 训练的 8B 小模型，在实际人类体感上，已经能在相当一部分问题上和体量大几十倍的模型掰手腕了。

2. 治好了大模型的“废话字数作弊症”（Length Bias）

传统算法（尤其是 PPO 和早期的 DPO）有一个致命弱点：模型会发现人类偏好“长篇大论”。于是，为了拿高分，模型无论遇到什么问题都会强行水字数。而 INPO 在 AlpacaEval 2.0 上拿下的 42.6% 是**“长度控制胜率（Length-controlled win rate）”**。这意味着 INPO 是凭真本事（逻辑、准确性、语气）赢的，而不是靠堆砌废话作弊。

3. 更稳定的迭代轨迹

很多其他试图“左脚踩右脚”的迭代算法，往往在第 2 轮或第 3 轮时因为模型“学歪了”而导致胜率断崖式下跌。而 INPO 得益于其底层 FTRL（无悔学习） 和那个极其优美的 KL 惩罚闭式解，它的训练轨迹呈现出完美的、单调递增的稳步爬坡状态。