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

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

第 4 章机器学习基础

路线全部路线最短路线

本章导读

本章问题
  • 机器怎样从数据中学习?
要点
  • 机器学习不让人写规则,而是给出带标签的例子,让程序自己调整参数;交给你的是预测,不是参数(§4.2)。
  • 训练就是沿着损失曲线的斜率一步步往更低处走,它只会降低你写下的那个损失(§4.3)。
  • 训练集调参数,验证集选设置,测试集只在最后用一次;测试集的信息漏进训练或选择,分数往往偏高(§4.4)。
  • 训练分数高不等于对新数据有效;对新数据的结论只在新数据与测试数据相似时成立(§4.5)。
本章的视频讲解,5 分,没有声音,文字在画面左侧。下载视频(MP4)
文字稿
  1. 0:071000 封邮件
    1000 封邮件,每封都由人标上了“垃圾邮件”或“正常邮件”。分类器在这些邮件上几乎全对。明天来的 1000 封新邮件没人标过答案,怎样知道它对新邮件也有效?
  2. 0:24不写规则,给例子4.1
    自己写规则,越写越多、彼此冲突,换个说法就失效。机器学习给程序很多带答案的例子,让它自己找规则。一个输入连同标签叫样本;标签错了,模型可能照着错的学。
  3. 0:46带空位的式子4.2
    用三个数描述一封邮件,叫特征。打分式子里的 a、b、c、d 是空位,叫参数;学习就是找一组好的参数。用学完的参数给一封邮件打分:“中奖”两次、一个链接、不在通讯录,分数 5,大于 0,预测为垃圾邮件。
  4. 1:10你拿到的是预测4.2
    参数是模型本身,训练后固定;预测是对某个输入的回答。用模型时你拿到的是预测,AI 交给你的记账程序也是一个预测。检查过的预测都对,没试过的输入上仍可能出错。
  5. 1:29损失与梯度下降4.3
    损失函数把参数在训练样本上的预测和标签比较,算出一个数,越小越好。设只有一个参数 w,损失是 (w − 3)²。梯度下降看脚下的斜率,往反方向走。学习率 0.1 时步子越走越小,26 步后 w 离 3 不到 0.01。
  6. 1:54学习率太大4.3
    学习率取 1.1,第一步就从 w = 0 跳到 6.6,损失从 9 升到 12.96。之后来回跳,越跳越远。学习率这类由人选定、训练中不变的设置,叫超参数。
  7. 2:11只降低你写下的损失4.3
    梯度下降只降低你写下的那个损失,在你给它的那批数据上。标签有错,或损失没表达你真正想要的,它同样把模型推向错误的方向。
  8. 2:31三份数据,测试集用一次4.4
    1000 封分成 600、200、200:训练集调参数,验证集选学习率这类设置,测试集等所有选择做完只用一次。试 50 种一样好的设置,在测试集上挑最高分,平均约 86.1%(按互不相关算)。测试集就成了另一个验证集。
  9. 2:55数据泄漏4.4
    本该只在最后评估时用的信息,以某种方式进入了训练或选择,叫数据泄漏,它让评估结果比真实情况好。右边是常见的几种,共同点是测试数据的信息提前漏了进去。
  10. 3:18过拟合4.5
    在新数据上也表现好,叫泛化。用多项式拟合 12 个点:次数越高,参数越多,曲线越灵活。11 次时穿过全部点,却在点间剧烈摆动,这叫过拟合。训练误差降到 0,测试误差总体先降后升。
  11. 3:40捷径与前提4.5
    若收集时垃圾邮件大多夜里发出,模型可能学会“夜里发出就是垃圾邮件”。这不是过拟合,是新数据不再相似。“对新数据有效”总带着前提:新数据和评估数据相似。
  12. 4:02神经网络4.6
    神经元把输入加权求和,加一个数,再做简单变换,如负数变成 0。许多神经元组成一层,一层的输出是下一层的输入。权重是参数,对所有输入都一样;每层算出的数叫激活,随输入而变。
  13. 4:23用 scikit-learn 走一遍4.7
    24 封为教学构造的短邮件,18 封训练、6 封测试,只用训练集挑 20 个词作特征,训练逻辑回归:测试集准确率 0.83。可总猜垃圾邮件也有 50%;6 封里差一封就差约 17 个百分点,换 200 次划分,从 0.5 到 1.0。

带走的几句话:

  1. 参数是模型本身,预测是它对某个输入的回答;你拿到的是预测。
  2. 梯度下降总往斜率的反方向走;学习率太大,会越跳越远。
  3. 调参不能用测试集;还要问数据之间有没有重复或同源。

第 1 章说过,今天的语言模型在很大程度上是靠人的判断训练出来的。要看懂这句话,先要知道“训练”是什么意思:一个程序怎样从例子里学会做事,学到的东西放在哪里,以及我们怎样知道它学对了。本章用最简单的例子讲清这几件事。后面几乎每一章都会用到这里的词。

先看一个具体的问题。你收集了 1000 封邮件,每一封都由人看过,标上了“垃圾邮件”或“正常邮件”。你用这些邮件训练出一个垃圾邮件分类器,在这 1000 封邮件上它几乎全对。明天又会来 1000 封新邮件,没有人给它们标过答案。你怎样知道分类器对新邮件也有效?

这本身就是一个监督问题。分类器每天要处理的邮件太多,你不可能一封封检查;你需要一个办法,在不逐一核对的情况下,对它的表现有可靠的估计。机器学习给出的办法是:留出一部分有答案的邮件,训练时不让程序看,最后用它们来考。这个办法很有用,但它只在几个条件下成立:留出的邮件确实没有被“偷看”过,新邮件和留出的邮件确实相似。本章后半部分讲这些条件怎样被破坏。它们在本书中会反复出现:当被检查的对象是更强的模型,而检查的方法是“在一批题上考一考”时,同样的条件决定了分数能说明什么。

4.1 从数据中学习 #

最直接的做法是自己写规则。比如“邮件里出现‘中奖’就算垃圾邮件”“邮件里有三个以上链接就算垃圾邮件”。这样做很快会遇到困难:规则越写越多,彼此冲突;发垃圾邮件的人换个说法,规则就失效了;而且你很难说清自己是凭什么一眼认出垃圾邮件的。

机器学习(machine learning)换了一个思路:不让人写规则,而是给程序很多带答案的例子,让程序自己找出能把例子分对的规则。这里有几个词要先说清。

  • 输入(input):交给程序的东西,这里是一封邮件。
  • 输出(output):程序给出的回答,这里是“垃圾邮件”或“正常邮件”。
  • 标签(label):一个例子的正确答案,由人或别的可靠来源给出。1000 封邮件上的“垃圾邮件”“正常邮件”就是标签。
  • 样本(sample):一个输入连同它的标签。1000 封带标签的邮件,就是 1000 个样本,合起来叫一个数据集(dataset)。

用带标签的样本训练模型,叫作监督学习(supervised learning)。这里的“监督”和本书书名里的“监督”(oversight)不是一回事:前者指训练时有人提供了正确答案,后者指判断 AI 的输出能不能接受。但两者有联系。每一个标签背后都有一次判断:有人读了这封邮件,认定它是垃圾邮件。标签错了,训练会把模型往错的标签上拉,模型可能学到错的东西。第 6 章会看到,训练语言模型时,人的判断也是这样变成训练数据的;第 17 章讨论标签本身质量有限时会发生什么。

按输出的形式,最常见的任务分两类。

  • 分类(classification):输出是有限几个类别之一。“垃圾邮件或正常邮件”是分类;“这段代码有没有缺陷”也是分类,只有“有”和“没有”两类。
  • 回归(regression):输出是一个数。“预测这封邮件多少分钟后会被回复”是回归;给一个回答打一个质量分数,也可以看成回归。

分清这两类,是因为它们衡量好坏的方式不同。分类最常用的指标是准确率,即分对的比例;回归通常看预测的数和真实的数差多少。

4.2 参数与预测 #

“让程序自己找规则”,具体是怎样做的?先把规则写成一个带空位的式子,再让程序去填空位。

假设我们决定用三个数描述一封邮件:“中奖”这个词出现了几次,邮件里有几个链接,发件人是否在你的通讯录里(是记作 1,否记作 0)。这种描述输入的数叫特征(feature)。再规定一个打分的式子:

分数=aד中奖”出现次数+b×链接个数+c×是否通讯录联系人+d\text{分数} = a \times \text{“中奖”出现次数} + b \times \text{链接个数} + c \times \text{是否通讯录联系人} + d

分数大于 0 就判为垃圾邮件,否则判为正常邮件。式子里的 aa、bb、cc、dd 就是空位。它们叫作参数(parameter):模型里可以调整的数。所谓“学习”,就是根据样本找到一组好的参数。

假设学完之后,a=2a = 2、b=1.5b = 1.5、c=−1c = -1、d=−0.5d = -0.5。来了一封邮件,“中奖”出现两次,有一个链接,发件人不在通讯录里。它的分数是 2×2+1.5×1−1×0−0.5=52 \times 2 + 1.5 \times 1 - 1 \times 0 - 0.5 = 5,大于 0,判为垃圾邮件。另一封邮件没有“中奖”,有一个链接,发件人在通讯录里,分数是 0+1.5−1−0.5=00 + 1.5 - 1 - 0.5 = 0,不大于 0,判为正常邮件。“垃圾邮件”“正常邮件”这两个回答,就是模型对这两封邮件的预测(prediction)。

参数和预测要分清,因为它们是两种性质完全不同的东西。

  • 参数是模型本身,预测是模型对某个输入的回答。训练结束后参数就固定了;预测则每来一封新邮件就产生一个。
  • 用一个模型时,你拿到的是预测。你看到的是“这封是垃圾邮件”,看不到 aa、bb、cc、dd。AI 交给你的记账程序,也是一个模型对你的请求给出的输出。
  • 检查了几个预测,不等于检查了参数。一组参数在你试过的邮件上都对,在没试过的邮件上仍可能出错。
  • 大模型的参数没法直接读。上面的例子只有 4 个参数,看一眼就知道“中奖”会让分数变高。第 6.3 节会提到的 GPT-3 有 1750 亿个参数(Ouyang 等,2022),没有人能一个个读完,再推断它会怎样回答一个问题。

最后一点决定了本书的基本处境:我们评价一个模型,主要靠看它的预测,也就是它的行为。第 18 章讨论能不能越过输出,从模型内部的数值里得到额外的证据。

第 4.2 节引用的文献 1
  1. Ouyang 等人(2022)Training language models to follow instructions with human feedback

4.3 损失函数与梯度下降 #

怎样找到好的参数?先要有一个数,说明一组参数有多差。

损失函数(loss function)就是这样一个数的算法:拿一组参数,在全部训练样本上做预测,和标签比较,算出一个总的“差距”。预测和标签越不一致,损失越大。对回归任务,常用的做法是把每个样本上“预测减标签”的差平方后取平均,这样差得越远,罚得越重。对分类任务,模型通常不只给出类别,还给出“它是垃圾邮件的概率”,损失则在模型给真实答案的概率越低时越大:把一封垃圾邮件判成“只有 1% 可能是垃圾邮件”,比判成“40% 可能”罚得更重。具体公式这里不需要,记住一件事就够了:损失是一个数,越小表示模型在训练数据上越接近标签。

有了损失,“学习”就变成了“找到让损失最小的参数”。为了能画出来,先假设模型只有一个参数,叫它 ww。每取一个 ww 的值,就能算出一个损失;把所有的 ww 和对应的损失画在图上,就是一条损失曲线。下图是一条示意的损失曲线。

损失曲线与梯度下降横轴是参数 w,纵轴是损失。曲线是 U 形,最低点在 w 等于 3。左侧切线向右下倾斜,斜率为负;右侧切线向右上倾斜,斜率为正。从 w 等于 0 出发的几个点一步步走向最低点,步子越来越小。 参数 w 损失 0 1 2 3 4 5 6 0 2 4 6 8 10 12 斜率为负:往右走 斜率为正:往左走 最低点 w = 3 从 w = 0 出发,每一步走得更短
一条示意的损失曲线:损失 = (w − 3)²。虚线是曲线在 w = 1 和 w = 5 处的切线,它的倾斜程度就是该点的斜率。圆点是从 w = 0 出发、学习率为 0.1 时梯度下降走过的前几步(数字由 tools/exercises/ch04_gradient_descent.py 算出)。

训练的目标是走到曲线的最低点。在这张图上,最低点一眼就能看到:w=3w = 3。但真实的模型有成千上万甚至上千亿个参数,损失随参数变化的“曲线”变成了一个没法画出来、也没法把每一点都算一遍的形状。这时我们只能做一件事:站在当前的位置,看脚下往哪边倾斜。好比在大雾里下山,看不见山谷在哪里,但能感觉到脚下的坡往哪边低。

脚下的倾斜程度,在图上就是斜率(slope):在某一点附近,ww 往右挪一小步,损失变化多少。图中的两条虚线是曲线在 w=1w = 1 和 w=5w = 5 处的切线,它们的倾斜方向就是这两点的斜率。

  • 在 w=1w = 1 处,曲线往右下方倾斜,斜率是负的。往右走,损失变小。
  • 在 w=5w = 5 处,曲线往右上方倾斜,斜率是正的。往左走,损失变小。
  • 在最低点,曲线是平的,斜率为 0,不需要再动。

所以规则很简单:斜率为负就往右走,斜率为正就往左走,也就是总往斜率的反方向走。每一步走多远,按斜率的大小乘上一个固定的小数,这个小数叫学习率(learning rate)。写成式子是:

新的 w=旧的 w−学习率×当前的斜率\text{新的 } w = \text{旧的 } w - \text{学习率} \times \text{当前的斜率}

对图中这条曲线,任意一点的斜率恰好是 2×(w−3)2 \times (w - 3)。这个式子可以从图上大致量出来验证(在 w=1w = 1 处,沿切线往右走 1,损失往下降 4,斜率是 −4-4),也可以用第 2.4 节的导数算出来,这里只需要接受它。从 w=0w = 0 出发,学习率取 0.1:

表 4.1 梯度下降的前五步(学习率 0.1)
步数 ww 斜率 损失
0 0 −6 9
1 0.6 −4.8 5.76
2 1.08 −3.84 3.6864
3 1.464 −3.072 2.3593
4 1.7712 −2.4576 1.5099
5 2.0170 −1.9661 0.9664

每一步损失都在下降,而且越接近最低点,斜率越小,步子也越小。照这样走 26 步,ww 离 3 就不到 0.01 了。表中的数字由 tools/exercises/ch04_gradient_descent.py 算出。

学习率不能随便取。取得太小,要走很多步才能到底。取得太大,会一步跨过最低点,落到对面更高的地方:同样从 w=0w = 0 出发,学习率取 1.1,第一步就跳到 w=6.6w = 6.6,损失从 9 升到 12.96,之后在两侧来回跳,越跳越远。学习率这类由人选定、不由训练过程调整的设置,叫超参数(hyperparameter),下一节讲怎样选它。

参数多于一个时,道理不变。对每个参数分别问:只把这一个参数挪一小步,损失怎样变化?这样每个参数都有自己的斜率。所有参数的斜率合在一起叫梯度(gradient),每一步让所有参数同时往各自斜率的反方向挪一点。这就是梯度下降(gradient descent)。对后面要讲的神经网络,有一种叫反向传播(backpropagation)的方法能高效地算出全部参数的斜率,本书不需要它的细节。

真实的损失形状比一条 U 形曲线复杂,可能有好几个低谷,梯度下降停下来的地方不一定是最低的那个。实际训练只要求损失“足够低”。

要点

梯度下降只做一件事:降低你写下的那个损失,在你给它的那批数据上。如果标签有错,或者损失没有表达你真正想要的东西,梯度下降同样会把模型推向错误的方向。第 8 章讨论这种“目标写错了”的情形。

4.4 训练集、验证集、测试集 #

回到 1000 封邮件。如果用全部邮件训练,再用同样的邮件检查,分数往往偏高,因为模型看过每一道题的答案。要知道它对新邮件怎么样,必须留出一些训练时没用过的邮件。实际做法是把数据分成三份,例如 600 封、200 封、200 封。

  • 训练集(training set):用来算损失、做梯度下降、调整参数。
  • 验证集(validation set):用来作那些梯度下降不负责的选择,例如学习率取多大、用哪些特征、模型做多大、训练到第几步停下。每个候选设置都在训练集上训练,在验证集上比较,选分数最好的。
  • 测试集(test set):所有选择都做完之后,只用一次,估计模型对新邮件的表现。

可以把三者比作课本习题、模拟考和正式考试。课本习题用来学;模拟考用来调整复习方法;正式考试的题目事先不能看,考完的分数才能说明你真实的水平。如果你拿到了正式考试的题目,反复练到满分,这个满分就不再说明任何问题。

为什么测试集只能用一次?设想你试了 50 种设置,每种都在测试集上算一次准确率,然后挑最高的那个报告。即使这 50 种设置其实一样好,对新邮件的真实准确率都是 80%,它们在这个只有 200 封邮件的测试集上的分数也会因为运气上下浮动(第 3.2 节讲过这种抽样误差)。挑出来的最高分,平均会是 86.1% 左右;而被挑中的那个设置,拿到真正的新邮件上,准确率仍然只有 80%。多出来的约 6 个百分点,全部来自“在同一批题上挑了运气最好的那一个”。(计算见 tools/exercises/ch04_test_tuning.py。它把 50 个分数当作互不相关的,这是一个简化:在同一个测试集上,各个设置的分数会有关联,偏高的幅度会小一些;但只要各设置的分数不总是相同,偏高就不会消失(本书的推断)。)这样一来,测试集实际上参与了选择,它就变成了另一个验证集,不再能估计新数据上的表现。

这是数据泄漏(data leakage)的一种。数据泄漏指本该只在最后评估时用到的信息,以某种方式进入了训练或选择的过程,使评估结果比真实情况好。常见的形式有下面几种。

  • 在测试集上反复调参,就是上面的例子。
  • 重复或几乎重复的样本分在两边。如果同一封垃圾邮件稍作改动发给了很多人,其中几份进了训练集、几份进了测试集,测试就变成了考原题。
  • 用全部数据做预处理。例如先用全部 1000 封邮件统计每个词出现的次数,只保留最常见的 5000 个词作为特征,再划分数据。哪些词能进入特征,已经受到了测试邮件的影响。按全部数据算平均值、再把特征缩放到同一尺度,也是同样的问题。正确的顺序是先划分,再只用训练集做这些统计。第 4.7 节的代码按正确的顺序做,并在 24 封教学邮件上用一个对照实验,测了这种泄漏在那里让准确率偏高多少。
  • 同一个来源跨在两边。同一个发件人的邮件分在训练集和测试集两边,模型可能只是记住了这个发件人,而不是学会了识别垃圾邮件。这时应当按发件人划分,让同一个发件人的邮件只出现在一边。训练 InstructGPT 的研究者就按用户划分训练集、验证集和测试集,使验证集和测试集里没有来自训练集用户的数据(Ouyang 等,2022)。第 18 章的探针练习按模板划分,也是同样的道理。
  • 用未来预测过去。用下个月的邮件训练,再去“预测”这个月的邮件,模型可能用上了实际使用时不可能知道的信息。

语言模型还有一种特殊的泄漏:它在训练时读过海量的文本,公开的测试题可能就在其中。第 11.7 节讨论题目进入训练数据的情形,第 23.3 节讨论在同一个基准上反复挑选造成的偏高。

易错点

看到“我们的模型在测试集上达到 87%”,先问两件事:测试集在选择模型和设置时用过没有?测试集和训练集之间有没有重复、同源或时间上的重叠?

第 4.4 节引用的文献 1
  1. Ouyang 等人(2022)Training language models to follow instructions with human feedback

4.5 过拟合与泛化 #

模型在没见过的新数据上也表现好,叫泛化(generalization)。训练的真正目的是泛化,训练集上的分数只是手段。

两者可以差得很远。考虑一个极端的“模型”:它把训练集里每一封邮件和它的标签原样记下来;遇到记过的邮件,就照抄标签;遇到没见过的邮件,一律判为正常邮件。它在训练集上的准确率是 100%,在新邮件上的表现则完全取决于新邮件里正常邮件占多少,它什么也没学会。

真实的模型不会这么极端,但会出现同一个方向的问题。模型越灵活、参数越多,越有能力把训练数据里偶然的细节也记下来,包括标错的标签,以及只在这一批样本里碰巧出现的巧合。这种在训练数据上拟合得太好、以至于在新数据上变差的现象,叫过拟合(overfitting)。图 4.1 用一个可以调节灵活程度的模型演示了这一点。

训练点sin(2πx),生成数据的规则拟合出的多项式−2−1012输出 y0.00.20.40.60.81.0输入 x训练误差测试误差10⁻⁴10⁻²110²均方误差01357911多项式次数噪声下限3 次多项式(4 个系数):训练误差 0.019,测试误差 0.096。在新数据上,任何拟合都不能低于噪声下限 0.0625。
训练点sin(2πx),生成数据的规则拟合出的多项式−2−1012输出 y0.00.20.40.60.81.0输入 x训练误差测试误差10⁻⁴10⁻²110²均方误差0357911多项式次数噪声下限3 次多项式(4 个系数):训练误差 0.019,测试误差 0.096。在新数据上,任何拟合都不能低于噪声下限 0.0625。
图 4.1 用多项式曲线拟合 12 个点。多项式的次数越高,曲线的系数(也就是参数)越多,曲线越灵活。数据由规则 y=sin⁡(2πx)y = \sin(2\pi x)(青色虚线)加上标准差 0.25 的随机噪声生成。拖动多项式次数:次数越高,拟合出的曲线(蓝色)越贴近训练点;下图中训练误差(橙色)一路下降,到 11 次时降为 0,因为 12 个系数可以让曲线穿过全部 12 个点。误差是预测值与观测到的 y 值之差的平方的平均(第 4.3 节)。测试误差(青色虚线)是在新输入上的误差:它总体上先降后升(个别次数会有起伏),次数过高时曲线在点与点之间剧烈摆动。点线是噪声下限 0.0625(即 0.25 的平方),连生成数据的规则本身在新数据上也不能低于它。下图纵轴是对数刻度,每一格差 100 倍;超出纵轴范围的值画在上下边上,读数里小于 0.0001 的误差记作 0。“换一组数据”会重新抽 12 个点。数据的生成方式是为说明而设定的示意,误差都由计算得出;默认这组数据下,3 次多项式的训练误差是 0.019,测试误差是 0.096。

怎样发现过拟合?最直接的信号是训练集上的分数明显高于验证集上的分数。训练过程中常见的形态是:训练集分数一路上升,验证集分数先升后平,甚至开始下降。验证集分数开始下降的时候,就该停下来了。这种做法叫提前停止(early stopping)。其他常见的对策有:收集更多数据;用更简单的模型;在损失里加一项,惩罚过大的参数,这叫正则化(regularization)。

还有一种失效,看起来像过拟合,其实不是。假设你收集邮件的那段时间里,垃圾邮件确实大多是夜里发出的,这不是样本太少造成的巧合,而是那段时间的数据本来如此。模型可能学会“夜里发出就是垃圾邮件”,因为在这样的数据上,这条规则确实管用,比真正利用邮件内容容易得多。等到发垃圾邮件的人改在白天发,白天发出的垃圾邮件会被放过,夜里发出的正常邮件会被拦下。模型学到的是一个在训练数据里与标签相关、但并不是真正原因的特征,这常被称为“捷径”。图 4.2 把这个例子换成两个抽象的特征,可以看到训练准确率怎样掩盖捷径。

训练出的分类器只看核心特征的规则训练准确率0.00.20.40.60.81.0准确率0.00.20.40.60.81.0测试数据中,背景与标签一致的比例随机猜测训练数据中背景与标签一致的比例为 95%,分类器给背景的权重是核心特征的 1.4 倍。训练准确率 96%;测试时一致比例为 50%,准确率 67%(只看核心特征的规则:85%)。
训练出的分类器只看核心特征的规则训练准确率0.00.20.40.60.81.0准确率0.00.20.40.60.81.0测试时背景与标签一致的比例随机猜测训练数据中背景与标签一致的比例为 95%,分类器给背景的权重是核心特征的 1.4 倍。训练准确率 96%;测试时一致比例为50%,准确率 67%(只看核心特征的规则:85%)。
图 4.2 一个学会了捷径的分类器。每个例子有两个特征。核心特征相当于邮件的内容,是设计者希望分类器使用的;按设定,只看它,不论背景线索与标签一致的比例是多少,准确率都是 85%。背景线索相当于“夜里发出”,在训练数据中有 95% 的时候与标签一致。分类器像第 4.2 节的打分式子一样给两个特征各一个权重(就是第 4.7 节的逻辑回归),权重取在训练数据的分布上最好的值,相当于训练数据无限多,所以这里没有过拟合。横轴是测试数据中背景线索与标签一致的比例。蓝线是训练出的分类器的准确率,青色虚线是只看核心特征的规则(处处 85%),橙色点是训练准确率,也就是开发者看得到的那个数。拖动“测试时的一致比例”:一致比例低于约 78% 时,训练出的分类器就不如只看核心特征的规则(在默认的 50% 处,它的准确率只有 67%);背景与标签完全相反时,它的准确率只有 35%。把“训练时的一致比例”降到 50%,分类器就不再依赖背景。两个特征和它们的比例是为说明而设定的示意,准确率由公式精确算出。

图中的分类器只有两个权重,权重又是按训练数据的分布取的最好值,相当于训练数据无限多,所以这不是过拟合:只要测试时背景与标签一致的比例和训练时相同,它在测试数据上的准确率就和训练准确率一样高。对付过拟合的常见办法之一,从同样的来源再多收集数据,在这里帮不上忙:背景线索照样与标签相关,训练出的分类器照样会用上它。问题只出在测试数据与训练数据不再相似。这个现象在后面会以更严重的形式出现:第 8.3 节讨论模型在训练中看起来对、换个环境就追求另一个目标的情形;第 18.2 节、第 18.5 节讨论探针读出的可能只是与标签相关的其他特征。

捷径只是一个例子,背后是一个更根本的限制。即使没有泄漏、没有过拟合,测试集上的分数也只说明模型在与测试集相似的数据上表现如何。如果发垃圾邮件的人换了手法,新邮件和过去的邮件不再相似,测试分数就不再能代表新邮件上的表现。所以“对新数据有效”永远带着一个前提:新数据和评估用的数据相似,即来自同样的来源,而且来源本身没有变(例如发垃圾邮件的人没有换手法)。本书后面评价每一种监督方法的实验时,都要问这个前提是否成立。如果被评估的模型在评估时和实际使用时表现不同,这个前提就会以更难察觉的方式被打破(第四部分)。

4.6 神经网络 #

第 4.2 节的打分式子只能做一件事:把几个特征加权求和,看结果是否大于 0。很多判断不是这样的。比如“有链接”本身不可疑,“陌生人发来的、带链接的、催你马上操作的邮件”才可疑;几个特征要组合起来才有意义。

神经网络(neural network)的做法是把许多简单的、可调节的计算一层层叠起来。

  • 最小的单元常被叫作“神经元”(neuron)。它做的事和第 4.2 节的式子差不多:把输入加权求和,加上一个数,再经过一个简单的变换,例如“负数变成 0,正数不变”。
  • 许多神经元并排组成一层(layer)。一层的输出,作为下一层的输入。
  • 第一层读入原始的特征,最后一层给出预测,中间可以有许多层。层数多的网络叫深度网络,训练它们的方法统称深度学习(deep learning)。

网络里的全部权重和加上的那些数,就是它的参数。训练方法与第 4.3 节完全相同:定义损失,算出每个参数的斜率,用梯度下降一点点调整。那个“简单的变换”看起来不起眼,却很关键:如果去掉它,许多层的加权求和叠在一起,结果仍然只是一次加权求和,叠多少层都没有用。

一种常见的直觉是:前面的层把原始特征组合成一些中间的特征,比如“陌生发件人且带链接”;后面的层再把这些中间特征组合成更抽象的判断。这个直觉有助于理解为什么多层比一层强,但不要把它当成事实描述。在大型网络里,某个神经元或某一层到底表示什么,通常很难直接读出来,这本身是一个研究方向(第 18 章)。

有一个词后面会用到。给网络一个具体的输入,每一层都会算出一组中间数值,它们叫激活(activation)。参数对所有输入都一样;激活则随输入而变,就像预测随输入而变一样。第 18 章讨论能不能从激活里读出模型输出之外的信息。

语言模型就是一种神经网络,只是结构经过了专门的设计,参数的数量多得多(第 5 章)。本节只要求你记住结构上的直觉:多层、可调节、用梯度下降训练。想看它的图像,可以看本章读物里 3Blue1Brown 的视频。

4.7 用 scikit-learn 训练一个分类器(实验路线)#

本节面向实验路线,需要第 2 章的 Python 和 NumPy 基础。scikit-learn 是一个常用的 Python 机器学习库,里面有现成的模型、划分数据的工具和计算指标的函数。安装方法是在命令行运行 pip install scikit-learn(下面的代码需要 1.0 或更新的版本)。

在 scikit-learn 里,数据要整理成特征矩阵:每一行是一个样本,每一列是一个特征(第 2.5 节讲过矩阵的行和列)。对邮件这样的文本,最简单的特征是词袋(bag of words):每一列对应一个词,矩阵里的数是这个词在这封邮件里出现的次数。词的顺序被丢掉了,就像把一封邮件的词倒进袋子里只数个数。标签则是一个和行数一样长的列表。

下面的程序用 24 封为教学构造的短邮件,走一遍完整的流程。中文没有空格分词,这里预先用空格把词隔开。

代码实现用逻辑回归训练一个垃圾邮件分类器
from sklearn.feature_extraction.text import CountVectorizer
from sklearn.linear_model import LogisticRegression
from sklearn.model_selection import train_test_split
from sklearn.metrics import accuracy_score

# 为教学构造的 24 封邮件,词之间用空格隔开。标签 1 表示垃圾邮件,0 表示正常邮件。
emails = [
    "恭喜 您 中奖 了 请 点击 链接 领取 奖金",
    "限时 优惠 点击 链接 立即 领取 红包",
    "您的 账户 异常 请 点击 链接 验证 密码",
    "免费 领取 手机 名额 有限 马上 回复",
    "中奖 通知 请 提供 银行卡 号码 领取",
    "低价 出售 发票 联系 微信",
    "恭喜 获得 免费 旅游 名额 点击 领取",
    "投资 回报 高 稳赚 不赔 立即 加入",
    "您的 快递 无法 投递 点击 链接 补填 地址",
    "贷款 秒批 无需 审核 马上 申请",
    "特价 商品 最后 一天 点击 抢购",
    "账户 即将 冻结 请 立即 验证 身份",
    "明天 下午 三点 开会 请 带上 报告",
    "这周 的 记账 程序 需求 说明 已 更新",
    "周末 一起 吃饭 吗",
    "附件 是 上个月 的 账单 请 核对",
    "代码 审查 意见 已 写在 文档 里",
    "妈妈 说 晚上 回家 吃饭",
    "图书馆 借的 书 下周 到期",
    "请 确认 一下 转账 金额 是否 正确",
    "课程 作业 截止 时间 改到 周五",
    "测试 用例 已经 补上 请 再 看看",
    "生日 快乐 礼物 已经 寄出",
    "会议 记录 发 你 了 有 问题 再 说",
]
labels = [1] * 12 + [0] * 12

# 第一步:先划分。测试集占四分之一,留到最后才用。
train_text, test_text, y_train, y_test = train_test_split(
    emails, labels, test_size=0.25, random_state=0, stratify=labels)

# 第二步:把文字变成特征矩阵,只保留出现次数最多的 20 个词。
# “哪 20 个词最常见”只按训练集统计,测试集不参与,避免数据泄漏。
vectorizer = CountVectorizer(token_pattern=r"[^ ]+", max_features=20)
X_train = vectorizer.fit_transform(train_text)
X_test = vectorizer.transform(test_text)
print("训练集特征矩阵的形状(邮件数, 词数):", X_train.shape)

# 第三步:训练逻辑回归,即调整参数。
model = LogisticRegression()
model.fit(X_train, y_train)

# 第四步:在测试集上预测,读出准确率。
pred = model.predict(X_test)
print("预测:", pred.tolist())
print("标签:", y_test)
print("测试集准确率:", accuracy_score(y_test, pred))

# 参数:每个词一个权重。权重越大,这个词越把分数推向“垃圾邮件”。
words = vectorizer.get_feature_names_out()
for weight, word in sorted(zip(model.coef_[0], words), reverse=True)[:5]:
    print(f"{word}\t{weight:+.2f}")

在 scikit-learn 1.9.1 上的运行结果:

训练集特征矩阵的形状(邮件数, 词数): (18, 20)
预测: [1, 0, 1, 0, 0, 0]
标签: [1, 0, 1, 1, 0, 0]
测试集准确率: 0.8333333333333334
领取	+0.76
立即	+0.68
马上	+0.58
点击	+0.49
验证	+0.42

逐步看一下这段程序做了什么。

  1. train_test_split 把 24 封邮件随机分成 18 封训练、6 封测试。stratify=labels 让两边的垃圾邮件比例相同;random_state=0 固定随机数,让每次运行的划分都一样,结果才能复现。
  2. CountVectorizer 把文字变成词袋特征矩阵。max_features=20 让它只保留出现次数最多的 20 个词,其余的词不进入特征。注意 fit_transform 只用在训练集上:哪些词最常见,只按训练集统计;测试集只用 transform,按训练集定下的 20 个词计数,其他词直接忽略。这正是第 4.4 节说的“先划分,再只用训练集做统计”。
  3. LogisticRegression 是逻辑回归(logistic regression)。名字里有“回归”,它却是一个分类模型:它做的事和第 4.2 节的打分式子一样,给每个特征一个权重,加权求和,再把分数换算成“是垃圾邮件的概率”。fit 就是用梯度下降一类的方法调整这些权重。
  4. predict 给出预测,accuracy_score 把预测和测试集标签比较,算出准确率。
  5. 最后几行打印出权重最大的几个词。model.coef_ 是参数,pred 是预测,这两样东西在程序里也是分开放的。

6 封测试邮件里,分类器判错了一封:“特价商品最后一天点击抢购”是垃圾邮件,被判成了正常邮件。这封邮件里只有“点击”在那 20 个词之中,其余的词对分类器来说等于不存在。

读 0.83 这个准确率时要记住三点。第一,和一个最笨的基线比:总是猜“垃圾邮件”,在这个测试集上能对一半,准确率 50%。第二,测试集只有 6 封邮件,准确率只能是 0、1/6、2/6 直到 1 中的一个,差一封邮件就差约 17 个百分点(第 3.3 节讲过样本少时误差有多大)。第三,结果在很大程度上取决于哪 6 封邮件碰巧被分进测试集。下面的对照实验把 random_state 从 0 换到 199,得到 200 次划分(其中有两次碰巧相同):同一段程序的准确率最低 0.5、最高 1.0。所以在这么小的数据上,哪怕某次运行得到 1.0,也说明不了什么。这段程序的用处是看清流程,不是得出结论。

同一个对照实验还可以测出第 4.4 节说的数据泄漏有多大影响。把挑词这一步改成用全部 24 封邮件统计,其余完全不变,在这 200 次划分上各算一次准确率:

代码实现对照实验:挑词时用不用测试邮件
# 接在上面的程序后面运行。
def test_accuracy(seed, leak):
    train_text, test_text, y_train, y_test = train_test_split(
        emails, labels, test_size=0.25, random_state=seed, stratify=labels)
    vectorizer = CountVectorizer(token_pattern=r"[^ ]+", max_features=20)
    if leak:
        vectorizer.fit(emails)        # 泄漏的做法:用全部 24 封邮件挑出最常见的词
    else:
        vectorizer.fit(train_text)    # 正确的做法:只用训练集挑词
    model = LogisticRegression()
    model.fit(vectorizer.transform(train_text), y_train)
    pred = model.predict(vectorizer.transform(test_text))
    return accuracy_score(y_test, pred)

clean = [test_accuracy(seed, leak=False) for seed in range(200)]
leaky = [test_accuracy(seed, leak=True) for seed in range(200)]
print("只用训练集挑词:平均准确率", round(sum(clean) / 200, 3),
      "最低", round(min(clean), 3), "最高", round(max(clean), 3))
print("用全部邮件挑词:平均准确率", round(sum(leaky) / 200, 3))
print("泄漏的做法准确率更高、更低的划分各有几种:",
      sum(b > a for a, b in zip(clean, leaky)), sum(b < a for a, b in zip(clean, leaky)))

运行结果:

只用训练集挑词:平均准确率 0.828 最低 0.5 最高 1.0
用全部邮件挑词:平均准确率 0.853
泄漏的做法准确率更高、更低的划分各有几种: 33 4

泄漏的做法让平均准确率从 0.828 升到 0.853。200 次划分里,有 33 次因为泄漏多判对了邮件,只有 4 次少判对了,其余各次的准确率没有变化。一种可能的解释是:测试邮件参与了“哪些词最常见”的统计,测试邮件里常用的词就更容易被选进特征(本书的推断,这个实验没有把原因单独分离出来)。不管原因是什么,真正的新邮件不会参与挑词,所以 0.853 不能算作对新邮件准确率的估计,应当报告的是 0.828 这种做法得到的数。

反过来,如果去掉 max_features=20,保留全部的词,那么用不用测试邮件统计词表,预测完全一样(这一点用同样的对照实验可以验证)。只在测试邮件里出现的词,在每一封训练邮件里的计数都是 0,训练不会给它们非 0 的权重,它们对预测也就没有影响。可见一个预处理步骤会不会泄漏、泄漏多少,要看它具体用测试数据算了什么;最稳妥的做法仍然是一律先划分,再只用训练集做统计。

4.7.1 后面的练习代码要懂到什么程度 #

第 17 章和第 18 章的实验路线练习都用逻辑回归,代码比上面长,但骨架相同。读那些代码时,下面这些部分必须真正理解,因为实验的结论就取决于它们;另一些部分可以暂时当作工具使用。

表 4.2 练习代码中必须理解的部分和可以当作工具的部分
必须理解 可以暂时当作工具
数据 数据分成了哪几份,每一份用来做什么;哪些数据在最后评分之前绝不能碰 读文件、整理格式的代码
特征 特征矩阵的形状:多少行(样本)、多少列(特征);每一行对应哪个样本 词袋怎样切词计数;嵌入(另一个预训练模型把每段文字变成的一串数)和激活是怎样算出来的
训练 每次 fit 用的是哪一份数据、哪一种标签 逻辑回归内部怎样求参数,solver、max_iter、C 等选项的含义
评分 每个准确率是在哪一份数据上算的;最终结果只在测试集上算一次 指标函数的实现、画图代码

具体到两章的练习。下面提到的弱老师、强学生、强参考在第 17.2 节定义,恢复比例在第 17.3 节定义,按模板或实体划分在第 18.2 节讲;现在读不懂这些词没有关系,读到那两章时再回来看这一段。

  • 第 17 章:数据分成老师训练集、学生训练集和最终测试集三份。你必须看清,弱老师只在老师训练集上用真实标签训练;强学生在学生训练集上用的是弱老师的预测,而不是真实标签;强参考模型用的才是学生训练集的真实标签。最终测试集的真实标签只用于最后评分。如果这几处的标签用错了一处,算出的恢复比例就没有意义。至于强学生用的“预训练文本嵌入”是怎样得到的,可以当作现成的特征矩阵。
  • 第 18 章:激活文件就是一个特征矩阵,每一行是一条陈述(一句或真或假的话)在模型某一层的激活,每一列是激活向量中的一个数。你必须看清训练集和留出测试集是按模板或实体划分的,同一个模板不能同时出现在两边;“打乱标签”的对照只打乱训练标签,测试集和它的真实标签不变。激活是怎样从模型里提取出来的,实验路线可以当作工具。

运行时如果看到 ConvergenceWarning,意思是求参数的过程在规定的步数内还没有收敛,通常把 LogisticRegression(max_iter=1000) 的步数调大即可。这类问题属于“工具”一列;“哪一份数据配哪一种标签”属于“必须理解”一列,后者出错时程序不会给任何警告。

读物 #

  • 入门讲解 · 教材:Hendrycks《Introduction to AI Safety, Ethics, and Society》第 2 章 Artificial Intelligence Fundamentals,开放获取(Hendrycks,2024)。非数学化地讲解机器学习和深度学习的基本概念,可以和本章对照着读。
  • 入门讲解 · 视频:3Blue1Brown《Neural networks》系列第 1 到 3 集(Sanderson,2017b)。三集依次用动画讲神经网络的结构、网络怎样用梯度下降学习,以及反向传播(算出梯度的方法)的直观解释,补上第 4.3 节和第 4.6 节的图像直觉。
  • 入门讲解 · 课程(实验及研究):Google《Machine Learning Crash Course》中的线性回归和分类单元(Google,n.d.)。带交互式的可视化和练习,适合在做第 4.7 节之前或之后巩固损失、梯度下降、准确率等概念。
本节引用的文献 3
  1. Hendrycks(2024)Introduction to AI Safety, Ethics, and Society
  2. Sanderson(2017b)Neural networks
  3. Google(n.d.)Machine Learning Crash Course

练习 #

习题 4.1 数据泄漏发生在哪一步

一位同学这样做垃圾邮件分类实验:

  1. 收集 1000 封已标注的邮件,随机打乱顺序。
  2. 用全部 1000 封邮件统计每个词出现的次数,只保留最常见的 5000 个词,把每封邮件变成词袋特征。
  3. 把邮件分成训练集 800 封、测试集 200 封。
  4. 用默认设置在训练集上训练逻辑回归,测试集准确率为 81%。
  5. 又试了 30 种设置(不同的正则化强度、词表大小、是否去掉常用词),每种都在训练集上训练,在测试集上算准确率。
  6. 选出测试集准确率最高的设置,它的准确率是 87%。报告写道:“我们的分类器对新邮件的准确率为 87%。”

请回答:

  1. 主要的数据泄漏发生在哪一步?为什么它会让 87% 偏高?
  2. 还有哪一步也让测试集的信息进入了模型?它的影响通常比第一处大还是小?
  3. 应当怎样重新设计这个实验?
  4. 第 4 步的 81% 是不是对新邮件准确率的合理估计?
提示

对照第 4.4 节的列表。想一想,如果 30 种设置其实一样好,挑出来的那个最高分会怎样。

解答
  1. 主要的泄漏在第 5、6 步:用测试集比较 30 种设置并挑出最好的,测试集就参与了选择,实际上成了验证集。即使这些设置对新邮件一样好,它们在 200 封测试邮件上的分数也会因为运气上下浮动,挑出来的最高分会系统地偏高。用第 4.4 节的方法计算:如果默认设置和另外 30 种设置,一共 31 种,真实准确率都是 80%,在 200 封邮件上挑最好的,平均会显示约 85.6%(tools/exercises/ch04_test_tuning.py,同样把 31 个分数当作互不相关)。所以 87% 里有一部分是挑选带来的,不能代表新邮件上的准确率。
  2. 第 2 步用全部 1000 封邮件挑出最常见的 5000 个词,测试邮件影响了哪些词能成为特征。这也是泄漏。第 4.7 节的对照实验在 24 封邮件上测到,这样挑词让平均准确率从 0.828 升到 0.853。它的影响多半比第 5、6 步小,因为测试邮件只占全部邮件的五分之一,只能部分改变“哪些词最常见”(本书的推断);不过影响到底多大,只有做同样的对照实验才知道。做法同样不对:应当先划分,再只用训练集统计词频、挑选词表。
  3. 先把数据分成三份,例如训练集 600 封、验证集 200 封、测试集 200 封(如果邮件有发件人信息,还应按发件人划分,并去掉重复邮件);词频和词表只用训练集统计;30 种设置都在训练集上训练、在验证集上比较;选定设置后,在测试集上只算一次准确率并报告这个数。
  4. 第 4 步本身是在测试集上的第一次、也是唯一一次评估,如果没有第 2 步的泄漏,81% 是一个合理的估计(仍有抽样误差,200 封邮件的误差范围见第 3.3 节)。但第 5 步之后再报告任何测试集上的数字,都已经不干净了。
习题 4.2 手算梯度下降

损失曲线是 (w−3)2(w - 3)^2,它在任意一点的斜率是 2×(w−3)2 \times (w - 3)。从 w=0w = 0 出发:

  1. 学习率取 0.1,算出前三步之后的 ww 和损失。
  2. 学习率取 1.1,再算前三步。发生了什么?
  3. 学习率固定不变,为什么第 1 小题里每一步走的距离越来越短?
解答

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

  1. 学习率 0.1:第 1 步,斜率 −6-6,w=0−0.1×(−6)=0.6w = 0 - 0.1 \times (-6) = 0.6,损失 5.76;第 2 步,斜率 −4.8-4.8,w=1.08w = 1.08,损失 3.6864;第 3 步,斜率 −3.84-3.84,w=1.464w = 1.464,损失约 2.3593。损失一步步下降。
  2. 学习率 1.1:第 1 步 w=0−1.1×(−6)=6.6w = 0 - 1.1 \times (-6) = 6.6,损失 12.96;第 2 步斜率 7.2,w=6.6−7.92=−1.32w = 6.6 - 7.92 = -1.32,损失约 18.66;第 3 步斜率 −8.64-8.64,w≈8.184w \approx 8.184,损失约 26.87。每一步都跨过了最低点,落到对面更高的地方,损失越来越大,不会收敛。
  3. 每一步走的距离是学习率乘以斜率。越接近最低点,曲线越平,斜率越小,所以步子自动变短。
习题 4.3 参数、预测,还是别的

下面每一项,是模型的参数、模型的预测,还是两者都不是?

  1. 垃圾邮件分类器对一封新邮件给出“垃圾邮件”。
  2. 训练好的分类器里,“中奖”这个词的权重是 2。
  3. 学习率 0.1。
  4. 一个神经网络读入某封邮件后,第 3 层算出的一组中间数值。
  5. AI 交给你的那个 500 行记账程序。
解答
  1. 预测:模型对一个具体输入的回答。
  2. 参数:训练时调整出来的数,训练后对所有邮件都一样。
  3. 都不是。它是超参数,由人选定,训练过程不调整它;应当用验证集比较不同的取值。
  4. 都不是。它是激活:随输入变化,但不是最终的回答(第 4.6 节)。
  5. 预测,或者说模型的输出:生成程序的模型对你的请求给出的回答。你拿到的是它,而不是生成它的模型的参数。

学完能做到 #

  • 解释为什么调参不能用测试集:在测试集上挑选设置,测试集就变成了验证集,挑出的分数会系统地偏高。
  • 区分“参数”和“预测”:前者是模型本身、训练后固定,后者是模型对某个输入的回答;用模型时你拿到的是预测。
  • 对着一条损失曲线,说出梯度下降的每一步往哪边走,以及学习率太大会怎样。
  • 看到“训练集准确率 99%”或“测试集准确率 87%”时,先问验证集上的分数、测试集是否参与过选择、数据之间有没有重复或同源。

参考文献

  1. Google (n.d.). Machine Learning Crash Course. Google for Developers. 非同行评审
  2. Hendrycks, D. (2024). Introduction to AI Safety, Ethics, and Society. CRC Press.
  3. Ouyang, L., Wu, J., Jiang, X., Almeida, D., Wainwright, C. L., Mishkin, P., … Lowe, R. (2022). Training language models to follow instructions with human feedback. Advances in Neural Information Processing Systems. doi:10.52202/068431-2011. 引用于 §4.2 §4.4
  4. Sanderson, G. (2017b). Neural networks. 3Blue1Brown (YouTube). 非同行评审