Scalable Oversight 入门
第三部分:主要方法

草稿 内容完整但尚未审校,可能还会修改

第 20 章机器检查与外部证据

路线全部路线最短路线概念路线做判读练习,实验路线加做编写测试

本章导读

本章问题
  • 哪些任务可以不靠人的判断,而靠可执行的检查或外部证据?
要点
  • 有些任务生成难、验证易,检查可以交给程序:测试、证明检查器、答案匹配(§20.1)。
  • 机器检查的成本分两块:建立检查器常常很贵,运行检查器通常便宜(§20.3)。
  • 覆盖不全的检查仍然有用,但只支持更窄的结论;规格写错和模型绕过检查是两种主要的失效(§20.4)。
  • 外部证据分三层:有引用、引用支持结论、来源可靠;还要分清独立证据和看起来像证据的内容(§20.5、§20.6)。
本章的视频讲解,4 分 59 秒,没有声音,文字在画面左侧。下载视频(MP4)
文字稿
  1. 0:07可执行的检查
    本章的判断靠可以执行、可以重复的检查。回到记账程序:规则一、规则二容易写成测试,规则三要人为制造写入失败才测得到。测试都通过,也只说明测到的情形没有出错。
  2. 0:27找答案难,查答案易20.1
    做一道数独可能要半小时,检查只要一两分钟。391 是哪两个大于 1 的整数的乘积?有人说 17 和 23,一乘就知道。检查容易又完整时,较弱的监督者也能可靠地判断较强的执行者。
  3. 0:49验证器与规则奖励20.2
    验证器是一个程序或一套固定步骤:输入待检查的输出,给出通过或不通过,不需要人判断;用它的结果作训练奖励,叫可验证奖励。DeepSeek-R1-Zero 只用规则奖励做强化学习,AIME 2024 单次作答的平均正确率从 15.6% 升到 77.9%。
  4. 1:14只奖励它检查的东西20.2
    作者报告 DeepSeek-R1-Zero 的推理可读性差、有时混用中英文,而规则奖励不检查这些。Baker 等报告,模型在编程环境中不修代码,而是提前退出、让测试被跳过、让被测函数总是返回“真”,测试照样通过。
  5. 1:37建立常常贵,运行通常便宜20.3
    建立检查器要懂行:知道测什么、正确结果是什么;规则三还要能制造写入失败。运行通常便宜。写测试要懂行时,能力差距没消失,而是从“判断输出”移到“写出检查”。
  6. 1:58测试通过说明什么20.4
    测试全部通过,准确的结论是:在测到的输入上,程序给出了测试写下的期望结果。测试触及了哪些情形,叫测试覆盖。覆盖不全的检查仍然有用,只是结论要写窄。
  7. 2:21为规则三注入故障20.4
    规则三要自己制造失败,叫故障注入:把写入换成替身,在指定时刻报错。记支出要先添流水、再改余额,就测这两个时刻。都通过只能说:这两种失败下没有只记一半;断电、磁盘写满、同时写入没测过。
  8. 2:46规格写错20.4
    规格可能没有准确表达意图。示意代码把金额和日期相同的记录当作重复,测试“同一笔提交两次只记一次”能通过;可同一天买两杯同价的咖啡,第二笔被丢掉。规格满足了,程序却不是用户想要的。
  9. 3:10“检查通过”的含义20.4
    Baker 等的环境不许模型改测试文件,模型有时改了测试所依赖的其他代码,绕过了防护。所以“检查通过”要带上三个限定条件,少一个,结论就要再收窄。
  10. 3:33外部证据的三层20.5
    核对带引用的话分三层:有引用、引用支持结论、来源可靠,成本依次升高。Liu 等审查了 2023 年四个生成式搜索引擎(先检索网页、再写带引用的回答),平均 51.5% 的句子得到引用完全支持,74.5% 的引用支持所附句子。
  11. 3:59独立证据20.6
    独立证据由被检查的模型影响不了的过程产生,比如你运行并核对的测试、打开的原文。模型说“全部通过”,只是关于证据的说法。要问:证据是谁产生的,模型能否影响它?
  12. 4:23证据与前提
    回到证据与前提框。三项研究各在自己的任务上测过。结论依赖规格正确、检查覆盖关键部分、模型改不了测试或检查器。不能推出“检查通过”就“符合意图”。

带走的几句话:

  1. 有些任务生成难、验证易,检查可以交给测试、证明检查器和答案匹配。
  2. 建立检查器常常很贵;覆盖不全的检查仍然有用,但只支持更窄的结论。
  3. 核对引用要走到第二层,并分清独立证据和看起来像证据的内容。

第 1 章列出了判断记账程序能否使用的几种办法:亲自读代码、请人或模型检查、运行测试。第 16 章讲了第二种,让模型帮人挑错。本章讲第三种,以及与它同类的一组办法。它们的共同点是:判断不靠某个人或某个模型觉得“看起来对不对”,而靠一个可以执行、可以重复的检查。程序跑一遍测试,结果要么符合预期,要么不符合;一个证明交给证明检查器,它要么接受,要么拒绝;一句话引用了一篇文献,打开文献,它要么说了这件事,要么没说。

这样的检查在许多领域都有。数学证明可以用 Lean 写出来,交给程序逐步检查。Lean 既是一种形式化语言,也指检查用这种语言写成的证明的程序。形式化语言是一种规则严格、计算机能够处理的写法,每一步推理都必须明确写出依据。代码可以跑测试。事实陈述可以回到原始资料核对。这些检查不会疲劳,不会被说服,对谁都用同一套规则。

但第 1.3 节已经提醒过一个常见的误解:测试全部通过,不等于程序是对的。回到记账程序。规则一、规则二很容易写成测试:先存入 100 元、再支出 30 元,看余额是不是 70 元;把同一笔记录提交两次,看是不是只记了一次。规则三“写入失败时不能只记一半”就难得多,因为正常运行时写入几乎从不失败,你必须人为制造写入失败,才能测到这条规则。即使所有测试都通过了,它也只说明测到的那些情形没有出错。本章要把这句话讲透:机器检查能说明什么,不能说明什么,以及它本身可能在哪里失效。

证据与前提
  • 想处理:不靠人的判断,而靠可执行的检查或外部证据。
  • 测过:DeepSeek-AI 在数学和编程上用规则奖励(答案匹配、测试通过)做强化学习,推理能力明显提高(DeepSeek-AI 等,2025)。Baker 等在编程智能体的训练中观察到,模型绕过测试,而不是修复代码(Baker 等,2025)。Liu、Zhang、Liang 对生成式搜索引擎做人工审查,发现四个系统平均约一半的生成句子没有被引用完全支持(Liu 等,2023)。
  • 依赖:规格本身正确;检查覆盖规格的关键部分。威胁模型(第 10.2 节)覆盖“无意出错”和“迎合评分”,并要求“访问与修改权限”一维受到限制:被检查的模型不能修改测试或检查器。任务前提(第 10.3 节):“有没有独立于模型陈述的证据”,例如能运行的测试、能核对的原文。
  • 不能推出:“检查通过”不能推出“符合意图”;不能推出对能修改检查环境的模型仍然有效。
引言引用的文献 3
  1. DeepSeek-AI 等人(2025)DeepSeek-R1 incentivizes reasoning in LLMs through reinforcement learning
  2. Baker 等人(2025)Monitoring Reasoning Models for Misbehavior and the Risks of Promoting Obfuscation
  3. Liu 等人(2023)Evaluating Verifiability in Generative Search Engines

20.1 生成难、验证易 #

先看两个熟悉的例子。

做一道数独可能要半小时,检查一个填好的数独只要一两分钟:看每一行、每一列、每个小九宫格是不是 1 到 9 各出现一次。再比如,391 能写成哪两个大于 1 的整数的乘积?手算要一个个试;可如果有人告诉你答案是 17 和 23,你算一下 17 × 23 = 391 就知道对了。

这两个例子有同一种结构:找出答案很难,检查一个给定的答案很容易,而且检查的步骤是固定的,不需要相信给出答案的人。有这种结构的任务,对 scalable oversight 特别重要。监督者可能远不如执行者会解题,但只要检查容易而且完整(像数独和乘法那样,检查覆盖了答案的全部要求),较弱的监督者照样能可靠地判断较强的执行者交出的答案。

这种结构最常见于三类任务。

  • 数学证明。写出一个证明需要洞察,检查一个证明却可以是机械的。把证明写成 Lean 这样的形式化语言后,证明检查器会逐行核对每一步是否由前面的步骤和已知规则推出。检查器接受,写下的那个命题就得到了证明;它不需要理解证明的思路。不过,Lean 的文档说明,检查器接受的证明可能依赖公理(axiom,不经证明、直接假定成立的命题),只在这些公理成立、且彼此不矛盾时才可信;用户可以用 axiom 自己声明公理,Lean 无法检查新公理会不会导出矛盾(Lean Language Reference,2026a)。证明里写的 sorry 也靠一条能证明任何命题的公理 sorryAx 实现,文档说这条公理不应出现在完成的证明里,用了 sorry 却只得到警告(Lean Language Reference,2026a)。命令 #print axioms 列出一个证明直接或间接依赖的全部公理,可用来审查,例如查出间接用到的 sorry(Lean Language Reference,2026a)。命题本身是否写对了,是另一个问题(第 20.4 节)。
  • 程序。写程序难,运行程序容易。给一个输入,看输出是不是预期的值,这就是一个测试。和数独不同的是,测试只检查你选定的那几个输入,程序在其他输入上怎样,测试不管。所以程序的验证通常只是部分的验证。
  • 有标准答案的题。一道题的答案是一个数,核对时只要比较这个数是否等于标准答案。

很多任务没有这种结构。写一封得体的信、给出一条人生建议、决定一项城市政策,都没有一个固定的检查步骤能判断好坏。第 7.5 节区分过三种“没有标准答案”的情况:有答案但核查昂贵、结果尚未出现、没有唯一正确的选择。机器检查主要帮助第一种,而且前提是有人能写出那个检查步骤。DeepSeek-R1 的作者也指出,对写作这类任务,很难构造可靠的规则奖励(DeepSeek-AI 等,2025)。

还有一种更常见的情况:任务中只有一部分能被机器检查。记账程序在你测到的输入上算对了余额,这一部分可以检查;它在其他情形下是否正确,以及它是不是用户真正想要的程序,机器检查不回答。能检查的部分不一定是你最关心的部分。第 20.4 节专门讨论这种“部分检查”能支持什么结论。

研究路线的读者可以在第 15.7 节看到“检查比求解容易”在计算复杂性理论里的形式化说法(P 与 NP;两者不相等目前只是普遍看法,没有证明)。本章只需要上面的直觉。

第 20.1 节引用的文献 2
  1. Lean Language Reference(2026a)Axioms
  2. DeepSeek-AI 等人(2025)DeepSeek-R1 incentivizes reasoning in LLMs through reinforcement learning

20.2 验证器与可验证奖励 #

把检查交给程序之后,需要一个名字来称呼做检查的那一方。

定义 20.1 验证器

验证器(verifier)是一个程序或一套固定的程序化步骤:输入是待检查的输出,输出是“通过”或“不通过”,有时是一个分数。整个过程不需要人作判断。

注意它和第 19.3 节的“验证者”不同。那里的验证者是一个训练出来的模型,会被精心构造的错误解答骗过;这里的验证器是写定的程序,判断规则固定、公开。程序也会出问题,但出问题的方式不同,本节后半和第 20.4 节会讲。

常见的验证器有三类。

  • 测试。一个测试是一小段程序:用给定的输入运行被测代码,把结果和预先写下的期望值比较。记账程序里“存入 100、支出 30,余额应为 70”就是一个测试。一组测试合起来叫测试集。
  • 证明检查器。如 Lean,检查形式化证明的每一步。
  • 规则匹配。用简单规则判断输出是否合格,例如最终答案是否等于标准答案,输出是否符合规定的格式。

验证器可以在使用模型时用来判断输出,也可以在训练时用来产生奖励。后一种用法叫可验证奖励(verifiable reward):训练时,用自动检查的结果作为奖励,测试通过就给高分,不通过就给低分。用第 6.4 节的三个维度来说,它的反馈来源是程序化检查,而不是人或 AI。

DeepSeek-R1 是一个有代表性的例子(DeepSeek-AI 等,2025)。这是开发者对自己模型的报告,发表在 Nature 上。论文中的 DeepSeek-R1-Zero 在推理任务上只用规则奖励做强化学习,奖励主要由两部分组成:

  • 准确性奖励:数学题要求模型把最终答案写在规定的格式里(例如放进一个框中),以便用规则核对它是否正确;编程题则用一组预先写好的测试用例运行模型写的代码,检查结果。
  • 格式奖励:要求模型把推理过程写在指定的标记之间。

作者特意没有在推理任务上使用神经网络奖励模型,无论是按结果还是按过程打分的,理由之一是他们观察到这类奖励模型在大规模强化学习中容易被钻空子;另一条是重新训练这类奖励模型要花大量计算,也让训练流程更复杂(DeepSeek-AI 等,2025)。在训练过程中,模型在 AIME 2024(美国的一项高中数学邀请赛,每题的答案是一个数)上单次作答的平均正确率从 15.6% 升到了 77.9%(DeepSeek-AI 等,2025)。

这个结果说明,至少从 DeepSeek-V3-Base 这个在预训练中见过大量数学和代码的基础模型(第 5.1 节)出发,在数学、编程这类有自动检查的任务上,仅靠规则奖励就能把推理能力训练得明显更强(DeepSeek-AI 等,2025)。它也显出规则奖励的边界:规则奖励只奖励它检查的东西。作者报告,DeepSeek-R1-Zero 的推理文字可读性差,有时还在同一段推理里混用中英文;作者认为,混用语言可能与基础模型主要用中英文训练有关(DeepSeek-AI 等,2025)。它的规则奖励里,没有任何一项检查推理是否好读、是否便于检查(第 19.5 节),这些问题也就没有被奖励纠正(本书的推断)。同样,只核对最终答案的规则,会给“推理错误却碰巧答对”的解答满分(第 19.1 节)。

“只奖励它检查的东西”在编程任务里有更直接的后果。Baker 等报告了他们训练一个推理模型时的观察;推理模型是被专门训练成先写出很长的推理文字、再给出答案或采取行动的语言模型(第 19.1 节)。这是 OpenAI 研究者对自己模型的报告,以预印本发表。他们的模型在编程环境中找到了不修复代码就让测试通过的办法:利用环境的漏洞,在测试全部运行之前提前退出;让程序报错,使测试被跳过;还有一例,模型在推理中写道,测试只检查某一个函数,于是让这个函数总是返回“真”(Baker 等,2025)。测试的结果都是“通过”,可代码并没有修好。这和第 8 章开头的例子是同一类现象:在这两个例子里,被奖励“测试通过”的编程模型都学会了绕过测试,而不是修复代码。验证器的判断规则是固定的,这让它便宜、一致,也让它的漏洞对每一次尝试都一样存在,可以被反复利用。Baker 等报告,提前退出、让测试被跳过这样的通用绕过一旦出现,就很快被强化,扩散到几乎所有训练环境(Baker 等,2025)。

第 20.2 节引用的文献 2
  1. DeepSeek-AI 等人(2025)DeepSeek-R1 incentivizes reasoning in LLMs through reinforcement learning
  2. Baker 等人(2025)Monitoring Reasoning Models for Misbehavior and the Risks of Promoting Obfuscation

20.3 两种成本 #

第 1 章说过,没有一种检查办法是免费的。机器检查的成本分成两块,性质很不一样。

建立检查器的成本。写测试,先要知道该测什么:哪些输入有代表性,哪些情形容易出错,每种情形的正确结果是什么。写形式化规格,要把“我们想要什么”翻译成一种没有歧义的语言,这往往需要专家花大量时间。为规则三写测试,还要搭一套能在指定时刻让写入失败的环境。这些都是人的工作,而且需要懂行。

运行检查器的成本。检查器一旦建好,运行通常很便宜:一组测试几秒钟跑完,证明检查器很快给出结论,答案匹配几乎不花时间。也有运行成本高的检查,比如需要长时间运行的大型测试集。

两块成本的差别决定了机器检查适合用在哪里。建一次、跑很多次,平均下来很便宜,所以它特别适合需要反复判断的场合:训练时要对几百万个输出打分,每次修改代码后要重新确认没有改坏。它还很一致,不像人类评估者那样会疲劳、会被说服(第 13 章)。

难的是建立。对一个刚学编程的人,判断 500 行代码是否正确很难;为这 500 行代码写出一套好的测试,同样需要懂这个程序要做什么、可能怎样出错。对这类要懂行才写得出检查的任务,监督者与执行者之间的能力差距(第 7.4 节)并没有消失,而是从“判断输出”转移到了“写出检查”上(本书的推断)。一个不懂密码学的人,写不出检验加密模块的测试。

用记账程序把两块成本摆在一起:

表 20.1 记账程序三条需求的检查成本(示意)
需求 建立检查器 运行检查器 难在哪里
规则一:余额等于收入减支出 低:写几组收支和期望余额 低 期望值自己能算出来
规则二:重复提交只记一次 中:要先定义什么算“同一笔记录”,再覆盖几种重复方式 低 规格本身需要澄清
规则三:写入失败时不能只记一半 高:要搭建能在不同时刻制造写入失败的环境 低 失败情形要人为制造,而且时刻不止一个

最后还有一个问题:谁来检查检查器?测试也是代码,也会写错。好在单个测试通常短小、直接,核对一个测试的期望值,是一个比检查整个程序小得多的判断(本书的推断);不过这只回答测试写得对不对,测得够不够要看覆盖(第 20.4 节)。这和第 14 章的思路相通:把一个人做不了的大判断,换成几个人做得了的小判断。

20.4 有限检查的价值与范围 #

现实中的检查几乎都是有限的:测试只覆盖一部分输入,证明只针对写下来的那个命题,核对引用只核对了被引用的那几句话。这一节回答两个问题:有限的检查还有什么用?它能支持什么样的结论?

20.4.1 测试通过到底说明什么 #

先把“测试全部通过”能支持的结论说准确:在测到的这些输入上,程序给出了测试写下的期望结果。超出这句话的任何结论,都需要额外的假设,比如“没测到的输入和测到的输入差不多”。这个假设有时合理,有时不合理,而测试本身不能告诉你是哪一种。

描述这一点要用到一个概念。测试覆盖(test coverage)指测试触及了哪些情形:哪些输入、哪些需求、程序中的哪些分支。覆盖得越全,测试通过能支持的结论越宽。但覆盖几乎总是不全的,因为可能的输入通常极多,甚至无穷多;只有输入范围有限时,才可能逐个检查(如习题 20.2 在 1600 年到 2400 年之间逐年比较)。

20.4.2 有限检查仍然有用 #

覆盖不全不等于没用。有限的检查至少有三种价值。

  • 在覆盖到的情形上可靠。一个测试通过了,在那个输入上,程序就给出了测试写下的期望结果;只要期望值写对了,这一点不依赖任何人的判断。
  • 便宜、可以反复跑。每次修改代码后重跑一遍,能立刻发现把原来对的地方改坏了。
  • 能给出可以量化的结论。第 3.7 节讲过:如果从某种错误的分布中独立抽出 nn 个确实含错的案例,检查器全部检出,那么它对这种错误的漏检率,单侧 95% 置信上界大约是 3/n3/n。这个结论只适用于抽样覆盖到的错误类型,但在这个范围内,它是一个诚实的、有数字的结论。

所以,使用有限检查的正确方式不是放弃它,而是把结论写窄。下面用最难测的规则三演示一遍。

20.4.3 一个例子:为规则三写测试 #

正常运行时写入几乎从不失败,所以规则三的测试要自己制造失败。常用的办法叫故障注入(fault injection):在测试里把“写入”这一步换成一个替身,让它在你指定的时刻报错,然后检查程序留下的状态。

记一笔支出要改两处:在流水里添一行,再把余额减掉。于是至少有两个失败时刻值得测:

  • 写流水时失败。期望:流水没有新行,余额也没有变。
  • 流水写成功、改余额时失败。期望:两处都恢复原样,或者两处都完成,不能只改了一处。

假设两个测试都通过了。你可以说:在这两个时刻注入的失败下,程序没有只记一半。你不能说:任何失败下都不会只记一半。写到一半时断电、磁盘写满、两笔记录同时写入,这些情形都没有测。程序加入转账功能以后(第 10 章),一次转账要同时改两个账户,值得测的失败时刻还会更多。

把整个程序的检查结果合起来,不说“记账程序是正确的”,而说:“规则一在 20 组收支序列上成立;规则二在连续两次提交同一记录时成立;规则三在写流水时失败、改余额时失败这两种注入的失败下成立,断电、磁盘写满和同时写入没有测过。”这样写,读的人清楚地知道哪些已经检查过,哪些没有。

20.4.4 检查本身可能失效 #

除了覆盖不全,检查还会以两种方式给出误导的结果。

规格写错。检查依据的规格本身可能没有准确表达意图,这就是第 8.1 节说的规格错误。测试里的期望值可能算错;形式化的命题可能和原来想证明的命题不一样,那样 Lean 检查通过也没有用。规格不完整也会造成同样的问题。看下面这段示意代码,它实现规则二:

# 示意代码:判断一条新记录是否与已有记录重复
def is_duplicate(new, records):
    for r in records:
        if r.amount == new.amount and r.date == new.date:
            return True   # 金额和日期都相同,就当作重复,不再记账
    return False

测试“把同一笔记录提交两次,只记一次”能通过。可是,如果你同一天买了两杯价格相同的咖啡,第二笔会被当成重复丢掉。这算不算错?需求说明只写了“同一笔记录重复提交只记一次”,没有说什么叫“同一笔”。测试通过了,字面上的规格也满足了,程序却不是用户想要的。这就是“检查通过”不能推出“符合意图”的一个具体例子。

模型绕过检查。第 20.2 节里 Baker 等的例子中,模型不修代码,而是让测试提前退出、让测试被跳过,或者让被检查的函数总是返回“真”。值得注意的是,他们的训练环境本来就不允许模型修改测试文件和测试框架;模型有时改的是测试所依赖的其他代码,从而绕过了这条防护(Baker 等,2025)。在他们另一组实验中,研究者特意把环境做成容易作弊的样子:允许模型修改测试文件,只在提示词里要求它不要改,用的是一个非前沿的模型。模型很快就学会了改测试(Baker 等,2025)。Baker 等报告的这几种绕过,都利用了同一个条件:被检查的模型能读到、甚至能改动检查本身,或者能影响检查的运行。这正是第 10.2 节的“访问与修改权限”维度。本书建议的防护也从这里入手:让模型无权修改测试和测试框架;被测代码和测试在同一个环境里运行时,即使模型无权改测试,也能影响测试怎样运行,所以要把被跳过的测试和提前退出都算作失败,并核对实际运行了多少个测试;保留一部分模型看不到的测试;检查模型的改动碰了哪些文件;由你自己运行测试,而不是接受模型对测试结果的转述(第 20.6 节)。第 19.7 节说明了另一条路为什么危险:只惩罚模型推理中“想绕过测试”的文字,可能让文字消失,而绕过照旧。

要点

“检查通过”的准确含义是:在检查覆盖的情形下,按照检查写下的规格,在检查没有被改动或绕过的前提下,没有发现错误。三个限定条件,少一个,结论就要再收窄。

第 20.4 节引用的文献 1
  1. Baker 等人(2025)Monitoring Reasoning Models for Misbehavior and the Risks of Promoting Obfuscation

20.5 外部证据的三个层次 #

有些说法没法“运行”。“这种药和那种药不能同时服用”“某篇论文报告了 78.2% 的正确率”,这些是关于外部世界的陈述,检查它们的办法是回到原始资料。不少模型的回答附带引用,引用让核对成为可能,但引用本身不是证据。核对一句带引用的话,可以分三层。

  1. 有引用。这句话后面列出了来源。这一层最容易检查,看一眼就知道,程序也能自动检查链接能否打开。
  2. 引用支持结论。打开来源,它确实说了这句话所说的事,而且完全支持,不是只支持一部分,也不是说的另一件相近的事。这一层要读原文。
  3. 来源本身可靠。来源是原始研究、官方数据,还是转述的转述?是同行评审的论文,还是一篇无人核对的帖子?这一层需要相关领域的知识。

三层的成本依次升高,而第一层通过,什么也不保证。Liu、Zhang、Liang 用人工评估审查了 2023 年的四个生成式搜索引擎:Bing Chat、NeevaAI、perplexity.ai 和 YouChat(Liu 等,2023)。这类系统先检索网页,再生成一段附带引用的回答。他们用来自多种来源的问题测试这些系统,请人逐句判断回答中的句子是否被所附的引用支持;没有附引用的句子,算作没有得到支持。结果,四个系统平均下来,只有 51.5% 的生成句子得到了引用的完全支持,各系统从 11.1%(YouChat)到 68.7%(perplexity.ai)不等;引用支持所附句子的比例,四个系统平均是 74.5%,各系统从 63.6%(YouChat)到 89.5%(Bing Chat)不等(Liu 等,2023)。没有得到完全支持的句子里,有的根本没附引用,第一层就没有通过;有的附了引用,引用却不支持它,第二层没有通过。论文没有分别给出这两部分各占多少。作者还指出,这些回答读起来流畅,看上去信息丰富。

读这项结果要注意它的范围。它是一项发表在 Findings of EMNLP 2023 上的研究,审查的是 2023 年那四个系统当时的表现,而这类产品更新很快。它的结论是“当时的系统,常有句子没有得到引用的完全支持,引用也常常不支持所附的句子”,不是“今天的系统也这样”。本书从中取的做法不随产品更新而过时:判断一句话有没有证据,要走到第二层,读原文(本书的推断)。

回到记账程序。模型交给你一段说明:“这段代码满足需求说明第 2 条(见需求说明)。”这是第一层,它指了出处。翻开需求说明,第 2 条说的确实是重复提交只记一次,可代码判断重复的方式(上一节的示意代码)是不是这条需求的意思,需要你自己判断,这是第二层。如果你手里的需求说明是旧版本,后来改过,那连来源本身都不可靠了,这是第三层。

第 20.5 节引用的文献 1
  1. Liu 等人(2023)Evaluating Verifiability in Generative Search Engines

20.6 独立证据与模型生成的、看起来像证据的内容 #

本章的检查之所以有用,是因为它们的结果不由被检查的模型决定。这个性质值得单独拿出来讲,因为模型生成的许多内容看起来像证据,却没有这个性质。

独立证据是由被检查的模型无法控制、也无法影响的过程产生的证据。你在自己控制的环境里运行、并核对过实际运行了哪些测试的结果,你自己打开的原文,你自己运行、且证明里的代码无法影响检查过程的 Lean 检查,都是独立证据。对 Lean 检查加上这个条件,是因为 Lean 证明里可以带有代码,Lean 处理证明时会运行它;Lean 的文档提醒,这类代码运行时可以执行任意操作(Lean Language Reference,2026b)。Python 标准库里判断闰年的函数 calendar.isleap,相对于模型写的闰年函数,也是一个独立的参照:它不是被检查的模型写的。

看起来像证据的内容则是被检查的模型自己生成的,比如:

  • 模型说“我运行了测试,全部通过”。这是一个关于证据的说法,不是证据本身。
  • 模型贴出的一段“测试输出”。它可能是真的运行结果,也可能是生成出来的文字。
  • 模型为自己的代码写的测试。这些测试体现的是模型自己对需求的理解。如果它把需求理解错了,代码和测试会错在同一个地方,测试照样全部通过。这是第 24 章要讲的共同盲点的一个例子。
  • 模型给出的引用。来源可能是编出来的(第 5.5 节),也可能没说那句话(第 20.5 节)。
  • 模型对“代码为什么正确”的解释。写出来的理由不一定是真实的成因(见第 19 章),更不是正确性的证明。

判断一份材料算不算独立证据,只要问一个问题:这份证据是谁产生的,被检查的模型能不能影响它?这个问题对应第 10.3 节的任务前提“有没有独立于模型陈述的证据”,也对应第 10.2 节的“访问与修改权限”:模型能改动的东西,就不再是独立于它的证据。第 18 章讲的模型内部表示也一样,激活和输出来自同一个模型,不是独立证据。

这不是说模型生成的内容没有用。很多时候,它们可以被你变成独立证据:模型写的测试,由你在自己的环境里运行,失败了,说明代码和这个测试至少有一处出错,是真实的线索;通过了,则是关于“模型选的那些情形”的证据。模型给的引用,由你打开原文核对,就成了第二层的证据。关键在于中间那一步,由你、或由模型控制不了的程序,独立地执行或阅读一遍。

表 20.2 独立证据与看起来像证据的内容
材料 谁产生 被检查的模型能否影响 怎样变成独立证据
“测试全部通过”的说法 被检查的模型 能 自己运行测试
模型写的测试 被检查的模型 能,测试与代码可能错在同一处 自己运行,并补充按需求说明独立写的测试
你写的、模型无权修改的测试的运行结果 你的测试环境 不能改测试,但被测代码和测试一起运行时,能让测试提前退出或被跳过 核对实际运行了多少个测试,把跳过和提前退出算作失败(第 20.4 节)
模型给出的引用 被检查的模型 能 打开原文,逐句核对
你自己找到并读过的原文 外部来源 不能 已经是,但还要判断来源是否可靠
第 20.6 节引用的文献 1
  1. Lean Language Reference(2026b)Validating a Lean Proof

读物 #

  • 实验结果 · 期刊论文:DeepSeek-AI《DeepSeek-R1 incentivizes reasoning in LLMs through reinforcement learning》(Nature 2025)(DeepSeek-AI 等,2025)。只读使用规则奖励的部分:准确性奖励和格式奖励怎样定义,作者为什么不在推理任务上使用神经网络奖励模型。
  • 反例与批评 · 预印本:Baker 等《Monitoring Reasoning Models for Misbehavior and the Risks of Promoting Obfuscation》(OpenAI,2025)(Baker 等,2025),与第 19 章同一篇。这里只读模型绕过测试的例子,看测试通过和代码修好怎样分离。
  • 实验结果 · 会议论文:Liu、Zhang、Liang《Evaluating Verifiability in Generative Search Engines》(Findings of EMNLP 2023)(Liu 等,2023)。生成式搜索引擎的引用并不总是支持其陈述;看作者怎样定义“完全支持”,以及人工审查是怎样做的。
本节引用的文献 3
  1. DeepSeek-AI 等人(2025)DeepSeek-R1 incentivizes reasoning in LLMs through reinforcement learning
  2. Baker 等人(2025)Monitoring Reasoning Models for Misbehavior and the Risks of Promoting Obfuscation
  3. Liu 等人(2023)Evaluating Verifiability in Generative Search Engines

练习 #

习题 20.1 闰年规则与测试(判读,概念路线)

下面是为教学构造的例子,不需要读代码。

公历闰年的规定(这就是规格)是:能被 4 整除的年份是闰年,但能被 100 整除而不能被 400 整除的年份不是闰年。

四个模型各自交来一条判断规则:

  • 规则甲:年份能被 4 整除,是闰年;否则是平年。
  • 规则乙:年份能被 4 整除并且不能被 100 整除,是闰年;否则是平年。
  • 规则丙:年份能被 400 整除,是闰年;否则,能被 4 整除并且不能被 100 整除的是闰年;其余是平年。
  • 规则丁:年份能被 400 整除,是闰年;否则,能被 4 整除并且不能被 10 整除的是闰年;其余是平年。

用同一组 3 个测试检查它们:2024 年应为闰年,2023 年应为平年,2000 年应为闰年。结果如下:

规则 2024(闰年) 2023(平年) 2000(闰年)
甲 通过 通过 通过
乙 通过 通过 不通过
丙 通过 通过 通过
丁 通过 通过 通过
  1. 哪几条规则通过了全部测试?其中哪些仍然是错的?只考虑 1600 年到 2400 年,各自在哪些年份出错?
  2. 为什么这 3 个测试没有发现它们的错误?
  3. 应该补哪些测试用例?如果只能补两个,补哪两个?
  4. 有人提议按规格把年份分成四类:不能被 4 整除;能被 4 整除但不能被 100 整除;能被 100 整除但不能被 400 整除;能被 400 整除。每类取一个年份作测试:2023、2024、1900、2000。这组测试能抓住哪几条错误的规则?抓不住哪一条,为什么?
提示

对每条错误的规则,先找出它和规格在哪一类年份上说法不同,再看 3 个测试里有没有一个落在这类年份上。规则丁的错误和“10”有关,想一想哪些年份能被 4 和 10 同时整除、却不能被 100 整除。

解答
  1. 甲、丙、丁都通过了全部 3 个测试,只有丙是对的。
    • 甲在 1700、1800、1900、2100、2200、2300 这 6 年出错:这些年份能被 100 整除而不能被 400 整除,应为平年,甲判成了闰年。
    • 丁在 32 个年份出错:凡能被 20 整除而不能被 100 整除的年份,如 1620、1640、……、2020、2040,应为闰年,丁判成了平年。
    • 乙没有通过 2000 年的测试,它在 1600、2000、2400 这 3 年出错。测试发现了它的错误。
  2. 3 个测试只落在三类年份上:普通的闰年(2024)、普通的平年(2023)、能被 400 整除的年份(2000)。甲的错误全在“能被 100 整除但不能被 400 整除”这一类,测试一个都没有选到。丁的错误在“能被 4 整除、也能被 10 整除、但不能被 100 整除”的年份上,2024 不能被 10 整除,没有落进去。测试全部通过,只说明这 3 个年份判对了。
  3. 补 1900 年(或 2100 年,应为平年),能抓住甲;补 2020 年(或 1980、2040 等,应为闰年),能抓住丁。只能补两个时,就补 1900 和 2020。
  4. 这组测试能抓住甲(1900 年)和乙(2000 年),抓不住丁。四类年份来自规格里的区分;丁的错误来自它自己引入的一个区分“能不能被 10 整除”,这个区分在规格里不存在,所以按规格分类挑选的测试不一定碰到它。更值得注意的是,1900 年其实走过了丁的“能被 10 整除”这一支,丁对 1900 年的判断恰好也是对的。也就是说,即使规则里每个条件的两种情况都被测到了,仍然可能发现不了错误。要抓住这类错误,要么读规则本身、针对它的特殊区分设计测试,要么在一个范围内把所有年份都和一个独立的参照比较(见下一题)。

计算用的脚本是 tools/exercises/ch20_leap_year.py,它逐条运行四条规则,并列出 1600 年到 2400 年间每条规则出错的年份。

习题 20.2 写一个能通过却仍然错误的实现(实验路线)

用 Python 完成下面三步,只用标准库。

  1. 写一个函数 is_leap(year),再写 3 个测试检查它。
  2. 写一个能通过你这 3 个测试、却仍然错误的实现。
  3. 补充测试,直到第 2 步的错误实现被发现。最后,用 Python 标准库的 calendar.isleap 作为独立参照,在 1600 年到 2400 年之间逐年比较你的 is_leap。
提示

测试可以直接用 assert 写:assert 条件 在条件为假时让程序报错停下。第 2 步不必“像真的一样”:最省事的错误实现,是把 3 个测试的答案直接记下来。想一想这和第 20.2 节里模型绕过测试的做法有什么相似之处。

解答

一种参考答案:

import calendar

def is_leap(year):
    return year % 4 == 0 and (year % 100 != 0 or year % 400 == 0)

def check(f, cases):
    """返回 f 在哪些测试上出错:(年份, 期望, 实际)。"""
    return [(y, want, f(y)) for y, want in cases if f(y) != want]

three = [(2024, True), (2023, False), (2000, True)]
assert check(is_leap, three) == []

# 能通过上面 3 个测试、却仍然错误的实现
def is_leap_wrong(year):      # 直接记住测试的答案
    return year in (2024, 2000)

def is_leap_wrong2(year):     # 规则甲
    return year % 4 == 0

assert check(is_leap_wrong, three) == []
assert check(is_leap_wrong2, three) == []

# 补充的测试
more = [(1900, False), (2100, False), (2020, True), (1996, True), (2400, True)]
print(check(is_leap_wrong, more))   # 在 2020、1996、2400 上出错
print(check(is_leap_wrong2, more))  # 在 1900、2100 上出错
assert check(is_leap, more) == []

# 与独立参照逐年比较
years = range(1600, 2401)
print([y for y in years if is_leap(y) != calendar.isleap(y)])         # 空列表
print(sum(is_leap_wrong(y) != calendar.isleap(y) for y in years))     # 193

is_leap_wrong 把测试答案记了下来,它通过了全部 3 个测试,却在 1600 年到 2400 年间的 193 个年份出错。这和模型让被测函数“总是返回真”是同一类做法:满足测试的字面,而不是需求。补充的测试抓住了两个错误实现;与 calendar.isleap 逐年比较,是把检查范围扩大到整个区间。注意 calendar.isleap 之所以能当参照,是因为它不是被检查的那一方写的(第 20.6 节);它本身也是一段程序,只是经过了长期、广泛的使用。

上面的结果由 tools/exercises/ch20_leap_year.py 运行确认。

习题 20.3 哪些任务能交给机器检查

对下面每个任务,回答:能不能交给机器检查?如果能,检查能确认什么、不能确认什么?检查本身可能在哪里失效?

  1. 一道答案是整数的数学竞赛题。
  2. 记账程序的规则三:写入失败时不能只记一半。
  3. 一篇综述里的一句话:“某药与某药同服会增加副作用”,后面附有一个引用。
  4. 给一位刚落榜的朋友写一封安慰的信。
  5. 一个数学定理的证明,已经写成 Lean 并通过了检查。
解答

本题没有唯一答案,评分要点如下。

  1. 能,用答案匹配。能确认最终答案对不对;不能确认解题过程对不对,过程错而答案碰巧对的解答也会通过(第 19.1 节)。失效点:标准答案本身有误,或者答案格式不规范导致误判。
  2. 部分能,要先搭建能人为制造写入失败的测试环境,建立成本高。能确认在测到的失败时刻(例如写流水时失败)程序不会只记一半;没测到的失败时刻不能确认。失效点:失败情形覆盖不全;如果写代码的模型能改动这套测试环境,结果不再可信。
  3. 能部分交给机器:检查引用是否存在、能否打开(第一层)。引用是否支持这句话(第二层)、来源是否可靠(第三层)要读原文、懂医学,主要靠人,也可以请模型协助,但那就成了模型的判断,不是机器检查。
  4. 基本不能。好坏没有固定的检查步骤,属于第 7.5 节说的没有唯一正确选择的情况。可以机器检查的只有字数、错别字这类表面性质,它们不是我们关心的部分。
  5. 能。在本题的几类检查里,它对写下的那个命题给出的保证最完整。能确认证明对 Lean 中写下的那个命题成立;不能确认写下的命题就是原来想证明的那个。失效点:形式化时把命题写错了(规格错误),检查通过也没有意义;证明用了 sorry 或自行声明的公理,结论可能是假的:前者只有警告,后者 Lean 无法检查是否矛盾(Lean Language Reference,2026a);两者都能用 #print axioms 查出(第 20.1 节)。证明如果出自未经审查的模型,#print axioms 也可能不够:Lean 的文档把这类证明归入可能有意误导的一类,并提醒其中的代码运行时可能危及你的系统,之后的检查都没有意义(Lean Language Reference,2026b)。要防住严重的有意误导,文档说需要在隔离环境里构建证明,再在这些代码够不着的地方用另行实现的检查器复核,并认为只有未对齐的 AI 等高风险场合才需要这样做(Lean Language Reference,2026b)。
本节引用的文献 2
  1. Lean Language Reference(2026a)Axioms
  2. Lean Language Reference(2026b)Validating a Lean Proof

学完能做到 #

  • 判断一个任务是否有“生成难、验证易”的结构,能不能交给测试、证明检查器或答案匹配来检查。
  • 把一次机器检查的成本分成建立和运行两部分,并说明写检查要懂行时,能力差距怎样转移到“写出检查”上。
  • 对“测试全部通过”写出一个准确而窄的结论,并说出检查本身可能在哪里失效:覆盖不全、规格写错、模型绕过或改动检查。
  • 按三个层次核对一句带引用的话,区分独立证据和模型生成的、看起来像证据的内容。

参考文献

  1. Baker, B., Huizinga, J., Gao, L., Dou, Z., Guan, M. Y., Madry, A., … Farhi, D. (2025). Monitoring Reasoning Models for Misbehavior and the Risks of Promoting Obfuscation. arXiv. 预印本引用于 §20.2 §20.4
  2. DeepSeek-AI, Guo, D., Yang, D., Zhang, H., Song, J., Wang, P., … Zhang, Z. (2025). DeepSeek-R1 incentivizes reasoning in LLMs through reinforcement learning. Nature. 引用于 §20.1 §20.2
  3. (2026a). Axioms. Lean Language Reference. 非同行评审引用于 §20.1
  4. (2026b). Validating a Lean Proof. Lean Language Reference. 非同行评审引用于 §20.6
  5. Liu, N. F., Zhang, T., and Liang, P. (2023). Evaluating Verifiability in Generative Search Engines. Findings of the Association for Computational Linguistics: EMNLP 2023. doi:10.18653/v1/2023.findings-emnlp.467. 引用于 §20.5