草稿 内容完整但尚未审校,可能还会修改
第 2 章编程与数学工具:Python、数组和函数的变化
路线实验及研究路线
本章导读
文字稿
- 0:07两个问题
本章只教后面要用的最少工具,回答两个问题:100 道题的判断结果存成数组后,怎样用一行代码算出准确率?训练时“沿着斜率往下走”是什么意思? - 0:24列表与循环2.1
一组答案放进列表,位置编号叫下标,从 0 开始数。循环对每一项做同样的事:zip 把两个列表按位置配成对,相等就把计数加 1。等号表示“存入”:n_correct = n_correct + 1 是取出、加 1、再存回。5 道题答对 3 道。 - 0:45数组:逐项比较2.2
NumPy 数组能对整组值一次运算。model == truth 逐项比较,得到一组真假值。求和时 True 算 1、False 算 0,平均值就是 True 所占的比例。准确率只要一行。 - 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。 - 1:27损失函数2.3
损失函数的输入是模型的参数,输出一个数,衡量模型在训练数据上错得有多厉害,训练要降低它。玩具函数能整张表算出来;真实模型参数太多,试不完,但总能在当前位置算斜率。 - 1:49沿斜率的反方向走2.3
规则是:新位置 = 旧位置 − 步长 × 斜率。从 x = 0 出发,步长 0.1。往右走一小步算出那里的斜率约为 −6,第一步往右挪了 0.6。越靠近 3,斜率越平,每步挪得越少,30 步后 x = 2.996。 - 2:10下降的是损失2.3
梯度下降里的“下降”,指朝损失变低的方向走,不是参数变小:步长 0.1 时,x 从 0 增大到接近 3,f(x) 从 9 降到接近 0。它只看脚下,所以找到的是“附近的低处”;曲线有好几个凹处时,从不同起点出发,可能停在不同的凹处。 - 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。 - 2:51步长选得好不好2.4
步长在机器学习里常叫学习率。从 0 出发走 6 步:0.1 稳步靠近 3,但比较慢;0.5 一步到 3,是这个函数的巧合;1.0 在 0 和 6 之间来回跳;1.1 越跳越远,损失越来越大。 - 3:11很多参数:梯度2.4
参数多时,对每个参数分别问:只挪这一个,损失怎样变?各自的斜率排在一起就是梯度。同一个学习率要同时适合陡和缓两个方向:学习率 0.07 时,30 步后损失从 22.6 降到 0.13。 - 3:31行是样本,列是特征2.5
向量是按顺序排列的一串数。一封邮件用 3 个数描述:链接数、字数(百字)、是否含“免费”。4 封邮件每封一行,就是形状 (4, 3) 的矩阵。读形状时,先问每一行、每一列是什么。 - 3:54嵌入与激活的形状2.5
语言模型也这样读。T 个 token 的嵌入是 (T, d) 的矩阵,每行一个 token。N 条陈述在某一层的激活排成 (N, d),比如 (1000, 512)。划分训练集和测试集,就是把行分成两部分。 - 4:14点积与矩阵乘法2.5
两个等长的向量逐项相乘再加起来,叫点积:(1, 0, 2) 和 (3, 4, 5) 的点积是 13。线性探针打分,核心是权重与激活的点积。矩阵乘以向量,就是矩阵的每一行分别和向量做点积。
带走的几句话:
- 计算准确率只要一行:(model == truth).mean()。
- 梯度下降沿斜率的反方向走,步长合适时损失逐步降低。
- 读数组的形状,先问每一行是什么、每一列是什么。
本书后面的许多练习,要你亲手算出一个数:一个模型在 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
- NumPy Developers(2026)NumPy: the absolute basics for beginners
2.3 函数图像与斜率 #
现在转到本章的第二个问题。先从一个简单的函数开始,它把输入的数先减去 3,再求平方:
函数是一条规则:给一个输入 ,按规则算出一个输出 。这条规则是“先减 3,再平方”。把一批 的值和算出的 列成表,再画到坐标纸上连起来,就得到函数的图像。
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 形曲线(抛物线),左右对称,最低点在 ,那里 。这就是从图上读出的最小值:函数在 处取到最小值 0。
接下来看斜率(slope)。在图上任取两个点,斜率是“ 变了多少”除以“ 变了多少”,也就是高中学过的直线斜率。从 走到 , 从 4 变成 1,斜率是 ;从 走到 , 从 1 变成 4,斜率是 。斜率的正负有一个直接的意思:
- 斜率为负:往右走, 变小。曲线在这里是往右下方倾斜的。
- 斜率为正:往右走, 变大;反过来,往左走 变小。
- 斜率为 0:曲线在这里是平的,例如最低点。
两点之间的斜率取决于你取哪两个点。想知道曲线在某一点有多陡,就让第二个点离它非常近:往右走很小的一步 ,看 变了多少,再除以 。
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 章会讲损失函数从哪里来;这里先把 当成一个只有一个参数 的玩具损失函数。
对这个玩具函数,我们能把整张表算出来,一眼看到最低点在哪里。真实的模型有大量参数,不可能把所有取值都试一遍。但有一件事总能做到:在当前位置算出斜率。斜率为正,就往左挪一点;斜率为负,就往右挪一点。写成一条规则,就是“新位置 = 旧位置 − 步长 × 斜率”。步长是一个事先选定的小正数,决定每次挪多远。
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。从 出发,那里斜率约为 ,是负的,所以第一步往右挪了 。越靠近 3,斜率越平,每步挪得越少。30 步之后, 已经非常接近 3, 接近 0。这个过程就是梯度下降(gradient descent)最简单的形式。
梯度下降里的“下降”,指的是朝着让损失函数的值变低的方向走,不是参数在变小。每一步看当前位置的斜率:斜率为负就增大参数,斜率为正就减小参数,每次只走一小步。步长合适时,损失一步步降低。
步长不能随便取。步长太大时,一步会跨过最低点,落到对面更高的地方,甚至越走越远;第 2.4 节用程序演示了这种情况。
这个办法只看脚下,所以它找到的是“附近的低处”。如果一条曲线有好几个凹处,从不同起点出发,可能停在不同的凹处。
2.4 导数(选读)#
上一节用一个很小的步长 来近似某一点的斜率。让 越来越小、无限接近 0 时,这个近似值趋近的那个数,就是函数在这一点的导数(derivative),记作 。用式子写出来,它说的是“往右走一小步 , 的变化除以 ,再让 趋近 0”:
对 可以直接算出来。先把分子展开:
除以 得到 。让 趋近 0,多出来的那个 消失,所以
代入 得 ,代入 得 。上一节程序算出的是 和 ,正好多了一个 ,和推导一致。
有了导数,梯度下降的规则可以写成:
是希腊字母,读作“艾塔”,就是步长,在机器学习里常叫学习率(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.)。
真实模型的损失函数有许多参数,比如 。这时对每个参数分别问同一个问题:其他参数不动,只把这一个参数往右挪一点,损失怎样变?这样得到每个参数各自的斜率,叫偏导数;把它们排在一起,就是梯度(gradient)。梯度下降让每个参数都朝着自己斜率的反方向走一小步。“梯度下降”这个名字就是这么来的。在实际训练中,梯度由程序库自动算出,你不需要手算;需要理解的只是它在做什么。图 2.1 画出了两个参数时的情形:同一个学习率要同时适合坡陡和坡缓两个方向,太大会在陡的方向上跨过头,太小又会在缓的方向上走得很慢。
第 2.4 节引用的文献 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 变成一个由 个数组成的向量,这个向量叫嵌入(embedding)。一段有 个 token 的文本,嵌入就是一个形状为 的矩阵:每行一个 token,每列是向量的一个维度。模型在计算过程中,每一层都会对每个位置产生一组新的数,叫激活(activation)。第 18 章的练习会给你一个激活文件:对 条陈述,在模型的某一层各取出一个长度为 的向量,排成一个形状为 的矩阵。比如形状 (1000, 512) 表示 1000 条陈述,每条 512 个数(数字是示意)。配套的标签是一个形状为 (1000,) 的一维数组,每条陈述一个“真”或“假”。划分训练集和测试集,就是把这些行分成两部分。偶尔你还会看到三个数的形状,如 ,它表示 段文本、每段 个位置、每个位置 个数,可以理解为 个 矩阵叠在一起。
实验路线还需要认识一种运算:点积(dot product)。两个长度相同的向量,逐项相乘再加起来,得到一个数。例如 和 的点积是 。也可以把它理解为加权求和:一个向量是权重,另一个是数据,点积就是按权重把数据加起来。第 18 章的线性探针给每条陈述打分,核心就是这样一次点积:用一个长度为 的权重向量 ,与这条陈述的激活向量做点积。NumPy 用 @ 表示点积;对 条陈述一起算,写成 acts @ w,得到形状为 的结果,每条陈述一个分数。
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 研究路线:矩阵乘法 #
研究路线需要再多走一步:把模型的一层看作“矩阵乘以向量”。
先说矩阵乘以向量算的是什么。矩阵 有 行、 列,向量 有 个数。结果是一个有 个数的向量 :它的第 个数,是把 的第 行与 逐项相乘再加起来。写成式子:
举一个能手算的例子:
“逐项相乘再加起来”正是上面讲的点积。所以矩阵乘以向量,就是拿矩阵的每一行分别和向量做点积。在 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)
形状要对得上: 的矩阵只能乘以长度为 的向量,结果长度为 。一次处理很多样本时,把样本按行排成 的矩阵 X,写成 X @ W.T,其中 W.T 是把 W 的行和列对调(叫转置,形状变成 ),结果的形状是 ,每一行对应一个样本。形状不匹配时,NumPy 会直接报错,这是检查代码的好帮手。
最基本的一种神经网络层,核心就是这样一次乘法:输入是一个长度为 的向量,乘以一个 的权重矩阵,加上一个长度为 的向量(偏置),再对每个数套用一个简单的非线性函数,得到长度为 的输出,交给下一层。第 4.6 节会讲这种层层叠加的结构;语言模型的层里还有注意力(第 5 章)。相比之下,第 18 章的线性探针只相当于输出长度 的一层:一个权重向量、一次点积,再加一个偏置。
读物 #
- 入门讲解 · 课程:哈佛 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
- Malan(2022)CS50's Introduction to Programming with Python
- NumPy Developers(2026)NumPy: the absolute basics for beginners
- Sanderson(2017a)Essence of calculus
- Sanderson(2016)Essence of linear algebra
练习 #
下面是为教学构造的数据:一个模型在 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.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.3 节的
slope函数),标出斜率的正负,并说明:站在这两点上,各应往哪边走, 才会变小? - 从 出发,步长取 0.1,用第 2.3 节的规则走 3 步。 往哪边移动?每一步 怎样变化?
提示
不用绘图库也可以“画”图:对每个 打印一行,行里星号的个数与 成正比。这样画出的图是横过来的, 从上往下增大, 从左往右增大。
解答
- 数值表见第 2.3 节第一个程序的运行结果。下面的程序把它横过来画出,每个星号代表 的 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 到 2 的两点斜率是 ),为负,往右走 变小,所以应往右走。 处斜率约为 (从 5 到 6 的两点斜率是 ),为正,往右走 变大,所以应往左走。两种情况都是“朝斜率的反方向走”,都指向最小值点 。
- 用第 2.3 节的
slope函数(),三步分别是:斜率 4.0010, 变为 4.5999,;斜率 3.2008, 变为 4.2798,;斜率 2.5606, 变为 4.0238,。斜率为正, 往左移动,朝 3 靠近; 从 4 依次降低,每一步降得比上一步少,因为越靠近最低点,曲线越平。
核对用的脚本是 tools/exercises/ch02_answers.py。
你拿到一个激活文件,读入后得到数组 acts,形状为 (1000, 512);还有一个标签数组 labels,形状为 (1000,)。
acts的一行代表什么?一列代表什么?一共有多少条陈述,每条有多少个数?acts[:800]和acts[800:]的形状各是什么?这样切分相当于做了什么?acts.mean(axis=0)的形状是什么?它的每个数是什么的平均值?- 权重向量
w的形状为(512,),acts @ w的形状是什么?它的每个数是什么? - (研究路线)另有一个形状为
(64, 512)的矩阵W,acts @ W.T的形状是什么?直接写acts @ W会怎样?
提示
先回答“每一行是什么”。可以用 np.zeros((1000, 512)) 造一个同样形状的数组,在 NumPy 里直接试。
解答
- 一行是一条陈述在这一层的激活向量;一列是激活向量的同一个维度在所有陈述上的取值。共 1000 条陈述,每条 512 个数。
acts[:800]是前 800 行,形状(800, 512);acts[800:]是后 200 行,形状(200, 512)。这相当于把陈述分成 800 条和 200 条两部分,例如分别作为训练集和测试集。对应的标签也要用同样的方式切分:labels[:800]和labels[800:]。- 形状
(512,)。axis=0表示沿行的方向求平均,所以每个数是某一个维度在 1000 条陈述上的平均值。 acts @ w的形状是(1000,)。每个数是一条陈述的激活向量与w的点积,即这条陈述的分数。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 一行算出准确率,并用布尔数组挑出一部分题目单独计算。
- 从函数图像上读出最小值点,说出某一点斜率的正负意味着往哪边走函数值更低。
- 解释梯度下降里的“下降”指什么:损失函数的值在下降;每一步沿斜率的反方向调整参数,步长决定走多远,步长过大会跨过最低点。
- 读懂数据矩阵、嵌入和激活的形状,说出每一行、每一列代表什么,会算两个向量的点积。研究路线还要能手算一个矩阵乘以向量,并判断两个数组的形状能否相乘。
参考文献
- (n.d.). Machine Learning Crash Course. Google for Developers. 非同行评审引用于 §2.4
- (2022). CS50's Introduction to Programming with Python. Harvard University. 非同行评审
- (2026). NumPy: the absolute basics for beginners. NumPy documentation. 非同行评审引用于 §2.2
- (2016). Essence of linear algebra. 3Blue1Brown (YouTube). 非同行评审
- (2017a). Essence of calculus. 3Blue1Brown (YouTube). 非同行评审