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

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

第 2 章编程与数学工具:Python、数组和函数的变化

路线实验及研究路线

本章导读

本章问题
  • 后面的实验需要哪些最低限度的编程和数学?
要点
  • 变量、列表、循环、函数和读文件,这五样 Python 就够把一份答题记录变成准确率(§2.1)。
  • NumPy 把一组判断存成数组,比较、计数、求平均对整组一次完成,准确率只要一行(§2.2)。
  • 斜率的正负告诉你往哪边走函数值更低;梯度下降就是沿斜率的反方向一小步一小步地走(§2.3)。
  • 数据矩阵的行是样本、列是特征;用同样的读法能读懂嵌入和激活的形状,研究路线再学矩阵乘法(§2.5)。
本章的视频讲解,4 分 50 秒,没有声音,文字在画面左侧。下载视频(MP4)
文字稿
  1. 0:07两个问题
    本章只教后面要用的最少工具,回答两个问题:100 道题的判断结果存成数组后,怎样用一行代码算出准确率?训练时“沿着斜率往下走”是什么意思?
  2. 0:24列表与循环2.1
    一组答案放进列表,位置编号叫下标,从 0 开始数。循环对每一项做同样的事:zip 把两个列表按位置配成对,相等就把计数加 1。等号表示“存入”:n_correct = n_correct + 1 是取出、加 1、再存回。5 道题答对 3 道。
  3. 0:45数组:逐项比较2.2
    NumPy 数组能对整组值一次运算。model == truth 逐项比较,得到一组真假值。求和时 True 算 1、False 算 0,平均值就是 True 所占的比例。准确率只要一行。
  4. 1:03函数与斜率2.3
    函数是一条规则:给一个 x,算出一个 y。f(x) = (x − 3)² 画出来是一条 U 形曲线。斜率是 y 变了多少除以 x 变了多少:从 x = 1 走到 2,斜率 −3,往右走 y 变小;从 4 走到 5,斜率 +3,往左走 y 变小;最低点 (3, 0) 处斜率为 0。
  5. 1:27损失函数2.3
    损失函数的输入是模型的参数,输出一个数,衡量模型在训练数据上错得有多厉害,训练要降低它。玩具函数能整张表算出来;真实模型参数太多,试不完,但总能在当前位置算斜率。
  6. 1:49沿斜率的反方向走2.3
    规则是:新位置 = 旧位置 − 步长 × 斜率。从 x = 0 出发,步长 0.1。往右走一小步算出那里的斜率约为 −6,第一步往右挪了 0.6。越靠近 3,斜率越平,每步挪得越少,30 步后 x = 2.996。
  7. 2:10下降的是损失2.3
    梯度下降里的“下降”,指朝损失变低的方向走,不是参数变小:步长 0.1 时,x 从 0 增大到接近 3,f(x) 从 9 降到接近 0。它只看脚下,所以找到的是“附近的低处”;曲线有好几个凹处时,从不同起点出发,可能停在不同的凹处。
  8. 2:33导数2.4
    从 x = 1 往右走一小步 h,用 y 的变化除以 h:h = 1 时斜率 −3,h = 0.001 时 −3.999。让 h 无限接近 0,趋近的那个数就是导数:f(x) = (x − 3)² 的导数是 2(x − 3),x = 1 处是 −4。
  9. 2:51步长选得好不好2.4
    步长在机器学习里常叫学习率。从 0 出发走 6 步:0.1 稳步靠近 3,但比较慢;0.5 一步到 3,是这个函数的巧合;1.0 在 0 和 6 之间来回跳;1.1 越跳越远,损失越来越大。
  10. 3:11很多参数:梯度2.4
    参数多时,对每个参数分别问:只挪这一个,损失怎样变?各自的斜率排在一起就是梯度。同一个学习率要同时适合陡和缓两个方向:学习率 0.07 时,30 步后损失从 22.6 降到 0.13。
  11. 3:31行是样本,列是特征2.5
    向量是按顺序排列的一串数。一封邮件用 3 个数描述:链接数、字数(百字)、是否含“免费”。4 封邮件每封一行,就是形状 (4, 3) 的矩阵。读形状时,先问每一行、每一列是什么。
  12. 3:54嵌入与激活的形状2.5
    语言模型也这样读。T 个 token 的嵌入是 (T, d) 的矩阵,每行一个 token。N 条陈述在某一层的激活排成 (N, d),比如 (1000, 512)。划分训练集和测试集,就是把行分成两部分。
  13. 4:14点积与矩阵乘法2.5
    两个等长的向量逐项相乘再加起来,叫点积:(1, 0, 2) 和 (3, 4, 5) 的点积是 13。线性探针打分,核心是权重与激活的点积。矩阵乘以向量,就是矩阵的每一行分别和向量做点积。

带走的几句话:

  1. 计算准确率只要一行:(model == truth).mean()。
  2. 梯度下降沿斜率的反方向走,步长合适时损失逐步降低。
  3. 读数组的形状,先问每一行是什么、每一列是什么。

本书后面的许多练习,要你亲手算出一个数:一个模型在 100 道题上答对了多少,两个模型差了多少,一个分类器在没见过的数据上表现如何。还有一些章节会说“训练让损失一步步下降”,要你读懂这句话在说什么。本章只教做这两件事所需的最少工具:一点 Python,一点 NumPy,函数图像和斜率,以及读懂数据“形状”所需的向量与矩阵。

本章属于实验路线和研究路线。只走概念路线的读者可以跳过它:第 4.3 节会用图形单独讲训练怎样“往更低处走”,不依赖本章。本章围绕两个具体问题展开。第一,100 道题的判断结果存成一个数组之后,怎样用一行代码算出准确率?第二,人们说训练时“沿着斜率往下走”,这是什么意思?读完以后,你应当能不查资料写出计算准确率的代码,并说清梯度下降里的“下降”指什么。

注怎样运行本章的程序

本章的每个程序都是完整的,只用到 Python 自带的功能和 NumPy 库。在电脑上安装 Python 3 后,在终端里运行 pip install numpy 安装 NumPy。把程序保存成一个以 .py 结尾的文件,例如 accuracy.py,再在终端里运行 python3 accuracy.py,就能看到输出。程序下方的“运行结果”是在 Python 3.14 和 NumPy 2.5 上实际运行得到的;换一个版本,数字不会变,显示格式可能略有不同。也可以使用任何在线的 Python 笔记本环境,不必在本机安装。

2.1 Python 最小集 #

程序是一串指令,计算机从上到下逐条执行。下面是一个最短的例子:一个模型在 100 道题里答对了 71 道,算出它的准确率,也就是答对的题数占总题数的比例。

correct = 71              # 答对的题数
total = 100               # 总题数
accuracy = correct / total
print("准确率:", accuracy)

运行结果:

准确率: 0.71

这里出现了 Python 的第一个概念:变量(variable),即一个起了名字的值。correct = 71 的意思是“把 71 存起来,起名叫 correct”。这里的等号表示“存入”,不是数学里的“相等”,所以 x = x + 1 在 Python 里是合法的:取出 x 的值,加 1,再存回 x。# 后面的文字是注释,写给人看,计算机会忽略。print 把结果显示出来。

变量里可以存不同种类的值:整数(71),带小数点的数(0.71,叫浮点数),文字("B",要加引号,叫字符串),以及只有两个取值的真假值 True 和 False(叫布尔值)。

一道题一道题地存变量太麻烦。一组答案可以放进一个列表(list):用方括号括起来、用逗号隔开的一串值。下面的程序把模型对 5 道题的答案和正确答案各存成一个列表,然后数出答对了几道。

model = ["B", "C", "A", "D", "B"]   # 模型对 5 道题的答案
truth = ["B", "C", "B", "D", "A"]   # 5 道题的正确答案
print("第一题:", model[0], truth[0])
print("题数:", len(truth))

n_correct = 0
for m, c in zip(model, truth):      # 两个列表按位置配对,依次取出
    if m == c:                      # 两个等号:比较是否相等
        n_correct = n_correct + 1
print("答对:", n_correct)

运行结果:

第一题: B B
题数: 5
答对: 3

先看前四行。列表里的每个值有一个位置编号,叫下标,从 0 开始数,所以第一道题的答案是 model[0],第二道是 model[1]。len(truth) 给出列表的长度,也就是题数。

后半段是一个循环(loop),它对列表的每一项做同样的事。zip(model, truth) 把两个列表按位置配成对:第一对是两个列表的第 0 项,第二对是第 1 项,依此类推。for m, c in ...: 依次取出每一对,分别叫作 m 和 c,然后执行下面缩进的几行。Python 用缩进(通常是 4 个空格)表示“这几行属于循环”。

循环里的 if m == c: 是条件判断:两个等号表示“比较是否相等”,结果为真时,才执行它下面再缩进一层的那一行,把计数加 1。5 道题里,第 0、1、3 道两边相同,所以答对 3 道。

这几行计算以后会反复用到。把它包装成一个函数(function),换一组数据也能直接调用。def 定义函数,括号里是函数的输入(叫参数),return 给出函数的输出。

def accuracy(model_answers, correct_answers):
    """返回两个列表中,同一位置的值相等的比例。"""
    n_correct = 0
    for m, c in zip(model_answers, correct_answers):
        if m == c:
            n_correct = n_correct + 1
    return n_correct / len(correct_answers)


print(accuracy(["B", "C", "A", "D", "B"], ["B", "C", "B", "D", "A"]))
print(accuracy(["A", "A", "C"], ["A", "B", "C"]))

运行结果:

0.6
0.6666666666666666

同一个函数,用在两组不同的数据上:第一组 5 道对 3 道,准确率 0.6;第二组 3 道对 2 道,准确率约 0.667。函数里三个引号括起来的一行是说明文字,写给读代码的人看。

实验数据通常不会写在程序里,而是存在文件中。常用的一种格式是 CSV(comma-separated values,逗号分隔值):一个纯文本文件,每行是一条记录,同一行的各项用逗号隔开,第一行常常是列名。下面的程序先写出一个小小的 CSV 文件,这样它可以直接运行;实际使用时,这个文件来自你的实验。然后它用 Python 自带的 csv 模块把文件读回来。import csv 表示载入这个模块;with open(...) as f: 打开文件,缩进部分执行完后自动关闭它。

import csv

# 先写出一个示例文件。实际使用时,这个文件来自你的实验。
with open("answers.csv", "w", newline="") as f:
    f.write("model_answer,correct_answer\n")
    f.write("B,B\nC,C\nA,B\nD,D\nB,A\n")

model, truth = [], []
with open("answers.csv", newline="") as f:
    for row in csv.DictReader(f):      # 每次读出一行,按列名取值
        model.append(row["model_answer"])
        truth.append(row["correct_answer"])

print(model)
print(truth)

运行结果:

['B', 'C', 'A', 'D', 'B']
['B', 'C', 'B', 'D', 'A']

append 把一个值加到列表末尾。读出这两个列表后,交给上面的 accuracy 函数,就得到准确率。

变量、列表、循环、函数、读取文件,这五样就是后面练习需要的 Python 最小集。程序出错时,Python 会打印一段错误信息,最后一行通常说明了原因,例如 NameError 表示用了一个还没定义的变量名,IndentationError 表示缩进不对。读错误信息的最后一行,是排错的第一步。

2.2 用 NumPy 处理一组判断结果 #

用循环逐项比较,对 5 道题没有问题,只是写起来啰嗦。NumPy 是 Python 中广泛使用的数值计算库(NumPy Developers,2026),它提供一种叫数组(array)的数据结构:一组同类型的值排在一起,可以对整组值一次完成同一种运算,不必自己写循环。这种“对整组一次运算”的写法叫向量化运算(vectorized operation)。题目很多时,逐项循环比向量化运算慢(NumPy Developers,2026)。

import numpy as np

model = np.array(["B", "C", "A", "D", "B"])
truth = np.array(["B", "C", "B", "D", "A"])

same = model == truth           # 逐项比较,得到一组真假值
print(same)
print(same.sum())               # True 当作 1,False 当作 0,加起来
print(same.mean())              # 平均值,就是 True 所占的比例

scores = np.array([71, 69, 80])
print(scores / 100)             # 每一项都除以 100

a = np.array([True, True, False, True, False])    # 模型甲每道题是否答对
b = np.array([True, False, True, True, False])    # 模型乙每道题是否答对
print((a & b).sum(), (a & ~b).sum(), (~a & b).sum(), (~a & ~b).sum())

运行结果:

[ True  True False  True False]
3
0.6
[0.71 0.69 0.8 ]
2 1 1 1

import numpy as np 载入 NumPy,并约定用简称 np。np.array(...) 把一个列表变成数组。关键在 same = model == truth 这一行:model == truth 不是比较“两个数组是否完全相同”,而是逐项比较,得到一个由 True 和 False 组成的新数组,叫布尔数组。对布尔数组求和时,True 算 1,False 算 0,所以 .sum() 数出了相同的个数;.mean() 是平均值,也就是 True 所占的比例。于是,计算准确率只要一行:accuracy = (model == truth).mean()。

易错点

这一行代码有三种容易犯的错误,每一种都会让你得到错误的准确率或一条报错。

  • 忘了转成数组。对两个普通的 Python 列表,model == truth 比较的是“两个列表是否完全相同”,只得到一个 True 或 False,接着调用 .mean() 会报错 AttributeError。先用 np.array(...) 转成数组。
  • 两个数组长度不同。本章所用的 NumPy 版本一般会报错 ValueError,说两者的形状对不上;如果其中一个数组只有一项,它不报错,而是拿这一项去和另一个数组的每一项比较,算出的准确率是错的。长度不同通常说明数据少读或多读了一行,应当先查清楚,不要随手截断。
  • 文字里藏着空格。CSV 文件里写成 A, C 时,逗号后面的空格会被读进去," C" 和 "C" 被判为不同,答对的题被算成答错,程序却不报错。可以用 np.char.strip(...) 去掉首尾空格,再比较。算出的准确率明显偏低时,先检查这一点。

回到上面那个程序,它的最后三行展示了布尔数组的组合。& 表示“并且”,~ 表示“不是”(还有 | 表示“或者”)。a & ~b 就是“甲答对并且乙没答对”的题。四个数依次是:两个都对、甲对乙错、甲错乙对、两个都错的题数。第 3 章比较两个模型时,正需要这四类计数。

现在回答本章的第一个问题。下面是一个模型在 100 道题上的判断记录,1 表示答对,0 表示答错;前 40 道是数学题,后 60 道是阅读题。

import numpy as np

# 100 道题的判断记录(为教学构造的数据):1 表示答对,0 表示答错
record = ("11110100001001101110111111100101111111111011110111"
          "01100011111111011101010101101111101011101111101011")
results = np.array([int(ch) for ch in record])
print(results.shape)
print(results[:10])
print("准确率:", results.mean())

# 前 40 道是数学题,后 60 道是阅读题
kinds = np.array(["数学"] * 40 + ["阅读"] * 60)
is_math = kinds == "数学"
print("数学题准确率:", results[is_math].mean())
print("阅读题准确率:", round(results[~is_math].mean(), 3))

运行结果:

(100,)
[1 1 1 1 0 1 0 0 0 0]
准确率: 0.71
数学题准确率: 0.7
阅读题准确率: 0.717

[int(ch) for ch in record] 把字符串里的每个字符变成整数,得到一个 100 项的列表。results.shape 是数组的形状:(100,) 表示这是一个有 100 项的一维数组。results[:10] 取出前 10 项(下标 0 到 9)。最后一行的 round(x, 3) 把 x 四舍五入到 3 位小数,这是 Python 自带的函数。准确率 0.71 来自 results.mean():0 和 1 的平均值,正好是 1 所占的比例。

后半段用到另一个常用技巧:用布尔数组挑选元素。is_math 是一个 100 项的布尔数组,数学题的位置是 True。results[is_math] 只取出这些位置上的值,于是 .mean() 给出数学题上的准确率。第 3.1 节会把“只看数学题时的准确率”叫作条件概率。

最后是从 CSV 文件读入。NumPy 的 np.loadtxt 可以把整个文件读成一个数组:

import numpy as np

with open("answers.csv", "w") as f:
    f.write("model_answer,correct_answer\n")
    f.write("B,B\nC,C\nA,B\nD,D\nB,A\n")

data = np.loadtxt("answers.csv", delimiter=",", dtype=str, skiprows=1)
print(data.shape)
model, truth = data[:, 0], data[:, 1]
print("准确率:", (model == truth).mean())

运行结果:

(5, 2)
准确率: 0.6

delimiter="," 说明各项用逗号分隔,dtype=str 说明按文字读入,skiprows=1 跳过第一行列名。读出的 data 形状是 (5, 2):5 行,2 列。data[:, 0] 取出第 0 列的全部行,data[:, 1] 取出第 1 列。这种有行有列的数组叫二维数组,第 2.5 节会专门讲怎样读它的形状。

第 2.2 节引用的文献 1
  1. NumPy Developers(2026)NumPy: the absolute basics for beginners

2.3 函数图像与斜率 #

现在转到本章的第二个问题。先从一个简单的函数开始,它把输入的数先减去 3,再求平方:

f(x)=(x−3)2f(x) = (x - 3)^2

函数是一条规则:给一个输入 xx,按规则算出一个输出 y=f(x)y = f(x)。这条规则是“先减 3,再平方”。把一批 xx 的值和算出的 yy 列成表,再画到坐标纸上连起来,就得到函数的图像。

import numpy as np

x = np.arange(0, 6.5, 0.5)     # 从 0 开始,每次加 0.5,直到 6
y = (x - 3) ** 2               # ** 表示乘方;对整个数组一次算完
for xi, yi in zip(x, y):
    print(f"x = {xi:3.1f}   y = {yi:5.2f}")

i = np.argmin(y)               # y 最小的那一项的下标
print("最小值点:x =", x[i], ",y =", y[i])

运行结果:

x = 0.0   y =  9.00
x = 0.5   y =  6.25
x = 1.0   y =  4.00
x = 1.5   y =  2.25
x = 2.0   y =  1.00
x = 2.5   y =  0.25
x = 3.0   y =  0.00
x = 3.5   y =  0.25
x = 4.0   y =  1.00
x = 4.5   y =  2.25
x = 5.0   y =  4.00
x = 5.5   y =  6.25
x = 6.0   y =  9.00
最小值点:x = 3.0 ,y = 0.0

f"..." 是一种带格式的字符串,花括号里的变量会被替换成它的值,:5.2f 表示保留两位小数。把这 13 个点画到坐标纸上、用平滑的曲线连起来,就得到下图:一条开口向上的 U 形曲线(抛物线),左右对称,最低点在 x=3x = 3,那里 y=0y = 0。这就是从图上读出的最小值:函数在 x=3x = 3 处取到最小值 0。

函数 y = (x − 3)² 的图像横轴是 x,从 0 到 6;纵轴是 y。曲线是开口向上的 U 形,左右对称,最低点在 x 等于 3、y 等于 0。曲线上标出了数值表中的 13 个点。左侧从 x 等于 1 到 2 的线段向右下倾斜,斜率为负 3;右侧从 x 等于 4 到 5 的线段向右上倾斜,斜率为正 3。 x y 0 1 2 3 4 5 6 0 2 4 6 8 10 斜率 −3 往右走,y 变小 斜率 +3 往左走,y 变小 最低点 (3, 0)
函数 y = (x − 3)² 的图像。灰色圆点是上面数值表中的 13 个点,连起来是一条开口向上的 U 形曲线,最低点在 (3, 0)。两段蓝色线段各连接曲线上的两点,它们的倾斜程度就是两点之间的斜率:左边从 (1, 4) 到 (2, 1),斜率为 −3;右边从 (4, 1) 到 (5, 4),斜率为 +3。

接下来看斜率(slope)。在图上任取两个点,斜率是“yy 变了多少”除以“xx 变了多少”,也就是高中学过的直线斜率。从 x=1x = 1 走到 x=2x = 2,yy 从 4 变成 1,斜率是 (1−4)÷(2−1)=−3(1 - 4) \div (2 - 1) = -3;从 x=4x = 4 走到 x=5x = 5,yy 从 1 变成 4,斜率是 +3+3。斜率的正负有一个直接的意思:

  • 斜率为负:往右走,yy 变小。曲线在这里是往右下方倾斜的。
  • 斜率为正:往右走,yy 变大;反过来,往左走 yy 变小。
  • 斜率为 0:曲线在这里是平的,例如最低点。

两点之间的斜率取决于你取哪两个点。想知道曲线在某一点有多陡,就让第二个点离它非常近:往右走很小的一步 hh,看 yy 变了多少,再除以 hh。

def f(x):
    return (x - 3) ** 2

def slope(x, h=0.001):
    """x 处的斜率(近似):往右走一小步 h,y 的变化除以 h。"""
    return (f(x + h) - f(x)) / h

for x in [1, 2, 4, 5]:
    print(x, round(slope(x), 3))

运行结果:

1 -3.999
2 -1.999
4 2.001
5 4.001

最低点左边的斜率是负的,右边是正的;离最低点越远,斜率的绝对值越大,曲线越陡。

为什么要关心这些?训练一个机器学习模型时,人们会定义一个损失函数(loss function):输入是模型的参数(模型里可以调节的数),输出是一个数,衡量模型在训练数据上错得有多厉害。损失越小,说明错得越少,训练就是要把它降下来(训练数据上的损失低,不等于在新数据上也好,见第 4.5 节)。第 4 章会讲损失函数从哪里来;这里先把 f(x)=(x−3)2f(x) = (x - 3)^2 当成一个只有一个参数 xx 的玩具损失函数。

对这个玩具函数,我们能把整张表算出来,一眼看到最低点在哪里。真实的模型有大量参数,不可能把所有取值都试一遍。但有一件事总能做到:在当前位置算出斜率。斜率为正,就往左挪一点;斜率为负,就往右挪一点。写成一条规则,就是“新位置 = 旧位置 − 步长 × 斜率”。步长是一个事先选定的小正数,决定每次挪多远。

def f(x):
    return (x - 3) ** 2

def slope(x, h=0.001):
    return (f(x + h) - f(x)) / h

x = 0.0          # 起点
step = 0.1       # 步长:每次挪多远
for i in range(1, 31):
    x = x - step * slope(x)        # 沿斜率的反方向挪一步
    if i in (1, 2, 3, 10, 20, 30):
        print(f"第 {i:2d} 步:x = {x:.3f},f(x) = {f(x):.4f}")

运行结果:

第  1 步:x = 0.600,f(x) = 5.7605
第  2 步:x = 1.080,f(x) = 3.6871
第  3 步:x = 1.464,f(x) = 2.3600
第 10 步:x = 2.677,f(x) = 0.1041
第 20 步:x = 2.965,f(x) = 0.0012
第 30 步:x = 2.996,f(x) = 0.0000

range(1, 31) 依次给出 1 到 30。从 x=0x = 0 出发,那里斜率约为 −6-6,是负的,所以第一步往右挪了 0.1×6=0.60.1 \times 6 = 0.6。越靠近 3,斜率越平,每步挪得越少。30 步之后,xx 已经非常接近 3,f(x)f(x) 接近 0。这个过程就是梯度下降(gradient descent)最简单的形式。

要点

梯度下降里的“下降”,指的是朝着让损失函数的值变低的方向走,不是参数在变小。每一步看当前位置的斜率:斜率为负就增大参数,斜率为正就减小参数,每次只走一小步。步长合适时,损失一步步降低。

步长不能随便取。步长太大时,一步会跨过最低点,落到对面更高的地方,甚至越走越远;第 2.4 节用程序演示了这种情况。

这个办法只看脚下,所以它找到的是“附近的低处”。如果一条曲线有好几个凹处,从不同起点出发,可能停在不同的凹处。

2.4 导数(选读)#

上一节用一个很小的步长 h=0.001h = 0.001 来近似某一点的斜率。让 hh 越来越小、无限接近 0 时,这个近似值趋近的那个数,就是函数在这一点的导数(derivative),记作 f′(x)f'(x)。用式子写出来,它说的是“往右走一小步 hh,yy 的变化除以 hh,再让 hh 趋近 0”:

f′(x)=lim⁡h→0f(x+h)−f(x)hf'(x) = \lim_{h \to 0} \frac{f(x + h) - f(x)}{h}

对 f(x)=(x−3)2f(x) = (x - 3)^2 可以直接算出来。先把分子展开:

(x+h−3)2−(x−3)2=2(x−3)h+h2(x + h - 3)^2 - (x - 3)^2 = 2(x - 3)h + h^2

除以 hh 得到 2(x−3)+h2(x - 3) + h。让 hh 趋近 0,多出来的那个 hh 消失,所以

f′(x)=2(x−3)f'(x) = 2(x - 3)

代入 x=1x = 1 得 −4-4,代入 x=5x = 5 得 44。上一节程序算出的是 −3.999-3.999 和 4.0014.001,正好多了一个 h=0.001h = 0.001,和推导一致。

有了导数,梯度下降的规则可以写成:

x新=x旧−η f′(x旧)x_{\text{新}} = x_{\text{旧}} - \eta \, f'(x_{\text{旧}})

η\eta 是希腊字母,读作“艾塔”,就是步长,在机器学习里常叫学习率(learning rate)。步长选得好不好,结果差别很大:

def grad(x):
    return 2 * (x - 3)      # f(x) = (x - 3)**2 的导数

for step in [0.1, 0.5, 1.0, 1.1]:
    x = 0.0
    path = []
    for i in range(6):
        x = x - step * grad(x)
        path.append(round(x, 2))
    print("步长", step, ":", path)

运行结果:

步长 0.1 : [0.6, 1.08, 1.46, 1.77, 2.02, 2.21]
步长 0.5 : [3.0, 3.0, 3.0, 3.0, 3.0, 3.0]
步长 1.0 : [6.0, 0.0, 6.0, 0.0, 6.0, 0.0]
步长 1.1 : [6.6, -1.32, 8.18, -3.22, 10.46, -5.96]

步长 0.1 稳步靠近 3,但比较慢。步长 0.5 一步就到了 3,这是这个函数的巧合,不能指望别的函数也这样。步长 1.0 每次都跨过最低点,在 0 和 6 之间来回跳,永远到不了。步长 1.1 跨得更远,越跳离最低点越远,损失越来越大。实际训练中选学习率,也要在“太慢”和“跨过头”之间找平衡(Google,n.d.)。

真实模型的损失函数有许多参数,比如 w1,w2,…w_1, w_2, \ldots。这时对每个参数分别问同一个问题:其他参数不动,只把这一个参数往右挪一点,损失怎样变?这样得到每个参数各自的斜率,叫偏导数;把它们排在一起,就是梯度(gradient)。梯度下降让每个参数都朝着自己斜率的反方向走一小步。“梯度下降”这个名字就是这么来的。在实际训练中,梯度由程序库自动算出,你不需要手算;需要理解的只是它在做什么。图 2.1 画出了两个参数时的情形:同一个学习率要同时适合坡陡和坡缓两个方向,太大会在陡的方向上跨过头,太小又会在缓的方向上走得很慢。

−101w₂(陡峭方向)−5−4−3−2−101参数 w₁(平缓方向)起点最低点10⁻⁶10⁻⁴10⁻²110²10⁴损失020406080100步数η = 0.070:30 步后损失为 0.13(起点为 22.6)。η 超过 2/25 = 0.08 就会发散。
−101w₂(陡峭方向)−4−20参数 w₁(平缓方向)起点最低点10⁻⁶10⁻⁴10⁻²110²10⁴损失020406080100步数η = 0.070:30 步后损失为 0.13(起点为 22.6)。η 超过2/25 = 0.08 就会发散。
图 2.1 两个参数的梯度下降。损失函数是 L(w1,w2)=12(w12+25w22)L(w_1, w_2) = \tfrac{1}{2}(w_1^2 + 25 w_2^2)。上图的灰色椭圆是损失相等的点连成的线,像地图上的等高线;两个轴按相同比例画出,所以这个山谷又长又窄:沿 w2w_2 方向坡陡,沿 w1w_1 方向坡缓。蓝色折线是从点 (−4.5, 1) 出发、每一步都朝梯度的反方向走的路径;下图是每一步之后的损失,纵轴是对数刻度,每一格差 100 倍,淡色部分是之后的步数,超出纵轴范围的损失贴着上边缘画出。拖动学习率 η\eta:默认的 0.07 下,路径在陡的方向上来回摆动,在缓的方向上慢慢前进,30 步后损失从 22.6 降到 0.13;η\eta 超过 0.08,陡的方向上的摆动越来越大,最后发散;η\eta 很小时,陡的方向还能较快收敛,缓的方向几乎不动。损失函数是为说明而设定的示意,不是哪个真实模型的损失,图中的数都由它精确算出。
第 2.4 节引用的文献 1
  1. Google(n.d.)Machine Learning Crash Course

2.5 向量与矩阵 #

后面的实验章节会反复出现这样的说法:特征矩阵的形状是 1000 × 20,每个 token 的嵌入是一个向量,激活的形状是 (500, 4096)。本节教你读懂这些话(这里的数字都是示意)。实验路线读到“研究路线:矩阵乘法”之前即可;研究路线读完整节。

向量(vector)就是按顺序排列的一串数,在 NumPy 里是一维数组。一封邮件可以用 3 个数描述:里面有几个链接,有多少字(以百字为单位),是否出现“免费”这个词(是记 1,否记 0)。这 3 个数排在一起,就是一个长度为 3 的向量。向量里数的个数叫它的维度(dimension)。

很多封邮件放在一起,每封占一行,就得到一个矩阵(matrix),也就是二维数组。按惯例,每一行是一个样本,每一列是一个特征。这样的矩阵叫数据矩阵或特征矩阵,它的形状写作(行数, 列数),即(样本数, 特征数)。

import numpy as np

# 4 封邮件 × 3 个特征(为教学构造的数据)
# 列依次是:链接数、字数(百字)、是否含“免费”
X = np.array([[5, 1.2, 1],
              [0, 3.5, 0],
              [2, 0.8, 1],
              [0, 2.1, 0]])
print(X.shape)            # (行数, 列数)
print(X[0])               # 第 0 行:第一封邮件的 3 个特征
print(X[:, 0])            # 第 0 列:每封邮件的链接数
print(X.mean(axis=0))     # 每一列的平均值

运行结果:

(4, 3)
[5.  1.2 1. ]
[5. 0. 2. 0.]
[1.75 1.9  0.5 ]

X[0] 取一行,得到一封邮件的全部特征;X[:, 0] 取一列,冒号表示“所有行”,得到全部邮件的同一个特征。X.mean(axis=0) 沿着行的方向求平均,也就是对每一列求平均,得到 3 个数:平均每封邮件 1.75 个链接、190 字,一半的邮件含“免费”。读形状时,先问“每一行是什么,每一列是什么”,大部分困惑就解决了。第 4.7 节用 scikit-learn 训练分类器时,输入正是这样的矩阵。

同样的读法适用于语言模型。第 5 章会讲到,语言模型先把文本切成一个个 token(可以粗略理解为词或词的一部分)。模型内部会把每个 token 变成一个由 dd 个数组成的向量,这个向量叫嵌入(embedding)。一段有 TT 个 token 的文本,嵌入就是一个形状为 (T,d)(T, d) 的矩阵:每行一个 token,每列是向量的一个维度。模型在计算过程中,每一层都会对每个位置产生一组新的数,叫激活(activation)。第 18 章的练习会给你一个激活文件:对 NN 条陈述,在模型的某一层各取出一个长度为 dd 的向量,排成一个形状为 (N,d)(N, d) 的矩阵。比如形状 (1000, 512) 表示 1000 条陈述,每条 512 个数(数字是示意)。配套的标签是一个形状为 (1000,) 的一维数组,每条陈述一个“真”或“假”。划分训练集和测试集,就是把这些行分成两部分。偶尔你还会看到三个数的形状,如 (N,T,d)(N, T, d),它表示 NN 段文本、每段 TT 个位置、每个位置 dd 个数,可以理解为 NN 个 (T,d)(T, d) 矩阵叠在一起。

实验路线还需要认识一种运算:点积(dot product)。两个长度相同的向量,逐项相乘再加起来,得到一个数。例如 (1,0,2)(1, 0, 2) 和 (3,4,5)(3, 4, 5) 的点积是 1×3+0×4+2×5=131 \times 3 + 0 \times 4 + 2 \times 5 = 13。也可以把它理解为加权求和:一个向量是权重,另一个是数据,点积就是按权重把数据加起来。第 18 章的线性探针给每条陈述打分,核心就是这样一次点积:用一个长度为 dd 的权重向量 ww,与这条陈述的激活向量做点积。NumPy 用 @ 表示点积;对 NN 条陈述一起算,写成 acts @ w,得到形状为 (N,)(N,) 的结果,每条陈述一个分数。

import numpy as np

w = np.array([1, 0, 2])               # 权重
v = np.array([3, 4, 5])               # 一条数据
print(w @ v)                          # 点积:1*3 + 0*4 + 2*5

acts = np.array([[3, 4, 5],
                 [1, 0, 0],
                 [0, 2, 1]])          # 3 条陈述 × 3 个数(示意)
print(acts @ w)                       # 每条陈述一个分数
print((acts @ w).shape)

运行结果:

13
[13  1  2]
(3,)

2.5.1 研究路线:矩阵乘法 #

研究路线需要再多走一步:把模型的一层看作“矩阵乘以向量”。

先说矩阵乘以向量算的是什么。矩阵 WW 有 mm 行、dd 列,向量 xx 有 dd 个数。结果是一个有 mm 个数的向量 yy:它的第 ii 个数,是把 WW 的第 ii 行与 xx 逐项相乘再加起来。写成式子:

yi=Wi1x1+Wi2x2+⋯+Widxdy_i = W_{i1} x_1 + W_{i2} x_2 + \cdots + W_{id} x_d

举一个能手算的例子:

(10201−1)(345)=(1×3+0×4+2×50×3+1×4+(−1)×5)=(13−1)\begin{pmatrix} 1 & 0 & 2 \\ 0 & 1 & -1 \end{pmatrix} \begin{pmatrix} 3 \\ 4 \\ 5 \end{pmatrix} = \begin{pmatrix} 1 \times 3 + 0 \times 4 + 2 \times 5 \\ 0 \times 3 + 1 \times 4 + (-1) \times 5 \end{pmatrix} = \begin{pmatrix} 13 \\ -1 \end{pmatrix}

“逐项相乘再加起来”正是上面讲的点积。所以矩阵乘以向量,就是拿矩阵的每一行分别和向量做点积。在 NumPy 里用 @ 表示:

import numpy as np

W = np.array([[1, 0, 2],
              [0, 1, -1]])        # 形状 (2, 3)
x = np.array([3, 4, 5])           # 形状 (3,)
print(W @ x)                      # 形状 (2,)

X = np.array([[3, 4, 5],
              [1, 0, 0]])         # 2 个样本 × 3 个特征
print(X @ W.T)                    # 每一行是一个样本乘以 W 之后的结果
print((X @ W.T).shape)

运行结果:

[13 -1]
[[13 -1]
 [ 1  0]]
(2, 2)

形状要对得上:(m,d)(m, d) 的矩阵只能乘以长度为 dd 的向量,结果长度为 mm。一次处理很多样本时,把样本按行排成 (N,d)(N, d) 的矩阵 X,写成 X @ W.T,其中 W.T 是把 W 的行和列对调(叫转置,形状变成 (d,m)(d, m)),结果的形状是 (N,m)(N, m),每一行对应一个样本。形状不匹配时,NumPy 会直接报错,这是检查代码的好帮手。

最基本的一种神经网络层,核心就是这样一次乘法:输入是一个长度为 dd 的向量,乘以一个 (m,d)(m, d) 的权重矩阵,加上一个长度为 mm 的向量(偏置),再对每个数套用一个简单的非线性函数,得到长度为 mm 的输出,交给下一层。第 4.6 节会讲这种层层叠加的结构;语言模型的层里还有注意力(第 5 章)。相比之下,第 18 章的线性探针只相当于输出长度 m=1m = 1 的一层:一个权重向量、一次点积,再加一个偏置。

读物 #

  • 入门讲解 · 课程:哈佛 CS50P《CS50's Introduction to Programming with Python》第 0 到第 6 讲(Malan,2022)。从变量和函数讲到文件读写(第 6 讲 File I/O),覆盖第 2.1 节的大部分内容,并且讲得更慢、练习更多。
  • 入门讲解 · 文档:NumPy 官方《NumPy: the absolute basics for beginners》(NumPy Developers,2026)。数组的创建、形状、索引和常用运算,对应第 2.2 节和第 2.5 节。
  • 入门讲解 · 视频:3Blue1Brown《Essence of calculus》第 1 到 2 集,只看图形直觉(Sanderson,2017a)。用动画说明斜率和导数,对应第 2.3 节和第 2.4 节。
  • 入门讲解 · 视频(研究路线):3Blue1Brown《Essence of linear algebra》第 1 到 4 集(Sanderson,2016)。把向量看作箭头、把矩阵看作对空间的变换,为“研究路线:矩阵乘法”建立几何直觉。
本节引用的文献 4
  1. Malan(2022)CS50's Introduction to Programming with Python
  2. NumPy Developers(2026)NumPy: the absolute basics for beginners
  3. Sanderson(2017a)Essence of calculus
  4. Sanderson(2016)Essence of linear algebra

练习 #

习题 2.1 从 CSV 文件算准确率

下面是为教学构造的数据:一个模型在 20 道选择题上的答案和正确答案。把它保存成文件 answers.csv(可以用任何文本编辑器,也可以像第 2.1 节那样用程序写出)。

model_answer,correct_answer
A,A
C,C
B,B
D,D
C,A
B,B
C,C
D,D
A,D
A,A
C,C
B,B
B,A
D,D
B,B
C,C
A,A
D,B
D,D
A,C

用 NumPy 读入这个文件,算出:

  1. 模型的准确率;
  2. 模型答错的题数;
  3. (选做)答错的是第几道题(从 1 开始数)。
提示

读文件照第 2.2 节最后一个程序。答错的题数可以用 (model != truth).sum(),!= 表示“不相等”。第 3 问可以用 np.flatnonzero(...),它返回布尔数组中 True 所在的下标;下标从 0 开始,要加 1。

解答
import numpy as np

data = np.loadtxt("answers.csv", delimiter=",", dtype=str, skiprows=1)
model, truth = data[:, 0], data[:, 1]
print("准确率:", (model == truth).mean())
print("答错题数:", (model != truth).sum())
print("答错的题:", np.flatnonzero(model != truth) + 1)

运行结果:

准确率: 0.75
答错题数: 5
答错的题: [ 5  9 13 18 20]

20 道题答对 15 道,准确率 75%。核对用的脚本是 tools/exercises/ch02_answers.py。

习题 2.2 画出 y = (x − 3)² 并读出斜率
  1. 列出 x=0,0.5,1,…,6x = 0, 0.5, 1, \ldots, 6 时 y=(x−3)2y = (x - 3)^2 的值,在坐标纸上画出图像(也可以用程序画,见提示)。
  2. 在图上标出最小值点。
  3. 在最小值点左右两侧各选一点,算出那里的斜率(用两点之间的斜率,或第 2.3 节的 slope 函数),标出斜率的正负,并说明:站在这两点上,各应往哪边走,yy 才会变小?
  4. 从 x=5x = 5 出发,步长取 0.1,用第 2.3 节的规则走 3 步。xx 往哪边移动?每一步 f(x)f(x) 怎样变化?
提示

不用绘图库也可以“画”图:对每个 xx 打印一行,行里星号的个数与 yy 成正比。这样画出的图是横过来的,xx 从上往下增大,yy 从左往右增大。

解答
  1. 数值表见第 2.3 节第一个程序的运行结果。下面的程序把它横过来画出,每个星号代表 yy 的 0.25:
for k in range(13):
    x = k / 2
    y = (x - 3) ** 2
    print(f"{x:3.1f} | " + "*" * round(y * 4))

运行结果:

0.0 | ************************************
0.5 | *************************
1.0 | ****************
1.5 | *********
2.0 | ****
2.5 | *
3.0 | 
3.5 | *
4.0 | ****
4.5 | *********
5.0 | ****************
5.5 | *************************
6.0 | ************************************
  1. 最小值点是 (3,0)(3, 0)。
  2. 例如取 x=1x = 1 和 x=5x = 5。x=1x = 1 处斜率约为 −4-4(从 1 到 2 的两点斜率是 −3-3),为负,往右走 yy 变小,所以应往右走。x=5x = 5 处斜率约为 +4+4(从 5 到 6 的两点斜率是 +5+5),为正,往右走 yy 变大,所以应往左走。两种情况都是“朝斜率的反方向走”,都指向最小值点 x=3x = 3。
  3. 用第 2.3 节的 slope 函数(h=0.001h = 0.001),三步分别是:斜率 4.0010,xx 变为 4.5999,f(x)=2.5597f(x) = 2.5597;斜率 3.2008,xx 变为 4.2798,f(x)=1.6379f(x) = 1.6379;斜率 2.5606,xx 变为 4.0238,f(x)=1.0481f(x) = 1.0481。斜率为正,xx 往左移动,朝 3 靠近;f(x)f(x) 从 4 依次降低,每一步降得比上一步少,因为越靠近最低点,曲线越平。

核对用的脚本是 tools/exercises/ch02_answers.py。

习题 2.3 读懂数组的形状

你拿到一个激活文件,读入后得到数组 acts,形状为 (1000, 512);还有一个标签数组 labels,形状为 (1000,)。

  1. acts 的一行代表什么?一列代表什么?一共有多少条陈述,每条有多少个数?
  2. acts[:800] 和 acts[800:] 的形状各是什么?这样切分相当于做了什么?
  3. acts.mean(axis=0) 的形状是什么?它的每个数是什么的平均值?
  4. 权重向量 w 的形状为 (512,),acts @ w 的形状是什么?它的每个数是什么?
  5. (研究路线)另有一个形状为 (64, 512) 的矩阵 W,acts @ W.T 的形状是什么?直接写 acts @ W 会怎样?
提示

先回答“每一行是什么”。可以用 np.zeros((1000, 512)) 造一个同样形状的数组,在 NumPy 里直接试。

解答
  1. 一行是一条陈述在这一层的激活向量;一列是激活向量的同一个维度在所有陈述上的取值。共 1000 条陈述,每条 512 个数。
  2. acts[:800] 是前 800 行,形状 (800, 512);acts[800:] 是后 200 行,形状 (200, 512)。这相当于把陈述分成 800 条和 200 条两部分,例如分别作为训练集和测试集。对应的标签也要用同样的方式切分:labels[:800] 和 labels[800:]。
  3. 形状 (512,)。axis=0 表示沿行的方向求平均,所以每个数是某一个维度在 1000 条陈述上的平均值。
  4. acts @ w 的形状是 (1000,)。每个数是一条陈述的激活向量与 w 的点积,即这条陈述的分数。
  5. acts @ W.T 的形状是 (1000, 64)。acts @ W 会报错:acts 有 512 列,而 W 有 64 行,两者对不上。

可以这样检查:

import numpy as np

acts = np.zeros((1000, 512))
w = np.zeros(512)
W = np.zeros((64, 512))
print(acts[:800].shape, acts[800:].shape, acts.mean(axis=0).shape)
print((acts @ w).shape, (acts @ W.T).shape)
try:
    acts @ W
except ValueError:
    print("acts @ W:形状不匹配,报错")

运行结果:

(800, 512) (200, 512) (512,)
(1000,) (1000, 64)
acts @ W:形状不匹配,报错

学完能做到 #

  • 不查资料,用 Python 读入一个包含“模型答案、正确答案”两列的 CSV 文件,写出计算准确率的代码;会用 NumPy 一行算出准确率,并用布尔数组挑出一部分题目单独计算。
  • 从函数图像上读出最小值点,说出某一点斜率的正负意味着往哪边走函数值更低。
  • 解释梯度下降里的“下降”指什么:损失函数的值在下降;每一步沿斜率的反方向调整参数,步长决定走多远,步长过大会跨过最低点。
  • 读懂数据矩阵、嵌入和激活的形状,说出每一行、每一列代表什么,会算两个向量的点积。研究路线还要能手算一个矩阵乘以向量,并判断两个数组的形状能否相乘。

参考文献

  1. Google (n.d.). Machine Learning Crash Course. Google for Developers. 非同行评审引用于 §2.4
  2. Malan, D. J. (2022). CS50's Introduction to Programming with Python. Harvard University. 非同行评审
  3. NumPy Developers (2026). NumPy: the absolute basics for beginners. NumPy documentation. 非同行评审引用于 §2.2
  4. Sanderson, G. (2016). Essence of linear algebra. 3Blue1Brown (YouTube). 非同行评审
  5. Sanderson, G. (2017a). Essence of calculus. 3Blue1Brown (YouTube). 非同行评审