论文精度第四期：OPENAI-Let‘s Verify Step by Step:拒绝幻觉，验证每一个思考的瞬间

最新推荐文章于 2026-01-01 13:05:56 发布

原创最新推荐文章于 2026-01-01 13:05:56 发布 · 955 阅读

23 ·

CC 4.0 BY-SA版权

文章标签：

#人工智能 #神经网络 #深度学习 #自然语言处理 #语言模型 #transformer #nlp

论文精读专栏收录该内容

5 篇文章

订阅专栏

内容概览

这篇论文的核心是探索如何更有效地训练大型语言模型，使其在解决复杂数学问题时变得更可靠和准确。它重点关注并比较了两种提供监督信号的方法：过程监督 和 结果监督。

一、研究背景与核心问题

在理解这篇论文之前，我们需要先看一个背景：Chain-of-Thought (CoT)。你应该很熟悉 prompt 里的那句咒语：“Let's think step by step”（让我们一步步思考）。这能显著提高模型的推理能力。

但是，OpenAI 发现了一个致命的问题：逻辑幻觉（Logical Hallucination）。模型经常会写出一长串推理步骤，中间逻辑是错的，但碰巧“蒙”对了答案；或者中间逻辑是对的，最后一步算错了。

为了解决这个问题，这篇论文提出了两个核心概念的对比：

传统的做法：结果监督（Outcome Supervision, ORM）

定义：就像现在的许多 RLHF（基于人类反馈的强化学习），我们只看模型最后输出的那个答案是对还是错。
机制：模型生成一整段解题过程，如果不看过程，只看最后答案。答案对，给正向奖励；答案错，给负向奖励。我们称之为 ORM (Outcome Reward Model)。
缺点：这非常像是一个只看分数的粗心老师。学生（模型）可能中间全是瞎编的，但只要蒙对了答案，老师就给满分。这就导致模型学会了“走捷径”或“欺骗”，而不是真正学会推理。

论文提出的新做法：过程监督（Process Supervision, PRM）

定义：这是本篇论文的主角。我们不只看结果，而是要一步一步地检查模型的推理步骤。
机制：模型每生成一个推理步骤（Step），我们就让一个“监考官”（Reward Model）去判断这一步是对是错。只有每一步都走对了，才能得到奖励。我们称之为 PRM (Process Reward Model)。
优点：这就像一个负责任的数学老师，他会一行一行检查你的证明过程。如果你第一行公式推错了，他立刻打叉，哪怕你最后答案是对的也没用。

在 2023 年，学界普遍存在一个担忧：对齐税（Alignment Tax）。大家认为，如果你为了让模型更安全、更符合人类逻辑（Alignment）而去强行干预它，可能会导致模型变笨，性能下降。

但这篇论文得出了一个惊人的结论：

使用过程监督（PRM）不仅能让推理更靠谱，而且在极难的数学数据集（MATH）上，PRM 的表现显著击败了 ORM。

这意味着：在这个领域，“对齐”并没有导致“税收”，反而带来了“红利”。 我们通过更细致的人类思维对齐，直接提升了模型的智力上限。

二、研究方法与关键实验

1. 核心组件

研究包含几个关键部分：

生成器：一个基于GPT-4微调得到的模型，负责生成数学问题的多步解决方案。
过程监督奖励模型（PRM）：训练用于预测每个推理步骤的正确概率。
结果监督奖励模型（ORM）：训练用于预测整个解决方案最终答案的正确性。

2. 数据收集：PRM800K数据集

为了训练一个能看懂每一步逻辑的 PRM，OpenAI 发布了一个极具价值的数据集：PRM800K。

规模：包含 80 万（800,000） 个经过人类标注的步骤级标签。
来源：基于 MATH 数据集（一个包含极大挑战性的数学竞赛题目集）。
标注颗粒度：这是关键。他们不是给整道题打分，而是让标注员看着模型生成的解题过程，给每一个步骤打标签。

OpenAI 制定了一套非常严格的标注标准，将每个步骤分为三类（注意这个分类对你的 RLHF 研究很有参考价值）：

Positive (+)：这一步是正确的，并且对解题有帮助。
Negative (-)：这一步是错误的，或者是逻辑跳跃太大无法验证。
Neutral (?)：这一步虽然没错，但对解题没啥大用（比如废话），或者只是简单的重述。

OpenAI 在训练最终的 PRM 模型时，为了简化，通常只关注 Positive 和 Negative。也就是说，他们实际上训练的是一个二分类器：预测每一步“出错的概率”。

如果随机生成一堆解题过程让人去标，效率会极低，因为模型在很多简单题上不会出错，标注这些数据对提升模型能力边际效益为零。

OpenAI 使用了主动学习策略来“寻找”那些最值得标注的数据。这是极佳的 Data-Centric AI 范例。

流程如下：

生成：用现有的模型针对一道题生成 N 个解题方案。
筛选 (Filtering)：这是核心。他们不想标那些显而易见的对或错。他们设计了一种机制，专门挑选那些能骗过现有 PRM 的错误样本。
- 即：目前的 PRM 认为这一步是对的（高分），但最终答案却是错的。这说明这里面藏着一个很隐蔽的逻辑陷阱。
标注：把这些最具迷惑性的样本丢给人类专家去标注。
迭代：用新数据更新 PRM，然后重复上述步骤。

本质：这其实是一个对抗过程。我们在不断寻找模型逻辑链条中最薄弱、最容易产生幻觉的环节进行修补。

3. PRM 的训练方式：从 Token 到逻辑

有了数据，怎么训练？

模型架构：基于 GPT-4（小参数版本）。
输入形式：[Question] [Step 1] [Step 2] ... [Current Step]
预测目标：模型不需要生成下一个 token，而是要对当前这个 Step 的最后一个 Token 进行分类（Good/Bad）。

这里有一个数学上的重要处理：

$L_{PRM} = - \sum_{t \in Steps} \log P(label_t | context_t)$

简单来说，就是标准的交叉熵损失函数，只在每个步骤结束的地方计算 Loss。

与之对比，ORM（结果监督） 的训练就粗糙得多，它只能等到整个序列生成完，拿到最终答案，再回过头来给整个序列打一个分。

核心实验结果：PRM 到底强在哪？

OpenAI 做了一个非常直观的对比实验，称为 Best-of-N (BoN) 搜索。

玩法：让模型针对一道题生成 N 个不同的解法。
ORM 的选法：用 ORM 模型给这 N 个解法打分，选分最高的那个作为答案。
PRM 的选法：用 PRM 模型给每个解法的“每一步”打分，计算出每条路径的可靠性（通常是所有步骤分数的乘积或最小值），选最可靠的那条路径。

结果：

随着 N（生成的解法数量）增加，PRM 的性能曲线一路飙升，远远甩开了 ORM。

在 MATH 数据集上，PRM 的准确率达到了 78.2%，而当时 SOTA 的 GPT-4 只有 54% 左右。
更重要的是，ORM 的曲线在大 N 时会饱和甚至下降。为什么？因为 ORM 容易被“投机取巧”的解法欺骗（逻辑错但答案对），样本越多，这种欺骗样本越多。而 PRM 因为一步步检查，很难被骗。

三、主要研究结果与贡献

1. 核心发现：过程监督显著优于结果监督

在具有挑战性的MATH数据集上，过程监督（PRM）的表现远胜于结果监督（ORM）。随着对每个问题生成的解决方案数量（N）增加，PRM的优势更加明显。

上图直观展示了PRM的工作方式：它能准确识别出错误解决方案中的具体错误步骤（红色背景），而对正确的解决方案（绿色背景）给予高分。

2. 主动学习大幅提升数据效率

论文发现，采用主动学习策略后，过程监督的数据效率提升了2.6倍。这意味着可以用更少的人工标注数据，训练出性能更好的模型，显著降低了成本。

3. 出色的泛化能力

将训练好的ORM和PRM模型应用于全新的STEM考试题目（如AP、AMC等）上，PRM同样表现出最强的性能，这说明其能力可以很好地迁移到未见过的、不同分布的问题上。

4. 发布PRM800K数据集

为了促进相关研究，论文开源了完整的PRM800K数据集，为后续研究消除了数据收集这一巨大障碍。

四、讨论与意义

1. 信用分配问题

过程监督的优势根源在于它更好地解决了信用分配问题。结果监督只知道最终答案错了，但不知道是哪里错了，模型很难从中学习。而过程监督精确指出了错误的位置，让模型学习起来更高效。

2. 对AI对齐的积极影响

论文指出，过程监督不仅性能更好，而且对AI对齐有积极意义：

负对齐税：通常，更安全的方法会牺牲一些性能（即“对齐税”）。但过程监督反其道而行，在提升安全性的同时也提升了性能，这有助于推动其在实际中的应用。
鼓励可解释性：过程监督直接奖励符合人类逻辑的推理过程，可能促使模型生成更易于人类理解和检查的推理步骤。
更安全：它减少了模型通过“瞎蒙”或错误推理得到正确答案而受到奖励的风险，这有助于防止模型学习到不符合人类意图的行为。

总结

这篇论文通过严谨的大规模实验证明，在训练模型解决复杂数学推理问题时，过程监督是一种远比结果监督更有效、数据效率更高且更有利于AI对齐的方法。其主要贡献在于确立了过程监督的优越性，引入了主动学习策略，并发布了宝贵的PRM800K数据集，为未来构建更可靠、更可信的AI系统奠定了重要基础。

伪代码：Let's Verify Step by Step (PRM vs ORM)

class MathSolverTrainer:
    def __init__(self, model, optimizer):
        self.llm = model  # 基础的大语言模型 (如 GPT-4 base)
        self.optimizer = optimizer

    def train_step(self, question, ground_truth_answer):
        """
        对比两种训练模式的核心逻辑
        """
        # 1. 让模型生成推理链 (CoT)
        # 这里的 solution 包含一系列步骤: [step_1, step_2, ..., step_N]
        generated_solution = self.llm.generate(question)
        
        # ==========================================
        # 方式 A: 结果监督 (ORM - Outcome Reward Model)
        # ==========================================
        # 逻辑：只看最后一眼。
        # 缺点：如果过程错了但答案蒙对了（False Positive），模型会被错误奖励。
        # ==========================================
        def train_orm():
            final_answer = extract_answer(generated_solution)
            
            # 只有 0 或 1 的稀疏信号
            reward = 1.0 if final_answer == ground_truth_answer else 0.0
            
            # ORM 预测整个序列的好坏 (通常取最后一个 token 的 logits)
            prediction = self.llm.predict_outcome(question, generated_solution)
            
            # Loss 只在序列末尾计算一次
            loss_orm = binary_cross_entropy(prediction, reward)
            
            loss_orm.backward()
            self.optimizer.step()

        # ==========================================
        # 方式 B: 过程监督 (PRM - Process Reward Model)
        # ==========================================
        # 逻辑：步步为营。论文的核心贡献。
        # 优点：信号密集，能纠正“逻辑幻觉”。
        # ==========================================
        def train_prm(human_labeler):
            total_loss = 0
            history_context = question
            
            # 遍历每一个推理步骤
            for step in generated_solution.steps:
                # 关键点 1: 获取每一步的标签 (Data Engine 的核心)
                # 标签通常是: Positive, Negative, Neutral
                # 论文中使用 Active Learning 挑选难样本给人类标注
                step_label = human_labeler.verify(history_context, step) 
                
                # 关键点 2: 模型基于当前上下文，预测这一步是对是错
                # 实际上是预测这一步最后一个 Token 的分类 logits
                step_prediction_score = self.llm.predict_step_validity(history_context, step)
                
                # 关键点 3: 每一步都计算 Loss
                step_loss = cross_entropy(step_prediction_score, step_label)
                
                # 累加 Loss
                total_loss += step_loss
                
                # 更新上下文，准备检查下一步
                history_context += step

            # 反向传播：梯度流向每一个步骤，修正每一个逻辑断点
            total_loss.backward()
            self.optimizer.step()

# ==========================================
# 补充：论文中的主动学习 (Active Learning) 数据筛选逻辑
# ==========================================
def active_learning_sampler(model, dataset):
    """
    OpenAI 并不是随机标注，那样太贵且效率低。
    他们专门找“骗过模型”的例子。
    """
    candidates = []
    
    for question in dataset:
        # 对一个问题生成 N 个解法
        solutions = model.generate(question, num_return_sequences=100)
        
        for sol in solutions:
            # 找到那些：PRM 觉得是对的 (High Score)，但最终答案是错的解法
            # 这叫 "Convincing False Positives" (极具迷惑性的错误)
            if model.prm_score(sol) > 0.9 and extract_answer(sol) != correct_answer:
                candidates.append(sol)
                
    # 只把这些最能提升模型智商的样本送去给人类标注
    return send_to_human_annotators(candidates)