第 1 章 · 打地基

数学预备:看懂公式的一点点数学

这本书尽量不堆数学,但有六样小工具后面会反复用到:向量、点积、矩阵、导数、链式法则, 还有一点点概率。这一章用大白话加图把它们过一遍(顺带说清“对矩阵求导”这种唬人写法其实不难)——都是初中/高一水平。 已经熟的同学可以直接跳到第 2 章;后面卡在某个公式时,随时翻回来查。

读完这一章,你会明白

  • 向量为什么既是“一串数”又是“一个方向”;
  • 点积怎么衡量两个向量“合不合拍”(注意力、相似度全靠它);
  • 矩阵 = 一次批量线性变换:矩阵乘向量 = 一堆加权求和,矩阵乘矩阵 = 给一批向量同时变换;还有形状怎么对齐和转置 QKT 到底在干嘛;
  • 导数 = 斜率 = “往哪走会变大”,这是梯度下降的根;
  • 链式法则:复合函数怎么一层层求导——反向传播的唯一秘密;
  • 矩阵/向量求导其实不吓人:梯度和参数同形状,不过是一堆标量求导打包(大模型梯度的底层直觉);
  • softmax / 交叉熵会用到的一点点概率与对数。

1. 别怕:你需要的数学比想象少

很多人一看到 Σ、∂ 就头皮发麻。但深度学习里 99% 的场景,反复出现的其实只有两个动作: “一堆数乘起来再加总”(点积 / 矩阵乘法)和“顺着斜率往下滑”(求导 / 梯度下降)。 把这两件事想通,后面的公式基本都是它们的换装。这一章就带你把这几样小工具认全。

怎么用这一章

不用背。先读个眼熟,知道“有这么个东西、大概在干嘛”即可。等后面章节真用到时,你会“哦原来是它”, 那时再回来精读对应一节,效率最高。

2. 向量:一串数字,也是一个箭头

向量(vector)就是有序的一串数,比如 a = [3, 1]。它有两副面孔:

x y a = [3, 1] b = [1, 2]

向量 [3, 1] 就是从原点指向 (3, 1) 的箭头。方向和长度,后面点积会用到。

两个基本操作:

深度学习里到处是向量

一个样本(一张图、一行特征)是向量;一个词的词嵌入是向量(第 15 章); 一个神经元的权重也是向量(第 2 章)。学会向量,等于拿到了后面所有内容的“通用容器”。

3. 点积:两个向量有多“合拍”

点积(dot product)是本书出镜率最高的运算。做法极简单—— 对应位置相乘,再全部加起来,得到一个数:

a · b = a1b1 + a2b2 + … + anbn 例:[3, 1] · [1, 2] = 3×1 + 1×2 = 5

它最有用的性质是几何意义:点积衡量两个向量“方向合不合拍”。

a · b = |a| |b| cosθ θ 是两向量夹角:方向越接近,cosθ 越大,点积越大
记住这一条,后面省一半力气

一个神经元算的就是“输入向量 · 权重向量 + 偏置”(第 2 章); 注意力用 Query 和 Key 的点积当“相关性打分”(第 17 章); 词向量相似度也是点积(第 15、20 章)。点积 = “合拍程度”,这个直觉会一路带你到大模型。

4. 矩阵:一次“批量线性变换”

矩阵(matrix)就是把数字排成的长方形表格(几行几列)。你可以把它理解成一台 “把向量变成另一个向量”的机器。这一节稍微多花点篇幅——因为后面注意力、Transformer 里满屏的 X·W、QKT 全是矩阵乘法,这里一次讲透,后面就不会卡。

4.1 矩阵 × 向量 = 一堆点积

核心操作是矩阵 × 向量:

[ 2  1 ][ 0  3 ] × [ 1 ][ 2 ] = [ 2×1 + 1×2 ][ 0×1 + 3×2 ] = [ 4 ][ 6 ] 关键:输入 [1, 2] 其实是竖着的一列(形状 2×1),为省地方才横着写。所以是 [2×2]·[2×1]=[2×1],输出 [4, 6] 也是一列
别被“横着写的向量”骗了:2×2 乘的其实是 2×1

你可能会按形状算:2×2 的矩阵,后面跟着看起来像 1×2 的 [1, 2],那不就对不上了吗? 坑就在“横着写”这三个字。单独一个向量,书里(以及几乎所有教材)为了省版面常横着印, 但在 W·x 里它是竖着的一列:[1, 2] 实为 [1; 2],形状 2×1。 于是 [2×2]·[2×1]=[2×1]——正好符合后面 4.3 的形状规则“中间对齐、两头留下”,输出 [4, 6] 也是一列(2×1)。

看出来了吗?矩阵乘向量 = 一堆点积 = 一堆加权求和。矩阵有几行,输出就有几个数, 每个数都是“那一行的权重”和输入的点积。这正是神经网络一整层在做的事: 一层有很多神经元,每个神经元用自己那行权重和输入做点积——用一个矩阵就一次算完(第 3 章)。

4.2 矩阵 × 矩阵:把“很多次点积”一次算完

真正让人犯怵的其实是矩阵 × 矩阵。但它一点都不神秘——无非是把上面那种“一行 · 一列”的点积,在每一对(行, 列)上都做一遍。 规则只有一句话:结果的第 i 行第 j 列 = 左边矩阵的第 i 行 · 右边矩阵的第 j 列(还是点积!)。

[ 1  2 ][ 3  4 ] × [ 5  6 ][ 7  8 ] = [ 1·5+2·7  1·6+2·8 ][ 3·5+4·7  3·6+4·8 ] = [ 19  22 ][ 43  50 ] 左上角 19 = 左边第 1 行 [1,2] · 右边第 1 列 [5,7];其余三个格子同理,各是一次点积

换个角度看更贴近深度学习:如果把左边矩阵看成一叠行向量(每行是一个样本 / 一个词), 那“左矩阵 × 右矩阵”就是让每一行都各自过一遍同一台变换机器。这正是后面的关键一步—— 一句话有 n 个词、每个词一个向量,叠成矩阵 X;乘上权重矩阵 W,就一次性把 n 个词全部变换完,不必写循环。

等一下——4.1 明明把输入放右边,这里怎么放左边了?

好眼力,这不是笔误。“数据在左、权重在右”和“权重在左、数据在右”两种写法都对,它们只是互为转置:

· 4.1 的写法 W·x:输入是一列,权重矩阵每行一个神经元,一次只算一个样本。
· 4.2 的写法 X·W:每个样本是一行,一叠行就是一批样本,一次算一整批。

换句话说,把 4.1 的式子整体转置(行列对调)就得到 4.2:(W·x)T = xT·WT。 本书里 MLP 那几章(如第 3 章)常写成 W·x(方便盯住单个神经元), 注意力 / Transformer(第 17 章起)几乎都写成 X·W(方便一次处理一整句)。 看到哪种都别慌:认准“谁是数据、谁是权重”,点积规则完全一样。

这就是你后面会反复看到的 X·W

第 17 章里 Q = X·WQ 这种式子,就是本节这件事: X 是“一整句词向量叠成的矩阵”,WQ 是变换矩阵,一乘就把每个词都投影成了 Query。 矩阵乘法 = 对一批向量同时做同一种线性变换。

4.3 形状:能不能乘、乘出来多大,看一眼就知道

矩阵乘法能不能做、结果多大,完全由形状(几行几列)决定,这也是读代码时排查 bug 的第一招。规则:

[ m × n ] × [ n × k ] = [ m × k ] 左边的“列数”必须等于右边的“行数”(中间的 n 要对上),否则乘不了;结果的形状 = 左边行数 × 右边列数

记住一句口诀:“中间对齐、两头留下”——中间的 n 必须相等并被“消掉”,剩下两头的 m 和 k 就是结果的形状。举几个后面天天见的例子:

算式形状含义
权重 × 输入[128×784] × [784×1] = [128×1]把 784 维图片压成 128 维(第 3 章一层)
X · WQ[n×d] × [d×d] = [n×d]n 个词各投影成 Query,形状不变(第 17 章)
Q · KT[n×d] × [d×n] = [n×n]每个词和每个词的相关性打分表(第 17 章)
“784→128”这种写法是什么意思

后面看到“784→128”,意思就是有个 128×784 的权重矩阵,把 784 维输入变成 128 维输出(第 3 章)。 箭头左边是输入维度、右边是输出维度——和矩阵的“列数→行数”对应上了。

4.4 转置 AT:把行和列对调一下

最后一个小记号,后面那个吓人的 QKT 就靠它。转置(transpose)写作 AT,做的事只有一件:把矩阵沿对角线翻一下,行变成列、列变成行。

A = [ 1  2  3 ][ 4  5  6 ] (2×3)  →  AT = [ 1  4 ][ 2  5 ]
[ 3  6 ] (3×2) 原来的第 1 行 [1,2,3] 变成了第 1 列;形状从 2×3 变成 3×2

它最常见的用途,就是为了让形状对齐、好做矩阵乘法。比如注意力要拿“每个词的 Query”和“每个词的 Key”两两点积: Q 是 n×d,K 也是 n×d,直接乘形状对不上(d≠n); 把 K 转置成 d×n,Q·KT 就变成 [n×d]×[d×n]=[n×n]—— 正好是一张“第 i 个词对第 j 个词”的打分表。到第 17 章你就会看到这个式子,现在知道 ᵀ 只是“翻转对齐”就够了。

5. 导数:斜率,告诉你“往哪走会变大”

导数(derivative)说的是:一个函数在某一点变化有多快、朝哪个方向变, 也就是那一点的斜率。

f(x) = x2 的导数是 f′(x) = 2x 在 x=3 处斜率是 6(陡上坡);在 x=0 处斜率是 0(谷底最平)

当函数有很多个输入(比如模型有几百万个参数),对每个参数分别求导,把这些导数打包成一个向量, 就叫梯度(gradient)。梯度指向“函数上升最快”的方向; 所以想让损失下降,就往梯度的反方向挪一小步——这就是第 5 章的梯度下降。

下山的比喻(会贯穿全书)

把损失函数想成一片山地,你要走到最低的谷底。梯度就是脚下“最陡上坡”的方向, 你每次都朝反方向(最陡下坡)迈一小步,慢慢就滑到谷底了。步子多大,由学习率决定(第 5 章)。

6. 链式法则:复合函数怎么求导

神经网络是很多层套在一起的复合函数:f(g(h(x)))。要知道“最里层的参数 怎么影响最终损失”,就得会给复合函数求导。工具只有一条——链式法则:

[ f(g(x)) ]′ = f′(g(x)) · g′(x) 外层的导数 × 内层的导数——“一层一层的变化率乘起来”
齿轮传动

想象一串咬合的齿轮:第一个转 1 圈带动第二个转 2 圈,第二个转 1 圈带动第三个转 3 圈。 那第一个转 1 圈,最后一个转几圈?2 × 3 = 6 圈。链式法则就是这个理: 总的“变化率”等于沿途每一环变化率的乘积。

反向传播(第 6 章)的全部数学,就是这一条链式法则——从损失出发,一层层把导数乘回去, 就能算出每个参数“该往哪调”。现在记不住细节没关系,知道“反传 = 链式法则”这个等式就够了。

7. 矩阵与向量求导:其实就是一堆标量求导打包

上一节的导数是“一个数对一个数”求导。但后面网络里的参数动辄是一整块矩阵 W (第 17 章的 WQ、第 3 章一层的权重都是), 于是你会看到 ∂L/∂W 这种“对矩阵求导”的写法。第一次见容易慌:这是不是要学一套全新的、很吓人的数学? 不是。这一节把这颗定心丸先吃下,后面第 6 章、第 18 章再用它就不会怵。

一条铁律:梯度和它对应的东西同形状

对向量 w(比如一个神经元的一排权重)求导,∂L/∂w 还是一个同样长的向量; 对矩阵 W([m×n])求导,∂L/∂W 还是一个同样 [m×n] 的矩阵。 而且里面每一个元素 ∂L/∂W[i][j] 都只是一个普普通通的“一个数对一个数”的偏导——就是上一节那种, 只不过“对第 i 行第 j 列这一个权重”单独求了一次。

所以“对矩阵求导”根本不是新运算,它只是把 m×n 个“上一节那样的标量求导”整整齐齐码进一张同样大小的表。 你不是在对“一个矩阵”求导,你是在同时对矩阵里每个格子各求一次导,结果自然排成和原矩阵一样的形状。一张表看清:

参数是什么它的梯度 ∂L/∂(它)每个元素是
一个数 w(标量)一个数就是它自己那一个偏导
一排数 w(向量,长 n)同样长 n 的向量第 i 个 = ∂L/∂w[i]
一整块 W(矩阵,m×n)同样 m×n 的矩阵第 i,j 个 = ∂L/∂W[i][j]

规律一句话:求导不改变形状。参数多大,它的梯度就多大,里面装的全是普通标量偏导。

为什么它们能“一次矩阵乘”算完(直觉)

既然梯度是“每个格子各求一次导”,那岂不是要算 m×n 次、很慢?妙就妙在:这些格子的求导公式 长得一模一样,只是下标不同。数学上可以证明,它们正好能拼成一次矩阵乘法—— 比如一层 Y = X·W,整块 W 的梯度就是简洁的 ∂L/∂W = Xᵀ·G(G 是从后面传来的梯度)。 这也是为什么“上万亿参数求梯度”不会慢到天荒地老:不是逐个格子循环,而是几次矩阵乘。 这里先建立直觉即可,第 6 章会把 Xᵀ·G 是怎么来的一步步推给你看。

记住这一节一句话就够:看到 ∂L/∂W 别慌,它和 W 一样大,每格是个普通偏导,整体能用矩阵乘一次算出。 矩阵求导不是新数学,是上一节的标量求导“批量打包”。

8. 概率、softmax 与对数

做分类时,我们希望模型输出“每个类别的概率”。这里只需三个小概念:

交叉熵损失 = −log(模型给“正确答案”的概率) 概率≈1 → −log≈0(几乎没损失);概率≈0 → −log 很大(狠狠惩罚)

直觉:模型对正确答案越有把握(概率越接近 1),损失越接近 0;越是把正确答案判得没可能 (概率接近 0),损失就飙得越大。这个 −log(正确概率) 就是第 4 章的交叉熵, 也是分类任务里最常用的损失。

小结

  • 向量 = 一串数,也是一个有方向、有长度的箭头;深度学习里的样本、词、权重都是向量。
  • 点积 = 对应相乘再加总,衡量两个向量“合不合拍”:同向大、垂直为 0、反向为负。
  • 矩阵 × 向量 = 一堆点积 = 一堆加权求和,正是神经网络“一层”的计算;矩阵 × 矩阵则是把一批向量同时变换(后面的 X·W)。形状看“中间对齐、两头留下”:[m×n]·[n×k]=[m×k];转置 AT 把行列对调,用来凑形状(如 QKT)。
  • 导数 = 斜率 = “往哪走会变大”;把每个参数的导数打包成梯度,反方向走就能降损失。
  • 链式法则:复合函数求导 = 各层变化率相乘——这就是反向传播的全部数学。
  • 矩阵/向量求导:梯度和参数同形状,每个格子只是普通标量偏导,整体能用一次矩阵乘算出(如 ∂L/∂W = Xᵀ·G)——不是新数学,是标量求导打包。
  • softmax 把分数变概率,−log(正确概率) 就是交叉熵损失。

工具备齐了。下一章我们就用上它们,把那台“带旋钮的机器”拆到最小的一个零件—— 一个神经元,看看它内部无非就是一次点积 + 一个激活。