第 3 讲：鲁棒的验证（Robust Verification）——怎样缩小 Generation–Verification Gap

对应：Stanford CS329A Autumn 2025 Lecture 3（Mon 9/29，Robust Verification）。阅读材料：Training Verifiers to Solve Math Word Problems（Cobbe et al. 2021）、Let’s Verify Step by Step（Lightman et al. 2023）、Math-Shepherd（Wang et al. 2023）、Shrinking the Generation-Verification Gap with Weak Verifiers（Weaver，Saad-Falcon et al. 2025）。幻灯片没有公开，本讲依据这四篇论文编写。 配套代码：code/lecture03/（只用 Python 标准库，每个文件 2 秒以内） 预计阅读时间：3 小时（含运行代码）

0. 本讲导航

0.1 学完本讲，你应该能够

1. 说出 verifier 在自我改进中的三种用途：测试时挑选和搜索、强化学习的奖励、自我训练的数据过滤；解释为什么 verifier 的质量决定了这三件事的上限。
2. 区分几类 verifier：规则 / oracle、outcome reward model（ORM）、process reward model（PRM）、LLM-as-judge、生成式 verifier。
3. 说出 Cobbe et al. 的方法和发现：GSM8K、用最终答案标注训练 verifier、verifier 的效果相当于把模型放大约 30 倍、候选太多时 verifier 会被骗。
4. 说出 Lightman et al. 的结论：过程监督比结果监督好（MATH 上 78.2% vs 72.4%）；说出过程监督的三个好处：更精确的 credit assignment、不奖励”答案对但过程错”、可以给不完整的解答打分。
5. 说出 Math-Shepherd 怎样用 rollout 自动生成过程标签（hard / soft estimation），并指出这种标签估计的其实是 completer 的价值函数，而不是”这一步对不对”。
6. 说出 Weaver 的思路：用弱监督（不需要标签）估计每个弱 verifier 的准确率并加权组合；解释为什么 verifier 准确率差别大时加权很关键，以及条件独立假设被违反时会发生什么。
7. 说出 verifier 不鲁棒的几种方式（被大量候选攻破、被搜索过度优化、和生成者错得一样），以及让 verifier 更鲁棒的思路。

0.2 先修知识

0.3 本讲地图

第1节  为什么 verification 是自我改进的核心
第2节  检查结果：outcome verifier（Cobbe et al. 2021）            ← 代码 01 演示 1
第3节  检查过程：process verifier（Lightman et al. 2023）          ← 代码 01 演示 2、3
第4节  没有人工标注的过程监督：Math-Shepherd                        ← 代码 02
第5节  把弱 verifier 合成强 verifier：Weaver                       ← 代码 03
第6节  verifier 怎样失效，怎样让它更鲁棒
第7–10节 小结、练习、延伸阅读、下一讲预告

0.4 toy world 里的 verifier

本讲的工具模块 verifier_tools.py 让 verifier 也是一个 ToyLLM（称为 checker），它用自己的能力去检查：

例如一道 5 步题，一个在最后一步犯了 bug 的候选，100B checker 给各步的分数是 [0.92, 0.98, 0.94, 0.85, 0.04]：前四步可信，最后一步非常可疑。而一个全对的候选是 [0.92, 0.98, 0.94, 0.85, 0.94]。

这些都是卡通：真实的 ORM / PRM 是训练出来的打分模型，并不真的”重算”。但它们刻画了几个真实的机制：检查一步比解完整道题容易、checker 和生成者有同样的盲点、过程信息能用来定位错误和指导搜索。

关于本讲的数字：论文里的数字注明出处；模拟实验的数字都来自 01~03 号代码的实际输出（固定随机种子，Python 3.9 与 3.13 逐字相同），说明的是机制，不代表真实模型。

1. 为什么 verification 是自我改进的核心

1.1 回顾：generation–verification gap

第 1、2 讲反复看到同一个现象：模型能生成正确答案的概率（coverage）远高于我们能挑出正确答案的概率。第 1 讲第 6.6 节还算出了一个上限：一个 FPR 为 15% 的 judge，在难题上会把准确率限制在它的 precision 附近。

这个差距叫 generation–verification gap。它决定了：

• test-time scaling 能走多远：采样再多，挑不出来也没用（第 2 讲）。
• 强化学习能学到什么：RL 的奖励就是 verifier 的输出；verifier 有漏洞，模型就会学会钻漏洞（reward hacking，第 6 讲）。
• 自我训练会不会越训越歪：STaR 这类方法只用”verifier 认为正确”的样本训练自己（第 6 讲）；verifier 放进来的错误样本，会被模型学进去。

1.2 verifier 的三种用途

注意第二种用途特别苛刻：测试时的候选是”自然地”生成的，而 RL 的策略会主动地寻找能得高分的输出。一个在测试时表现不错的 verifier，在 RL 里可能很快被攻破。

1.3 验证比生成容易吗？

自我改进的一个基本信念是：检查一个答案比生成一个答案容易。很多问题确实如此：

• 数独、因数分解、很多数学证明：找到解很难，验证解很容易（这是计算复杂性里 P vs NP 问题的直觉）。
• 代码：写对很难，跑一遍测试很容易。

但并不总是如此：

• 开放式的写作：判断一篇文章好不好，可能和写一篇一样难。
• 事实性问题：判断”某个冷门事实对不对”，需要的知识和回答它一样多。
• 长推理链：要判断一个 20 步的推理对不对，可能需要把每一步都重新推一遍。

本讲的几个方法，可以看作在不同程度上”人为地”让验证变得更容易：Lightman 把”判断整份解答”拆成”判断每一步”（第 3 节）；Math-Shepherd 用”能不能做到正确答案”代替”这一步在逻辑上对不对”（第 4 节）；Weaver 用很多个不完美的判断代替一个完美的判断（第 5 节）。

1.4 verifier 的种类

2. 检查结果：Outcome Verifier

2.1 GSM8K 与”训练一个 verifier”

Cobbe et al. 2021（OpenAI）做了两件事。第一件是发布 GSM8K：8.5K 道小学数学应用题（7.5K 训练、1K 测试），每题需要 2~8 步推理，答案是一个数。题目在概念上很简单，但当时最大的模型也做得很差。这让 GSM8K 成为之后几年衡量”多步推理”最常用的数据集之一。

第二件是提出训练 verifier：

1. 在训练集上微调一个生成器（generator）。
2. 对每道训练题，用生成器采样 100 个解答，按最终答案是否正确给每个解答打上对 / 错的标签。
3. 用这些带标签的解答训练一个 verifier：输入题目和解答，输出”这个解答正确的概率”。
4. 测试时，对每道题采样 100 个解答，选 verifier 分数最高的。

注意第 2 步的标签只需要最终答案，不需要人去看过程，非常便宜。这就是 outcome supervision（结果监督）。

2.2 主要发现

• verifier 的效果很大：论文报告，6B 的模型加上 verifier，略好于微调过的 175B 模型——相当于把模型放大约 30 倍。
• verifier 随数据扩展得更好：训练数据增加时，“生成 + 验证”的提升比”只微调生成器”的提升更快。
• token 级的 verifier 更好：不只在解答末尾预测一次”对不对”，而是在每个 token 的位置都预测”到这里为止，最终能做对的概率”。这样训练信号更密，也更不容易过拟合。这其实已经有了一点”过程”的味道（第 3、4 节）。
• 候选太多时会变差：从 100 个候选增加到大约 400 个时效果最好，再多反而下降——候选越多，越有可能出现”骗过 verifier”的错误解答。第 1 讲第 5.4 节用 toy world 复现过这个现象。

2.3 toy world：verifier 的强弱比类型更重要

01_orm_vs_prm.py 演示 1：10B 生成器，200 道 3~8 步题，比较几种挑选方法（ORM、PRM 都直接选最高分）：

三个发现：

1. 自己检查自己，只比投票好一点点（ORM(10B)、PRM(10B)：$N = 64$ 时约 0.70，投票 0.685）。checker 和生成者有同样的盲点：它”最相信”的错误套路，检查时也会被判成对的。这和第 1 讲 self-check 的问题一模一样。
2. 换成更强的 checker，挑选几乎追上 coverage。generation–verification gap 要靠一个”比生成者更懂”的检查者来缩小。verifier 的强弱远比它的类型重要：同样用 100B 当 checker，ORM 和 PRM 在这里挑得一样好。
3. verifier 很可靠时，weighted 反而更差（0.840 vs 0.985）。weighted 把同一答案的分数相加，频繁出现的错误答案”人多势众”地被加了分。第 2 讲用的是一个噪声大的 verifier，那里 weighted 更稳健；这里 verifier 很准，直接选最高分更好。挑选方法要和 verifier 的质量匹配。

既然只比较完整答案时 ORM 和 PRM 一样好，PRM 的价值在哪里？下一节回答。

3. 检查过程：Process Verifier

3.1 过程监督 vs 结果监督

Lightman et al. 2023（OpenAI，Let’s Verify Step by Step）问了一个直接的问题：训练 reward model 时，是只告诉它”最终答案对不对”（结果监督，outcome supervision），还是告诉它”每一步对不对”（过程监督，process supervision）？

PRM800K：他们请人给 GPT-4 生成的 MATH 解答逐步打标签，每一步标为正确、错误或中性，一共约 80 万个步骤标签，覆盖 1.2 万道题的 7.5 万个解答。标注员从第一步开始判断，标到第一个错误为止。

PRM 的打分：PRM 对每一步预测”这一步正确的概率”，整个解答的分数是所有步骤都正确的概率，即各步概率的乘积。

结果（GPT-4 生成器，MATH 测试集的一个代表性子集，每题 1860 个候选）：

论文还做了受控的小规模实验（用大 PRM 当”标注员”来合成标签，从而公平地比较两种监督），发现在各种数据规模下过程监督都优于结果监督；并且用主动学习（优先标注”答案错但看起来很有说服力”的解答）能让过程监督的数据效率提高约 2.6 倍。

3.2 为什么过程监督更好？

原因一：更精确的 credit assignment（功劳分配）。 结果监督只告诉模型”这份 10 步的解答错了”，没告诉它错在哪一步。reward model 必须自己从大量样本里推断”哪种步骤导致了错误”，这需要更多的数据。过程监督直接指出错误的位置。这是 RL 里经典的 credit assignment 问题，第 6 讲还会遇到。

原因二：不奖励”答案对但过程错”。 结果监督把所有答对的解答都当作好的，包括那些推理有错、答案碰巧对了的。这在答案只有少数几种可能的题上（选择题、是非题）尤其严重。

01_orm_vs_prm.py 演示 2 量了一下这种情况有多常见：

在 toy world 里，错误会互相抵消（例如一步少算 10、后一步多算 10），所以弱模型”答对”的解答里有十分之一其实推理有错。用最终答案当标签时，这些都会被当成好样本：ORM 学会奖励错误的推理，用自己的正确解答训练自己（第 6 讲的 STaR）也会把错误的推理学进去。 足够强的 PRM 逐步检查，把它们全部找了出来；对答错的解答，它多数时候能指出第一个错误在哪一步（生成器越强、错误越少越集中，定位越准）。

Lightman et al. 把这一点上升到对齐（alignment）的高度：过程监督奖励的是”人类认可的推理过程”，而不只是”正确的结果”。他们认为过程监督有”负的对齐税”（negative alignment tax）：它既让模型的推理更可信，又让成绩更好。

原因三：可以给不完整的解答打分，从而指导搜索。 ORM 必须等解答写完才能打分；PRM 在写到一半时就能说”到这里为止看起来是对的”。这让逐步搜索成为可能。

3.3 PRM 引导的 beam search

第 2 讲第 4.2 节介绍过 Snell et al. 的 beam search：一步一步地生成，每一步只保留 PRM 分数最高的几个部分解答。01_orm_vs_prm.py 演示 3 在相同的生成量下比较了它和 best-of-N：

（$B$ 是保留的部分解答数，$E$ 是每个部分解答扩展出的”下一步”数。）

• 用强的 PRM 时，beam search 明显更好，预算越小差距越大（预算 4：0.885 vs 0.745）。best-of-N 要等整道题写完才能挑，一步写错整份解答就作废；beam search 每一步都把明显错误的分支剪掉，把生成量集中在”还在正确的路上”的前缀上。
• 用自己当 PRM 时，beam search 没有优势：PRM 看不出模型自己的误解，剪枝剪错了方向。
• Snell et al. 在 MATH 上的发现一致：预算小、题目难时 beam search 更好；预算大、题目简单时，beam search 会”过度优化” PRM 的分数，反而不如 best-of-N（第 2 讲第 4.2 节）。这是 verifier 不鲁棒的另一种表现（第 6 节）。

3.4 聚合方式与成本

怎样把各步的分数合成一个？

• 乘积（Lightman）：所有步骤都对的概率。缺点：对长解答不公平，步数越多乘积越小。
• 最小值：只看最可疑的一步。对长度不太敏感。
• 最后一步（Snell 的选项之一）：等于把 PRM 当 ORM 用。

实践中不同的数据集、不同的 PRM 适合不同的聚合方式，通常要在开发集上选。

成本：真实的 PRM 读一遍解答，在每一步的末尾输出一个分数，一次前向传播就能给所有步骤打分，成本和 ORM 差不多。toy world 里的 ORM 要让 checker 重解 4 遍，实际上贵得多——这是 toy 的简化，不是真实 ORM 的特点。真正昂贵的是 PRM 的训练标签：PRM800K 需要大量的人工标注。下一节看怎样不用人工得到过程标签。

4. 没有人工标注的过程监督：Math-Shepherd

4.1 想法：一步好不好，看从这一步往后还能不能做对

Math-Shepherd（Wang et al. 2023）的想法很简单：

解答的第 $i$ 步是好的，当且仅当从这一步出发，还能得到正确的最终答案。

怎样知道”能不能”？试一试：保留解答的前 $i+1$ 步，让一个 completer 模型往后续写 $N$ 次，看有几次做对。由此得到两种标签：

• hard estimation（HE）：只要有一次做对，第 $i$ 步就标为”好”：$\ell_i = \mathbb{1}[\exists j:\ \text{续写}_j \text{ 做对}]$。
• soft estimation（SE）：做对的比例：$\ell_i = \frac{1}{N}\sum_j \mathbb{1}[\text{续写}_j \text{ 做对}]$。

训练数据只需要题目和最终答案（用来判断续写是否做对），不需要人去看过程。用这些标签训练出的 PRM 有两种用途：测试时给候选排序（verification），以及在 RL 里给每一步提供奖励（step-by-step PPO）。论文报告，step-by-step PPO 把 Mistral-7B 在 GSM8K 上从 77.9% 提高到 84.1%、MATH 上从 28.6% 提高到 33.0%；再加上 Math-Shepherd 的 verification，分别达到 89.1% 和 43.5%。第 2 讲里 Snell et al. 训练 PRM 用的也是这种 Monte Carlo 标签。

4.2 toy world：标签有多准？

02_math_shepherd.py 演示 1 用 10B 模型当生成器和 completer，对 300 个解答的每一步（最后一步除外）生成标签，和”真实的过程标签”（这一步之前是否全对）比较：

• 漏判随 $N$ 增大迅速减少：$N$ 小时，completer 可能只是”这几次运气不好”。
• 误判却随 $N$ 增大而上升，$N = 64$ 时约 10%。续写次数一多，总有几次因为错误碰巧抵消而”做对”——正是第 3.2 节”答案对、过程错”的现象。HE 只要”有一次做对”就算好，对这种运气非常敏感，所以它的准确率在中间的 $N$（这里是 16）上最高。
• SE 在好、坏两类上分得很开（约 0.59 vs 0.005），而且不随 $N$ 漂移。“SE 超过一个小阈值”的硬标签在 $N$ 大时比 HE 更稳（$N \le 16$ 时 SE 的最小非零值 $1/N$ 已经超过 0.05，两种标签完全相同）。
• 代价是续写次数：每个解答要续写 $N \times$ 步数次。但这只在造训练数据时做一次，之后训练出的 PRM 打分很便宜。续写需要知道标准答案，所以 rollout 不能在测试时直接当 verifier 用。

演示 3 用这些标签定位第一个错误步骤（155 个”错误发生在最后一步之前”的错误解答）：

$N$ 小时标签常在第一个错误之前就报错（漏判），定位偏早；$N$ 太大时 HE 又会因为”碰巧做对”把错误的前缀标成好，定位偏晚。

4.3 SE 估计的到底是什么？

演示 2 只看”前缀全对”的步骤（真实标签都是”好”），按剩余步数分组看 SE 的平均值（每步续写 16 次）：

同样是完全正确的前缀，剩下的步骤越多，SE 越低；换一个更强的 completer，同样的前缀 SE 就高得多。所以：

SE 估计的是”completer 从这里出发还能做对的概率”，也就是 completer 的价值函数 $V^{\pi}(\text{前缀})$，而不是”这一步本身对不对”。

用强化学习的语言：设 completer 是策略 $\pi$，奖励只在最后（答案对为 1，否则为 0），那么

这是一个用 Monte Carlo 方法估计的价值函数（CS234 第 3 讲的 MC 策略评估）。

这有好有坏：

• 对搜索和 RL 来说，这正是想要的：beam search 和 RL 关心的就是”从这里出发能不能做对”（第 5、6 讲）。
• 对”判断推理在逻辑上对不对”来说，它混入了”后面难不难""completer 强不强”的因素。一个完全正确的步骤，如果后面的路很难走，也会得到低分。用它训练出的 PRM，学到的是”对这个 completer 来说前途如何”。

5. 把弱 verifier 合成强 verifier：Weaver

5.1 动机

Weaver（Saad-Falcon et al. 2025，作者包括讲师 Azalia Mirhoseini）的出发点是：高质量的 verifier 要么不可扩展（人），要么适用面窄（Lean 这样的证明器）。手头常有的是一堆弱 verifier：开源的 reward model、各种 LLM judge，各有各的偏差，准确率参差不齐。它们单独用都和 oracle 差距很大，能不能合起来？

5.2 三种组合方式

1. 不加权投票：每个 verifier 一票，票数最多的候选胜出。简单，但好的、差的 verifier 一人一票。
2. 加权：给准的 verifier 更大的权重。最自然的权重来自朴素贝叶斯：verifier $j$ 的真阳性率 $\text{TPR}_j$、假阳性率 $\text{FPR}_j$ 已知时，候选正确的对数赔率是

其中 $v_j \in \{0, 1\}$ 是 verifier $j$ 的投票，$\pi$ 是候选正确的先验概率。TPR > FPR 的 verifier 投”对”时增加赔率；TPR < FPR 的（“反着来”的）verifier 投”对”时降低赔率——它的权重自动变成负的；TPR ≈ FPR 的 verifier 权重接近 0。问题是 TPR、FPR 需要有标签的数据来估计。 3. Weaver：弱监督（weak supervision）。在没有标签的情况下估计每个 verifier 的 TPR、FPR。核心假设是条件独立：在”候选是否正确”已知的条件下，各个 verifier 的判断彼此独立。在这个假设下，只看 verifier 之间”谁和谁意见一致”，就能推断出谁更准。

5.3 为什么”意见一致”能告诉我们谁准？

直觉：假设有三个 verifier。如果 A 和 B 经常意见一致，A 和 C 也经常一致，B 和 C 也经常一致，那么它们大概都比较准（三个随机猜测的 verifier 不会这么一致）。如果 C 和所有人都经常不一致，C 大概不准，或者是反着来的。

数学上，用 EM 算法同时估计”每个候选正确的概率”和”每个 verifier 的 TPR、FPR”：

• E 步：用当前的参数，按上面的朴素贝叶斯公式算出每个候选正确的后验概率 $q$。
• M 步：把 $q$ 当作”软标签”，重新估计参数：$\pi = \bar{q}$，$\text{TPR}_j = \frac{\sum q\, v_j}{\sum q}$，$\text{FPR}_j = \frac{\sum (1-q)\, v_j}{\sum (1-q)}$。
• 反复迭代直到收敛。

这和 CS329H 第 17 讲的 Dawid–Skene 模型是同一个算法：从一群标注员的标注里估计谁更可靠。有一个细节：标签 $y$ 和 $1-y$ 互换后似然完全相同，所以要从”每个 verifier 都比随机好”的初始值出发，EM 才会收敛到正确的那个解。

Weaver 在此基础上还解决了几个实际问题：

• 输出格式不统一：有的 verifier 输出概率，有的输出 1~10 分，有的输出”是 / 否”。Weaver 用数据集的统计量把它们归一化、二值化。
• 低质量的 verifier：用数据集的统计量识别并过滤掉几乎没有信息的 verifier。
• 成本：用一堆大模型当 verifier 很贵，所以 Weaver 最后用组合出的分数训练一个 400M 的 cross-encoder，把整个集成”蒸馏”成一个小模型。

结果：用 Llama 3.3 70B Instruct 当生成器、一组 70B 及以下的 judge 和 reward model 当 verifier，Weaver 在推理和数学任务上的平均挑选准确率达到 87.7%，接近 o3-mini 的水平；这个提升幅度相当于从 GPT-4o（69.0%）到 o3-mini（86.7%）——后者需要大量的微调和后训练。

5.4 toy world：EM 估得准吗？加权什么时候重要？

03_weaver.py 用 10B 生成器、每题 16 个候选，设计了 7 个弱 verifier：

EM 没有用任何标签，独立评委（V4~V7）的 TPR、FPR 估得很准，连 V7 是”反着来”的都看出来了。来自模型的 V1、V2、V3 却被高估了（TPR 估高、FPR 估低）：它们的错误彼此相关，“意见一致”被误读成”都很准”（第 5.5 节）。

挑选准确率（测试集 120 题）：

• 演示 1：这组 verifier 大多比较像样，三种组合方法都好于最好的单个 verifier，彼此相差不到 0.03（在噪声范围内）。
• 演示 2：再加两个”反着来”的评委（候选和原有 7 票完全相同），不加权投票从 0.833 掉到 0.783：一人一票时，三个反着来的评委足以把结果带偏。有标签的加权和 Weaver 几乎不受影响，因为它们知道 V7~V9 的票要”反着读”。

这正是 Weaver 论文的核心发现：verifier 的准确率差别很大时，加权组合远好于不加权组合，而弱监督能在没有标签的情况下估出这些权重。 在真实场景里，“差别很大”是常态：一个在代码上很强的 reward model，在数学上可能几乎随机；一个有长度偏差的 judge，在”短而正确 vs 长而错误”的比较上会系统性地反着来。

5.5 条件独立被违反时

演示 3 量了 V1 和 V2 在错误候选上一起犯错的程度：

• V1 误判率 0.11，V2 误判率 0.13。如果两者独立，同时误判的比例应为 0.01，实际是 0.07。
• 对照：V1 和独立的 V4 同时误判的比例 0.02，独立时应为 0.03，基本吻合。

V1、V2 都来自生成器自己：模型”最相信”的错误答案，自查时两者会一起放过。EM 把这种”一起犯错”误读成”两人都很准”，于是高估了它们，给了它们过大的权重。这正是第 1 讲”self-check 和生成者错得一样”的问题，在 verifier 集成里又出现了。

教训：弱监督的方法都依赖某种独立性假设。要警惕”来自同一个模型、同一种训练数据”的 verifier：它们的一致不代表正确。集成 verifier 时，“错得不一样”比”每个都更准一点”更有价值。

6. verifier 怎样失效，怎样让它更鲁棒

6.1 四种失效方式

把前三讲的观察放在一起，verifier 至少有四种不鲁棒的方式：

1. 被大量候选攻破：候选越多，越可能有一个错误答案”恰好”骗过 verifier（Cobbe et al. 的 400 个候选之后下降；第 1 讲演示 3；第 2 讲第 4.4 节）。
2. 被搜索过度优化：搜索（beam search、RL）主动寻找 verifier 打高分的输出，找到的往往是 verifier 的漏洞而不是正确答案（Snell et al. 的 beam search 在简单题上变差）。在 RL 里这叫 reward hacking，是古德哈特定律（“当一个指标变成目标，它就不再是好的指标”）的一个实例（CS329H 第 14 讲）。
3. 和生成者错得一样：checker 和生成者共享盲点时，验证几乎没用（本讲第 2.3 节、第 5.5 节；第 1 讲 self-check）。
4. 分布偏移：verifier 在一种模型的输出上训练，用在另一种模型（或训练过程中不断变化的策略）的输出上，准确率会下降。RL 训练中的策略分布一直在变，这个问题尤其严重。

6.2 让 verifier 更鲁棒的思路

6.3 一个总结性的原则

verifier 是自我改进循环里的”真理来源”。它有多可靠，循环就能走多远；它在哪里有漏洞，循环就会在哪里出问题。

这也是为什么课程后半部分的成功案例——AlphaProof（第 13 讲，用 Lean 验证）、AlphaEvolve（第 7 讲，用程序评估）、coding agent（第 10 讲，用测试验证）——几乎都发生在有可靠、可扩展的 verifier 的领域。

7. 小结

1. verifier 是自我改进的核心：它决定了测试时能挑出多少（generation–verification gap）、RL 能学到什么（奖励）、自我训练会不会越训越歪（数据过滤）。RL 对 verifier 的要求最高，因为策略会主动寻找漏洞。
2. Cobbe et al.：用最终答案标注的数据训练 verifier（结果监督），效果相当于把模型放大约 30 倍；token 级的 verifier 更好；候选太多时 verifier 会被骗。toy world 显示：自己检查自己只比投票好一点点，verifier 的强弱比类型更重要；挑选方法要和 verifier 的质量匹配（可靠的 verifier 直接选最高分）。
3. Lightman et al.：过程监督优于结果监督（MATH 上 78.2% vs 72.4%）。原因：更精确的 credit assignment；不奖励”答案对但过程错”（toy world 里弱模型答对的解答有 10% 推理有错）；能给不完整的解答打分，从而指导逐步搜索（强 PRM 引导的 beam search 在小预算下远好于 best-of-N）。
4. Math-Shepherd：用 rollout 自动生成过程标签。HE 的漏判随续写次数减少、误判却随之增加（“碰巧做对”）；SE 更稳。SE 估计的是 completer 的价值函数，混入了”后面难不难""completer 强不强”的因素——对搜索和 RL 正合适，对”判断逻辑对错”有偏差。
5. Weaver：用弱监督（EM，不需要标签）估计每个弱 verifier 的 TPR / FPR，再按朴素贝叶斯加权组合。verifier 准确率差别大时（尤其有”反着来”的 verifier 时），加权远好于不加权。条件独立被违反时（verifier 来自同一个模型），EM 会高估它们——“一致不代表正确”。
6. 鲁棒性：verifier 会被大量候选攻破、被搜索过度优化、和生成者错得一样、在分布偏移下失准。对策是用不可欺骗的信号、检查过程、组合错得不一样的 verifier、限制优化力度、持续更新 verifier。

8. 练习

1. 三种用途（第 1.2 节） 同一个 verifier，在测试时 best-of-16 的挑选中表现很好，却在 RL 训练中很快被”攻破”。为什么？举一个具体的例子说明策略可能怎样钻它的空子。

2. ORM 和 PRM 的打分（第 3.1、3.4 节） 一份 6 步的解答，PRM 给各步的分数是 0.95、0.9、0.95、0.3、0.9、0.95。 (a) 用乘积和最小值聚合，分数各是多少？ (b) 另一份 3 步的解答各步都是 0.8。用乘积聚合，它和 (a) 相比谁的分数高？这公平吗？ (c) 如果这两份解答是同一道题的候选，你会用哪种聚合方式？

(a) 乘积 $0.95 \times 0.9 \times 0.95 \times 0.3 \times 0.9 \times 0.95 \approx 0.198$；最小值 0.3。 (b) $0.8^3 = 0.512$，比 (a) 高。乘积天然惩罚长解答：即使每一步都很可信，步数多了乘积也会变小。 (c) 同一道题的候选步数可能不同，用最小值（或者对乘积做长度归一化，例如取几何平均）更公平。但如果”步数多”本身意味着更容易出错，乘积反而合理——要在开发集上比较。

3. “答案对、过程错”（第 3.2 节） (a) 为什么 toy world 里弱模型（1B）“答对但过程错”的比例（10.2%）远高于强模型（10B，0.6%）？ (b) 一道四选一的选择题，模型完全随机地猜，“答对但过程错”的解答占所有答对的解答的比例大约是多少？这说明结果监督在选择题上有什么问题？

(a) 弱模型每道题犯的错误多，错误之间碰巧抵消的机会也多；而且它真正做对的次数少，分母小。强模型很少犯错，几乎所有答对的解答都是真的做对了。 (b) 如果模型从不真正推理对（推理全错）、只是随机猜，答对的 25% 全部是”过程错”——比例是 100%。更一般地，设真正推理正确的概率是 $s$，推理错时有 1/4 的概率蒙对，那么答对的解答中”过程错”的比例是 $\frac{(1-s)/4}{s + (1-s)/4}$。$s = 0.2$ 时是 50%。结果监督会把一半的”蒙对”当作好样本。

4. Math-Shepherd 的误判（第 4.2 节） (a) 为什么 HE 的误判率随续写次数 $N$ 增大而上升？写出一个错误前缀”至少一次碰巧做对”的概率，设单次碰巧做对的概率是 $\epsilon$。 (b) $\epsilon = 0.002$ 时，$N = 16$ 和 $N = 64$ 的误判概率各是多少？ (c) 为什么 SE 不受这个问题影响？

(a) HE 只要有一次做对就标为好，所以误判概率是 $1 - (1-\epsilon)^N$，随 $N$ 增大。 (b) $N = 16$：$1 - 0.998^{16} \approx 0.031$；$N = 64$：$1 - 0.998^{64} \approx 0.12$。 (c) SE 是做对的比例，期望就是 $\epsilon$，不随 $N$ 增大；$N$ 越大，SE 对 $\epsilon$ 的估计越准，用一个小阈值就能把它和”真正好的前缀”（SE 约 0.6）分开。

5. SE 是价值函数（第 4.3 节） (a) 一个完全正确的前缀，剩下 5 步，completer 每步的正确率是 0.85，SE 的期望大约是多少？ (b) 用 SE 训练的 PRM 去给另一个更强的生成器的解答打分，会有什么问题？ (c) 如果你想要一个”只判断这一步在逻辑上对不对”的 PRM，Math-Shepherd 的标签可以怎样修正？（提示：比较第 $i$ 步之前和之后的 SE。）

(a) 约 $0.85^5 \approx 0.44$（忽略碰巧做对）。 (b) PRM 学到的是”对原来那个较弱的 completer 来说前途如何”，会系统性地低估长解答前段的步骤（强生成器其实能做完）。 (c) 用”这一步带来的价值变化” $\text{SE}_i - \text{SE}_{i-1}$（或比值）：正确的一步不会让价值明显下降，错误的一步会让价值掉到接近 0。这和 RL 里的 advantage 是同一个想法（第 6 讲）。

6. Weaver 的权重（第 5.2 节） (a) 一个 verifier 的 TPR = 0.9、FPR = 0.1，另一个 TPR = 0.6、FPR = 0.4。它们投”对”时，对数赔率各增加多少？ (b) 一个 verifier 的 TPR = 0.3、FPR = 0.7。它投”对”时对数赔率怎样变化？为什么说它其实是有用的？ (c) 如果把两个完全相同的 verifier（总是投一样的票）都放进集成，朴素贝叶斯会怎样？EM 会怎样估计它们的准确率？

(a) $\log(0.9/0.1) \approx 2.20$；$\log(0.6/0.4) \approx 0.41$。前者的一票相当于后者的 5 票多。 (b) 增加 $\log(0.3/0.7) \approx -0.85$，即降低赔率。它系统性地反着来，把它的票反过来读，就是一个 TPR = 0.7、FPR = 0.3 的有用 verifier。 (c) 朴素贝叶斯会把同一份证据算两次，过度自信。EM 会看到”两人总是一致”，把它们估计得过于准确（和本讲演示 3 的 V1、V2 是同一个问题）。

7. 动手改代码 (a) 在 01 号文件演示 1 里加一个 30B 的 checker。挑选准确率在 10B（自查）和 100B 之间的哪个位置？ (b) 在 01 号文件演示 3 里试 $B$ = 4、$E$ = 4 和 $B$ = 1、$E$ = 16（每步生成量都是 16）。保留更多 beam 好，还是每个 beam 扩展更多好？ (c) 在 02 号文件里把 completer 换成 1B，HE 的漏判率会怎样变化？ (d) 在 03 号文件里把 V1、V2 从集成里去掉，EM 对 V3 的估计会更准吗？挑选准确率呢？

8. 设计题 你要为一个”写 SQL 查询”的 agent 设计 verifier。手头有：一个可以执行 SQL 的数据库（但没有标准答案）、两个开源的 reward model、一个 LLM judge。你会怎样组合它们？哪些 verifier 之间可能”错得一样”？怎样在没有标签的情况下估计它们的可靠性？

9. 延伸阅读

本讲的阅读材料

• Cobbe et al. 2021. Training Verifiers to Solve Math Word Problems.（GSM8K）
• Lightman et al. 2023. Let’s Verify Step by Step.（PRM800K）
• Wang et al. 2023. Math-Shepherd: Verify and Reinforce LLMs Step-by-step without Human Annotations.
• Saad-Falcon et al. 2025. Shrinking the Generation-Verification Gap with Weak Verifiers.（Weaver）

相关工作

• Uesato et al. 2022. Solving Math Word Problems with Process- and Outcome-Based Feedback.（最早系统比较过程与结果反馈的工作之一）
• Zhang et al. 2024. Generative Verifiers: Reward Modeling as Next-Token Prediction.（生成式 verifier）
• Ratner et al. 2017. Snorkel: Rapid Training Data Creation with Weak Supervision.（弱监督的经典框架）
• Gao, Schulman, Hilton 2022. Scaling Laws for Reward Model Overoptimization.（reward hacking 的定量研究）
• 同目录 CS329H 第 14 讲（古德哈特定律与代理指标）、第 17 讲（Dawid–Skene）；CS224V 第 15 讲（LLM 评委的偏差）。

10. 下一讲预告

第 4 讲：从工具与代码的反馈中学习

本讲的 verifier 都是”另一个模型”。还有一类更可靠的反馈来自环境：搜索引擎返回的结果、代码执行的报错、测试是否通过。第 4 讲讨论：

• ReAct：让模型交替地”思考”和”行动”，用工具的返回结果纠正自己的推理。
• RLEF：模型往往不会利用执行反馈来修改代码；怎样用强化学习教会它？
• Constitutional AI：如果反馈来自 AI 自己（按一组原则批评和修改），能不能代替人类的反馈？