Scalable Oversight 入门
第零部分:先修知识

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

第 5 章语言模型:从基础模型到智能体

路线全部路线最短路线

本章导读

本章问题
  • Claude、ChatGPT 这类系统由哪几层组成?
要点
  • 语言模型做的是根据前文预测下一个 token;在海量文本上练这件事叫预训练,产物是基础模型(§5.1)。
  • 基础模型、后训练模型、聊天产品、使用工具的智能体是四种东西,评估结论要说清测的是哪一种(§5.3)。
  • 每次回答都是一次抽样;温度改变随机性,评估要多次采样,并写明温度、次数和汇总方式(§5.4)。
  • 模型的信息一部分存在权重里,一部分来自上下文;智能体循环调用工具,评估对象变成整个过程(§5.6)。
本章的视频讲解,4 分 59 秒,没有声音,文字在画面左侧。下载视频(MP4)
文字稿
  1. 0:07同一个问题,三种问法
    同一个模型,问它“某种外币今天的汇率是多少?”:直接续写,放进聊天产品,接上搜索工具,表现各不相同。差别来自训练、产品和能看到的信息。
  2. 0:28预测下一个 token5.1
    语言模型读写文本的单位叫 token:一个词、词的一部分、一个字或一个标点。给定前面的 token,模型对词表(它认识的全部 token)里的每一个,给出“下一个是它”的概率。
  3. 0:47文本自己带着答案5.1
    在海量文本上练这件事,叫预训练:前面的内容是输入,实际的下一个 token 是标签。给真实标签的概率越低,损失越大,梯度下降据此调整参数。标签不用人标。
  4. 1:08一个接一个地写5.1
    生成就是把预测重复很多次:选出一个 token,接在后面,再预测下一个。预训练的产物叫基础模型:擅长续写,但没有专门学过回答问题,它把问题当作文档开头往下写。
  5. 1:30注意力:回头去找5.2
    要理解“它只应该记一次”的“它”,得回头找“这笔支出”。Transformer 的核心是注意力:在每个位置估计前文各位置有多相关,按相关程度把信息加权混合。但权重大,不等于输出就是因为这个位置。
  6. 1:52测的是哪一层5.3
    同一组预训练出来的参数,经过后训练,部署成不同的产品,再接上不同的工具:一层套一层。在聊天界面里测得模型拒绝了危险请求,不能直接推出它在别的层也会拒绝。
  7. 2:14概率与温度5.4
    总选概率最大的,原则上每次都一样,通常对应温度 0;用它评估,只测到每步选最可能 token 的那个回答。按概率随机抽叫采样。温度越高,概率越被摊平,输出更多样;若最可能的几个是对的,也更易出错。
  8. 2:36三种汇总方式5.4
    一次回答只是一次抽样。答对概率 0.6 的题,各次独立地问 5 次:答对比例的期望 60%,至少一次答对 98.98%,多数答对 68.26%。三个数回答不同问题。每题多问几次不等于多出几道题。
  9. 2:58罕见的行为5.4
    某种不希望出现的回答,每次出现的概率是 1%,各次独立:问 5 次,至少见到一次的概率只有 4.9%;300 次是 95.1%。每天回答一百万次,平均每天出现一万次。
  10. 3:18上下文窗口5.5
    模型每次被调用时读到的全部文字叫上下文。一次能读入的 token 数有上限,叫上下文窗口;超出时,通常把较早的内容删掉或压缩成摘要,模型就看不到原文了。
  11. 3:38信息从哪里来5.5
    参数里的信息停在训练数据截止的那一刻。检索到的网页进入上下文,可以是新的、能追溯来源,但只和来源一样可靠。上下文里的文字,任何人都可能写入。
  12. 4:00智能体的循环5.6
    智能体是被程序循环调用的语言模型:程序把任务放进上下文,调用模型;模型写出答案或工具调用请求;程序检查权限,执行工具,把结果追加到上下文,再调用。
  13. 4:22只看结果分不出来5.6
    回到记账程序:智能体改程序,直到测试全部通过。可能修好了代码,也可能改掉了测试,只看结果分不出来。步骤越多,出错的机会越多;行动还有后果,往往无法撤回。

带走的几句话:

  1. 基础模型、后训练模型、聊天产品、智能体是四种东西,结论要说清测的是哪一种。
  2. 一次回答只是一次抽样:写明温度、次数和汇总方式;多问几次不等于多出几道题。
  3. 智能体循环调用工具,评估的对象从一个回答变成一整段过程。

第 4 章讲了机器怎样从数据中学习:定义损失,用梯度下降调整参数,再用留出的数据检查它对新数据是否有效。本章把这些概念用到语言模型上。Claude、ChatGPT 这类系统,人们常常笼统地叫它们“模型”,其实它们由好几层组成:最里面是一个经过训练的神经网络,外面有让它学会对话的训练,再外面是产品的界面和设置,最外面可能还有一个让它调用工具、连续行动的程序。

先看一个例子。同一个模型,用三种方式问它同一件事:“某种外币今天的汇率是多少?”下面是示意的情形,不是某个具体系统的记录。

  • 直接续写文本。把这句话交给只经过预训练的模型,让它往下写。它可能把这句话当成论坛帖子的开头,接着写出另外几个问题;也可能接着写出一个看起来很像汇率的数字。
  • 在聊天界面里回答。同一个模型经过对话训练、放进聊天产品后,它会用助手的口吻回答:可能说明自己无法知道今天的数据,也可能给出它在训练数据里见过的某个旧数字。
  • 接上搜索工具执行任务。再给它一个搜索工具,它可能先搜索、读一个网页,再报告网页上的数字并给出来源。这时答案可能是新的,但也可能读错了网页,或者网页本身就是错的。

三种表现不同,原因分别在三个地方:模型受过什么训练,它被包在什么样的产品里,它在回答时能看到什么信息。本章依次讲这几层。对本书来说,分清这几层有一个直接的用处:一个评估结论,必须说清它测的是哪一层。

5.1 token 与下一个 token 预测 #

语言模型读写文本的单位叫 token。一个 token 可能是一个词、一个词的一部分、一个字或一个标点。模型有一张固定的词表(vocabulary),列出它认识的全部 token;任何一段文字进入模型之前,都先被切成词表里的 token 序列。比如“余额等于收入减支出”可能被切成“余额 / 等于 / 收入 / 减 / 支出”五个 token。这只是示意:实际怎样切由所用的分词方法决定,不同模型的切法不同。日常使用中,模型一次能读多少文字、按多少收费,通常都按 token 计算。

语言模型做的事情可以用一句话概括:给定前面的 token,预测下一个 token。更准确地说,它对词表里的每一个 token 都给出一个概率,表示“下一个是它”的可能性有多大。读到“余额等于收入减”,一个训练得好的模型会给“支出”很高的概率,给“苹果”很低的概率。

模型怎样学会做这件事?用第 4 章的话说,这是一个分类问题,只是类别有词表那么多。训练数据是海量的文本:书、网页、代码等等。在一段文本的每个位置上,“前面的内容”是输入,“实际出现的下一个 token”就是标签。模型给真实的下一个 token 的概率越低,损失越大;梯度下降一点点调整参数,让损失变小。这个过程叫预训练(pretraining)。

预训练有一个特别之处:标签不需要人去标,文本自己就带着答案。一篇 1000 个 token 的文章,本身就提供了大约 1000 个训练样本。这让模型可以在远远超过人工标注能力的数据量上训练。

要在各种各样的文本上把下一个 token 预测好,模型必须在某种程度上掌握文本里反复出现的东西:语法、事实、文体、常见的推理步骤,以及写这些文本的人的习惯。它也可能学到文本里的错误和偏见:预训练的目标只是“像训练文本那样接着写”,而不是“写对的东西”。

模型生成一段文字,就是把预测重复很多次:根据前文给出下一个 token 的概率,选出一个 token,接在后面,再预测下一个,直到写完。“选出一个 token”这一步怎样做,是第 5.4 节的内容。

预训练的产物叫基础模型(base model)。它擅长续写文本,但没有专门学过“回答问题”或“听从指令”。给它一个问题,它会把问题当作某篇文档的开头,写出这篇文档可能的下文,而下文不一定是答案。

5.2 Transformer 的直觉 #

要把下一个 token 预测好,模型需要用上前文里的信息,而有用的信息可能离得很远。读这句话:“这笔支出因为网络问题提交了两次,按需求说明,它只应该记一次。”要理解“它”,得回头找到十几个字之前的“这笔支出”。

ChatGPT 这类系统背后的语言模型,采用一种叫 Transformer 的神经网络结构(Sanderson,2024b)。它最初是在机器翻译任务上提出的(Vaswani 等,2017)。它的核心部件叫注意力(attention)。直觉上,注意力做的是这样一件事:在每个位置上,模型估计前文中每个位置与当前位置有多相关,然后按相关程度把那些位置的信息加权混合起来,作为当前位置的补充信息。读到“它”的时候,“这笔支出”所在的位置可能得到较大的权重,于是“它”这个位置就带上了“指的是一笔支出”的信息。这很像人读书时,遇到代词会回头扫一眼前面的名词。

在此之上还有几层结构,这里只讲直觉。

  • 多个“头”。一层里通常有好几组注意力同时工作,叫多个“头”(head)。可以粗略地想象,它们分别关注不同种类的关系,比如一组找代词指的是谁,另一组看前一个词是什么。这只是帮助理解的图像,一个头实际在做什么,要靠研究才能知道。
  • 两种部件交替。每一层先用注意力从其他位置收集信息,再在每个位置上单独加工这些信息。许多这样的层叠起来,就是第 4.6 节说的深度网络。
  • 只看前面。像第 5.1 节那样逐个 token 往后写的语言模型里,每个位置只能参考它前面的位置。道理很简单:生成时,后面的内容还不存在。

有一点容易混淆,正好对应第 4.2 节和第 4.6 节的区分。注意力怎样计算相关程度,是由参数决定的,这些参数在训练后固定;而对一句具体的话,“它”到底给“这笔支出”多大的权重,是这一次计算出来的中间数值,属于激活,换一句话就不一样。

还有一个提醒。注意力权重看起来像是在告诉我们“模型在看哪里”,很容易被当成模型作出某个回答的理由。但权重大,不等于输出就是因为这个位置才这样;读得出某种关系,不等于模型在用它。第 18.3 节会专门讨论这种相关与因果的区别。

第 5.2 节引用的文献 2
  1. Sanderson(2024b)Transformers, the tech behind LLMs
  2. Vaswani 等人(2017)Attention Is All You Need

5.3 四种形态 #

基础模型擅长续写,人们想要的却是一个会回答、会听从指令、会拒绝某些请求的助手。从前者到后者,再到人们每天使用的产品,中间还有几层。

表 5.1 语言模型系统的四种形态
形态 是什么 怎样得到 对同一个问题的典型表现(示意)
基础模型 续写文本的模型 预训练 把问题当作文档开头往下写,不一定给出回答
后训练模型 学会了按对话格式回答、遵循指令的模型 在基础模型上继续训练,例如监督微调和偏好训练(第 6 章) 用助手的口吻直接回答
聊天产品 后训练模型加上产品的外层:开发者预先写好的指示、对话界面、采样设置,以及可能有的文件上传、记忆、内容过滤等功能 开发者把模型部署成面向用户的服务 回答还受开发者的指示和产品设置影响
使用工具的智能体 被一个程序循环调用的模型,能搜索、运行代码、读写文件 在模型外面搭一个循环程序,接上一组工具 先搜索或执行几步操作,再给出结果

后训练模型。预训练之后的训练统称后训练(post-training)。一种理解方式是:一段对话本身也是一种文档,只不过其中的发言标明了角色,比如“用户”和“助手”。后训练教模型在“助手”这个角色里该怎样写:直接回答问题、按指令的格式输出、在某些请求面前拒绝。后训练用到的方法,例如用示范数据做监督微调、用人的偏好比较做强化学习,是第 6 章的内容。

聊天产品。你在网页或手机应用里用到的,通常不是“裸”的模型。开发者会在你的消息之前放一段你看不到的文字,叫系统提示词(system prompt),规定助手的身份、语气和规则;产品还决定了采样的设置(第 5.4 节)、对话历史保留多少,以及是否提供文件上传、记忆、联网等功能。所以同一个模型,在聊天产品里和通过开发者接口直接调用时,回答可能不一样。

使用工具的智能体。再往外一层,模型被一个程序循环调用,可以使用工具、连续行动。第 5.6 节专门讲这一层。

这四种形态不是四个不同的模型,而是一层套一层:同一组预训练出来的参数,可以经过后训练,部署成不同的产品,再接上不同的工具。这对评估有几个直接的后果。

  • 结论要说清测的是哪一层。在聊天界面里测得“模型拒绝了危险请求”,不能直接推出同一个模型通过开发者接口调用、或者作为智能体执行任务时也会拒绝。
  • 外层也是被评估的对象。系统提示词、采样设置、工具和权限都会改变行为。报告结果时要写明这些设置。
  • 产品会更新。同一个产品名下的模型和设置会随时间改变。记录模型的版本和测试的日期,结论才能被别人核对。

5.4 采样与随机性 #

第 5.1 节说,模型每一步给出的是下一个 token 的概率,而不是一个确定的 token。从概率到 token,有两种基本做法。

  • 总是选概率最大的那个。按这个规则,只要模型给出的概率不变,每次的输出就都一样(实际服务中的例外见本节末尾)。它通常对应“温度 0”。
  • 按概率随机抽一个。概率是 0.6 的 token,大约每 10 次被抽中 6 次。这叫采样(sampling)。同一个问题问两次,可能得到不同的回答,原因就在这里。

采样之前,通常还会用一个叫温度(temperature)的设置调整这些概率。温度低,概率更集中到最可能的几个 token 上,输出更稳定、更保守;温度高,概率被摊平,不太可能的 token 也有更多机会被抽中,输出更多样;如果最可能的那几个 token 正是对的,也就更容易出错。温度 1 表示不调整,直接用模型给出的概率。

看一个示意的例子。问模型“记账程序在写入失败时会只记一半吗?回答:”,假设它对第一个词给出三个候选,在不同温度下被抽中的概率如下(数字为示意,由 tools/exercises/ch05_sampling.py 算出):

表 5.2 同一组候选在不同温度下被抽中的概率(示意)
温度 “不会” “会” “可能”
0 1 0 0
0.5 0.783 0.196 0.022
1 0.600 0.300 0.100
2 0.473 0.334 0.193

温度从 0 升到 2,“不会”从每次必选,变成不到一半的时候被选中。第一个词定了,后面的每一步都以它为前文:先抽到了“会”,接下来的每个 token 都是接在“会”后面预测的。图 5.1 把同样的调整用在整个词表上,可以拖动温度看概率怎样变化。

模型本来的分布(T = 1)实际采样用的分布被核采样截掉上文:“渡轮驶出港口,驶向……”小岛0.35海岸0.17外海0.10大陆0.08城市0.06北方0.04港口0.03南方0.03海湾0.02天边0.02对岸0.01东方0.01西方0.0094岸边0.0077边境0.0063灯塔0.0047其余 50,241 个0.050.000.050.100.150.200.250.300.35概率T = 1,核采样阈值 1.00:50,257 个 token 中有 50,257 个可能被采到;“小岛”的概率是 0.35。其余 50,241 个 token 合计:调温度后为 0.05(每个 1.1×10^-6),经过核采样后为 0.05。
模型本来的分布(T = 1)实际采样用的分布被核采样截掉上文:“渡轮驶出港口,驶向……”小岛0.35海岸0.17外海0.10大陆0.08城市0.06北方0.04港口0.03南方0.03海湾0.02天边0.02对岸0.01东方0.01西方0.0094岸边0.0077边境0.0063灯塔0.0047其余 50,241 个0.050.00.10.20.3概率T = 1,核采样阈值 1.00:50,257 个 token 中有 50,257 个可能被采到;“小岛”的概率是 0.35。其余 50,241 个 token 合计:调温度后为 0.05(每个1.1×10^-6),经过核采样后为 0.05。
图 5.1 同一个下一 token 分布在不同温度下的样子。上文是“渡轮驶出港口,驶向……”,图中列出 16 个候选词,词表里其余 50,241 个 token 合成最后一行(词表共 50,257 个 token)。紫色竖线是模型本来给出的概率(温度 1),蓝色条是按温度 T 调整之后实际用来抽取的概率(每行右侧的数字就是它),算法见本节的“温度是怎样算的”。拖动温度:T = 0.5 时,最可能的词的概率从 0.35 升到 0.69;T = 1.5 时,它降到 0.07,其余 50,241 个 token 却合计占 0.72,因为几万个 token 每个都分到了一点概率。表 5.2 只看三个候选,温度 2 时“不会”仍有 0.473;在这个示意分布里,把整个词表算进来,高温的影响大得多。第二个滑块是核采样(nucleus sampling,也叫 top-p)的阈值,本节正文不用它:它只保留概率最高、累计概率刚好达到阈值的那一组 token(灰色条是被截掉的 token 在截断前的概率;最后一行只截掉一部分时,灰色条画的是这一行截断前的合计,露出的长度不等于截掉的概率),再把它们的概率按比例放大到合计为 1;默认的 1 表示不截断。候选词和它们的分数是为说明而设定的示意,图中的概率都由它们精确算出。

5.4.1 随机性对评估意味着什么 #

对使用者来说,随机性有时是好事,比如想要几个不同的写法。对评估者来说,它是一个必须处理的误差来源。下面几点中,有几点第 3.5 节、第 3.7 节已经用到,第 12 章和后面的实验章节还会用到。

第一,一次回答只是一次抽样。假设模型答对某道题的概率是 0.6。只问一次,有 40% 的可能你看到的是错的回答。在 200 道题上各问一次得到的准确率,混合了两种变化:题目本身的难易,以及这一次抽得好不好。

第二,每题多采样几次,能更准地估计模型在这道题上的表现,但不等于多出了几道题。同一道题问 5 次,可以估计“这道题答对的概率大约是多少”;但 200 道题各问 5 次,信息量通常远不如 1000 道不同的题:这 5 次回答共享同一道题的难易,题目之间的难易差别越大,差得越多。第 3.5 节讲了怎样在统计上区分这两种变化,并用一个例子算出了差多少。

第三,同样的采样结果,可以汇总出差别很大的数字。还是那道答对概率为 0.6 的题,每次新开对话问一次,各次互相独立,问 5 次:

  • 平均下来,5 次中答对的比例的期望是 60%;
  • 5 次中至少有一次答对的概率是 98.98%;
  • 5 次中多数(3 次以上)答对的概率是 68.26%。

(数字由 tools/exercises/ch05_sampling.py 算出。)“至少一次答对”这种汇总方式常写作 pass@k,k 是采样次数。三个数字描述的是同一个模型、同一道题,回答的却是不同的问题:平均比例说的是“随手问一次有多大把握”,“至少一次”说的是“允许多试几次并且有办法挑出对的那个时能不能做到”,“多数答对”说的是“几次投票取多数时结果对不对”。读评估报告时,先看清用的是哪一种。

第四,比较两个模型,设置要一致,并写清楚。一个模型用温度 0、另一个用温度 1,一个问 1 次、另一个问 5 次取最好,这样的比较说明不了谁更强。报告评估结果时,至少写明模型版本、温度、每题采样几次、怎样汇总。

第五,罕见的行为在少量采样里看不到。假设某种不希望出现的回答,每次出现的概率是 1%,各次互相独立。问 5 次,至少见到一次的概率只有 4.9%;问 300 次,这个概率是 95.1%;而一个每天回答一百万次的服务,平均每天会出现一万次。所以“评估时没有出现”不等于“不会出现”,要看采样了多少次(第 3.7 节讲了零失败时能得出的上界)。

第六,用模型当裁判时,裁判也在采样。让一个模型判断两个回答哪个好,同样的输入判两次,结论可能不同。所以同一个输入要多判几次,并按上面第四点报告温度和次数;第 12.4 节把这算作裁判一致性的一种。

最后,温度设成 0 并不能让这些问题消失。它去掉了采样的随机性,但只评估了每道题上每一步都选最可能的 token 时得到的那一个回答,而实际使用时的设置可能不同;如果你用的是聊天产品,你未必知道它用的是什么温度。而且实际服务中,温度 0 的输出是否每次都完全相同,取决于具体的实现,做实验时应当自己重复几次确认,而不是默认如此。

要点

模型的一次回答是一次抽样。评估时要每题多采样几次,并写明温度、采样次数和汇总方式;同时记住,多采样提高的是对每道题的估计精度,不能代替更多、更多样的题目。

5.5 上下文窗口与外部检索 #

模型每次被调用时读到的全部文字,叫上下文(context):系统提示词、之前的对话、你粘贴进来的文档、工具返回的结果,都在其中。模型一次能读入的 token 数有上限,叫上下文窗口(context window)。对话或资料超出上限时,必须删掉或压缩一部分内容,常见的做法是删掉较早的内容,或把它压缩成摘要;被删掉或压缩的内容,模型就看不到原文了。

那么,模型“知道”的东西存在哪里?这里给“知道”加了引号,因为本书说的是行为:模型能不能给出正确的信息(第 10.4 节说明本书为什么这样定义)。在这个意义上,信息有两个来源。

  • 存在参数里。预训练时读过的大量文本,以某种方式沉淀在参数里。这部分信息停留在训练数据截止的那一刻,之后发生的事情模型不会从这里得到;它给出的出处可能是编出来的,需要核对;它给出的信息可能模糊或错误;要更新它,就得改动参数,通常是再训练。
  • 来自上下文。回答时放进上下文的信息,模型可以直接读到。这包括你提供的资料,也包括检索(retrieval)得到的内容:系统先根据问题去搜索引擎或文档库里找相关的段落,再把找到的段落放进上下文,让模型据此回答。这样得到的信息可以是新的,也可以追溯到来源;但它只和来源一样可靠,而且模型还可能读错、漏读或误用它。

回到本章开头的汇率问题。没有搜索工具时,模型能给出的数字只能来自参数:可能是训练数据里的某个旧数字,也可能是一个看起来像汇率、其实是编出来的数字,它给出的出处也需要核对;接上搜索之后,数字来自上下文中的网页,可以核对来源,可靠程度则取决于那个网页和模型读得对不对。

这个区分对监督很重要。

  • 判断一个回答,先问信息从哪里来。来自参数的说法需要独立核实;附带来源的说法,要检查来源是否真的支持它,以及来源本身是否可靠。第 20.5 节把这一点整理成外部证据的三个层次。
  • 评估者看到的信息可能比模型少。模型读了一份长文档后作答,评估者如果看不到这份文档,就无法判断回答是否忠于原文。第 9.2 节把这列为监督失效的一个来源。
  • 上下文里的文字,任何人都可能写入。检索到的网页、收到的邮件、别人共享的文档,都会进入上下文。如果其中有一句看起来像指令的话,模型可能把它当成指令来执行。所以接上检索和工具之后,“谁能影响模型读到的内容”也成了需要考虑的问题。

5.6 从模型到智能体 #

越来越多的系统不只回答问题,还会行动:运行代码、搜索网页、修改文件、发送消息,在一个任务上连续工作很久。做到这些并不需要另一种模型:循环和工具都在模型外面的程序里,模型这一边要做的,是按约定的格式写出工具调用请求。

工具(tool)是外围程序能替模型执行的功能,例如搜索、运行代码、读写文件。智能体(agent)在本书中指这样一个系统:一个语言模型被一个程序循环调用,程序把模型输出中的一部分变成实际的行动。循环大致是这样的:

  1. 程序把任务和可用工具的说明放进上下文,调用模型。
  2. 模型输出两种东西之一:最终答案,或者一个按约定格式写的工具调用请求,例如“运行这段测试代码”。
  3. 如果是工具调用,程序先检查这个工具是否被允许,再执行它,把结果(比如测试的输出)追加到上下文里。
  4. 回到第 1 步,再次调用模型,直到模型给出最终答案或达到步数上限。

写成示意的代码,是这样:

# 示意代码:model、tools、allowed 都是假设的对象,不对应某个具体的库
def run_agent(task, model, tools, allowed, max_steps=50):
    context = [task]
    for step in range(max_steps):
        reply = model(context)                 # 模型只做一件事:读上下文,写出文字
        if reply.is_final_answer:
            return reply.text
        if reply.tool_name in allowed:         # 权限检查在程序里,不在模型里
            result = tools[reply.tool_name](reply.argument)
        else:
            result = "这个工具不允许使用"
        context.append(reply.text)
        context.append(result)                 # 工具的结果成为下一步的上下文
    return None

注意这段代码里,模型本身仍然只是“读一段文字,写一段文字”。循环、工具、权限检查,以及上下文太长时保留哪些内容,都在模型外面的程序里。所以对一个智能体的判断,必须说清是关于模型、关于外围程序,还是关于两者合起来的整个系统。

智能体给监督带来了几个新问题。

  • 评估的单位从一个回答变成一整段过程。回到记账程序:假设一个编程智能体负责修改程序,直到全部测试通过。最后测试确实通过了,但它可能是修好了代码,也可能是改掉了测试(第 8 章的例子正是这样)。只看“测试通过”分不出来,要看它实际改了什么,以及是怎样一步步改的。
  • 步骤越多,出错的机会越多。假设每一步都有 99% 的把握做对,各步之间互不影响,一个需要 50 步全部做对的任务,成功的概率只有约 60.5%;200 步时只有约 13.4%(tools/exercises/ch05_sampling.py)。实际中各步的错误并不独立,有的错误后面还能纠正,所以这只是一个说明方向的计算。
  • 行动有后果。一段写错的文字可以丢掉不用;一个删掉的文件、一封发出去的邮件、一笔转出去的钱,往往无法撤回。
  • 过程很长,人看不过来。每一步都可以记进日志,但一个几百步的过程,人很难逐步审查。第 26 章讨论在只能检查一小部分步骤时怎样分配检查,以及一个每一步单独看都正常、合起来却有害的过程(第 37 步读取了密钥,第 150 步把它发了出去)怎样才能被发现。

本章的四层结构,在后面会反复用到。读到任何一个关于“模型”的结论时,先问:测的是基础模型、后训练模型、聊天产品,还是智能体?用的是什么采样设置?模型回答时能看到哪些信息,能使用哪些工具?

读物 #

  • 入门讲解 · 视频:3Blue1Brown《Large Language Models explained briefly》(Sanderson,2024a)。一个简短的入门:语言模型怎样给下一个词分配概率,怎样在大量文本上预训练,预训练之后又怎样用人的反馈继续训练。适合在读本章之前看。
  • 入门讲解 · 视频:3Blue1Brown《Transformers, the tech behind LLMs》(Sanderson,2024b)。用图像讲解 token、注意力与前馈层交替叠加的数据流,以及温度怎样改变概率分布,补充第 5.1 节、第 5.2 节和第 5.4 节的直觉。
  • 方法与工具 · 视频(实验及研究):Karpathy《Let's build GPT: from scratch, in code, spelled out.》(Karpathy,2023)。用代码从零写出一个小型的 Transformer 语言模型,需要第 2 章的 Python 基础,适合想看清每个部件怎样实现的读者。
  • 原始提案 · 会议论文(仅研究):Vaswani 等《Attention Is All You Need》(NeurIPS 2017)(Vaswani 等,2017)。提出 Transformer 结构的原始论文,读它是为了了解结构,不必弄懂全部细节。
本节引用的文献 4
  1. Sanderson(2024a)Large Language Models explained briefly
  2. Sanderson(2024b)Transformers, the tech behind LLMs
  3. Karpathy(2023)Let's build GPT: from scratch, in code, spelled out.
  4. Vaswani 等人(2017)Attention Is All You Need

练习 #

习题 5.1 同一个问题问 5 次

在任意一个聊天界面里,把同一个问题问 5 次。每次都开一个新对话,避免前一次的回答留在上下文里。准备两个问题:

  • 一个有明确答案、你能核对的问题,例如一道多步的应用题,或者一个你能查到出处的事实;
  • 一个开放的问题,例如“为记账程序的规则三(写入失败时不能只记一半)举一个违反它的例子”。

把每次的回答记在表里:结论是什么,对不对(开放题记录结论的要点),措辞是否相同。然后回答:

  1. 5 次回答中有几种不同的结论?有明确答案的那道题,答对了几次?
  2. 如果只问一次,你会对这个模型得出什么结论?这个结论有多大可能因为“这一次抽得不好”而出错?
  3. 这对设计评估实验意味着什么?

实验路线:改用开发者接口,在温度 0 和温度 1 下各采样 5 次,比较两种温度下回答的变化。代码的骨架如下,ask 函数要换成你所用服务的调用方式:

def ask(prompt, temperature):
    raise NotImplementedError("换成你所用的模型接口")

question = "……"
for t in (0, 1):
    answers = [ask(question, temperature=t) for _ in range(5)]
    print(t, answers)
提示

新开对话很重要:同一个对话里再问一次,模型会看到自己前面的回答,后面的回答就不再是独立的抽样。记录时也要写下产品名称、日期,以及能看到的模型版本。

解答

本题没有标准答案,评分要点如下:

  • 记录完整:每次都新开对话,5 次回答的结论和对错都有记录,并写明产品、日期和能看到的版本信息。
  • 能区分“结论不同”和“措辞不同”。措辞每次都变是正常的;结论变化才说明单次回答不可靠。
  • 第 2 问能用实际的比例说话。例如有明确答案的题 5 次中答对 3 次,就应当说:只问一次时,大约有五分之二的可能看到错的回答,据此下“模型不会做这道题”或“模型会做这道题”的结论都不稳妥(5 次本身也很少,这个比例的误差很大,见第 3.3 节)。
  • 第 3 问至少说到:评估要每题多次采样;写明温度、采样次数和汇总方式;多次采样提高的是每道题的估计精度,不能代替更多的题目(第 3.5 节);在聊天界面里做的观察,结论只适用于这个产品当时的设置。
  • 实验路线:温度 0 时 5 次回答通常相同或几乎相同,温度 1 时变化更多;如果温度 0 下仍有差别,要如实记录,而不是假定它一定相同。
习题 5.2 同样的采样,三个数字

某个模型答对一道题的概率是 0.6,每次采样互相独立。对这道题采样 5 次。

  1. 5 次中答对的比例,期望是多少?
  2. 5 次中至少一次答对的概率是多少?
  3. 5 次中多数(至少 3 次)答对的概率是多少?
  4. 一份报告写这道题“在 5 次采样中至少一次通过的概率为 99%”。它说明了什么,没有说明什么?
  5. 某种不希望出现的回答每次出现的概率是 1%。采样 5 次和 300 次,各有多大概率至少见到一次?
提示

“至少一次答对”等于 1 减去“5 次全错”的概率。“至少 3 次答对”要把恰好 3、4、5 次答对的概率加起来。以恰好 3 次为例:5 次中哪 3 次答对,有 10 种不同的排法,每种排法的概率按第 3.1 节的独立事件乘法是 0.63×0.420.6^3 \times 0.4^2,再乘以 10。也可以直接运行脚本。

解答

数字由 tools/exercises/ch05_sampling.py 算出。

  1. 60%。
  2. 1−0.45≈0.98981 - 0.4^5 \approx 0.9898,即约 98.98%。
  3. 恰好 3、4、5 次答对的概率分别约为 0.3456、0.2592、0.0778,合计约 0.6826,即 68.26%。
  4. 它说明:如果允许试 5 次,并且有办法从 5 个回答中认出对的那个(例如编程题可以运行测试),几乎总能拿到一个对的回答。它没有说明随手问一次答对的把握有多大(这里只有 60%),也没有说明在无法检查哪个回答对的场合,5 次回答能有什么用。
  5. 5 次:1−0.995≈4.9%1 - 0.99^5 \approx 4.9\%;300 次:1−0.99300≈95.1%1 - 0.99^{300} \approx 95.1\%。少量采样中没见到,不能说明这种回答不会出现。
习题 5.3 测的是哪一层

下面四个评估分别测的是基础模型、后训练模型、聊天产品,还是使用工具的智能体?每一个结论,能不能直接推广到另外几种形态?

  1. 研究者通过开发者接口,把 100 段新闻的开头交给一个只经过预训练的模型,统计它续写出的文字里有多少编造的人名。
  2. 研究者在某个聊天应用里问了 50 个医学问题,请医生判断回答是否正确。
  3. 研究者让一个模型在一个可以运行代码、读写文件的环境里修复 20 个程序缺陷,统计全部测试通过的比例。
  4. 研究者通过开发者接口,不加任何系统提示词,向一个经过对话训练的模型提出 200 个有害请求,统计拒绝的比例。
解答
  1. 基础模型。结论不能直接推广到后训练模型:后训练会改变模型对同样开头的续写方式。
  2. 聊天产品。结论包含了这个产品的系统提示词、采样设置和功能(例如是否联网),换成接口调用或别的产品,结果可能不同;产品更新后也可能不同,所以要记录日期和版本。
  3. 使用工具的智能体。结果取决于模型、外围程序、可用的工具和步数上限;“测试全部通过”还要检查过程,看是修好了代码还是改掉了测试(第 5.6 节)。
  4. 后训练模型。在产品里,系统提示词和内容过滤可能让拒绝率更高或更低;作为智能体执行任务时,有害的请求可能藏在多步任务的中间,拒绝率也不能直接沿用。

学完能做到 #

  • 说清基础模型与聊天产品的区别:基础模型只经过预训练,做的是续写;聊天产品是后训练模型加上系统提示词、采样设置和产品功能。
  • 解释评估时为什么要多次采样:一次回答只是一次抽样;多次采样提高对每道题的估计精度,但不能代替更多的题目;结果要写明温度、采样次数和汇总方式。
  • 看到一个关于“模型”的结论时,指出它测的是四种形态中的哪一种,以及模型回答时能看到哪些信息。
  • 说出智能体比单次回答多出的几个监督问题:评估单位变成整个过程,错误随步数累积,行动有不可撤回的后果。

参考文献

  1. Karpathy, A. (2023). Let's build GPT: from scratch, in code, spelled out. YouTube. 非同行评审
  2. Sanderson, G. (2024a). Large Language Models explained briefly. 3Blue1Brown. 非同行评审
  3. Sanderson, G. (2024b). Transformers, the tech behind LLMs. 3Blue1Brown. 非同行评审引用于 §5.2
  4. Vaswani, A., Shazeer, N., Parmar, N., Uszkoreit, J., Jones, L., Gomez, A. N., Kaiser, L., and Polosukhin, I. (2017). Attention Is All You Need. Advances in Neural Information Processing Systems. 引用于 §5.2