精读笔记：把 30 课真正读懂

一句话：把「猫像不像老虎」这种模糊直觉，变成一组有顺序的数字，让「相似度」第一次能被计算。

难度：★☆☆　　预计：约 15 分钟

原文：第 1 课 · 什么是向量

0. 先记住这三句

• 计算机只认数字；向量就是给事物拍的一张「数字照片」，用一组有序数字描述特征。
• 维度是数字的个数，每个维度是一种「看待事物的角度」，越多越能细分。
• 两个向量离得越近，事物越像——「像不像」从此变成一道可算的距离题。

1. 这一课在补哪个洞

写个程序回答「猫、老虎、金鱼哪两个更像」，你脱口而出「猫和老虎」。可计算机不懂「猫科」，只认数字，你没法把一只猫塞进 CPU。没有向量，机器对着文字图片只能干瞪眼，更别提理解词义。最早的补丁很朴素：给每样东西打 0 到 1 的「体型分」，压到一根数轴上。这样「比较事物」就悄悄变成「比较数字」，这是全系列最值钱的一步。可只用一个数字马上露馅：它把一只动物的信息全扔了、只剩体重，于是体重相近的狗和鳄鱼被硬凑成「近亲」。这一课补的洞是：怎么在保留「用数字描述」的前提下把丢掉的信息捡回来——答案是从一根数轴，升级成一组有顺序的数字。

2. 概念逐层拆

向量：一串有顺序的数字

大白话：像填体检表，身高、体重按固定格子填好，顺序不能乱。 正式定义：向量（vector）是一组有序数字，如 [0.45, 0.20]，每个数叫一个分量。 最小例子：原文里狗 = [0.45, 0.20]，第 1 个数是体型、第 2 个是凶猛，顺序一换意思全变。

维度：数字个数，也是看问题的角度

大白话：维度就是你填了几个格子、从几个角度打量东西。 正式定义：分量的个数叫维度，n 个数即 n 维向量。 最小例子：只有体型是 1 维，加凶猛变 2 维；猫和狐狸仍分不开，就再加一维「是否家养」。原文说 GPT-3 每个词是 12288 维，画不出来但照样算。

向量的三副面孔

大白话：同一样东西，换个场合就换个样子，说的还是同一件事。 正式定义：一个向量既是计算机看到的一列数字，也是平面上的一个点，还是从原点指向它的箭头。 最小例子：[0.45, 0.20] 在表里是两格数，在纸上是「右 0.45、上 0.20」的点，也是一支从原点戳过去的短箭头。

相似度 = 距离

大白话：谁跟谁像，就看它们在数字地图上挨得多近。 正式定义：用两组数的差距度量相似，差越小越像；一维时距离就是两数相减取绝对值。 最小例子：|0.45 − 0.50| = 0.05，说明狗和鳄鱼在「体型」这根轴上几乎贴在一起。

3. 亲手算一遍

用原文那组体型分，亲手把这套算法的荒唐结果算出来。

输入（5 种动物的体型分，0 到 1）：

规则：距离 = 两数相减取绝对值。

• 第 1 步，狗和鳄鱼：|0.45 − 0.50| = |−0.05| = 0.05。
• 第 2 步，猫和金鱼：|0.25 − 0.02| = |0.23| = 0.23。
• 第 3 步，猫和老虎：|0.25 − 0.90| = |−0.65| = 0.65。
• 第 4 步，比大小：0.05 < 0.23 < 0.65，所以「全场最像」是狗和鳄鱼，其次是猫和金鱼，猫和老虎反倒最不像。

所以结论是：只用「体型」一个数字时，算法把体重相近的狗和鳄鱼判成最近亲，把猫判得更像金鱼而不是老虎。这个数说明什么？把一只动物压成一个数字，丢掉了性格、习性、危险程度，只剩体重，于是「体重差不多」被错当成「长得像」。修法不是推翻「用数字描述」，而是补第二个数字——原文给狗加上「凶猛」写成 [0.45, 0.20] 后，狗和鳄鱼在纵轴上被狠狠拉开，距离从 0.05 变成约 0.70（要用勾股定理算，是下一课的内容）。每发现一种「区分不开」，就加一个维度。

4. 一个类比就够了

把向量想成「给事物拍的一张数字照片」：照片用一组像素格记录人，向量用一组数字格记录东西，格子越多越能拍清细微差别。 哪里像：都是「用固定位置的一组数值代表原物」，换掉或打乱某格，代表的东西就变。 哪里不像、别当真：大模型那 12288 个维度没有「体型」「凶猛」这种能叫出名字的含义，是模型从海量文本里自己学出来的，你我说不清第 800 维代表什么。类比只帮你理解「一组有序数字 = 一个事物」，别指望每维都有中文名。

5. 五个常见误区

误区 1：向量里的数字必须都是整数 → ❌ 把维度当「计数」了。 → ✅ 正解：分量可以是任意小数，原文体型分 0.02、0.25、0.90 全是小数。

误区 2：向量只能二维三维，超过三维没意义 → ❌ 把「画不出来」当成「算不了」。 → ✅ 正解：4 维、12288 维画不出，但距离公式照样套；GPT-3 就用 12288 维。

误区 3：两个向量长度相等就代表同一事物 → ❌ 只盯个数，忽略取值和顺序。 → ✅ 正解：每个位置都一样才相同；[0.45, 0.20] 与 [0.20, 0.45] 长度一样，意思全变。

误区 4：每个维度都得由人手工设定含义 → ❌ 把讲解用的小实验当成工业做法。 → ✅ 正解：真实模型里各维含义是训练时自己学出来的，没人逐个起名。

误区 5：距离越小就一定越像，永远成立 → ❌ 忘了「维度合适、长度可比」这个前提。 → ✅ 正解：一维体型分算出「狗和鳄鱼最像」正是反例；下一课还会看到词频受篇幅干扰时直线距离彻底失灵。

6. 和前后课的接口

• 上一课（起点）留下了：计算机只认数字，可「像不像」是模糊直觉，没有下手抓手。
• 这一课补上了：用有序数字（向量）给事物拍数字照片，把「比较事物」变成「比较数字」，并靠加维度修补信息丢失。
• 下一课（第 2 课）会来解决：距离到底怎么算才对，以及点积、余弦相似度这些更靠谱的算法。

7. 自测 6 题（附答案）

Q1 用向量表示「猫」「老虎」，最根本的目的是？A 省存储空间 B 把事物变成数字以便用数学度量「像不像」 C 把中文翻成英文 D 按拼音排序。 答案：B｜解析：向量反而比一个数字占得更多（A 错），也不做翻译（C）、不排序（D）。它解决「计算机只认数字」，让相似度变成可算距离，正是原文强调要保留的那件大事。

Q2 关于「向量是空间中的点 / 箭头」，哪种说法正确？A 只能二维三维 B 每个分量代表事物在某维度上的取值 C 长度相等就是同一事物 D 分量必须是整数。 答案：B｜解析：A 错在以为高维无意义；C 错在忽略取值与顺序；D 错在把分量当计数。B 正是「每维是一个看待角度」的定义。

Q3（判断）金鱼 0.02、猫 0.25、老虎 0.90 压到数轴上，猫和老虎的距离是 0.65。 答案：对｜解析：|0.25 − 0.90| = 0.65，相减取绝对值即可，与原文一致。

Q4 为什么只用一个体型分，狗和鳄鱼被判成最像？A 它俩确实是近亲 B 体型分最接近（0.45 与 0.50） C 程序算错了 D 维度太高。 答案：B｜解析：|0.45 − 0.50| = 0.05 全场最小。问题不在程序（C），恰恰在维度太低（D 说反了），一个数字丢光其它信息，才把「体重差不多」错当成「像」。

Q5（判断）狗加上「凶猛」变成 [0.45, 0.20] 后，狗和鳄鱼距离变大到约 0.70。 答案：对｜解析：横轴仍贴着，纵轴把鳄鱼拽向「猛兽区」，原文给出距离从 0.05 变成约 0.70，正是加维度修补成功的证据。

Q6 哪个不是向量「三副面孔」之一？A 一列数字 B 平面上的点 C 从原点出发的箭头 D 一段语音。 答案：D｜解析：三副面孔是「一列数字、一个点、一支箭头」，说的是同一个向量；语音（D）与此无关，是硬凑的干扰项。

8. 一页速记

• 一组有序数字就是一个向量，顺序不能乱。
• 每发现一种「区分不开」，就加一个维度。
• 一维反例：狗 0.45 与鳄鱼 0.50 距离仅 0.05，被错当近亲。
• 真实模型里维度含义是学出来的，不是人起的名。

一句话：当「长度」会骗人时，改用箭头方向的夹角来量「像不像」，顺带学会点积与向量加减。

难度：★★☆　　预计：约 15 分钟

原文：第 2 课 · 向量的常见运算

0. 先记住这三句

• 直线距离量的是「两支箭头末端隔多远」，会被文章长短这类无关因素带偏；余弦相似度量的是「方向多一致」，才是语义相似该用的工具。
• 点积是把对应分量相乘再相加，结果是一个数；几何上等于「一个向量在另一个方向上的投影有多长」。
• 向量还能相减做类比：国王 − 男人 + 女人 ≈ 女王，词的「含义」被编码成了空间里的方向。

1. 这一课在补哪个洞

第 1 课把「像不像」变成了「比距离」，可一上手做「找相似文章」就翻车了。三篇文章用词频向量表示：A 是约 3000 字的长篇 AI 文章（8 次 AI、6 次数据），B 是约 800 字的同主题摘要（2 次 AI、1 次数据），C 是几乎不谈 AI 的数据库专题（1 次 AI、7 次数据）。直觉上 A 和 B 最像，可勾股定理一算，A 到 B 约 7.8、A 到 C 约 7.1，反倒判 A 和 C 更近。如果没有更好的算法，搜索引擎会把「同话题的摘要」判成不相关，语义搜索、推荐系统全都得歪——问题就出在「长度」这个无关变量混进了比较。这一课补的正是这个洞：把注意力从「末端有多远」挪到「方向有多一致」，用余弦相似度把长度彻底消掉；顺便把配套的工具点积，以及能对「意义」做加减的向量运算一起交代清楚。

2. 概念逐层拆

点积：对应相乘再相加

大白话：像对账一样，把两列数一格一格对上、乘起来，最后全加起来，得到一个总数。 正式定义：a·b = a₁b₁ + a₂b₂ + … + aₙbₙ，结果是一个数（标量），不是向量；原文还给出几何版本 a·b = |a||b|cosθ。 最小例子：A=[8,6]、B=[2,1]，A·B = 8×2 + 6×1 = 22。

余弦相似度：只比方向，不比长短

大白话：不看两支箭头谁长谁短，只看它俩指的方向夹得紧不紧。 正式定义：cosθ = (a·b) / (|a||b|)，除以两个模长把长度影响消干净；取值 −1 到 1，1 完全同向、0 正交无关、−1 完全相反。 最小例子：原文算出 A 和 B 的 cos≈0.98、A 和 C 的 cos≈0.71，篇幅问题一下就消失了。

模长：这支箭头本身有多长

大白话：就是拿勾股定理量一下箭头自身的长度。 正式定义：|a| = √(a₁² + a₂² + … + aₙ²)。 最小例子：|A| = √(8²+6²) = √100 = 10，是后面亲手算要反复用到的数。

向量加法：意义也能做算术

大白话：把两组数按位置分别加减，得到一组新数；在词向量里，这相当于在「意义」上平移。 正式定义：[a₁,a₂] + [b₁,b₂] = [a₁+b₁, a₂+b₂]。 最小例子：原文那句著名的「向量(国王) − 向量(男人) + 向量(女人) ≈ 向量(女王)」，「男→女」是一个固定偏移，「平民→王室」是另一个，两者能独立叠加。

3. 亲手算一遍

用原文三篇文章的词频向量，亲手把「余弦相似度为什么赢」算明白。

输入：

A = [8, 6]   // 长篇 AI 文章，8 次 AI、6 次数据
B = [2, 1]   // 同主题摘要，2 次 AI、1 次数据
C = [1, 7]   // 数据专题，1 次 AI、7 次数据

先看清直线距离怎么闹笑话：A→B = √((8−2)²+(6−1)²) = √(36+25) = √61 ≈ 7.8；A→C = √((8−1)²+(6−7)²) = √(49+1) = √50 ≈ 7.1。7.1 < 7.8，距离硬说 A 和 C 更像，明显错。

改用余弦相似度 cosθ = (a·b)/(|a||b|)：

• 第 1 步，算模长：|A| = √(8²+6²) = √100 = 10；|B| = √(2²+1²) = √5 ≈ 2.236；|C| = √(1²+7²) = √50 ≈ 7.071。
• 第 2 步，算 A 和 B 的点积：A·B = 8×2 + 6×1 = 16 + 6 = 22。
• 第 3 步，算 A 和 B 的余弦：cos = 22 / (10 × 2.236) = 22 / 22.36 ≈ 0.98。
• 第 4 步，算 A 和 C 的点积：A·C = 8×1 + 6×7 = 8 + 42 = 50；余弦 cos = 50 / (10 × 7.071) = 50 / 70.71 ≈ 0.71。

所以结论是：按方向算，A 与 B 的 0.98 远高于 A 与 C 的 0.71，正确把「同主题、只差篇幅」的两篇认成最像；而直线距离因为被 B 的「短」钻了空子，给出了相反答案。这个数说明什么？说明当向量长度没有意义（词频会被文章字数放大）时，必须先除以模长把长度归一化、只保留方向信息——这正是搜索引擎、推荐系统、语义搜索背后几乎都在用余弦相似度、而不是两点距离的原因。点积本身也别只当公式背：a·b = |a| × (b 在 a 方向上的投影长度)，正、零、负分别对应方向一致、垂直无关、彼此对立。神经元里的 w·x 也正是这个运算。

4. 一个类比就够了

把每个向量想成「一支从原点射出的手电筒光柱」：余弦相似度问的是「两支光柱指的方向夹得紧不紧」，直线距离问的是「两个光斑落点隔多远」。 哪里像：方向一致的两支光柱（一长一短，对应长文与摘要）指向的是同一片墙，所以「话题相同」，长度无关紧要。 哪里不像、别当真：真实词向量是上千维的，没有「手电筒」这种能画出来的实体；原文标注的「夹角约 10°」「约 45°」只是二维示意，别以为语义相似真的等于某个几何角度。类比的用处仅限于「方向 ≈ 内容、长度 ≈ 篇幅」这一个对应关系。

5. 五个常见误区

误区 1：点积的结果是一个新向量 → ❌ 把「对应相乘」误解成「对应相加得到数组」；逐元素相加才是向量，点积还要把乘积全加起来。 → ✅ 正解：点积 Σaᵢbᵢ 得到的是一个数（标量），大致反映「同向程度 × 各自长度」。

误区 2：文章越长、词频越大，就越该和别的长文判为相似 → ❌ 把「数值大」当成「更相关」，正是距离失灵的同款错。 → ✅ 正解：绝对频次会被篇幅放大，得用余弦相似度先除掉长度，只看词频比例构成的方向。

误区 3：余弦相似度取值范围是 0 到 1，越大越像 → ❌ 漏掉了负相关这一半。 → ✅ 正解：范围是 −1 到 1；1 完全同向、0 正交（没关系）、−1 方向完全相反（对立）。

误区 4：点积越大就一定越相似 → ❌ 忽略了点积同时被两个模长撑大，一个又长又偏的向量也能点积很高。 → ✅ 正解：点积混进了长度，必须除以两模长归一化成余弦才公平；原文 A·C=50 比 A·B=22 大，可相似度反而更低，就是活证据。

误区 5：「国王−男人+女人≈女王」说明模型真的懂王权和性别 → ❌ 把漂亮的统计规律拔高成「理解」。 → ✅ 正解：这是词向量从海量文本里学出的方向偏移，是「含义被编码成空间方向」的数值现象；它怎么学出来是第 15 课的事，别急着赋予它人类式的理解。

6. 和前后课的接口

• 上一课（第 1 课）留下了：用向量和距离把「像不像」变成可计算的量，但直接距离会被无关的长度干扰。
• 这一课补上了：点积这个工具、用余弦相似度只看方向的正确算法，以及向量加减能对语义做平移。
• 下一课（第 3 课）来解决：当「一组输入要同时变成另一组输出」时，把一大堆点积整齐排成表格的那个数学对象——矩阵。

7. 自测 6 题（附答案）

Q1 要衡量两个向量「方向多一致」又不被长度干扰，该用哪种运算？A 向量加法 B 余弦相似度 C 逐元素相减 D 求向量长度。 答案：B｜解析：B 先除以两个模长把长度归一化，正是原文结论。A 得到的是新向量、不是相似度；C 量的是差异大小，仍含长度；D 干脆把方向信息全丢了，只剩长短。

Q2 两个向量的点积结果是什么？A 一个新向量 B 一个数（标量），大致反映同向程度×各自长度 C 一个旋转矩阵 D 恒为正的概率值。 答案：B｜解析：点积是 Σaᵢbᵢ，全加起来只剩一个数。A 把点积和向量加法搞混；C 是矩阵乘法的活；D 错在「恒为正」——点积可以是 0（垂直）甚至负数（方向对立），而且它不是概率。

Q3（判断）A=[8,6] 与 B=[2,1] 的直线距离约 7.8，比 A 到 C=[1,7] 的约 7.1 更大，所以距离认为 A 和 C 更像。 答案：对｜解析：√(36+25)=√61≈7.8，√(49+1)=√50≈7.1，7.1 更小，距离确实错判 A 和 C 更近，这正是本课要修的「笑话」。

Q4 亲手算 cos(A,B)：已知 A·B=22、|A|=10、|B|≈2.236，结果约为？A 0.71 B 0.98 C 7.8 D 22.36。 答案：B｜解析：22/(10×2.236)=22/22.36≈0.98。A 是 cos(A,C) 的值；C 是 A→B 的直线距离；D 是模长乘积本身，都代错了位置。

Q5 cosθ = 0 意味着什么？A 两个向量完全相同 B 两个向量方向相反 C 两个向量正交、没有方向上的一致性 D 计算溢出了。 答案：C｜解析：原文明确 0 表示正交（没有关系）。A 对应 1，B 对应 −1，D 是无中生有；0 是点积为 0 时分子塌陷的正常结果。

Q6（判断）「向量(国王)−向量(男人)+向量(女人)≈向量(女王)」说明「男→女」和「平民→王室」是两个可以独立叠加的方向偏移。 答案：对｜解析：这正是原文对「语义变成可计算的方向偏移」的解释；两个偏移互不干扰、叠加后终点自然落在女王，是词向量空间结构的体现。

8. 一页速记

• 长度会骗人：同方向但长短不同，两点距离可能反而更大。
• a·b = Σaᵢbᵢ = |a||b|cosθ，几何上等于「模长 × 投影长度」。
• cosθ = (a·b)/(|a||b|)，除以两模长把长度消干净，只留方向。
• 点积正负 = 方向一致 / 垂直 / 对立；语义搜索几乎都用余弦相似度。
• 词的「含义」被编码成空间方向，第 15 课讲怎么学出来。

一句话：把「同时做很多组加权求和」压成一张配方表，一次矩阵乘法就把整组输入变成整组输出。

难度：★☆☆　　预计：约 15 分钟

原文：第 3 课 · 什么是矩阵

0. 先记住这三句

• 矩阵就是把多组权重整齐排成的一张矩形表格：一行一份「配方」，一列对应一个输入。
• 矩阵乘向量 Wx 就是「每行与 x 做一次点积」，m 行产出 m 个结果，拼成 m 维输出。
• 维度规则：W(m×n) × x(n维) = y(m维)——内层列数必须相等，外层行数决定输出。

1. 这一课在补哪个洞

第 2 课学会了「一次点积 = 一组加权求和」，可现实里要算的从来不止一组。开一家奶茶店，3 款饮品每款都要按自己的配方、用同样的 4 种原料算成本，就是 3 条加权求和；放大到神经网络，一层里可能是几百万个权重、要同时算成千上万条。如果没有一个把这些公式收拢起来的对象，你就得把每条 y = 2x₁ + 1x₂ + 0x₃ + 3x₄ 分开写、分开算，代码和脑子一起爆炸，更没法一眼看清「整组输入怎么变成整组输出」。这一课补的就是这个洞：把所有配方的份数排成一张表，起名叫矩阵，于是「一次算完一整张菜单」被压缩成一个动作 Wx。往后你会看到，神经网络每一层做的，其实都是这同一个动作，只不过表大得多。

2. 概念逐层拆

矩阵：一张数字的矩形表

大白话：像 Excel 里一块规规矩矩的表格，横着一排排、竖着一列列，每格填一个数。 正式定义：矩阵（matrix）是 m 行 n 列的数字阵列，用 m×n 描述大小，读作「m 行 n 列」。 最小例子：原文把 3 款饮品、4 种原料的配方排成 3×4 的 W——每行是一份配方，每列是一种原料（茶、奶、糖、珍珠）。

矩阵乘向量：每行做一次点积

大白话：拿表格的每一行，去和输入那串数「对账」一次，得一个数；把所有行的结果摞起来，就是输出。 正式定义：Wx 的第 i 个分量 = W 第 i 行与 x 的点积。 最小例子：原料价格 x=[1,2,1,0] 时，第一行 2×1+1×2+0×1+3×0=4，就是珍珠奶茶的成本。

维度：从几维到几维

大白话：矩阵是个「转换器」，吃进几维、吐出几维都由它的形状说了算。 正式定义：W(m×n) × x(n维) = y(m维)；W 的列数必须等于 x 的维度，输出维度等于 W 的行数。 最小例子：原文 W 是 3×4，所以 x 必须是 4 维（4 种原料价），输出 y 是 3 维（3 款饮品成本）——把 4 维空间变成 3 维空间。

列数与行数：为什么一个都不能错

大白话：表格每行有 4 个格子，输入就得正好给 4 个数，多一个少一个都对不上。 正式定义：「内层维度必须相等」是点积能对齐的前提，「外层维度保留」决定结果形状。 最小例子：3×4 的 W 配 3 维或 5 维的 x 都算不了，因为一行 4 个数没法跟 3 个或 5 个数逐格相乘。

3. 亲手算一遍

用原文的奶茶店配方和原料价，把「一次矩阵乘法算完整张菜单」从头到尾算一遍。

配方矩阵 W（3 行 4 列，数字是份数）与价格列向量 x：

       茶  奶  糖  珍珠
珍珠奶茶 [ 2   1   0   3 ]
奶霸布丁 [ 0   4   1   2 ]
古早甜茶 [ 1   0   3   1 ]

x = [1, 2, 1, 0]   // 茶1元、奶2元、糖1元、珍珠0元（促销免费）

规则：y 的每个分量 = W 对应行与 x 的点积（对应位置相乘再相加）。

• 第 1 步，珍珠奶茶：2×1 + 1×2 + 0×1 + 3×0 = 2 + 2 + 0 + 0 = 4。
• 第 2 步，奶霸布丁：0×1 + 4×2 + 1×1 + 2×0 = 0 + 8 + 1 + 0 = 9。
• 第 3 步，古早甜茶：1×1 + 0×2 + 3×1 + 1×0 = 1 + 0 + 3 + 0 = 4。
• 第 4 步，把三个结果按顺序摞成输出向量：y = [4, 9, 4]。

所以结论是：一次 Wx 就把三款成本同时算完——珍珠奶茶 4 元、奶霸布丁 9 元、古早甜茶 4 元，与原文给出的 y=[4,9,4] 完全一致。这个数说明什么？说明矩阵乘法的本质不是什么新运算，而是「把第 2 课的点积批量做 m 次」：W 有 3 行就做 3 次点积、产出 3 个结果。再看形状：W 是 3×4、x 是 4 维、y 是 3 维，正好印证 W(m×n)×x(n)=y(m)——4 这个「内层」必须对齐，3 这个「外层」留下来当输出。神经网络每一层都在干这件事，只是把「4 种原料」换成上千维输入、把「3 款饮品」换成上千维输出而已。

4. 一个类比就够了

把矩阵想成「一台多出口的榨汁机」：每个出口（行）有自己的一份配方，你把同一批原料（输入向量 x）倒进去，每个出口按自己的配比同时流出一杯，一次得到好几杯不同口味的成品（输出向量 y）。 哪里像：都是「同一组输入、多组权重、并行产出多个加权和」，一行一份配方这一点完全对得上。 哪里不像、别当真：真实矩阵里的权重可以是负数、是训练出来的任意小数，没有「份数必须非负」这种限制；而且矩阵乘法不止乘一个向量，还能乘另一个矩阵、还能叠加变换。类比只帮你记住「一行一个结果、列对应输入」，别把它当成物理设备。

5. 五个常见误区

误区 1：矩阵就是一个放数字的普通表格，没有运算含义 → ❌ 只记住了「长什么样」，漏掉它「能把一组向量变成另一组向量」的本职。 → ✅ 正解：矩阵本质是「一次线性变换的说明书」，Wx 才是它存在的理由，下一课会专门讲这层几何意义。

误区 2：3×4 的矩阵可以乘任意维度的向量 → ❌ 以为矩阵乘法像普通乘法那样随便配对。 → ✅ 正解：W 有 4 列，x 就必须正好 4 维；内层对不齐，点积根本没法逐格相乘。

误区 3：3×4 矩阵乘 4 维向量，结果是 4 维 → ❌ 把「输入维度」错当成了「输出维度」。 → ✅ 正解：输出维度等于 W 的行数，这里是 3 维；规则是 (m×n)×(n维)=(m维)。

误区 4：矩阵乘向量是「对应位置相乘」得到一串新数 → ❌ 把矩阵乘法和「逐元素相乘」混为一谈。 → ✅ 正解：是每一行与 x 做点积（乘完还要加总），每行坍缩成一个数，m 行才得到 m 个数。

误区 5：现实里配方、权重都得由人一条条手工填好 → ❌ 把讲解用的奶茶店小例子当成了工程现实。 → ✅ 正解：原文点明神经网络里是几百万个权重，它们和偏置一样是从数据里学出来的，不需要、也不可能靠人逐个设定。

6. 和前后课的接口

• 上一课（第 2 课）留下了：点积能算「一组加权求和」，但一层网络要同时算成千上万组，逐条写不现实。
• 这一课补上了：用矩阵把所有权重排成一张表，把「批量点积」压成一次 Wx，并定死维度匹配规则。
• 下一课（第 4 课）来解决：这个 Wx 除了「算账」，在几何上到底对整个空间做了什么——旋转、拉伸、切变，以及为什么要再加个 b。

7. 自测 6 题（附答案）

Q1 描述「把一组数字整组变成另一组数字」的线性变换，最自然的数学对象是？A 一个单独的数 B 一个向量 C 一个矩阵 D 一段文字规则。 答案：C｜解析：矩阵每行是一组系数，一次 Wx 产出整组输出，正是原文 Q1 的正解。A 只能表示一个缩放；B 是「一组数」本身、不是「变换」；D 不是可计算的数学对象。

Q2 一个 3×4 矩阵乘向量，对输入和输出的维度要求是？A 输入 4 维、输出 3 维 B 输入 3 维、输出 4 维 C 进出都 3 维 D 任意维度、结果不变。 答案：A｜解析：列数 4 定输入、行数 3 定输出，即 (3×4)×(4维)=(3维)。B 把行列对调；C 无视列数匹配；D 错在「任意维度」，内层不符直接算不了。

Q3（判断）用 x=[1,2,1,0] 算珍珠奶茶那行，成本是 2×1+1×2+0×1+3×0 = 4 元。 答案：对｜解析：逐项 2+2+0+0=4，与原文图 3-2 及 y=[4,9,4] 的第一项一致；珍珠 0 元那一项乘完归零，正是促销免费的效果。

Q4 奶霸布丁那行算出 9 元，主要因为哪一项？A 茶 1 元 B 奶的权重是 4、奶价 2 元，贡献 8 C 糖价 1 元 D 珍珠免费。 答案：B｜解析：0×1+4×2+1×1+2×0 里 4×2=8 是绝对大头。A 茶那项系数是 0、直接归零；C 糖只贡献 1；D 珍珠项系数为 0，跟免不免费无关，都凑不成 9。

Q5 若把珍珠价格从 0 元改成 1 元（x 变成 [1,2,1,1]），古早甜茶的成本变成？A 4 B 5 C 9 D 7。 答案：B｜解析：古早甜茶配方是 [1,0,3,1]，原本 1+0+3+0=4；珍珠涨价后多出 1×1=1，变成 5。A 是忘了改、C 是奶霸布丁旧值、D 无对应算法。这题考的正是「每一列对应一种原料，改价格只影响用到它的那些行」。

Q6（判断）Wx 里 W 的每一行产生一个输出分量，所以 W 有几行，输出向量就有几维。 答案：对｜解析：这是「行数决定输出」的直白说法，正是 W(m×n)×x(n)=y(m) 里 m 的来源；3 行配方对应 3 款饮品成本，一一对应。

8. 一页速记

• 矩阵 = m 行 n 列；一行一组系数，一列对应一个输入。
• Wx 不是新运算，是批量做 m 次点积。
• 列数必须等于输入维度，否则点积对不齐。
• 行数决定输出维度：把 n 维变成 m 维。
• 下一课换个眼光：同一式子是「整个空间的一次变形」。

一句话：换个眼光看 Wx——它不是搬动一个点，而是把整张坐标纸统一地旋转、拉伸、切变；再加个 b 才能连「搬家」一起做。

难度：★★☆　　预计：约 15 分钟

原文：第 4 课 · 什么是线性变换

0. 先记住这三句

• 同一个 Wx，从「算账」换成「几何」看：它把输入的每个点搬到新位置，等于对整个空间做一次统一变形。
• 读懂一个矩阵只需看它的列：每一列正是某个坐标轴上的基向量变换后的落点（平面里就是 î、ĵ 两列）。
• 变形守住「直线仍是直线、平行仍平行、原点不动」，这叫线性；想整体平移得加偏置 b，凑成 y = Wx + b。

1. 这一课在补哪个洞

第 3 课把 Wx 当成一台计算器：每行做一次点积、吐出一个数。这个「算账」眼光够用，却回答不了一个更要紧的问题——神经网络一层层地做 Wx，到底把数据怎么了？如果只会逐个数地算，你永远看不出「为什么多叠几层能把原本混在一起的样本分开」，也说不清「一层」在几何上意味着什么。更麻烦的是，纯靠 Wx 还有个硬伤：线性变换永远把原点钉在原地，整张纸没法整体挪开，可网络常常需要「搬动」这一步。这一课补的洞就是这副「几何眼镜」：把 Wx 看成「整张坐标纸一起变形」，用「盯住基向量落点」的诀窍一眼读懂任意矩阵，再补上偏置 b 完成 y=Wx+b。没有这层理解，后面「为什么需要激活函数」就无从谈起。

2. 概念逐层拆

线性变换：整张纸一起变形

大白话：像修图软件里拖一下「自由变换」控制点，图片里成千上万个像素按同一条规则一起挪，谁也不落下。 正式定义：对空间里每个向量都施加同一个矩阵 W，把整个空间统一地重新摆放；保持直线、平行、等距、原点不动。 最小例子：原文取 W=[[2,1],[1,2]]，把点 [1,1] 搬到了 [3,3]。

基向量：两根最短的「坐标轴箭头」

大白话：正东、正北各走一步的两根单位箭头，平面上任何点都能靠「往东几步、往北几步」凑出来。 正式定义：î=[1,0]、ĵ=[0,1]，任意点是它们的线性组合，比如 [3,2] = 3î + 2ĵ。 最小例子：变换后 î、ĵ 落到 î′、ĵ′，那么 [3,2] 就老老实实落到 3î′ + 2ĵ′——不用逐点算，全空间去向就定了。

看列就懂：矩阵是「基向量去哪」的说明书

大白话：矩阵的第一列告诉你「正东那根箭头飞到哪」，第二列告诉你「正北那根飞到哪」。 正式定义：W 的第 k 列 = 第 k 个基向量变换后的落点；n 维空间有 n 个基向量，矩阵就有 n 列。 最小例子：W=[[2,1],[1,2]] 第一列 [2,1] 是 î 的落点、第二列 [1,2] 是 ĵ 的落点，画成两支箭头就知道空间被拉成什么样。

偏置 b：给变形补上「搬家」

大白话：W 只管又转又拉，b 负责把整张变形完的纸整体推到新位置。 正式定义：y = Wx + b，b 给每个输出一个可学习的基准偏移，W 的形状决定「几维变几维」。 最小例子：这就是全连接层的核心运算，神经网络里无处不在。

3. 亲手算一遍

用原文那个 W=[[2,1],[1,2]]，亲手把「一个单位正方形的四个角」搬一遍，看整个面怎么被改造。

输入：单位正方形四角 A=[0,0]、B=[1,0]、C=[1,1]、D=[0,1]，面积 = 1。 规则：新坐标 = W 乘旧坐标，即 [x,y] 变成 [2x+1y, 1x+2y]。

W = [ 2  1 ]
    [ 1  2 ]

• 第 1 步，A=[0,0]：2×0+1×0=0，1×0+2×0=0 → A′=[0,0]。
• 第 2 步，B=[1,0]：2×1+1×0=2，1×1+2×0=1 → B′=[2,1]。
• 第 3 步，C=[1,1]：2×1+1×1=3，1×1+2×1=3 → C′=[3,3]。
• 第 4 步，D=[0,1]：2×0+1×1=1，1×0+2×1=2 → D′=[1,2]。

四个新角按原顺序连起来，正方形变成了一个平行四边形。三件事值得盯住：原点 A 纹丝没动；四条边依旧是直的、对边依旧平行；而整块面积从 1 涨到了 3。这个 3 还能用行列式验一遍：det(W) = 2×2 − 1×1 = 4 − 1 = 3，正好是面积放大的倍数，和原文「面积从 1 涨到了 3」严丝合缝。

所以结论是：同一个 W 把整张坐标纸又拉又斜地整体改造了一遍，只盯住 î′=[2,1]、ĵ′=[1,2]（也就是 W 的两列）这两支箭头，就能预判所有点的去向。这个数说明什么？说明 Wx 不是搬一个孤零零的点，而是一次牵动全局的「空间变形」；而「直线仍直、平行仍平行、原点不动」正是「线性」二字的由来。再看旋转的例子：原文 R=[[0,−1],[1,0]] 把 [x,y] 变成 [−y,x]，右上角像素 (3,1) 跑到 (−1,3)，成千上万个像素同步照做，整张照片就转了 90°。想连「搬家」也做，就得在 Wx 后加 b，凑成 y=Wx+b：W 管旋转拉伸切变，b 管平移。

4. 一个类比就够了

把线性变换想成「拉伸一张印着方格纸的橡皮膜」：你捏住几个控制点一拉，膜上每一条格线都跟着一起变，横平竖直变成斜的、方格被压成菱形，但线始终是直的、间距始终均匀、你捏的那个原点不会跑。 哪里像：「同一条规则作用于所有点」「线保持直、平行保持平行」完全对得上，也解释了为什么正方形变成平行四边形。 哪里不像、别当真：真实神经网络是上千维空间，没有「橡皮膜」这种能看能摸的二维面；而且加了偏置 b 之后原点也会移动，就不再严格是「线性变换」（严格说是仿射变换）。类比只帮你建立「整体变形」这个画面，别把「原点绝不动」当成加了 b 之后还成立的铁律。

5. 五个常见误区

误区 1：矩阵乘法只是把一个点挪了个位置 → ❌ 停在「一个点」的故事，看不到全局。 → ✅ 正解：同一个 W 对空间每个点都搬一遍，是把整张坐标纸统一变形；单点的 [1,1]→[3,3] 只是其中一例。

误区 2：线性变换可以把整个空间平移（搬家） → ❌ 忘了「原点不动」这条硬规矩。 → ✅ 正解：Wx 永远把 [0,0] 送回 [0,0]，没法整体挪开；要平移必须在后面加偏置 b，凑成 Wx+b。

误区 3：变换后直线可能变成曲线、平行的线可能相交 → ❌ 把「非线性」的画风安到了线性头上。 → ✅ 正解：线性变换的定义就是「直线仍是直线、对边仍平行、间距仍均匀、原点不动」，正方形只能被送成平行四边形。

误区 4：「看列」是二维专属技巧，高维用不了 → ❌ 把「画得出两支箭头」误当成「规律只成立于二维」。 → ✅ 正解：二维有两列是因为有两个基向量；n 维有 n 个基向量、矩阵就有 n 列，第 k 列仍是第 k 根基向量的落点，道理一字不差，只是画不出来。

误区 5：网络叠很多层 Wx+b，表达能力就会一直变强 → ❌ 忽略了「线性叠线性还是线性」。 → ✅ 正解：原文把两层展开 W₂(W₁x+b₁)+b₂ = (W₂W₁)x + (W₂b₁+b₂)，合并后仍是一个矩阵加一个偏置，等价于一层；要突破天花板得靠层间的激活函数（第 8 课）。

6. 和前后课的接口

• 上一课（第 3 课）留下了：Wx 是「每行一次点积」的批量加权求和，以及 (m×n)×(n)=(m) 的维度规则。
• 这一课补上了：把 Wx 换成几何眼光——整空间统一变形、看列即懂变换，并补上偏置 b 得到每层核心式 y=Wx+b。
• 下一课（第 5 课）来解决：W 和 b 里这么多参数，预测错了该往哪个方向调、怎么让计算机自己找到答案——梯度。

7. 自测 6 题（附答案）

Q1 把一个矩阵乘到空间里所有向量上，几何上发生了什么？A 给每个数加个常数 B 把整个空间一起做旋转、拉伸、压缩、翻转等线性变换 C 把向量随机打乱 D 只改颜色不改位置。 答案：B｜解析：这正是本课核心。A 是加偏置 b 那种平移、且是「加」不是「乘」；C 无规律，和矩阵的统一规则相反；D 把几何变换当成贴图操作，完全无关。

Q2 「线性变换」必须满足哪条性质？A 原点会移到别处 B 直线可能变成曲线 C 保持直线仍直、原点不动、等比例叠加成立 D 只能放大不能缩小。 答案：C｜解析：C 是「线性」的定义。A 违反原点不动；B 是非线性的画风；D 错在「只能放大」，压缩（缩小）同样是线性变换，原文四类里就有它。

Q3（判断）W=[[2,1],[1,2]] 把点 [1,1] 搬到 [3,3]。 答案：对｜解析：2×1+1×1=3、1×1+2×1=3，与原文图 4-1 一致；这也是四个角里 C 的落点 C′。

Q4 亲手算 D=[0,1] 被同一个 W 搬到哪？A [0,0] B [2,1] C [3,3] D [1,2]。 答案：D｜解析：2×0+1×1=1、1×0+2×1=2，得 [1,2]。A 是 A′、B 是 B′、C 是 C′，都是把别的角张冠李戴。

Q5 那个单位正方形被 W 变形后，面积从 1 变成多少？A 1 B 2 C 3 D 4。 答案：C｜解析：原文明确「面积从 1 涨到了 3」，行列式 2×2−1×1=3 也印证。A 是没变、B 和 D 无依据；面积放大倍数正是行列式的几何含义。

Q6（判断）把两层 Wx+b 接起来，结果和一层 Wx+b 完全等价，所以纯线性网络叠再深也画不出圆形分界。 答案：对｜解析：W₂(W₁x+b₁)+b₂ 可合并成 (W₂W₁)x+(W₂b₁+b₂)，仍是单个矩阵加单个偏置，逃不出「直线 / 超平面」分界；要圈出圆形区域必须引入非线性激活函数。

8. 一页速记

• Wx 不是搬一个点，是对整个空间做一次统一变形。
• 变换保持「线还是线、平行还是平行、原点不动」，故名线性。
• 读懂矩阵只需看列：每列是一个基向量的落点，n 维有 n 列。
• 旋转矩阵 R=[[0,−1],[1,0]] 把 (x,y) 变成 (−y,x)，即转 90°。
• 线性叠线性还是线性，要表达力得等激活函数（第 8 课）。

一句话：把「蒙眼下山时脚底最陡方向」翻译成数学，让计算机能靠 w ← w − α∇L 自己把参数调对。

难度：★★★　　预计：约 15 分钟

原文：第 5 课 · 什么是梯度

0. 先记住这三句

• 梯度是「蒙眼下山时脚底最陡方向」的数学版本：一维是导数，多维是把各方向偏导数打包成一个向量。
• 梯度指向上升最快的方向，下山要朝它的反方向走：x_new ← x − α∇h。
• 训练就是一次超大规模下山：山高是损失，坐标是全部参数，一步把上千亿个参数推向更低的损失。

1. 这一课在补哪个洞

前面把机器造出来了：向量、矩阵、Wx+b 都能算，可致命问题悬着——W 和 b 里那么多参数谁来确定？第 4 课已点明，靠人手工调几百万个旋钮不现实。如果网络预测错了，却不知道每个参数该往哪挪、挪多少，这台机器就永远「不会学」，只是堆写死的公式。这一课补的正是这个洞：借「蒙眼站在山坡上、靠脚底感觉摸到谷底」这个人人都懂的办法，把「感受坡度」翻译成计算机能算的数学，依次经过导数、偏导数、方向导数，收束成梯度。有了它，参数调整才从「瞎猜」变成「有方向的自动更新」，第 12 课梯度下降、第 13 课反向传播都是它的工程展开。

2. 概念逐层拆

导数：曲线在一点的斜率

大白话：山坡太复杂，先退远看成一条曲线；导数就是「脚下这点有多陡、往哪边下坡」的一个数。 正式定义：h′(x₀) = lim(Δx→0) [h(x₀+Δx) − h(x₀)] / Δx，割线斜率取极限即切线斜率。 最小例子：原文 h(x)=(x−4)² 不套公式、从定义推出 h′(x)=2(x−4)；x=1 处 h′(1)=2(1−4)=−6，负号说往右下坡、大小 6 说坡挺陡。

偏导数：山其实是二维的

大白话：真实地面能往东西也能往南北走；偏导数是「只动一个方向、其余按住」量出的坡度。 正式定义：用圆头 ∂ 记，求 ∂h/∂x 时把 y 当常数。 最小例子：碗 h(x,y)=(x−4)²+(y−2)² 的两个偏导是 2(x−4) 与 2(y−2)。

方向导数：朝任意方向看坡度

大白话：下山会朝任意角度探脚，那个方向的坡度就是方向导数。 正式定义：方向写成单位向量 u，D_u h = (∂h/∂x)u₁ + (∂h/∂y)u₂，即「坡度向量与 u 的点积」。 最小例子：(1,5) 处坡度向量 (−6,+6)，朝正东 u=(1,0) 的坡度 = −6，是下坡。

梯度：最陡方向，打包成一个向量

大白话：把各方向坡度装进一个向量，它直接告诉你「哪边最陡、有多陡」。 正式定义：∇h = (∂h/∂x, ∂h/∂y)，指向上升最快，模长即最大坡度。 最小例子：(1,5) 处 ∇h=(−6,+6) 指向西偏北；下山走反方向 (+6,−6) 即东偏南，正对碗底 (4,2)。

3. 亲手算一遍

用原文那个「碗」h(x,y)=(x−4)²+(y−2)²，站在 (1,5)，亲手把下坡方向算出来。

• 第 1 步，一维导数。对 h(x)=(x−4)² 套极限：h′(x) = lim [2(x−4)Δx + (Δx)²]/Δx = lim [2(x−4)+Δx] = 2(x−4)。代 x=1 得 h′(1) = −6：负号说往右是下坡，大小 6 说坡陡，与原文图 5-3「切线斜率 −6.00」对得上。
• 第 2 步，二维偏导。∂h/∂x=2(x−4)、∂h/∂y=2(y−2)；代 (1,5)：∂h/∂x=2(1−4)=−6（往东下坡），∂h/∂y=2(5−2)=+6（导数为正 → 往北上坡、往南下坡）。
• 第 3 步，打包成梯度 ∇h=(−6,+6)，模长 √((−6)²+6²)=√72≈8.49，是这点可能的最陡坡度。
• 第 4 步，用方向导数验证最陡。取「东偏南」单位向量 u=(1/√2, −1/√2)≈(0.707, −0.707)：D_u h=(−6)(0.707)+(6)(−0.707)=−4.24−4.24=−8.49，负号是下坡，绝对值正好等于梯度模长，全场下降最快。

所以结论是：在 (1,5) 处梯度 ∇h=(−6,+6) 指向西偏北（上升最陡），下山该朝反方向 (+6,−6) 即东偏南走，那里坡度 −8.49、下降最快，恰好对准碗底 (4,2)。这个数说明什么？「蒙眼探一圈找最陡方向」这件靠感觉的事，被梯度一次计算精确给出、无需逐个方向试探——因为方向导数就是「坡度向量在 u 上的投影」，u 与梯度同向时投影最长。换回 AI：山高换成损失 L、坐标换成上千亿个参数 w，公式变成 w ← w − α∇L(w)，一步把全部参数朝损失更小推过去，这就是训练的核心引擎。

4. 一个类比就够了

把训练想成「蒙着眼睛下山」：看不见谷底，只能靠脚底探出最陡下坡，迈一小步、再探、再迈，迟早走到四面都是上坡的谷底。 哪里像：「只看脚下局部」「每步朝最陡下坡」「步子小、要重复」全对得上，x_new ← x − α∇h 里的 α 就是迈多大步。 哪里不像、别当真：真实损失地形上千亿维，有无数小水洼（局部极小）、平地（鞍点），梯度下降可能卡住；而且人探坡靠触觉，梯度是导数精确算的、毫无感觉成分。类比只帮你建立「局部最陡 + 小步迭代」这个画面。

5. 五个常见误区

误区 1：梯度指向谷底，顺着走就能下山 → ❌ 把「上升最快」记反成「下降最快」。 → ✅ 正解：梯度指向上升最陡，下山走 −∇h，公式里那个减号就是这么来的。

误区 2：导数是覆盖所有点的一整个函数 → ❌ 把「某点导数」和「导函数」混为一谈。 → ✅ 正解：h′(1)=−6 是一个数；h′(x)=2(x−4) 才是导函数，把具体 x 代进去才得到那点的数。

误区 3：梯度为零一定是走到了谷底 → ❌ 以为「平坦」只有谷底一种。 → ✅ 正解：只说明到了平坦处，可能是极小值、极大值或鞍点，得结合其它信息判断。

误区 4：偏导数和方向导数要分别硬算 → ❌ 以为每个方向都得重新实测。 → ✅ 正解：任意方向坡度 = 梯度与该方向的点积（投影），有两个偏导数就够。

误区 5：梯度是本课凭空新造的复杂运算 → ❌ 被 ∇ 符号唬住。 → ✅ 正解：它只是把几个偏导数「装进一个向量」的打包动作，真功夫在求偏导，打包后方向与大小两个含义才一起浮现。

6. 和前后课的接口

• 上一课（第 4 课）留下了：每层 Wx+b 都会算，可几百万个参数「预测错了该往哪调」仍无解。
• 这一课补上了：把「找最陡下坡」翻译成梯度，给出 w ← w − α∇L 这条自动更新全部参数的公式。
• 下一课（第 6 课）来解决：「预测错得多离谱」怎么量化成一个能求导的数——概率、信息量与交叉熵。

7. 自测 6 题（附答案）

Q1 蒙眼下山想尽快到谷底，梯度扮演什么角色？A 直接指向谷底最低点 B 指向最陡上坡、下山要朝反方向走 C 表示当前海拔 D 表示已走步数。 答案：B｜解析：梯度指向上升最快，下山走 −∇h。A 错在梯度只给局部最陡方向、不标谷底坐标；C 是函数值 h；D 是迭代次数，都无关。

Q2 一个点的梯度接近零向量，通常意味着？A 上升最快 B 到了平坦处，如极小、极大或鞍点 C 计算出错了 D 学习率太大。 答案：B｜解析：梯度为零即各方向坡度都是 0，是平坦点，正是原文 Q2 正解。A 与梯度为零相反；C 无据；D 学习率是步长 α，与此点地形无关。

Q3（判断）对 h(x)=(x−4)² 套极限定义可推出 h′(x)=2(x−4)，代 x=1 得 −6。 答案：对｜解析：展开 [(x+Δx−4)²−(x−4)²]/Δx = 2(x−4)+Δx，令 Δx→0 得 2(x−4)；代入 1 即 2(−3)=−6，与原文图 5-4 一致。

Q4 在 (1,5) 处两个偏导数分别是？A (−6, +6) B (+6, −6) C (0, 0) D (−6, −6)。 答案：A｜解析：∂h/∂x=2(1−4)=−6、∂h/∂y=2(5−2)=+6。B 是下山方向 −∇h；C 是碗底 (4,2) 才有；D 把南北项符号算反。

Q5 方向导数 D_u h 本质上是什么？A 一个新的偏导数 B 梯度与方向 u 的点积（投影） C 二阶导 D 向量长度。 答案：B｜解析：原文明确 D_u h=(∂h/∂x)u₁+(∂h/∂y)u₂=∇h·u，是点积即投影。A、C、D 都把它误认成别的量；正因是投影，u 与梯度同向时才最长最陡。

Q6（判断）w ← w − α∇L(w) 一次更新，就把上千亿个参数全部朝损失更小推了一步。 答案：对｜解析：山高换成损失 L、坐标换成全部参数 w，梯度 ∇L 对每个参数都有偏导，一次更新同步作用于所有参数，与二维情形道理一字不差。

8. 一页速记

• 一维是导数，多维先对每根轴求偏导，再打包成梯度。
• 梯度指向上升最陡；下山走 −∇h，α 是步长。
• 方向导数 = 梯度在方向上的投影，故同向时最陡。
• 训练 = 上千亿维的蒙眼下山，第 12、13 课讲坑与算法。

一句话：把「模型输出的一组数」和「猜词错得多离谱」接起来——从概率分布、信息量、熵，一路长出交叉熵损失。

难度：★★☆　　预计：约 15 分钟

原文：第 6 课 · 概率与信息

0. 先记住这三句

• 概率分布是「所有可能结果各占多少」的完整描述：每个数非负、加和正好 = 1，这正是模型输出被叫做「概率」的原因。
• 信息量 I = −log p 刻画一个结果有多意外；熵是整个分布的平均意外，交叉熵是「拿模型分布 q 面对真实分布 p」平均有多意外。
• 真实答案确定（独热）时，交叉熵塌缩成 −log(模型给正确答案的概率)，天生就是「错得多离谱」的打分器。

1. 这一课在补哪个洞

第 5 课给出了 w ← w − α∇L，可前提一直没落地：这个 L（损失，「预测错得多离谱」）怎么算成一个能求导的具体数？只会说「错了」，计算机没法求梯度、参数还是调不动。另一头，语言模型输入「今天天气很」后给每个候选词打分，这堆分数为什么叫「概率」、又怎么和正确答案对上？这一课补的正是这个洞：从「70% 降雨」这种长期频率讲起，把概率、概率分布、信息量、熵一层层搭起来，最后推出交叉熵——它不是谁拍脑袋规定的，而是「拿模型地图去赌真实世界」时信息论自然长出来的结果。有了它，第 10 课才能正式把「预测下一个词」定成训练目标。

2. 概念逐层拆

概率与概率分布

大白话：「明天降雨 70%」不是当天下 0.7 场雨，而是「气象相似的一堆日子里约七成下了雨」；所有候选各占多少的完整清单就是概率分布。 正式定义：概率是事件的长期占比；分布对每个结果给 ≥0 的数，全部加和 = 1。 最小例子：掷 1000 次骰子，3 出现 168 次，就说「3 的概率约 0.168」。

信息量：越意外的消息越「值钱」

大白话：「太阳东升」等于没说，「老板中五百万」让人瞪大眼——越罕见一旦成真，信息越多。 正式定义：I(x) = −log p(x)；用 −log 是因为它把「两独立消息的概率相乘」变成「信息量相加」，以 2 为底单位是比特（bit），自然对数是奈特（nat）。 最小例子：p=1 时 I=−log1=0；p=0.5 时 I=−log0.5=1 比特；p=0.001 时 I≈10 比特。

熵：整个分布平均有多难猜

大白话：把每个结果的意外程度按它自己的概率加权平均，得到「整体有多难预测」。 正式定义：H(p) = −Σ p(x) log p(x)；分布越均匀熵越高，某结果概率为 1 时熵 = 0。 最小例子：公平硬币最难猜、熵最大；灌铅硬币九成正面、熵很小；确定性分布 H = −1×log1 = 0。

交叉熵：拿一张可能画错的地图去赌真实世界

大白话：熵量「真实世界本身多难猜」，可 AI 手里只有模型画的地图 q，它未必准；拿它面对真实答案平均有多意外，就是交叉熵。 正式定义：H(p,q) = −Σ p(x) log q(x)，用真实分布 p 加权、用模型分布 q 给意外程度。 最小例子：猜词真实答案是「猫」，写成独热 p(猫)=1、其它全 0；模型给 q(猫)=0.7、q(狗)=0.2、q(鸟)=0.1。

3. 亲手算一遍

用原文那组「猜下一个词」的数字，亲手把交叉熵从求和式算成最终损失值。

输入：

真实分布 p（独热）：p(猫)=1, p(狗)=0, p(鸟)=0
模型预测 q：      q(猫)=0.7, q(狗)=0.2, q(鸟)=0.1
公式：H(p,q) = −Σ p(x) log q(x)   （用自然对数，单位 nat）

• 第 1 步，展开求和：H = −[ p(猫)log q(猫) + p(狗)log q(狗) + p(鸟)log q(鸟) ]。
• 第 2 步，代进独热 p：H = −[ 1×log0.7 + 0×log0.2 + 0×log0.1 ]。狗、鸟两项被 p=0 抹掉，只剩「猫」活着。
• 第 3 步，算剩下那项：ln 0.7 ≈ −0.3567，故 H = −1×(−0.3567) ≈ 0.36，与原文 −log0.7 ≈ 0.36 一致。
• 第 4 步，换个没信心的模型再算：若把正确答案压到 q(猫)=0.1，则 H = −ln0.1 ≈ 2.30；若自信给 q(猫)=0.99，则 H = −ln0.99 ≈ 0.01。

所以结论是：当真实答案是独热分布时，交叉熵塌缩成干净的一句 H(p,q) = −log(模型给正确答案的概率)，原文这组数算出来就是 −log0.7 ≈ 0.36。这个数说明什么？它是天生的「错得多离谱」打分器：模型越自信答对（q 越接近 1），−log q 越接近 0；越把正确答案概率压低（q 越接近 0），−log q 越往上飙、纠偏信号越猛——回想第 5 课，错得越离谱坡度越陡，网络回头才越快。所以「预测下一个词」的损失才该用交叉熵而非温和的平方差；把任意实数挤成概率分布是第 11 课 Softmax 的活，交叉熵 ≥ 熵、多出那截叫 KL 散度，衡量 q 离 p 有多远。

4. 一个类比就够了

把熵想成「猜谜的难度」：公平硬币正反完全没线索，最难猜、熵最高；灌铅硬币九成正面，闭眼猜正就对、熵很低。 哪里像：「每个结果按概率加权、平均有多意外」对应 H(p)=−Σp log p，也解释了均匀熵最大、确定熵为 0。 哪里不像、别当真：真实词表有几万个词、概率分布是高维的，不是两面的硬币；且交叉熵里的 q 是模型以为的分布，不是真实世界，混同就会把熵和交叉熵搞成一回事。类比只帮你抓住「越均匀越难猜」。

5. 五个常见误区

误区 1：「降雨 70%」是当天下七成、或对单日的承诺 → ❌ 把长期频率当成单次比例。 → ✅ 正解：它描述「气象相似的一堆日子里约七成下了雨」，概率是重复很多次后某结果的占比。

误区 2：那组数很小又加起来是 1，所以叫概率 → ❌ 「数字小」根本不是理由。 → ✅ 正解：关键是满足两条铁律——每个 ≥0、加和 = 1，这才配叫概率分布，正是原文 Q1 正解。

误区 3：信息量用 1 − p 就行，何必 −log → ❌ 只顾「概率越小值越大」，漏了可加性。 → ✅ 正解：两独立消息的信息量该直接相加，log 恰好把「概率相乘」变成「信息相加」，1 − p 做不到。

误区 4：熵越大，说明越有规律、越好预测 → ❌ 把「平均意外」的方向记反。 → ✅ 正解：熵越大越难猜，某结果概率为 1 时反而 H=0；真实语言熵不高不低，才既非送分题也非无解题。

误区 5：交叉熵和熵是同一个东西，可随便换用 → ❌ 没分清「真实世界多难猜」和「拿模型地图去赌多意外」。 → ✅ 正解：熵用 p 加权 p，交叉熵用 p 加权 q；交叉熵永远 ≥ 熵，多出部分是 KL 散度。

6. 和前后课的接口

• 上一课（第 5 课）留下了：w ← w − α∇L 更新公式，但「损失 L 怎么算成能求导的数」还空着。
• 这一课补上了：概率分布、信息量、熵、交叉熵，证明 −log(正确答案概率) 天生就是分类任务的损失打分器。
• 下一课（第 7 课）来解决：把卷一四件工具（向量、矩阵、梯度、概率）用神经元串成一台会判断、会学习的机器。

7. 自测 6 题（附答案）

Q1 分类时输出一组「加和等于 1 的非负数」，为什么解释为「概率」？A 因为数字比较小 B 因为满足概率基本要求：非负且总和为 1 C 因为是整数 D 因为一定大于 0.5。 答案：B｜解析：B 是原文 Q1 正解。A 错在「小」不是理由，0.99 照样是概率；C 错在输出是小数；D 错在概率可远小于 0.5（如 0.02），无此限制。

Q2 交叉熵损失衡量什么、何时最小？A 预测分布与真实分布的差距，越贴近真实答案越小 B 参数总量，越少越小 C 训练数据量，越多越小 D 输出向量长度，越短越小。 答案：A｜解析：交叉熵 = −Σ p log q，q 越贴近真实答案、给正确词的概率越接近 1，值越接近 0，是原文 Q2 正解。B、C、D 分别把损失误当成参数个数、数据量、向量长度。

Q3（判断）p=1 时信息量 I=−log1=0，p=0.001 时约 10 比特。 答案：对｜解析：必然发生零信息；−log₂0.001≈9.97≈10 比特，与原文图 6-2 三个极端值一致。

Q4 分布 A（下雨 0.9、晴 0.1）与 B（各 0.5），哪个熵更高、更难预测？A A B B C 一样 D 无法比。 答案：B｜解析：B 均匀、最没头绪，熵最大；A 九成下雨、几乎闭眼能猜对，熵很小。用 H=−Σp ln p 验：B≈0.693，A≈0.325，正对应原文第 3 站末尾的思考题。

Q5 真实答案「猫」（独热），q(猫)=0.7、q(狗)=0.2、q(鸟)=0.1，交叉熵约？A 0.36 B 1.61 C 2.30 D 0.7。 答案：A｜解析：求和里只有「猫」项活下来，−ln0.7≈0.36。B 是 −ln0.2、C 是 −ln0.1，拿错了概率；D 直接把 q 值当损失，忘了取 −log。

Q6（判断）交叉熵永远 ≥ 熵，多出部分叫 KL 散度，衡量模型分布 q 与真实分布 p 差多远。 答案：对｜解析：这是原文「两个补充直觉」第①条；q 越贴近 p，这段差距越小，交叉熵越逼近真实世界本身的熵、再也省不掉。

8. 一页速记

• 模型输出叫概率，是因为每个 ≥0、总和 = 1。
• 用 −log 而非 1−p，为让两独立消息的信息量可相加。
• 独热答案让交叉熵塌缩成 −log(正确答案概率)。
• 第 10、11 课分别讲损失目标与 Softmax。

一句话：把「猜水果」的加权判断写成 z = w·x + b，再经激活函数输出概率——这就是深度学习最小的零件「神经元」。

难度：★★☆　　预计：约 15 分钟

原文：第 7 课 · 神经元结构

0. 先记住这三句

• 神经元就是「各输入各乘权重 → 求和 → 加偏置 → 用 σ 压成 0~1 概率」，z = w·x + b，y = σ(z)；w·x 正是第 2 课的点积。
• 权重 w 控制每个输入说话多大声，偏置 b 是可调的「门槛」，两者都能从数据里学出来。
• 单个神经元只能用一条直线把空间切两半，连 XOR 都搞不定；多神经元 + softmax 才是一层，多层串起来才有表达力。

1. 这一课在补哪个洞

卷一把四件工具备齐了：向量拍数字照片，点积量「像不像」，矩阵做空间变换，梯度指出下坡方向，概率把输出变成可解释的分数。可工具终究是零件，还缺一台「会做判断」的整机。没有神经元这个最小判断单元，你就只能停在手工比较四条线索——像原文那样凭直觉给「颜色」权重 2.8、「酸甜」1.6，再把门槛挪到 2.4，一台机器尚且调得过来，成千上万个旋钮就彻底没戏。这一课补的洞是：把「又红又甜最像苹果，所以颜色和酸甜分量重」这套模糊直觉，精确写成可计算、参数还能自动学的小装置。它就是大名鼎鼎的神经元，也是把前面四课串起来的那根线。

2. 概念逐层拆

输入特征：给线索打分

大白话：把「个头、颜色、酸甜、水分」各换成 0 到 1 的一个数，机器才读得懂。 正式定义：输入向量 x = [x₁, x₂, x₃, x₄]，每个分量是一个特征。 最小例子：原文藏的水果，四条线索是尺寸 0.5、颜色 0.9、酸甜 0.7、水分 0.55。

权重与偏置：谁重要、门槛在哪

大白话：权重像「评委的话语权」，偏置像「及格线」——重要线索给大权重，最后减一道门槛决定算不算数。 正式定义：z = w₁x₁ + w₂x₂ + w₃x₃ + w₄x₄ + b = w·x + b；w 控制影响力，b 平移激活门槛。 最小例子：原文 苹果分 = 0.4×大小 + 2.8×红 + 1.6×甜 + 0.4×水分 − 2.4，−2.4 就是偏置，颜色和酸甜权重最大。

激活函数与输出：把分数压成概率

大白话：加权总分可能是 4.06 也可能是 −1.34，不好直接当答案，得压成 0 到 1 读成「是苹果的概率」。 正式定义：y = σ(z)，σ 是激活函数（下一课详讲），y 越接近 1 越确信「是」。 最小例子：原文互动里 z = 0.4×0.5 + 2.8×0.5 + 1.6×0.5 + 0.4×0.5 − 2.4 = 0.20，经 σ 得「苹果 55%」。

一层与深度：并排、再串起来

大白话：给每种水果各配一个神经元并排站，就是一层；前一层输出当后一层输入，串起来就是深度网络。 正式定义：一层 = 多个神经元共享输入，各算 σ(Wx+b)；多层串联能组合出弯曲的边界。 最小例子：四种水果各一个神经元，softmax 把四个分数挤成 36%、27%、13%、24%（合计 100%）；GPT-3 隐藏层 12288 维、96 层，每个神经元仍是这个简单公式。

3. 亲手算一遍

用原文那台「猜苹果」机器，亲手把「是不是苹果」从头算到尾。

输入与写死的权重、门槛：

权重 w = [0.4, 2.8, 1.6, 0.4]   // 大小、红、甜、水分
偏置 b = −2.4                    // 「多少分才算苹果」的门槛
苹果线索   x = [0.5, 0.9, 0.7, 0.55]
青果子线索 x = [0.3, 0.15, 0.2, 0.5]
规则：z = w·x + b；z > 0 判「是苹果」，z < 0 判「不是」

• 第 1 步，苹果加权和：0.4×0.5 + 2.8×0.9 + 1.6×0.7 + 0.4×0.55 = 0.20 + 2.52 + 1.12 + 0.22 = 4.06。
• 第 2 步，加偏置：z = 4.06 − 2.4 = +1.66 > 0 → 判「是苹果」。
• 第 3 步，青果子加权和：0.4×0.3 + 2.8×0.15 + 1.6×0.2 + 0.4×0.5 = 0.12 + 0.42 + 0.32 + 0.20 = 1.06。
• 第 4 步，加偏置：z = 1.06 − 2.4 = −1.34 < 0 → 判「不是苹果」。

所以结论是：这套「加权求和 + 偏置、再看正负」的装置，把「中等大、又红又甜」判成苹果（+1.66），把「又小又绿又酸」的青果子判成不是（−1.34），与直觉一致，全部数字和原文 4.06 / 1.06 / +1.66 / −1.34 严丝合缝。这个数说明什么？第一，权重真在起作用：颜色 2.8、酸甜 1.6 是大头，「红、甜」一拉高总分就从 1.06 蹦到 4.06；第二，偏置 −2.4 不是装饰，没有它你只知道「4.06 算高吗」，有了它判断才统一成「大于 0 就是」。而 w·x 正是第 2 课点积、一排摞成表就是第 4 课 Wx+b——早学过的运算换了个名字叫「神经元」。w 和 b 此刻写死，第 12 课梯度下降会让机器自己学出来。

4. 一个类比就够了

把神经元想成「一场加权投票」：四位评委各有一票，但话语权不同——颜色和酸甜是资深评委、票重（2.8、1.6），大小和水分是实习生、票轻（0.4）；计票后还要过及格线（偏置 −2.4），过线才算通过。 哪里像：「各乘权重再求和」「偏置当门槛」「输出 yes/no 或概率」完全对应公式。 哪里不像、别当真：真实神经元没有有主观意见的「评委」，权重只是可正可负的数字；投票是一次性静态的，网络里却是成千上万个神经元层层传递、参数被梯度反复改写。类比只帮你记住「加权 + 门槛」。

5. 五个常见误区

误区 1：神经元是把所有输入直接相加 → ❌ 漏了「各乘一个权重」这关键一步。 → ✅ 正解：是「加权求和，再加偏置，送入激活函数」，原文 Q1 正解；直接相加等于把所有权重设成 1。

误区 2：偏置 b 决定每个输入的重要性 → ❌ 把偏置和权重作用对调。 → ✅ 正解：权重 w 控制各输入影响力；偏置 b 是平移门槛的常数，与单个输入无关，原文 Q2 也考了这点。

误区 3：偏置没实际作用、可随手去掉 → ❌ 以为「减 2.4」只是书写习惯。 → ✅ 正解：去掉它只剩「4.06 算高吗」的悬案；正是 b 把判断统一成「z > 0 就是」，且它和 w 一样要学。

误区 4：有了 σ，单个神经元就能画弯曲边界 → ❌ 指望 σ 把直线掰弯。 → ✅ 正解：σ 单调，σ(z)=0.5 仍是 z=0 那条直线，只把分数压成概率、不改分界形状；一特征 → 直线，两特征 → 平面，n 特征 → 超平面，永远平。

误区 5：一个神经元什么分类都学得会 → ❌ 忽略「只能切一刀」的硬上限。 → ✅ 正解：线性可分时学得会，交错排列就没辙——经典反例 XOR：(0,0)否、(1,0)是、(0,1)是、(1,1)否，没直线分得开；好苹果「个头要适中」也框不住中间一段。

6. 和前后课的接口

• 上一课（第 6 课）留下了：概率、交叉熵这套输出与打分工具，但还没有用起来的最小判断单元。
• 这一课补上了：神经元 z = w·x + b 经 σ 输出概率，把卷一四件工具串成零件，并点明「单个神经元只能画直线」的极限。
• 下一课（第 8 课）来解决：被一笔带过的 σ 到底是什么、为什么非有它不可——用激活函数引入「弯折」，打破「多层等于一层」。

7. 自测 6 题（附答案）

Q1 最基础的人工神经元对输入做了什么计算？A 直接相加 B 加权求和、再加偏置，送入激活函数 C 取最大值 D 随机丢弃一半。 答案：B｜解析：B 是 y=σ(w·x+b) 的直白说法。A 漏了权重偏置；C 是「最大池化」那类操作；D 是 dropout 训练技巧，都不是神经元本职。

Q2 神经元里「偏置 b」起什么作用？A 决定每个输入的重要性 B 平移激活门槛，让神经元更易或更难被触发 C 把输出限制在 0 到 1 D 没作用、可去掉。 答案：B｜解析：B 是原文 Q2 正解。A 是权重 w 的活；C 是激活函数 σ 的活；D 错在忽略「没门槛就无法判定 z 正负」，且 b 是可学习参数。

Q3（判断）苹果线索 [0.5, 0.9, 0.7, 0.55] 代入权重 [0.4, 2.8, 1.6, 0.4] 的加权和是 4.06。 答案：对｜解析：0.20+2.52+1.12+0.22=4.06，与原文一致；颜色 2.8×0.9=2.52 与酸甜 1.6×0.7=1.12 贡献最大，印证「红、甜分量重」。

Q4 减掉门槛 2.4 后，青果子的 z 与判断是？A +1.66，是苹果 B −1.34，不是 C 1.06，无法判断 D 0，正好在边界。 答案：B｜解析：青果子加权和 1.06，减 2.4 得 −1.34 < 0，判「不是」。A 是苹果的 z；C 忘了减门槛；D 无据，两数都离 0 很远。

Q5 单个神经元为什么解决不了 XOR？A 参数太少 B 没激活函数 C 判定边界永远是直线 / 超平面，而 XOR 两类点交错 D 输入维度太高。 答案：C｜解析：z=w·x+b>0 的分界 w·x+b=0 永远直；(0,0)、(1,1) 为否、(1,0)、(0,1) 为是，两条对角线交错，没直线分得开。A、D 不是根因；B 错在即便加 σ，σ(z)=0.5 仍是 z=0 那条直线。

Q6（判断）给四种水果各配一个神经元、再用 softmax 把分数变成 36%、27%、13%、24%，这就是「一层」网络。 答案：对｜解析：一排并列神经元共享同一组输入、各算各的分数，经 softmax 挤成合计 100% 的概率分布，正是一层；多层串起来就是深度网络。

8. 一页速记

• w·x 是第 2 课点积，一排摞成表是第 4 课 Wx+b。
• w、b 都从数据里学，第 12 课梯度下降负责学出来。
• 单个神经元只能画直线，搞不定 XOR 与「中间一段」。
• GPT-3 隐藏层 12288 维、96 层，每个神经元仍是这个简单公式。

一句话：给每层 Wx+b 后面加一道「非线性弯折」，打破「一百层直线叠起来还是一层」的魔咒，让层数真正变成表达能力。

难度：★★☆　　预计：约 15 分钟

原文：第 8 课 · 激活函数

0. 先记住这三句

• 纯线性网络叠多少层都等价于一层 W′x+b′，边界永远是直的；要打破它，必须在层间插入非线性激活函数。
• 激活函数要既「能弯」又「够灵敏」：阶跃太死板、Sigmoid 两端饱和迟钝，ReLU 靠 max(0,z) 在正区间永远灵敏。
• 有了激活函数，两层就能托出「中间一段」这种单个神经元画不出的区域；层数越多，能折出的形状越复杂。

1. 这一课在补哪个洞

第 4 课证过「线性叠线性还是线性」，第 7 课那台猜水果机又卡在「单个神经元只能切一条直线」。这两堵其实是同一堵墙：输出端把总分压成概率的 σ，被一笔带过、从没正面解释。不拆掉它，网络就算堆一百层，本质上也只是 W′x+b′ 一层，能画的永远只是一条直线——连「好苹果个头要适中、太小太大都不行」这种「中间一段」都框不住，更别说圆形、月牙这类真实问题普遍存在的非线性结构。这一课补的洞是：给每层 Wx+b 之后加一道非线性函数，给网络添一次「弯折」机会，让「多层 = 一层」的魔咒失效。顺带把常见的几种弯折器（阶跃、Sigmoid、tanh、ReLU 及改良版）一一认全。

2. 概念逐层拆

激活函数：层与层之间的一道弯折

大白话：像把一张平整的纸「折」一道，折过之后原本一条直线分不开的两类点，就能被叠进同一侧或圈进不同区域。 正式定义：紧跟在每层 Wx+b 之后的非线性函数，打破「线性叠加可合并」，让每层真正增加表达力。 最小例子：原文把两台水果神经元接起来、中间不放激活时 y = W₂(W₁x+b₁)+b₂ = (W₂W₁)x+(W₂b₁+b₂) = W′x+b′，两层塌回一层。

阶跃与 Sigmoid：从「硬」到「软」的弯

大白话：阶跃像非黑即白的开关，过线就亮；Sigmoid 把它磨成平滑的 S 曲线，能细腻地调。 正式定义：阶跃 z<0 输出 0、z≥0 输出 1；Sigmoid σ(z) = 1/(1+e^(−z))，输出 0~1、正好能当概率读。 最小例子：原文互动里 z=0.20 时 Sigmoid(0.20)≈0.55、斜率≈0.25；但 z 拉到 10 或 −10 时输出贴死 1 或 0，进入饱和区、变得迟钝。

tanh：以 0 为中心的近亲

大白话：和 Sigmoid 一样是 S 曲线，只把输出从 0~1 挪到 −1~1，让每层输出有正有负、更均衡。 正式定义：tanh(z) = (e^z − e^(−z)) / (e^z + e^(−z))，输出 −1~1、以 0 为中心。 最小例子：正因「以 0 为中心」，同样 S 形的 tanh 往往比 Sigmoid 更好训练；但两端一样会压平、饱和迟钝。

ReLU 与改良版：又简单又好用

大白话：正数原样放过、负数全部归零，像一道干脆的闸门，正区间永远灵敏。 正式定义：ReLU(z) = max(0, z)，正区间导数恒为 1；LeakyReLU 给负区间留微斜坡，GELU 把 0 附近磨成平滑过渡。 最小例子：2012 年 AlexNet 用 ReLU 替代 Sigmoid、在 ImageNet 上引发深度学习革命；ResNet、BERT、GPT 隐藏层默认用 ReLU 或其变体，GELU 是 Transformer 标配。

3. 亲手算一遍

用原文第 5 站「中间一段」的例子，亲手证明「两层带激活能做出单个神经元做不到的事」。

任务：好苹果合格区间 0.4 ≤ x ≤ 0.7（太小太大都不是），只用「个头大小 x」。设计两层、中间放阶跃：

第一层  h1 = 阶跃(x − 0.4)   // 够大了吗？过了 0.4 就亮 = 1
        h2 = 阶跃(x − 0.7)   // 太大了吗？过了 0.7 也亮 = 1
第二层  y  = h1 − h2          // 够大、但还没太大，才判「是」

阶跃规则：括号 ≥ 0 输出 1，< 0 输出 0。代三个数（对应第 7 课图 7-4 三类样本）：

• 第 1 步，太小 x=0.2：h1=阶跃(−0.2)=0，h2=阶跃(−0.5)=0，y=0−0=0 → 不是 ✓。
• 第 2 步，适中 x=0.55：h1=阶跃(0.15)=1，h2=阶跃(−0.15)=0，y=1−0=1 → 是苹果 ✓。
• 第 3 步，太大 x=0.85：h1=阶跃(0.45)=1，h2=阶跃(0.15)=1，y=1−1=0 → 不是 ✓。

• 第 4 步，对照：若中间不放激活，直接把两条直线相减，y=(x−0.4)−(x−0.7)=0.3，是个常数——两层又塌回一层，正是开篇证过的「多层 = 一层」。

所以结论是：只有中间那道阶跃把两条直线各「折」成 0/1 台阶，第二层一相减才凭空托起 0.4~0.7 这「中间一段」；0.2、0.55、0.85 分别得到 0、1、0，与原文完全一致。这个数说明什么？激活函数才是「层数变成表达能力」的关键开关：单个神经元 z=wx+b 只有一个分界点，切不出「在某两段之间」；而「线性变换 + 一次弯折」每多一层就多一次折纸机会，圆、月牙、任意复杂边界都能这样折拼出来。开篇那道天花板，到此顶开。

4. 一个类比就够了

把激活函数想成「折纸」：线性变换只能把一张纸拉伸、旋转、平移，纸始终平、直线怎么变都还是直线；非线性像在纸上「折」一道弯，折过几次，原本被一条直线死死分开的两类点就能叠进同一侧或圈进不同区域。 哪里像：「每加一层线性变换 + 一次弯折，就多一次折纸机会、形状越复杂」完全对得上，也解释了为什么两层能托出「中间一段」。 哪里不像、别当真：真实网络是在上千维空间做逐元素数值函数，没有「纸」「折痕」这种几何实体；而且 ReLU 的「折」只是把负数归零，并非真的把空间对折。类比只帮你建立「线性平、非线性弯」这个画面。

5. 五个常见误区

误区 1：层数堆得越多，网络一定越强大 → ❌ 忽略「每层是不是线性」这个前提。 → ✅ 正解：层间没激活时 W₂(W₁x+b₁)+b₂ = W′x+b′，三层、一百层都压成「一个矩阵 + 一个偏置」，层数只带来运算量。

误区 2：激活函数只是把分数压成概率，可有可无 → ❌ 只看到「改数值范围」这一面。 → ✅ 正解：它真正的作用是引入非线性、打破层层相消；没有它，判定边界永远是直的，连 XOR、中间一段都做不到。

误区 3：Sigmoid 平滑又能当概率读，就是最理想的 → ❌ 没看见两端「饱和」短板。 → ✅ 正解：z 很大或很小时输出贴近 1 或 0、曲线几乎水平，输入再变输出也不动；网络一深，迟钝层层累积会拖慢学习。

误区 4：ReLU 把负数全变正数，和不加激活差不多 → ❌ 把 max(0,z) 误读成「取绝对值」。 → ✅ 正解：ReLU 负输入输出 0、正输入原样输出，正区间斜率恒为 1，是明确的非线性，与 f(x)=x 的直线有本质区别。

误区 5：tanh 以 0 为中心，就完全躲开了 Sigmoid 的毛病 → ❌ 把「更好训练」夸大成「没缺点」。 → ✅ 正解：以 0 为中心确实更均衡、通常更好训练，但 tanh 毕竟还是 S 形，两端饱和迟钝没躲过去。

6. 和前后课的接口

• 上一课（第 7 课）留下了：神经元 z=w·x+b 这个零件，以及「单个神经元只能画直线、框不住中间一段和 XOR」的硬上限。
• 这一课补上了：层间非线性激活函数，打破「多层 = 一层」，并认全阶跃 / Sigmoid / tanh / ReLU / LeakyReLU / GELU 的脾气。
• 下一课（第 9 课）来解决：神经元、激活函数都齐了，把它们叠成网络、再让这张网自己「学」是怎么回事。

7. 自测 6 题（附答案）

Q1 叠很多层、但每层都不加激活函数（都是线性的），会怎样？A 网络非常强大 B 无论叠多少层，仍等价于一个单层线性变换 C 无法计算 D 只能处理图像。 答案：B｜解析：W₂(W₁x+b₁)+b₂ 可合并成 W′x+b′，层数不带来表达力，正是原文 Q1 正解。A 与结论相反；C 错在照样能算、只是白算；D 无中生有。

Q2 关于 ReLU(x)=max(0,x)，哪种描述对？A 压到 0~1 B 负输出 0、正原样输出，简单且能引入非线性 C 把负数变正数 D 和不加激活没区别。 答案：B｜解析：B 是定义，也是原文 Q2 正解。A 是 Sigmoid 的活；C 把「归零」误当「取绝对值」；D 错在 f(x)=x 是直线、ReLU 是明确弯折。

Q3（判断）h1=阶跃(x−0.4)、h2=阶跃(x−0.7)、y=h1−h2，x=0.55 时 y=1，判「是苹果」。 答案：对｜解析：h1=阶跃(0.15)=1、h2=阶跃(−0.15)=0，y=1，落在 0.4~0.7 内，与原文互动 8-B 一致。

Q4 若中间不放激活，y=(x−0.4)−(x−0.7) 等于多少、说明什么？A 0，完全分不开 B 0.3，是常数，两层塌回一层 C 随 x 变化的直线，能切中间一段 D 1，判永远是苹果。 答案：B｜解析：x 项抵消，剩 0.7−0.4 = 0.3，与 x 无关，正是「线性叠线性还是线性」的活证据。A、D 数值算错；C 错在它根本不随 x 变。

Q5 Sigmoid 在 z=10 或 −10 附近的主要问题？A 输出超过 1 B 进入饱和区、曲线近水平，输入再变输出也不动、变迟钝 C 计算溢出 D 把正数变负数。 答案：B｜解析：这正是原文「饱和区」。A 错在输出始终在 0~1；C 无据；D 把 Sigmoid 和取反搞混。饱和导致梯度趋近 0、拖慢学习，是第 12、13 课要算的账。

Q6（判断）GELU 是 ReLU 改良版，把 0 附近尖折角磨成平滑曲线，是 GPT、BERT 等 Transformer 默认选择。 答案：对｜解析：原文明确 GELU 正区间类似 ReLU、0 附近用平滑过渡代替生硬折角，是 Transformer 标配；LeakyReLU 则给负区间留微斜坡、救「躺平」神经元。

8. 一页速记

• 没有激活函数，再多层也只能切一条直线，表达力为零。
• 激活函数要既「能弯」又「够灵敏」，Sigmoid 两端会饱和迟钝。
• ReLU 正区间斜率恒为 1、又快又稳，推动深度学习革命。
• 每「线性变换 + 一次弯折」就多一次折纸机会，形状越折越复杂。

一句话：把单个神经元一层层叠成一张网，再靠「前向算预测 → 算损失 → 求梯度 → 调参数」的循环，让网自己从带答案的数据里学会本事。

难度：★☆☆　　预计：约 15 分钟

原文：第 9 课 · 神经网络与训练

0. 先记住这三句

• 神经网络就是「前一层的输出喂给后一层」：收原始线索的叫输入层，给答案的叫输出层，夹在中间的叫隐藏层。
• 整张网本质是一个带参数的大函数 ŷ = f(x; θ)，θ 是所有权重 W 和偏置 b 的总和，网络的全部本事都藏在这堆数字里。
• 训练是拿带正确答案的数据反复微调参数；训练完把参数冻住、拿去对新数据做预测，那叫推理。

1. 这一课在补哪个洞

第 7、8 课造出了零件：一个神经元做「加权求和 + 偏置 + 激活」，激活函数让多层叠起来不至于白叠。可手里始终只有零件，没有整机。如果停在这里，你只能像第 7 课那样手工去拧「颜色」的权重、把门槛挪到 2.4，一个一个地试——一台机器尚且调得过来，成千上万个旋钮就彻底没戏了。 这一课把零件拼成整机，并回答一个更要命的问题：这么多参数到底从哪来？答案是「不猜，交给数据定」。把带标签的例子一批批喂进去，机器自己把参数拧到合适的位置。没有这一步，后面「大模型能学会写诗」的故事都无从发生，因为参数不会自己变好。

2. 概念逐层拆

层：一排并列的神经元

大白话：把几个神经元并排摆一排，让它们同时看同一组线索、各打各的分，这一排就是一层。 正式定义：对同一输入做一次线性变换 Wx+b、再过一道激活函数的一组神经元。 最小例子：那台猜水果机给苹果、香蕉、西瓜、柠檬各配一个神经元并排，四个分数经 softmax 变成 36%、27%、13%、24%，加起来正好 100%。

深度与宽度：网有多大

大白话：叠了几层叫深度，每层站几个神经元叫宽度；连线的条数就是权重的个数。 正式定义：相邻两层神经元两两相连（全连接）。第 8 课证过，层与层之间必须夹激活函数，否则再深也等于一层。 最小例子：原文那张小网是 4 → 5 → 5 → 4，三层权重、两个隐藏层，下一节会亲手数出它一共 79 个参数。

参数 θ 与「大函数」

大白话：θ 就是把所有旋钮打包记的一个符号；结构决定网「最多能多聪明」，θ 的具体数值决定它「实际会干什么」。 正式定义：

ŷ = f_网络(x; θ)
θ = {W1, b1, W2, b2, …}

最小例子：同一张 4→5→5→4 的网，一组 θ 可以认水果，另一组 θ 可以写诗；而 GPT-3 的 θ 里有 1750 亿个数。换一组参数，就是换一套判断规则。

3. 亲手算一遍

数一数那张 4 → 5 → 5 → 4 小网到底有多少个参数。规则只有一条：从 A 个神经元连到 B 个神经元，需要 A×B 条连线，也就是 A×B 个权重，再加 B 个偏置。

第 1 步：第一层，5 个神经元各看 4 条线索 → 20 个权重，加 5 个偏置 → 25。 第 2 步：第二层，5 个神经元各看上一层的 5 个输出 → 25 个权重，加 5 个偏置 → 30。 第 3 步：第三层，4 个输出神经元各看 5 个输入 → 20 个权重，加 4 个偏置 → 24。 第 4 步：全部相加 25 + 30 + 24 = 79。

所以结论是：这张只有 3 层、每层几个神经元的小网，就有 79 个需要调的旋钮。这个数说明两件事：一是「参数」不玄乎，就是连线上的数字，数得清；二是哪怕这么小的网，手工逐个去猜也几乎不可能，这正是训练必须自动化的直接理由。放到 GPT-3 的 1750 亿个参数上，靠人调更是天方夜谭。

4. 一个类比就够了

把训练想成「带标准答案的刷题」。学生先瞎蒙，对答案（算损失）、看错在哪（求梯度）、下次改一点点（更新参数），刷上成千上万道题后错题越来越少。 边界要划清：像的是「靠反馈一点点改」；不像的是，刷题改的是人脑里的理解，训练改的是 79 个（或 1750 亿个）明确的数字，而且每步改多少由导数值精确给出，不靠感觉。学生能读懂题意，网络从头到尾只是在调数字，并不「懂」苹果是什么。第 14 课会看到，这种「不懂但能拟合」既是优点也是麻烦。

5. 五个常见误区

误区 1：层数越多，网络一定越聪明 → ❌ 第 8 课证过，层间没有激活函数时多层线性变换仍等价于一层；层数多只是「能表达」的上限高，不等于已经学会。 → ✅ 深度给表达能力，真本事要靠训练把 θ 调好。

误区 2：训练就是把训练数据背下来 → ❌ 背下来对新题毫无办法，训练的目标是让预测贴近真实答案的规律。 → ✅ 训练是「根据预测误差反复微调 W 和 b」，学的是可迁移的判断规则，原文小测验 Q1 的正解正是这句。

误区 3：推理时参数还在被梯度更新 → ❌ 训练调参、推理用参数，是两套状态。 → ✅ 训练完成后参数就冻结，你平时用 ChatGPT 用的就是推理：参数不再变，只做前向预测。

误区 4：隐藏层直接和外界打交道 → ❌ 隐藏层夹在输入层和输出层中间，既不接收原始特征，也不直接给最终答案。 → ✅ 只有输入层收原始线索、输出层给答案，中间的统称隐藏层。

误区 5：只要前向算出预测，训练就完成了 → ❌ 前向只得到 ŷ，不知道错多少，也不知道每个参数该往哪挪。 → ✅ 完整循环是「前向 → 算损失 → 求梯度 → 更新参数」，缺一步都学不动。

6. 和前后课的接口

• 上一课（第 8 课）留下了：神经元和激活函数这些零件，但零件不会自己变好，参数全靠手工猜。
• 这一课补上了：把零件叠成网络，给出「参数交给数据自动定」的训练循环这张全局地图。
• 下一课（第 10 课）来解决：循环第②步——「错得有多离谱」怎么变成一个能比较、能求导的数。

7. 自测 6 题（附答案）

Q1 一张 3 → 4 → 2 的全连接网络，共有多少个权重？ A. 9　B. 20　C. 26　D. 14 答案：B｜解析：第一层 4×3=12 个，第二层 2×4=8 个，共 20 个权重。A 只数了神经元个数；C 把偏置也加进来了（12+4+8+2=26 是参数总数而非权重数）；D 没有对应算法。题目问的是「权重」，偏置要另算。

Q2 网络刚出生时参数是随机的，喂它一个苹果，它多半输出「30% 像香蕉」。下一步该做什么？ A. 立刻换一批数据　B. 拿真实答案算损失，再按梯度微调参数　C. 把 30% 直接改成 100%　D. 再增加两层 答案：B｜解析：这正是训练循环。A 换数据不改变参数，猜得一样烂；C 是硬改预测值而不是改参数；D 加层只会让随机参数更多，不解决「不会」的问题。

Q3（判断）推理阶段，网络的参数还在不断被梯度更新。 答案：错｜解析：训练才调参，要用到正确答案、损失和梯度，很费算力；推理时参数已冻结，只做前向预测。

Q4 训练循环四步，正确顺序是？ A. 更新参数 → 前向 → 算损失 → 求梯度　B. 前向 → 算损失 → 求梯度 → 更新参数　C. 算损失 → 前向 → 求梯度 → 更新参数　D. 求梯度 → 前向 → 更新参数 → 算损失 答案：B｜解析：先喂数据前向算出 ŷ，才有「和真实答案差多少」可算，再由损失反推每个参数的梯度，最后才更新。A、C、D 都把某一步放到了它依赖的结果之前：没有预测算不出损失，没有损失求不出梯度。

Q5 关于「深度」和「宽度」，下列说法正确的是？ A. 深度是每层神经元个数　B. 宽度是层数　C. 深度是层数，宽度是每层神经元个数　D. 两者都指参数总数 答案：C｜解析：原文定义明确，层数叫深度、每层神经元个数叫宽度。A、B 正好说反；D 把结构指标和参数个数混为一谈，参数个数还取决于层与层怎么连。

Q6（判断）把网络结构（多少层、多少神经元）定下来，就等于决定了它会认水果还是会写诗。 答案：错｜解析：结构只定下「能表达多复杂的规律」这个上限；具体表达成什么样，完全取决于参数 θ 取什么值。换一组参数，就是换一套判断规则。

8. 一页速记

• 网络 = 前一层输出当后一层输入；分输入层、隐藏层、输出层。
• 层间必须夹激活函数，否则再深等于一层（第 8 课）。
• 训练用带标签数据自动调参，四步循环缺一不可。
• 第 10、12、13 课分别拆开算损失、更新参数、求梯度这三步。
• 前向只是「猜」，有了损失和梯度才知道「往哪改」。

一句话：把「这次猜得有多差」压成一个可求导的数，梯度下降才知道每个参数该往哪调、该使多大劲。

难度：★★☆　　预计：约 15 分钟

原文：第 10 课 · 损失函数

0. 先记住这三句

• 损失是训练的方向标：它把预测误差变成一个能比较、能求导的数字。
• 回归（预测连续数值）用 MSE：误差取平方再平均；分类（输出概率）用交叉熵，即 −log(正确答案的概率)。
• 真正推动训练的不是损失值本身，而是它的导数；交叉熵「越错推得越狠」，MSE 在最该用力时反而封了顶。

1. 这一课在补哪个洞

第 9 课给出的训练循环里，第②步是「算损失」，可当时只说「量出错多少」。猜数字游戏里你只得到「大了 / 小了」三个字，就能一步步逼近答案，因为它至少给了方向。神经网络的处境难得多：一次要调成千上万个参数，输出的还是一组概率而不是一个数，没有谁在耳边说「大了」。 如果跳过这一课，梯度下降就无的放矢：没有损失这个数，就没有「对参数求导」这回事，成千上万个旋钮根本不知道该往哪拧。补上它，循环才真正闭合：误差 → 一个数 → 导数 → 方向和步幅。而且这导数比「大了 / 小了」信息更丰富，正负说方向、大小说该使多大劲。

2. 概念逐层拆

损失 / 损失函数：给「错」打分

大白话：一张考卷最后总得有个分数，错得越离谱扣得越狠；损失函数就是这台自动阅卷机。 正式定义：把预测 ŷ 与真实值 y 的差距映射成一个非负、可微的标量 L，供梯度下降求导。 最小例子：预测房价，真实 300 万，猜 299 万和猜 100 万都算错，但损失得把「错多少」区分开。

MSE：平方把符号消掉

大白话：先相减、再平方，负号没了，大错还被狠狠放大，最后对所有样本取平均。 正式定义：

MSE = (1/n) Σ (ŷᵢ − yᵢ)²
dL/dŷ = 2(ŷ − y)

适合预测连续数值的回归问题。最小例子：(299−300)² = 1，(100−300)² = 40000，差 200 万的惩罚是差 1 万的 40000 倍。导数 2(ŷ−y) 回忆第 5 课：平方求导把指数 2 挪到前面、次数减一，再乘括号里那项的导数 1。

交叉熵：越自信地猜错，越痛

大白话：只盯「你给正确答案打了几分」，打满分不扣分，几乎不给分就罚到无穷大。 正式定义：正确类别 c 的预测概率为 p̂c 时 CE = −log(p̂c)；K 类完整形式是 CE = −Σ yₖ log(p̂ₖ)，因标签只有正确类为 1、其余为 0，实际就等于 −log(正确类别概率)。 最小例子：实验台里 P(苹果)=55%，损失 −log(0.55) ≈ 0.60；调到自信猜对（接近 1）损失趋近 0，自信猜错（接近 0）损失飙升。它和第 6 课从信息论推出的 −log p 是同一个公式——两条完全不同的路殊途同归。

3. 亲手算一遍

准备两组输入。回归组：真实房价 y=300（万），预测 A=299、预测 B=100。分类组：真实标签 y=1（是苹果），网络输出概率 p=0.01 与 p=0.001。

第 1 步，算 MSE 损失值：(299−300)² = (−1)² = 1；(100−300)² = (−200)² = 40000。 第 2 步，算 MSE 对预测值的导数 2(ŷ−y)：A 为 2×(−1) = −2，B 为 2×(−200) = −400。误差放大 200 倍，推力也放大 200 倍，且负号提示「往大调」。回归里它工作得很好。 第 3 步，换到分类，损失 L(p)=(p−1)²，导数仍是 2(p−1)：p=0.01 → −1.98，p=0.001 → −1.998。把握从 1% 掉到 0.1%，错得更离谱，导数却几乎纹丝不动。 第 4 步，换成交叉熵 −log p，导数是 −1/p：p=0.01 → −100，p=0.001 → −1000；损失值 −log(0.01) ≈ 4.605，也远超 −log(0.9) ≈ 0.105。

所以结论是：分类时 MSE 的梯度最多到 −2 附近就涨不动，网络已经烂到家却只被轻轻推一下，训练拖拖拉拉甚至原地打转；交叉熵的导数随 p 变小而成倍变大，正好补上「最该用力时使不上劲」这块短板。这个数也解释了为什么交叉熵几乎是所有分类任务的默认损失，并且要配合第 11 课的 Softmax 输出使用。

4. 一个类比就够了

把损失想成「错题本的扣分规则」：普通规则是错一题扣一分（像 MSE 对误差线性敏感），严格规则是「越是自信地写错，扣分越狠，错到离谱直接扣爆」（像交叉熵对 p→0 趋向无穷）。 边界要划清：像的是「用分数驱动改进」；不像的是，人看到扣分是凭感觉调整复习，网络看到的是导数值，并且这个导数会经第 13 课的链式法则精确摊派到每个参数头上。另外别把「损失大」直接等于「学得快」——真正决定步长的是梯度，不是损失值本身。

5. 五个常见误区

误区 1：损失函数决定网络有几层、用什么激活函数 → ❌ 那是网络结构的事，与损失无关。 → ✅ 损失只负责把「预测错得有多离谱」量化成一个可比较、可优化、可微的数。

误区 2：直接拿「预测值减真实值」当损失就行 → ❌ 相减会带符号，正负误差互相抵消，一批样本加起来可能接近 0。 → ✅ 取平方消符号（MSE）或取负对数（交叉熵），保证非负且处处可微。

误区 3：损失值越大，参数就被推得越狠 → ❌ 原文反复强调，推动训练的是损失对参数的导数，不是损失值本身。 → ✅ MSE 在 p→0 时损失值趋近 1 看着不小，但导数封在 −2 附近，最该用力时使不上劲。

误区 4：分类也能直接用 MSE，惩罚倍数 98 倍已经够狠了 → ❌ 98 倍是损失值之比，梯度信号却几乎不随错误程度变化。 → ✅ 分类用交叉熵，p=0.01 到 p=0.001 导数从 −100 涨到 −1000，收敛更快。

误区 5：K 类交叉熵要把所有类别的 log 都算一遍 → ❌ 公式虽写成 −Σ yₖ log(p̂ₖ)，但标签只有正确类为 1、其余为 0。 → ✅ 实际只剩一项，就是 −log(正确类别的预测概率)，只看给正确答案打了多少分。

6. 和前后课的接口

• 上一课（第 9 课）留下了：训练循环这张地图，但第②步「算损失」还是个黑箱，误差没变成可优化的数。
• 这一课补上了：回归用 MSE、分类用交叉熵，把误差变成带导数的方向标。
• 下一课（第 11 课）来解决：交叉熵需要「概率」，可网络最后一层输出的是任意大小的分数，怎么把分数变成概率。

7. 自测 6 题（附答案）

Q1 真实房价 300 万，网络预测 100 万，单样本 MSE 是多少？ A. 200　B. 40000　C. 400　D. −200 答案：B｜解析：(100−300)² = (−200)² = 40000。A 是没平方的误差绝对值；C 是漏了一个零；D 带着负号，平方后不可能为负。平方既消符号又重罚大错。

Q2 分类任务中，真实标签 y=1，网络给正确类别的概率 p=0.01。MSE 的导数和交叉熵的导数分别约为？ A. −1.98 与 −100　B. −100 与 −1.98　C. 0.98 与 4.605　D. −2 与 −1.98 答案：A｜解析：MSE 导数 2(p−1)=2×(0.01−1)=−1.98；交叉熵导数 −1/p=−1/0.01=−100。B 把两者对调；C 给的是损失值不是导数；D 把交叉熵导数误当成 MSE 的封顶值。

Q3（判断）损失函数的值越大，梯度下降每一步迈得就一定越大。 答案：错｜解析：步长由导数（梯度）和学习率决定。原文的关键反例正是 MSE：p→0 时损失不小，导数却封顶在 −2，越离谱的错误越得不到更强的纠正信号。

Q4 关于交叉熵 CE = −Σ yₖ log(p̂ₖ)，下列说法正确的是？ A. 每个类别都要算一项再求和　B. 只有正确类别那一项不为 0　C. 它其实是 (p−1)² 的另一种写法　D. 概率越高损失越大 答案：B｜解析：标签是 one-hot，正确类为 1、其余为 0，求和塌缩成 −log(正确类别概率)。A 忽略了 yₖ 里大量的 0；C 那是 MSE；D 说反了，越有把握猜对损失越低。

Q5 预测房价 299 万、真实 300 万，用 MSE 时对 ŷ 的导数是？ A. −2　B. 2　C. −1　D. 0 答案：A｜解析：2(ŷ−y) = 2×(299−300) = −2。负号表示预测偏小，该往大调。B 符号反了会越调越错；C 漏了系数 2；D 意味着没误差，但实际差 1 万。

Q6（判断）回归任务用交叉熵、分类任务用 MSE，效果差不多。 答案：错｜解析：选择损失函数看的是任务类型与输出形式：连续数值用 MSE，类别概率用交叉熵。原文小测验 Q2 的正解正是这句；MSE 用在分类上会因梯度信号太弱而收敛缓慢。

8. 一页速记

• 损失把「猜得有多差」变成数，导数给出方向和劲头。
• 回归用 MSE（平方消符号、重罚大错），分类用交叉熵。
• 判损失函数好不好，要看导数，别只看损失值。
• 交叉熵与第 6 课信息论的 −log p 是同一个公式，殊途同归。
• 分类默认交叉熵，配合第 11 课 Softmax 输出效果最好。

一句话：对一组任意大小的原始分数先取指数、再整体归一化，变成一组非负且加起来等于 1 的概率。

难度：★★☆　　预计：约 15 分钟

原文：第 11 课 · Softmax

0. 先记住这三句

• 分类网络最后一层输出的是 logits（原始分数），可正可负、加起来也不等于 1，本身不是概率。
• Softmax = 先对每个分数取 eˣ（天然非负、不依赖别的数），再除以总和（保证和为 1）。
• 指数会放大差距，温度参数 T 能反向调节这个放大，这就是 ChatGPT 里 temperature 旋钮的数学来源。

1. 这一课在补哪个洞

第 10 课说分类的默认损失是交叉熵，而交叉熵要吃的是「给正确答案的概率」。可网络最后一层吐出来的，只是每个类别一个原始分数：苹果 2.1、香蕉 −0.5、西瓜 1.8。这三个数比得出大小，却回答不了「苹果的概率是多少」，而且加起来是 3.4，根本不是概率。 如果没有这一步，交叉熵连合法输入都拿不到，第 9 课那个训练循环会在算损失处直接断掉。更麻烦的是分数里有负数，随便「除以总和」还会算出负概率。这一课补上的就是这座桥：把任意实数变成一组像样的概率。

2. 概念逐层拆

Logits：还没换算的分数

大白话：网络给每个候选打的「原始得分」，像评委亮的分，还没折算成百分比。 正式定义：分类网络最后一层经若干层 Wx+b 和 ReLU 之后的输出，是任意实数，保留相对排序。 最小例子：[苹果 2.1, 香蕉 −0.5, 西瓜 1.8]，2.1 > 1.8 > −0.5 说明网络最看好苹果；但和是 3.4 ≠ 1，2.1 本身也没有概率意义。

为什么不能「直接除以总和」

大白话：想让三数相加为 1，最直觉的就是各除以总和，可负数会变成负概率。 正式定义：归一化要求每项非负且总和为 1；单纯平移（加上最小值绝对值）虽能消掉负数，但平移量是人为选的。 最小例子：都加 0.5 得 [2.6, 0, 2.3]，除以 4.9 约 [0.53, 0, 0.47]；若把最小值平移到 1，得 [3.1/6.9, 1/6.9, 2.8/6.9] 约 [0.45, 0.14, 0.41]。同一组分数，换个平移量结果就变了，这不合理。

指数函数与 Softmax

大白话：需要一个「不管输入正负，输出永远是正数」的函数，指数函数正好，而且不必知道其他项是多少。 正式定义：

softmax(zᵢ) = exp(zᵢ) / Σⱼ exp(zⱼ)

eˣ 对所有实数输出恒大于 0，且输入越大涨得越快。最小例子：e^2.1 ≈ 8.17、e^−0.5 ≈ 0.61、e^1.8 ≈ 6.05，负数也变正了。

温度 T 与数值稳定

大白话：指数会放大原本的差距，除以 T 可以把这股放大劲儿调小或调大。 正式定义：softmax(z/T)。T=0.5 时模型极度自信，T=2 时分布趋于均匀；低温 0.2 适合写代码做数学，高温 0.8~1.0 适合写故事头脑风暴。 最小例子：2.1 比 1.8 只大 17%，但 e^2.1/e^1.8 ≈ 1.35，差距被扩大 35%。另有数值陷阱：某个 logit 是 1000 时 e^1000 会溢出，解法是先把所有 logit 减去最大值（log-sum-exp 技巧），PyTorch 的 F.cross_entropy 已内置，直接传 logits 即可。

3. 亲手算一遍

输入就是原文那三个 logits：苹果 2.1、香蕉 −0.5、西瓜 1.8。

第 1 步，逐个取指数：e^2.1 ≈ 8.17，e^−0.5 ≈ 0.61，e^1.8 ≈ 6.05。注意香蕉原本是负数，取指数后也变成正数了。 第 2 步，求总和 Σ ≈ 8.17 + 0.61 + 6.05 = 14.83。 第 3 步，逐项归一化：苹果 8.17 / 14.83 ≈ 0.551，香蕉 0.61 / 14.83 ≈ 0.041，西瓜 6.05 / 14.83 ≈ 0.408。 第 4 步，验算 0.551 + 0.041 + 0.408 = 1.000。

所以结论是：三个 logits 变成了 [0.551, 0.041, 0.408]，非负且和恰为 1，可以放心喂给第 10 课的交叉熵。这个数还说明两件事：排序没变（2.1 > 1.8 > −0.5 对应 0.551 > 0.408 > 0.041），但差距被指数放大了——苹果只比西瓜高 0.3 分，概率却高出约 0.14；原本最不看好的香蕉被压到 4.1%，几乎出局。

4. 一个类比就够了

把 Softmax 想成「把评委打分换算成中奖比例」：分数高的拿大头，分数低的喝点汤，所有人份额加起来正好 100%。温度 T 像比赛的「残酷程度」：残酷时冠军通吃，宽松时大家差不多。 边界要划清：像的是「按相对高低分配、总和固定」；不像的是，普通加权只是按分数比例分，Softmax 用指数放大了差距，所以 2.1 和 1.8 的微小分差会拉出明显的概率差。另外它只保序、不改排序，也绝不产生负份额，这点和「有人倒扣成负数」的评分表不同。

5. 五个常见误区

误区 1：Softmax 就是每个数除以总和 → ❌ 有负数时会出现负概率，且先平移再除的结果会随人为选的平移量改变。 → ✅ 必须先取指数保证非负，再整体归一化保证和为 1。

误区 2：logit 2.1 就代表「苹果概率 2.1」或「210%」 → ❌ logits 是任意实数，没有概率含义，三个数加起来还是 3.4。 → ✅ 只有经过 Softmax 的 0.551 才是概率。

误区 3：Softmax 会重新排序，把落后的类别翻上来 → ❌ 指数函数单调递增，取指数再除法不改变大小顺序。 → ✅ 它只校准数值、放大差距，苹果仍是第一。

误区 4：温度 T 越大，模型越自信、输出越确定 → ❌ 说反了，T 放在分母上，T 越大各分数越被压平。 → ✅ T 越小分布越尖锐果断，T 越大分布越平缓随机；低温 0.2 写代码，高温 0.8~1.0 写故事。

误区 5：logit 是 1000 时直接算 e^1000 就好 → ❌ 超出浮点数上限会溢出。 → ✅ 先把所有 logit 减去最大值再取指数（分子分母同乘一个常数，数学上等价），或直接用 F.cross_entropy 传 logits。

6. 和前后课的接口

• 上一课（第 10 课）留下了：分类默认用交叉熵，可它要求输入是概率，网络却给了一组有正有负的分数。
• 这一课补上了：Softmax 把 logits 变成合法概率分布，顺带交出 temperature 参数和数值稳定技巧。
• 下一课（第 12 课）来解决：有了损失和概率，训练时一步该迈多大、梯度又该算在哪些数据上。

7. 自测 6 题（附答案）

Q1 三个 logits 为 [2.1, −0.5, 1.8]，取指数后总和约 14.83，苹果的概率约为？ A. 0.408　B. 0.551　C. 2.1　D. 0.041 答案：B｜解析：8.17/14.83 ≈ 0.551。A 是西瓜的；D 是香蕉的；C 把 logit 原值当成了概率。别把「分数」和「概率」混为一谈。

Q2 为什么不能简单地把 [2.1, −0.5, 1.8] 各除以总和 3.4？ A. 太慢　B. 会出现负概率，且平移量任意会改变结果　C. 结果加起来不等于 1　D. 指数函数不允许 答案：B｜解析：−0.5/3.4 是负的，不是概率；改用「加最小值绝对值」平移又会因选 0 还是选 1 得到 [0.53,0,0.47] 或 [0.45,0.14,0.41]，结果不稳定。C 说反了，除以总和恰恰能保证和为 1。

Q3（判断）Softmax 之后，原本 logit 最大的类别，概率也一定最大。 答案：对｜解析：eˣ 单调递增、分母又是同一个常数，所以只放大差距、不改排序。原文 2.1 > 1.8 > −0.5 对应 0.551 > 0.408 > 0.041。

Q4 同一组 logits，把温度从 T=1 调到 T=0.5，分布会怎样？ A. 更均匀　B. 更尖锐，最大项概率更接近 1　C. 完全不变　D. 变成负数 答案：B｜解析：softmax(z/T) 里 T 变小等于把分数放大，指数放大差距，低温让模型极度自信。A 是 T=2 的效果；C 忽略了 T 在分母；D 不可能，指数输出恒正。

Q5 关于「苹果 2.1 比西瓜 1.8 只大 17%，但概率 0.551 比 0.408 大约高 35%」，这说明什么？ A. 计算错了　B. 指数放大了 logits 之间的差距　C. 温度被设成了 2　D. 香蕉抢走了名额 答案：B｜解析：原文给出 e^2.1/e^1.8 ≈ 1.35，正是放大 35% 的来源。A 与原文数字一致，没错；C 会压平分布；D 香蕉只占 0.041，谈不上抢名额。

Q6（判断）用 PyTorch 做分类时，必须先自己手写 Softmax，再把概率传给 F.cross_entropy。 答案：错｜解析：F.cross_entropy 已内置 log-sum-exp 数值稳定技巧，直接传 logits 即可，它内部会把取指数和归一化一起高效算掉。

8. 一页速记

• Softmax 解决两件事：消掉负数、让概率和为 1。
• 公式分两步：先取指数，再整体归一化；顺序不能反。
• 指数放大差距但不改排序；平移归一化不可取，结果会随平移量变。
• T 越小越果断、T 越大越随机，这就是 ChatGPT 的 temperature。
• 输出层这四步正是第 7 课那台机器「挤成 100%」的内部做法。

一句话：梯度只告诉我们往哪边是下坡，学习率、批量大小和 Adam 一起决定这一步迈多大、走得稳不稳。

难度：★★☆　　预计：约 15 分钟

原文：第 12 课 · 梯度下降与优化器

0. 先记住这三句

• 梯度给方向，学习率 α 给步长：w ← w − α∇L；α 太大震荡、太小龟速。
• 全量梯度太慢、单样本太抖，Mini-batch SGD 每次抽 B 条样本折中，噪声还能帮模型跳出局部小坑。
• Adam = 动量（平滑轨迹）+ 每参数自适应学习率，默认参数开箱即用，是现代训练的事实标准。

1. 这一课在补哪个洞

第 5 课学过蒙眼下山，第 9 课的循环第④步写的是 w ← w − ∇L，听上去万无一失。可真迈一步就翻车：原文把某个权重 w 的损失画成一条山谷曲线，从 w=0.5 按「整个梯度值」更新，一步甩到 w=12.5，损失从 24 不降反升飙到 96。方向其实没错，问题是步子太大，直接飞过谷底冲到对面山坡上。 如果不管步幅，训练要么来回震荡要么原地打转，第 10 课算出的损失再准也没用。这一课补上「怎么走」：先管住步长，再解决「梯度算在哪些数据上」这个更基本的困难，最后用动量与 Adam 把路走得又稳又快。

2. 概念逐层拆

学习率 α：一步迈多大

大白话：梯度是个带方向的箭头，α 就是给这个箭头乘的缩放系数，别一口气跑过头。 正式定义：

w ← w − α · ∇L

α 通常在 0.001 到 0.1 之间。太大损失震荡无法收敛，太小下降极缓慢；实践中用学习率调度，初期较大快速接近最优区域、后期逐渐降低，如余弦退火、线性预热。原文互动台里把 α 拉到 6 看震荡、拉到 0.2 看龟速，就是这件事。

全量梯度的代价与 Mini-batch

大白话：每次更新都要把整个训练集扫一遍，数据一大就慢得没法用。 正式定义：全量梯度基于所有样本的平均损失；Mini-batch 每次随机抽 B 条，用 w ← w − α·(1/B)Σ∇Lᵢ(w) 更新一次，B 通常是 32、64、128，随 GPU 显存调整。 最小例子：GPT-3 训练集有 3000 亿个 token；更直观的账是 10 亿条数据、每条前向 1ms，算一次梯度要 10 亿 ms ≈ 277 小时，更新一次参数得等 11 天。一个 epoch 是扫完整个训练集一遍，里面含「数据集大小 / B」次更新，完整训练常要几十到几百个 epoch。

动量与 Adam

大白话：给下山加惯性，别在陡坡上左右横跳；再给每个参数配一个自己的步幅。 正式定义：动量用历史梯度加权平均 v ← βv + (1−β)∇L（β≈0.9，即 90% 保留旧方向、10% 接受新梯度），抵消峡谷地形里陡峭方向的震荡、在平缓方向积累速度。Adam 在此基础上为每个参数维护自适应学习率，频繁更新的自动降 α、稀疏的自动升 α，即「动量（一阶矩）+ 每参数自适应 α（二阶矩）」。 最小例子：Adam 默认 α=0.001, β₁=0.9, β₂=0.999，绝大多数任务开箱即用，Transformer 几乎清一色用 Adam 或 AdamW。

3. 亲手算一遍

沿用原文那条山谷曲线 L(w) = 1.5(w−4.5)²，开口向上、谷底在 w=4.5（损失为 0），当前权重停在 w=0.5。导数按第 5 课法则得 ∂L/∂w = 3(w−4.5)。

第 1 步，算当前损失：L(0.5) = 1.5×(0.5−4.5)² = 1.5×(−4)² = 1.5×16 = 24。 第 2 步，算当前梯度：∂L/∂w = 3×(0.5−4.5) = 3×(−4) = −12.0。负号说明「往右、w 变大」才是下坡。 第 3 步，直接用整个梯度更新：w ← 0.5 − (−12.0) = 12.5，再代回 L(12.5) = 1.5×(12.5−4.5)² = 1.5×8² = 1.5×64 = 96。损失从 24 涨到 96，一步跨过了谷底 4.5。 第 4 步，取原文给出的合法范围内 α=0.1：w ← 0.5 − 0.1×(−12.0) = 1.7，L(1.7) = 1.5×(1.7−4.5)² = 1.5×(−2.8)² = 1.5×7.84 = 11.76。

所以结论是：同一个梯度，步长决定成败——整步跨过谷底冲到对面山坡，乘上 0.1 只挪了 1.2，损失就从 24 降到 11.76。这个数说明「方向对」只是必要条件，训练能收敛靠的是把每一步限制在谷底附近；也说明盯着 w 和损失这几个数字跳动，看到的就是训练的全部秘密，几亿参数的大模型做的也只是同一件事。

4. 一个类比就够了

还是第 5 课的蒙眼下山：梯度告诉你脚下哪边最陡，学习率是你决定迈多大一步，动量像下山时身体的惯性，让你别在窄沟里左右撞墙。 边界要划清：像的是「靠局部坡度反复小步试探」；不像的是，真实损失地形有上亿维、根本画不出来，而且 Mini-batch 让你每次踩到的地面都在轻微晃动——它是带噪声的估计，不是精确的坡度。谷底 4.5 这种一眼可见的最低点，在真实网络里也未必存在。

5. 五个常见误区

误区 1：梯度指向下坡方向 → ❌ 梯度 ∇L 指出最陡的上坡方向，所以公式里要减号。 → ✅ 朝梯度的反方向迈步才是下坡，写成 w − α∇L。

误区 2：学习率越大，训练越快越好 → ❌ α 太大会在谷底两侧来回震荡甚至发散。 → ✅ 好的学习率让损失稳定下降；原文互动台 α=6 震荡、α=0.2 龟速，两头都不行，还要配合调度。

误区 3：Mini-batch 的「随机噪声」纯粹是缺陷 → ❌ 每次抽样的梯度不是全量梯度，确实有噪声，但它有帮助。 → ✅ 噪声能帮模型跳出局部小坑、找到泛化更好的区域；纯全量梯度太精确，反而更容易陷进局部最优。

误区 4：一个 epoch 就是一次参数更新 → ❌ epoch 是扫完整个训练集一遍。 → ✅ 每个 epoch 里有「数据集大小 / B」次更新，完整训练通常几十到几百个 epoch。

误区 5：Adam 得为每个任务精调一堆超参 → ❌ 它卖点恰恰是省心。 → ✅ 默认 α=0.001, β₁=0.9, β₂=0.999 在绝大多数任务上开箱即用，Transformer 几乎清一色用它或 AdamW。

6. 和前后课的接口

• 上一课（第 11 课）留下了：Softmax 给出概率、交叉熵算出损失，训练循环里「往哪调」有了方向标。
• 这一课补上了：步长怎么选、梯度算在哪些数据上、如何用动量与 Adam 走得稳。
• 下一课（第 13 课）来解决：一个更前置的问题——这个梯度本身，对几亿个参数怎么一次算出来。

7. 自测 6 题（附答案）

Q1 在 L(w)=1.5(w−4.5)² 上，w=0.5 处的梯度是多少？ A. 24　B. −12.0　C. 12.0　D. 4.5 答案：B｜解析：3×(0.5−4.5) = −12。A 是该点的损失值；C 符号反了，会误导成往左走；D 是谷底位置而非梯度。

Q2 按 w ← w − ∇L 在 w=0.5 更新一步后，损失变为多少？ A. 24　B. 11.76　C. 96　D. 0 答案：C｜解析：更新后 w=12.5，L(12.5)=1.5×64=96，不降反升。A 是没更新；B 是加了 α=0.1 的结果；D 只有恰好落在谷底 4.5 才是 0。

Q3（判断）学习率 α 决定的是「每一步迈多大」，梯度决定的是「往哪个方向」。 答案：对｜解析：这正是原文小测验 Q1 的正解。方向由 −∇L 给出，大小由 α 缩放，二者分工不同，缺一不可。

Q4 10 亿条数据、每条前向 1ms，算一次全量梯度大约要多久？ A. 1 秒　B. 277 小时　C. 11 分钟　D. 3000 亿毫秒 答案：B｜解析：10亿 × 1ms = 10亿 ms ≈ 277 小时，约 11 天。A、C 都把量级算小了；D 把 GPT-3 的 token 数和这条算式混在一起了。

Q5 Mini-batch SGD 相比每次用全部数据算梯度，主要好处是？ A. 结果一定更精确　B. 每步只用一小批样本估算梯度，更新更快，还能跳出一些局部坑　C. 完全不需要算梯度　D. 可以不用学习率 答案：B｜解析：这是原文小测验 Q2 的正解。A 说反了，抽样梯度带噪声；C、D 都否定了梯度下降的基本要素，更新公式里照样有 ∇L 和 α。

Q6（判断）动量 β≈0.9 意味着 90% 采用新梯度、10% 保留上一步方向。 答案：错｜解析：正好说反。原文是「90% 保留上一步的方向，10% 接受新梯度」，靠惯性抵消陡峭方向的来回震荡、在平缓方向积累速度。

8. 一页速记

• 梯度给方向，学习率给步长；方向对不等于走得到谷底。
• α 太大震荡、太小龟速，可用余弦退火、线性预热调度。
• 一个 epoch = 扫完训练集一遍，含「数据集大小 / B」次更新。
• 动量抵消峡谷震荡，Adam 再加每参数自适应学习率。
• 盯着 w、b 和损失三个数字，看到的就是训练的全部秘密。

一句话：用链式法则把「输出层错了多少」从后往前逐层摊派，一次前向加一次反向，就把所有参数的梯度都算出来。

难度：★★★　　预计：约 15 分钟

原文：第 13 课 · 反向传播

0. 先记住这三句

• 反向传播 = 链式法则在计算图上的系统化应用，代价仅是两倍前向传播，这让训练亿级参数成为可能。
• 数值微分对每个参数都要一次额外前向传播，n 个参数要 n 次；GPT-3 的 1750 亿个参数完全不可承受。
• 前向传播保存中间值、反向传播复用它们算本地导数；神经元 + Sigmoid + 交叉熵会漂亮地约成 ∂L/∂z = p − y。

1. 这一课在补哪个洞

第 12 课那台训练台，每点一步都用到了 ∂L/∂w，可梯度本身是怎么算出来的？最笨的办法是数值微分：把某个权重微微增大 ε，看损失变了多少。问题是这样一次只能算一个参数，n 个参数就要 n 次额外的前向传播——GPT-3 有 1750 亿个参数，算一次完整梯度就要 1750 亿次前向，时间和能源都是天文数字。 如果跳过这一课，第 9 课训练循环的第③步「求梯度」就是一堵算不动的墙：损失算得再准、Adam 再聪明，也不知道每个旋钮该负多大责任。这一课补上的正是「追责」的高效账本，也给卷二收尾。

2. 概念逐层拆

数值微分：一次只探一个旋钮

大白话：把某个旋钮轻轻拧一点点，看总分变了多少，用这个变化量当斜率。 正式定义：∂L/∂wᵢ ≈ [L(w+εeᵢ) − L(w)] / ε，其中 eᵢ 是第 i 个分量为 1、其余为 0 的单位向量。 最小例子：算一个参数的梯度需要一次额外前向传播；1750 亿个参数就是 1750 亿次，而每次前向本身要处理整个网络。

链式法则：追责的精确账本

大白话：最终亏了一笔钱，按「谁的影响大谁多背」往前倒查，乘法就是分摊比例。 正式定义：若 L = f(g(x))，则 dL/dx = (dL/dg)·(dg/dx)。翻译成网络：只要知道「损失对这层输出的梯度」，乘上本层的本地导数，就能得到「损失对这层输入的梯度」，继续往前传。 最小例子：原文那台机器上，中间一长串局部导数神奇地约成 ∂L/∂z = p − y（预测 − 真值），再乘输入得 ∂L/∂w = (p−y)x——猜得越离谱，梯度越大，参数被推得越狠。

计算图：前向记数，反向用数

大白话：每个节点在前向时把自己的输入值抄在小本上，回头算账时直接翻本子。 正式定义：前向传播从左到右计算并储存每个节点的值；反向传播从右到左，用记录的输入值算本地导数，再乘「右边传来的梯度」，结果继续往左。 最小例子：后面要算的网络里，前向存下 z=3 和 a=9，反向求 ∂a/∂z = 2z 时直接取用 z=3，不必重算一遍。

梯度消失与自动微分

大白话：梯度是一串小数连乘，乘多了就趋近于零，靠输入近的层几乎收不到信号。 正式定义：∂L/∂w₁ = ∂L/∂aₙ × ∂aₙ/∂aₙ₋₁ × … × ∂a₁/∂w₁。Sigmoid 最大导数只有 0.25，100 层相乘 0.25¹⁰⁰ ≈ 10⁻⁶⁰。 最小例子：解法一是 ReLU（正区间导数恒为 1），二是残差连接（第 24 课）给梯度开直通车，三是梯度裁剪防爆炸。好消息是几乎不用手写：PyTorch 里 loss.backward() 之后，所有参数的 .grad 自动填好。

3. 亲手算一遍

用原文最简单的网络：输入 x=2，权重 w=1.5，z = w·x，a = z²，L = (a−6)²，目标 y=6。

第 1 步，前向传播，把中间值记下来：

z = 1.5 × 2 = 3
a = 3² = 9
L = (9 − 6)² = 9

第 2 步，从最外层往回算本地导数：∂L/∂a = 2(a−6) = 2×(9−6) = 6。 第 3 步，再往前一层：∂a/∂z = 2z = 2×3 = 6；再往前：∂z/∂w = x = 2。 第 4 步，连乘起来：∂L/∂w = 6 × 6 × 2 = 72。

再用数值微分核对一遍：把 w 从 1.5 增到 1.501，z = 3.002，a ≈ 9.012004，L ≈ 9.072168，变化量 0.072168 ÷ 0.001 ≈ 72.2，和 72 对上了。

所以结论是：∂L/∂w = 72，与原文图 13-2 完全一致，而且整个过程只用到前向时存下的 z=3、a=9，没有多跑一次前向。这个数说明两件事：一是链式法则把一串局部导数连乘就能精确追责，不用逐个参数试探；二是「一次前向 + 一次反向」的代价只是两倍前向传播，与参数个数无关——这正是 1750 亿参数也能训练的根本原因。数值微分虽能算出约 72.2，却要对每个参数重复一次，代价差了上亿倍。

4. 一个类比就够了

把反向传播想成「公司季度亏损后的倒查」：财报上亏了一截，从销售、生产、采购一层层往前追，每个部门按自己对最终数字的影响比例领走一份责任。 边界要划清：像的是「从结果往回、按影响分摊」；不像的是，责任分摊常带人为判断和协商，而反向传播是纯粹的偏导数连乘，每个环节乘多少由公式定死，没有任何主观裁量。另外它传回的是「梯度」，不是把数据或错误本身倒着送一遍。

5. 五个常见误区

误区 1：反向传播是把数据从后往前再传一遍 → ❌ 数据仍是从左到右前向流动的。 → ✅ 反向流动的是「损失对每个节点的梯度」，靠链式法则逐层乘回去。

误区 2：每个参数都得单独做一次前向传播 → ❌ 那是数值微分，1750 亿次完全不可行。 → ✅ 反向传播一次前向存中间值、一次反向传梯度，就把所有参数的梯度算齐，代价约为两倍前向。

误区 3：误差能逐层传回，靠的是乘法分配律或大数定律 → ❌ 这两条都和复合函数求导无关。 → ✅ 靠的是微积分的链式法则 dL/dx = (dL/dg)·(dg/dx)，这也是原文小测验 Q2 的正解。

误区 4：梯度消失是代码写错了 → ❌ 它是小数连乘的必然数学结果。 → ✅ Sigmoid 最大导数 0.25，100 层相乘约 10⁻⁶⁰，靠近输入的层几乎收不到信号；用 ReLU、残差连接、梯度裁剪来治。

误区 5：训练时得自己手写反向传播 → ❌ 框架已经做好了。 → ✅ 用框架运算建网络，调 loss.backward()，所有参数的 .grad 自动填好，对用户完全透明。

6. 和前后课的接口

• 上一课（第 12 课）留下了：w ← w − α∇L 和 Adam，但式子里的梯度 ∂L/∂w 从哪来仍是黑箱。
• 这一课补上了：链式法则 + 计算图，一次反向扫描算出全部梯度，卷二「网络如何学习」到此完整。
• 下一课（卷三第 14 课）来解决：换个赛道，不再问「网络怎么学」，而是问「下一个词的概率该怎么估」。

7. 自测 6 题（附答案）

Q1 在 z=1.5×2=3、a=9、L=(a−6)² 这个网络里，∂L/∂a 是多少？ A. 3　B. 6　C. 9　D. 72 答案：B｜解析：2(a−6) = 2×3 = 6。A 是 a−6 的值；C 是 a 本身；D 是三层连乘后的 ∂L/∂w，不是这一环。

Q2 上题网络里 ∂L/∂w 等于多少？ A. 6×6×2 = 72　B. 6+6+2 = 14　C. 6×6 = 36　D. 2 答案：A｜解析：链式法则是「逐环相乘」，∂L/∂a × ∂a/∂z × ∂z/∂w = 6×6×2 = 72。B 错把乘法当加法；C 漏了 ∂z/∂w = x = 2；D 只是最后一环。

Q3 数值微分算 GPT-3 完整梯度为什么不可行？ A. 公式太难　B. 1750 亿个参数各需一次额外前向传播　C. 梯度一定是 0　D. 只能用 CPU 答案：B｜解析：原文明确「n 个参数需要 n 次额外前向传播」，每次前向还要跑整个网络。A、C 与事实不符；D 不是根因，换 GPU 也扛不住上亿次。

Q4（判断）反向传播要求前向传播时把每个节点的中间值保存下来。 答案：对｜解析：反向时要用记录的输入值算本地导数，例如 ∂a/∂z = 2z 直接取前向存下的 z=3，这样才不必重算，代价才是两倍前向。

Q5 神经元 + Sigmoid + 交叉熵组合，中间导数约成什么？ A. ∂L/∂z = p − y　B. ∂L/∂z = p + y　C. ∂L/∂z = 2(p−y)　D. ∂L/∂z = −log p 答案：A｜解析：原文互动 13-A 给出 ∂L/∂z = p − y（预测 − 真值），再乘输入得 ∂L/∂w = (p−y)x，正是第 12 课训练台每步用的梯度。C 是 MSE 的导数形式；D 是损失值不是梯度。

Q6（判断）Sigmoid 网络叠到 100 层，梯度消失主要是优化器没选对。 答案：错｜解析：0.25¹⁰⁰ ≈ 10⁻⁶⁰，是本地导数小于 1 连乘的必然结果，与优化器无关。解法是 ReLU、残差连接（第 24 课）这类结构手段。

8. 一页速记

• 反向传播解决的是「每个权重对损失各负多大责任」。
• 前向存中间值，反向复用它们算本地导数，与参数量无关。
• 代价仅两倍前向传播，这是亿级参数可训练的前提。
• 神经元 + Sigmoid + 交叉熵约成 ∂L/∂z = p − y，与第 12 课闭环。
• loss.backward() 帮你做完一切，几乎不用手写。

一句话：不懂语法也不懂语义，只看最近 N 个词、查历史频率表，就能给「下一个词」排出一张概率表。

难度：★☆☆　　预计：约 15 分钟

原文：第 14 课 · 语言的概率游戏：N-gram

0. 先记住这三句

• N-gram 是语言预测的「数数法」：看最近 N 个词 → 查频率表 → 挑最常见的下一个词。
• 本质是条件概率 P(w | 前文) = 共现次数 ÷ 前文总次数，训练只是爬文本、数频率、存表。
• 记性只有 N 个词；词被当成孤立符号，「猫」的统计借给不了「小猫」，没见过的组合概率近乎 0。

1. 这一课在补哪个洞

卷二把「神经网络怎么学习」讲完整了：参数、损失、梯度、更新，一应俱全。可卷三一开口是个新问题——语言模型到底要输出什么？答案是给「下一个词」分配一张概率分布表，就像手机输入「今天天气」弹出「真好」「不错」「怎么样」。 如果连这张表都没有一个能落地、能算的朴素实现，后面那些「更聪明的估计方式」就失去了参照物，也说不清自己到底改进了什么。这一课先补上最土也最诚实的那一版：纯粹数数。第 6 课说过语言模型的本质就是这张概率表，N-gram 就是它最朴素的实现——能数则数，数不到就抓瞎。

2. 概念逐层拆

从「整段短语」到「最近 N 个词」

大白话：别死记「今天天气」这一整句，只看最后几个字，这样换个说法也能用。 正式定义：不管前面说了多少，只用最近的 N−1 个词预测下一个词；看 1 个叫一元模型、2 个叫二元模型、N 个叫 N-gram（N 元语言模型）。 最小例子：原文图 14-2 里 N=2 时，无论前文多长，都只用「只」和「猫」来预测下一个词。大部分手机输入法和早期语音助手用的都是 N=2 或 N=3。

查表就是条件概率

大白话：翻到「前文 = 天气」那一页，数数它后面每个词出现过几次，再除以「天气」总共出现多少次。 正式定义：P(w | 前文) = count(前文, w) / count(前文)，是给定前 N 个词时下一个词出现的可能性。 最小例子：二元模型前文「天气」，语料中 count(天气) = 10000；「真好」共现 2300 次，概率就是 23.0%。整本表里每一个可能的前文都对应这样一行区块。

训练方式：只需要数数

大白话：爬下大量文本，把每一段连续的 N 个词都数一遍，统计频率，存成一张巨大的表格就完事。 正式定义：不需要语法规则、不需要理解语言，用历史频率直接当概率估计。 最小例子：第 6 课那张表——「今天天气」之后「真好」占 23%、「不错」占 21%、「香蕉」占 0.001%——就是这么数出来的。

3. 亲手算一遍

用原文图 14-3 那张二元模型查询表。输入：前文 =「天气」，语料里 count(天气) = 10000。

第 1 步，定分母：「天气」作为前文一共出现 10000 次，所以每个候选的概率都以 10000 为分母。 第 2 步，查「真好」的共现次数 2300，2300 ÷ 10000 = 0.23 = 23.0%。 第 3 步，同法算其余几项：2100 ÷ 10000 = 21.0%（不错）、1800 ÷ 10000 = 18.0%（预报）、1500 ÷ 10000 = 15.0%（怎么样）、1000 ÷ 10000 = 10.0%（好热）。 第 4 步，看两个极端和合计：3 ÷ 10000 = 0.0003 = 0.03%（香蕉），其余几千个词合计 1297 ÷ 10000 ≈ 13.0%；把分子全加起来 2300+2100+1800+1500+1000+3+1297 = 10000，正好等于分母。

所以结论是：给定「天气」，概率最高的是「真好」23.0%，输入法就把它排第一位；而「香蕉」只有 0.03%。分子合计恰好回到 10000，说明这张频率表是自洽的、概率确实归一（表里各项因四舍五入有极小舍入差）。这个数也点出了 N-gram 的命门：语料里没怎么数到的组合，它只能给个近乎 0 的概率；换成从没见过的组合就是 0，也就是后面反复要治的「稀疏性」。

4. 一个类比就够了

把 N-gram 想成「翻值班日志接话」：不看对方在聊什么，只翻本子查「上一句这么说的时候，别人下一句一般接什么」，照抄出现最多的那句。 边界要划清：像的是「只靠历史频率、不理解含义」；不像的是，人会结合更早的上下文——前面刚写「最近身体不太好」，就不会推「今天天气真好」，而 N-gram 的窗口之外一律当作不存在。还有一点更关键：人知道「猫」和「小猫」是一回事，日志里的字符串却完全不通气，这会引出第 15 课。

5. 五个常见误区

误区 1：输入法读懂了「天气」这个概念，或联网查了天气预报 → ❌ 原文说得很直白，它没读懂概念、没联网、也没问你心情。 → ✅ 它只是翻历史记录数数，和「理解语言」毫无关系。

误区 2：N 调得越大，模型就越懂长句子 → ❌ N 越大，每个具体组合在语料里出现的次数越少，大量组合根本从未出现。 → ✅ 这是两难：从「怕生人的小猫，今天第一次」这种整段组合几乎数不到，加大 N 反而更抓瞎。

误区 3：N-gram 能处理长距离依赖 → ❌ 它只看最近 N 个词。 → ✅ 补完「那只从小在胡同里长大、非常怕生人的小猫，今天第一次__」时，N=2 只看「第一次」，完全不知道前面在说一只猫。

误区 4：见过「猫 → 出门」，就能推断「小猫 → 出门」 → ❌ 查的是字符串是否完全匹配。 → ✅ 「猫」和「小猫」是两个毫不相关的符号，800 次的统计一丝一毫都借不过去。

误区 5：「稀疏性」指的是模型文件太大装不下 → ❌ 那是存储问题，不是估计问题。 → ✅ 稀疏性指很多合理的词组合在训练语料里从没出现过，于是概率被估成 0，这也是原文小测验 Q2 的正解。

6. 和前后课的接口

• 上一课（第 13 课）留下了：卷二收尾，「网络怎么学」已完整，但还没回答「语言模型的输出到底是什么」。
• 这一课补上了：给「下一个词」的概率表一个最朴素的实现——看最近 N 个词、查频率表。
• 下一课（第 15 课）来解决：词本身的问题——让「猫」和「小猫」不再是不相干的两个符号。

7. 自测 6 题（附答案）

Q1 二元模型里，count(天气) = 10000、count(天气, 预报) = 1800，P(预报 | 天气) 是多少？ A. 0.18%　B. 18.0%　C. 1.8%　D. 1800% 答案：B｜解析：1800 ÷ 10000 = 0.18 = 18.0%。A、C 把小数点挪错了；D 把次数直接当概率，概率不可能超过 100%。

Q2 上表中「真好」23.0% 与「香蕉」0.03% 相差近 800 倍，这个差距说明什么？ A. 模型懂语法　B. 固定短距离搭配靠数数就能捕捉　C. 香蕉不是中文词　D. 概率算错了 答案：B｜解析：「天气」后面接「预报」的概率远高于接「香蕉」，这类规律不需要深层理解。A 恰好说反；C 与事实无关；D 与原文表格一致，没算错。

Q3（判断）把 N 从 2 改成 5，就能补完「怕生人的小猫，今天第一次__」这类长句。 答案：错｜解析：N 越大，具体组合出现次数越少，「怕生人的小猫，今天第一次」这种整段几乎从未出现，模型只会返回「不知道」或乱猜。

Q4 N-gram 训练时主要在做哪件事？ A. 学语法树　B. 爬文本统计每段连续 N 个词的频率并存表　C. 反向传播调词向量　D. 人工标注词义 答案：B｜解析：原文强调「不需要理解语言，不需要语法规则，只需要数数」。A、D 都需要语言学知识；C 是第 15、16 课才有的神经网络做法。

Q5 下列哪个场景是 N-gram 长期真正能扛的？ A. 跨句子的指代理解　B. 手机输入法候选词推荐　C. 区分「银行（取钱）」和「银行（河岸）」　D. 长篇情绪推理 答案：B｜解析：原文列出的支柱应用是输入法候选词、早期语音识别、垃圾邮件过滤、机器翻译初级版本，靠的都是固定短搭配。A、C、D 都需要长距离或词义理解，正是它的短板。

Q6（判断）N-gram 眼里「猫」和「小猫」是两个不同的字符串，就像「苹果」和「梨子」一样没有关联。 答案：对｜解析：这正是原文点出的更根本的毛病：符号之间没有任何距离或相似度，所以「猫」的统计帮不了「小猫」，也是下一课词向量要补的洞。

8. 一页速记

• 训练 = 爬文本、数频率、存一张巨大的表，不需要理解语言。
• 本质是给「下一个词」分配概率表，直接拿历史频率当概率。
• 局限①：记性只有 N 个词，长距离依赖完全看不到。
• 局限②：词是孤立符号，「猫」与「小猫」不共享统计。
• 局限③：N 越大，没见过的组合越多，陷入两难。

一句话：把每个词变成一串数字，让意思相近的词在空间中挨得近，词的含义就第一次成了可计算的东西。

难度：★★☆　　预计：约 15 分钟

原文：第 15 课 · 词向量

0. 先记住这三句

• 词向量把一个词表示成一串数字 (v₁, v₂, …, v_d)，常见 128、300、768 维甚至上千；意思相近的词挨得近。
• 核心假设是「一个词的意思由它经常出现的场合决定」，Word2Vec 用「遮词猜词」的游戏让机器自己学出这串数字。
• 副产品是向量运算有了语义：国王 − 男人 + 女人 ≈ 女王；局限是每个词只有一个固定向量，处理不了一词多义。

1. 这一课在补哪个洞

上一课的 N-gram 学到了「猫 → 出门」在历史数据里出现过 800 次，可有人一写「小猫」，它查遍整张表只找到 3 次，完全没把握。病根在于：N-gram 用「字符串」代表词，符号之间没有任何距离或相似度，在它眼里「猫」和「小猫」就像「苹果」和「梨子」一样不相干。 如果不补这个洞，第 14 课的稀疏灾难就永远无解——再多的统计也借不到近义词头上。这一课让词带上「意思」：不是字典定义，而是数字，让「猫」和「小猫」的数字表示很接近、「猫」和「飞机」离得很远。有了它，第 16 课才能把「举一反三」真正算出来。

2. 概念逐层拆

先动手：给词的意思打分

大白话：挑几个能命名的属性当维度，给每个词逐项打 0~1 的分，一个词就变成平面上的一个点。 正式定义：用「动物性」「体型大小」两个手工维度，把词表示成二维坐标。 最小例子：猫 (0.86, 0.27)、小猫 (0.90, 0.13)、狗 (0.80, 0.32) 全挤在「小动物」那一角，而 飞机 (0.03, 0.95) 远在另一头。用第 2 课的距离一量，相似就出来了。

词向量与维数 d

大白话：真实词的意思牵涉成百上千种说不清却真实存在的属性，两个维度根本不够，得用几百维。 正式定义：把一个词表示成 (v₁, v₂, …, v_d) 就是它的词向量（word embedding，词嵌入），d 是维数，实际中常见 128、300、768 甚至上千。意思相近的词在 d 维空间里挨得近。 最小例子：说穿了它就是第 1 课的向量，只不过每个向量背着词义；第 2 课的点积与夹角，就成了量「两个词有多像」的尺子。

让机器自己学：Word2Vec

大白话：机器不懂「动物性」，但它能数上下文——总出现在相似句子里的词，就该离得近。 正式定义：语言学家那句老话「你可以通过一个词交的朋友来了解这个词」，即分布式假设；上下文越像的词，向量就该越近。 最小例子：先给每个词随机发一串数字，再反复玩填空「今天我带着___去公园散步，它很兴奋」→ 网络猜「猫」0.3、「狗」0.4、「孩子」0.2、「朋友」0.1，真实答案是「猫」，狗分最高但猜错，于是微调相关词的向量，让「猫」在这种上下文下得分更高一点。这套办法 2013 年由 Google 提出，就叫 Word2Vec。

意外惊喜：向量运算有意义

大白话：减掉一个方向、加上另一个方向，落点居然正好是那个对应的词。 正式定义：向量(国王) − 向量(男人) + 向量(女人) ≈ 向量(女王)，这里的加减是逐维度真算，不是比喻。 最小例子：类似的还有 北京 − 中国 + 法国 ≈ 巴黎、跑 − 跑步 + 游泳 ≈ 游。语义关系被编码成了空间里稳定的方向和距离。

3. 亲手算一遍

用原文那两个手工维度，亲手量一下「猫」到底离谁更近。输入坐标：猫 (0.86, 0.27)、小猫 (0.90, 0.13)、狗 (0.80, 0.32)、飞机 (0.03, 0.95)。距离就用第 2 课的欧氏距离：逐维相减、平方、相加、再开方。

第 1 步，猫 ↔ 小猫：逐维差 0.86−0.90 = −0.04、0.27−0.13 = 0.14；平方和 0.0016 + 0.0196 = 0.0212；开方 √0.0212 ≈ 0.146。 第 2 步，猫 ↔ 飞机：逐维差 0.86−0.03 = 0.83、0.27−0.95 = −0.68；平方和 0.6889 + 0.4624 = 1.1513；开方 √1.1513 ≈ 1.073。 第 3 步，比一比：1.073 ÷ 0.146 ≈ 7.3，猫到飞机的距离是猫到小猫的七倍多。 第 4 步，再看猫 ↔ 狗：逐维差 0.06、−0.05，平方和 0.0036+0.0025 = 0.0061，距离 ≈ 0.078，比猫和小猫还近。

所以结论是：猫与小猫的距离约 0.146，只有猫与飞机距离 1.073 的约七分之一，两个词在平面上确实挨得很近。这个数说明「意思」一旦变成坐标，相似度就能拿计算器算出来，而 N-gram 查字符串永远做不到这一点。第 4 步还暴露了另一半结论：猫和狗只差 0.078，几乎落在同一个点上——两个手工维度分不开它们，得再加「忠诚 vs 警觉」「会不会抓老鼠」这类维度，这正是真实模型要几百维的原因。

4. 一个类比就够了

把词向量想成「给每个人填一张性格问卷」：每项打一个分，分数相近的人兴趣相投，看问卷就知道谁和谁合得来。 边界要划清：像的是「用一串打分表示相似」；不像的是，手工维度人能叫出名字（动物性、体型），Word2Vec 学出来的每一维是机器自己摸索的、说不清却很好用的语义方向。更要紧的是，这张问卷是静态的：一个词只填一次，不像人那样看场合改答案，所以「银行」在「取钱」和「河岸」两处只能拿同一份分数。

5. 五个常见误区

误区 1：词向量的每一维都对应一个能说清的属性 → ❌ 只有第 2 站那两个手工维度是人命名的。 → ✅ 真实词向量的每一维是机器自己学出的语义方向，往往说不清叫什么，但确实有用。

误区 2：Word2Vec 靠背了一本同义词词典才做对类比 → ❌ 它既不懂「动物性」也不懂语法规则。 → ✅ 靠「上下文相似的词，意思也相似」这个假设，用遮词猜词的预测任务学出来，原文小测验 Q1、Q2 的正解都是这个。

误区 3：「国王 − 男人 + 女人 ≈ 女王」只是个比喻 → ❌ 不是修辞。 → ✅ 就是第 2 课的向量加减，逐个维度地减、逐个维度地加，学过的运算没变，变的是作用对象有了含义。

误区 4：词向量能区分「我去银行取钱」和「我坐在河岸边」 → ❌ 每个词只有一个固定向量。 → ✅ 它记住的是「银行」这个词的平均意思，无法按上下文动态调整；要每次重新计算表示，得靠注意力机制。

误区 5：取两维就够用词向量了 → ❌ 抽象词之间的细微差别两维装不下。 → ✅ 常见 128、300、768 甚至上千维，维度越多越能容下词与词的细微差别。

6. 和前后课的接口

• 上一课（第 14 课）留下了：N-gram 把词当孤立符号，「猫」的统计借给不了「小猫」，稀疏灾难无解。
• 这一课补上了：用坐标表示词义，让相似词共享统计强度，还附赠「国王−男人+女人≈女王」这样的语义方向。
• 下一课（第 16 课）来解决：把词向量拼进神经网络，看它能不能对从没见过的组合举一反三。

7. 自测 6 题（附答案）

Q1 按原文两个手工维度，猫 (0.86,0.27) 与小猫 (0.90,0.13) 的距离约为？ A. 0.146　B. 1.073　C. 0.078　D. 0.0212 答案：A｜解析：(−0.04)²+0.14² = 0.0212，开方约 0.146。B 是猫到飞机的距离；C 是猫到狗的距离；D 是平方和，忘了开方。

Q2 Word2Vec 学词向量所依据的核心假设是什么？ A. 出现频率越高的词越重要　B. 上下文相似的词，意思也相似　C. 词越长含义越丰富　D. 含义由拼写决定 答案：B｜解析：这正是原文小测验 Q2 的正解，也就是「你可以通过一个词交的朋友来了解这个词」。A、C、D 都和「看上下文」无关，无法解释为什么「猫」和「小猫」会挨近。

Q3（判断）国王 − 男人 + 女人 ≈ 女王 是人为设计进模型里的规则。 答案：错｜解析：原文强调这不是人为设计的，而是纯粹从大量文本里自然浮现出来的：模型发现两组关系在空间上是相同的方向和距离。

Q4 填空「今天我带着___去公园散步，它很兴奋」，网络猜「猫」0.3、「狗」0.4，真实答案是「猫」。接下来会怎样？ A. 把「狗」的分数改成 0　B. 微调相关词的向量，让「猫」在这种上下文下得分更高　C. 换一个损失函数　D. 删掉这个样本 答案：B｜解析：猜错就微调词向量，几十亿次之后总出现在相似上下文的词被推到相近位置。A 是硬改输出不是改参数；C、D 都不是这个训练游戏的动作。

Q5 关于词向量的维数 d，下列说法正确的是？ A. 固定为 2　B. 常见 128、300、768 甚至上千　C. 等于词表大小　D. 越大越糟 答案：B｜解析：原文给出 128、300、768 甚至上千。A 只是第 2 站为讲清楚做的简化；C 混淆了维数与词表规模；D 说反了，维度越多越能容下细微差别。

Q6（判断）词向量能根据「取钱」和「河岸」两种上下文，给「银行」算出两个不同的向量。 答案：错｜解析：每个词只有一个向量，它记的是平均意思。要每次按上下文重新计算词的表示，得靠注意力机制，这已是后面的课要解决的问题。

8. 一页速记

• N-gram 把词当符号，词向量让相似词的数字也相近。
• 核心直觉：上下文相似的词，意思相近。
• 训练技巧：遮住一个词让网络猜，猜错就挪那行数字。
• 语义关系被编码成空间方向，类比对不是人工设计的。
• 局限：每词一个固定向量，处理不了「银行」的一词多义。

一句话：把最近 N 个词的词向量拼成一长串送进神经网络，让相近的词带来相近的预测，从而绕开 N-gram 的稀疏灾难。

难度：★★☆　　预计：约 15 分钟

原文：第 16 课 · 前馈神经网络语言模型

0. 先记住这三句

• FFNN 语言模型 = 词向量 + 神经网络：查向量 → 首尾拼接 → 过网络，输出词表里每个词的概率。
• 关键进步是「举一反三」：相近的词向量 → 相近的网络输入 → 相近的预测，没见过的组合也能稳稳猜对。
• 遗留硬伤和 N-gram 一样：上下文窗口仍是固定大小（N 常取 3~5），看不到更远处。

1. 这一课在补哪个洞

第 14 课的 N-gram 有个死穴：没见过就不会。用 N=3 补「科学家发现了一颗围绕黑洞运转的 ___」，去数「围绕黑洞运转」后面跟过什么词，结果是 0 次。查不到统计只能回退到「的 ___」，于是「的」后面最常见的「人」「树」「东西」上位，一本正经地补出「围绕黑洞运转的树」。病根在于每个词都是孤立符号：哪怕语料里「围绕恒星运转的行星」出现过一万次，对「围绕黑洞运转」这条空白记录也一点忙都帮不上。 第 15 课刚把词变成了可比较远近的数字，这一课就把两样东西拼起来，看数字能不能替符号补上这个洞。

2. 概念逐层拆

Bengio 的三步法

大白话：把最近的几个词各换成一串数字，接成一条长数字，再交给网络猜下一个词。 正式定义：2003 年研究员 Bengio 提出的办法是——查向量（把最近 N 个词各自换成词向量）、拼起来（首尾相接成神经网络的输入）、过网络（输出词表里每个词「该是下一个词」的概率）。 最小例子：关键的转折就在第 1 步：网络的输入从今往后是数字，不再是符号。这一步看似平平无奇，却是举一反三的全部秘密。

骨架全是卷二的老零件

大白话：图里那个橙色「神经网络」方块不是新东西，是把卷二的积木拼了一遍。 正式定义：过 Wx + b 加激活函数（第 7、8 课），最后用 Softmax 把输出压成每个词的概率（第 11 课）；训练也照搬：真实下一个词当标准答案，交叉熵算损失（第 10 课），反向传播把误差摊回每个权重、连同词向量一起微调（第 13 课）。 最小例子：连 tanh 都是第 8 课见过的激活函数，没有造任何新运算。

固定窗口：它和 N-gram 共同的死结

大白话：窗口开多大是定死的，窗外一律当作不存在。 正式定义：上下文窗口大小固定，N 通常只设 3~5；窗口一变大，拼出的输入就变长、网络跟着变大，训练成本飙升而回报越来越小。 最小例子：「那只从小被遗弃在废弃工厂里、因为长期挨饿而变得格外暴躁的流浪犬，今天终于被好心人收留了，它＿＿」——要填最后一个词得读懂整段情绪，可 FFNN 只看得见最后 5 个词，前面一长串铺垫全被挡在窗外。

3. 亲手算一遍

按原文第 3 站的三处简化：上下文只取 2 个词「围绕」+ 待定词（先用「恒星」），每个词向量 2 维（第 1 维叫「天文性」），候选下一个词只留「行星」和「雨伞」。

第 1 步，查表并拼接：

围绕 = [0.10, 0.20]    恒星 = [0.90, 0.15]
拼接输入 = [0.10, 0.20, 0.90, 0.15]

隐藏层只盯着待定词的「天文性」，用 tanh(1.5×天文性 − 0.8)： 第 2 步，算隐藏层 h = tanh(1.5×0.90 − 0.8) = tanh(0.55) ≈ 0.50。 第 3 步，算分数并过 Softmax：行星分 = 2.5×0.50 = 1.25，雨伞分固定为 0；e^1.25 ≈ 3.49、e^0 = 1、和 = 4.49，于是行星 3.49/4.49 ≈ 78%，雨伞 ≈ 22%。 第 4 步，把第二个词换成「黑洞」[0.85, 0.20]：h = tanh(1.5×0.85 − 0.8) = tanh(0.475) ≈ 0.44，行星分 = 2.5×0.44 = 1.10，e^1.10 ≈ 3.00，3.00/4.00 ≈ 75%。

所以结论是：恒星给「行星」78%，换成从没在训练里出现过的「围绕 + 黑洞」组合，仍给约 75%，两者几乎一模一样。这个数说明「举一反三」是真的：黑洞向量 [0.85,0.20] 和恒星 [0.90,0.15] 只差一点点 → 拼出的输入只差一点点 → 隐藏层是连续函数、输出也只差一点点 → 概率自然只差一点点。而 N-gram 把这三个词当成毫无关系的符号，「恒星」的统计一丝一毫都借不给「黑洞」，只会补出「围绕黑洞运转的树」。顺带一提，把词换成「香蕉」时向量差得远，输出立刻翻盘成「雨伞」。

4. 一个类比就够了

把它想成「照着配方做菜，换个近似的食材，味道几乎不变」：恒星和黑洞是两种几乎一样的食材，秤上的数字差一点，出锅的味道也就差一点。 边界要划清：像的是「输入小变 → 输出小变」这条连续函数的性质；不像的是，厨师真的知道两种食材是什么、还能主动调整火候，而网络完全没有「理解」黑洞，只是数字相近引发的连锁反应。另外人的类推能跨很远，这里的泛化范围被词向量的距离牢牢限死，也跨不出那个固定窗口。

5. 五个常见误区

误区 1：FFNN 语言模型靠一张更大的统计表绕开稀疏灾难 → ❌ 更大的表仍然数不到没见过的组合。 → ✅ 靠把词表示成稠密词向量，让相似的词共享统计强度、泛化到没见过的组合，这是原文小测验 Q1 的正解。

误区 2：图里那个「神经网络」是这一课新发明的零件 → ❌ 它就是把卷二积木组合起来。 → ✅ Wx+b 加激活、Softmax 出概率、交叉熵算损失、反向传播连向量一起微调，全是学过的东西。

误区 3：模型是因为「记住了」围绕黑洞才预测行星的 → ❌ 原文明确假设训练语料里「围绕黑洞」从没出现过。 → ✅ 它靠的是黑洞向量和恒星挨得极近，是泛化不是记忆。

误区 4：FFNN 语言模型能读懂整段长文 → ❌ 上下文窗口固定大小。 → ✅ 它只看得见最后几个词，超出 N 个词的信息完全丢失，这是原文小测验 Q2 的正解，也是它和 N-gram 共同的死结。

误区 5：窗口开得越大越好 → ❌ N 通常只设 3~5。 → ✅ 窗口一变大，拼出的输入变长、网络变大，训练成本飙升而回报递减。

6. 和前后课的接口

• 上一课（第 15 课）留下了：词向量让「猫」和「小猫」的数字很接近，但还没用它去预测下一个词。
• 这一课补上了：查向量 → 拼接 → 过网络，用连续的词向量绕开 N-gram 的稀疏灾难。
• 下一课（第 17 课）来解决：固定窗口这个共同死结——让网络每读一个词就更新一次记忆，理论上能记住整篇文章。

7. 自测 6 题（附答案）

Q1 在缩小版网络里，恒星的天文性 0.90 代入 tanh(1.5×天文性 − 0.8)，得到 h 约为？ A. 0.55　B. 0.50　C. 1.25　D. 0.44 答案：B｜解析：1.5×0.90 − 0.8 = 0.55，tanh(0.55) ≈ 0.50。A 是 tanh 的输入不是输出；C 是 2.5×h 的行星分；D 是换成黑洞后的 h。

Q2 行星分 1.25、雨伞分 0，过 Softmax 后行星概率约为？ A. 50%　B. 78%　C. 22%　D. 1.25 答案：B｜解析：e^1.25 ≈ 3.49，e^0 = 1，3.49/4.49 ≈ 78%。A 是没取指数、两分相当时的直觉值；C 是雨伞的概率；D 把分数当成了概率。

Q3（判断）「围绕 + 黑洞」在训练语料里出现过，所以网络才预测「行星」。 答案：错｜解析：原文特意假设它从没出现过，靠的是黑洞向量 [0.85,0.20] 与恒星 [0.90,0.15] 极近，输入相近、输出自然相近，这才是泛化。

Q4 把第二个词从恒星换成黑洞，行星概率从 78% 变成约 75%，这个「几乎不变」说明什么？ A. 网络算错了　B. 连续的输入变化带来连续的输出变化，语义相近可泛化　C. 温度被调高了　D. 雨伞抢走了概率 答案：B｜解析：原文给的链路是「向量差一点 → 输入差一点 → h 差一点 → 概率差一点」，78% vs 75% 正是举一反三的证据。A 与原文数字一致；C、D 都不是原因。

Q5 关于 Bengio 的三步法，顺序正确的是？ A. 过网络 → 查向量 → 拼接　B. 查向量 → 拼接 → 过网络　C. 拼接 → 过网络 → 查向量　D. 查向量 → 过网络 → 拼接 答案：B｜解析：2003 年的办法是先把最近 N 个词各换成词向量，再首尾相接成输入，最后送进网络输出概率。其余顺序都把「先有数字」这一步放到了后面，网络根本没东西可算。

Q6（判断）FFNN 语言模型已经彻底解决了上下文窗口固定的问题。 答案：错｜解析：N 通常只设 3~5，窗口外的信息完全丢失，这是它和 N-gram 共有的硬伤，也是第 17 课 RNN 要接的洞。

8. 一页速记

• FFNN 语言模型 = 词向量 + 全连接网络，全是卷二零件。
• 相近词向量 → 相近输入 → 相近预测，这就是举一反三。
• 「围绕黑洞」没见过也照样预测「行星」，N-gram 做不到。
• 换「香蕉」向量差得远，输出立刻翻盘成「雨伞」。
• 遗留问题：上下文窗口固定，看不到更远处。

一句话：给网络装上一条会不断刷新的「记忆」，让句子开头的小猫能一路传到句尾，去填那个「它」。

难度：★★☆　　预计：约 15 分钟

原文：第 17 课 · RNN 循环神经网络

0. 先记住这三句

• 固定窗口只看最近几个词，窗口外的信息一律当作不存在，所以它填不出「小猫没有过马路，因为＿＿太害怕了」里的「它」。
• RNN 每读一个词就把「当前词向量 + 上一步记忆」合成一个新记忆，从句首到句尾反复做同一件事，句子多长都不换参数。
• 可旧记忆每走一步都被乘一次 0.6，隔 20 个词只剩 0.6²⁰≈0.00004，远处的词几乎等于没读过。

1. 这一课在补哪个洞

上一课的固定窗口模型有个死角：只把最近 5 个词摆上桌面。读「小猫没有过马路，因为＿＿太害怕了」，空格前最近的是「因为」「太」「害怕」「了」，压根瞧不见「小猫」；可要填对这个空，偏偏得知道前面是猫、是人还是狗。真实文本里，代词和指代对象常隔着几十个词，段落呼应甚至隔着几百个词——窗口一旦定死，窗外就永远是黑的。

如果没有能携带历史的东西会怎样？模型每到一个词都得重新猜主语是谁，长句一律抓瞎，只能干「看最近几个词猜下一个词」的短活。RNN 接上的正是这个洞：与其把历史硬塞进死宽度的窗口，不如配一份随身带走的「记忆」，读一个词更新一次，一路带到句尾。注意这不是把每个词原样存下来，而是压成一份固定大小的摘要，边走边改。

2. 概念逐层拆

向量：一串排好队的数字

大白话：向量就是「一串数字」，比如 [0.3, −1.2, 0.8]，可当成一个词在某几个方面的打分。正式定义：向量是有顺序的一组实数，是模型表示信息的基本单位。原文把记忆 h 缩成一个数，纯粹为了让你能口算——真实模型里 h 是几百维的向量。

隐藏状态 h：一本边走边改的随身笔记

大白话：它是网络读到这里为止「记住了什么」的摘要，像读书时随手写的笔记。正式定义：隐藏状态是 RNN 每个时间步输出的向量，既用于本步预测，又作为下一步输入传回去，原文记作 h。每读一个新词，笔记就擦掉一点、补上一点，从不是完整备份。

tanh：把数字压进 −1 到 1 的激活函数

大白话：它把任意大小的数压成 −1 到 1 之间的数，再大也只逼近 1，不会爆掉。正式定义：tanh（双曲正切）是第 8 课的激活函数，形状像 Sigmoid，但输出在 −1~1。RNN 用它把线性变换的结果收进稳定区间，更新公式外面那层就是它。

循环：把上一步的输出喂回这一步

大白话：平常网络算完就结束，RNN 算完还把结果递给自己下一次用，像接力。正式定义：更新式 h新 = tanh(W·[当前词向量, 旧记忆] + b)。拆开没造新零件——里面 W·[] + b 就是第 4、7 课的线性变换 Wx+b，外面套 tanh。所谓「循环」只是把「线性变换 + 激活」接成环：上一步输出回来当这一步输入，每步共用同一套 W、b。

3. 亲手算一遍

把记忆 h 缩小成一个数，专门记「这句话里有没有提到小猫」。更新规则简化为 h新 = tanh(0.6 × h旧 + x)：0.6 是记忆传递系数（上一步能带过来多少），x 是当前词带来的新信号。规定只有「小猫」带强信号 x=1.5，其余词 x=0。从 h₀=0 开始：

0.90 → 0.50 → 0.29 → 0.17 → 0.10

逐条盯中间结果：第 ① 步「小猫」把记忆点亮到 0.90；此后每个无关词都先乘 0.6、再被 tanh 压一下，于是一路矮下去。到第 ⑤ 个词「因为」，只剩峰值 0.90 的约 11%（0.10 ÷ 0.90 ≈ 0.11）。

所以结论是：RNN 确实把「小猫」带到第 5 个词，预测「它」时还残着点猫味，5 个词勉强够用。可每多隔一个无关词就多乘一次 0.6，隔 5 个词只剩 0.6⁵≈0.08，隔 20 个词是 0.6²⁰≈0.00004，几乎归零。这个数说明：记忆不是突然断的，是被距离一步步稀释的；记不住远处是数学上的硬限制，不是代码写错。

4. 一个类比就够了

打电话传话：第一个人说「小猫今天心情不好」，一个传一个，传到第二十个人，「小猫」多半变成「谁？」——每经一手丢一点，和 h 每步乘 0.6 一个道理。

类比的边界：像的是「信息随传递次数递减」；不像的是，人传话会主动挑重点、甚至复述强调，而 RNN 每步是机械地把旧记忆和新词无差别混合，重要的和无关的一起被稀释。正因为 RNN 不会「主动挑」，下一课才要给它装阀门。

5. 五个常见误区

误区 1：RNN 会把读过的每个词原样存起来 → ❌ 错。它只有一份固定大小的记忆向量，是摘要不是备份 → ✅ 正解：每步用新词刷新 h，旧内容被混合覆盖，查不回某个具体的词。

误区 2：句子越长，参数越多 → ❌ 错。那是固定窗口靠加长窗口的思路 → ✅ 正解：100 个词和 10 个词共用同一套 W、b，只是多执行若干步，参数量与句长无关。

误区 3：tanh 是 RNN 新发明的零件 → ❌ 错 → ✅ 正解：它就是第 8 课的激活函数，RNN 只是把「线性变换 + 激活」接成环，没造新运算。

误区 4：记忆淡出只是「忘了」，训练时无所谓 → ❌ 错。要让第 1 步的「小猫」影响第 20 步的「它」，梯度得沿链式法则反传回第 1 步，每步乘一次小于 1 的导数，连乘 20 次几乎变零 → ✅ 正解：这正是梯度消失，浅层参数拿不到更新；实践中 RNN 学不到间隔超过 5~10 个词的依赖。

误区 5：把 0.6 调大就能记住远处 → ❌ 错。系数稍小于 1 连乘多次仍趋于零，稍大于 1 又爆炸 → ✅ 正解：病根是「每步无差别混合所有信息」，得让记忆有选择地更新，这是下一课 LSTM 的思路。

6. 和前后课的接口

• 上一课（固定窗口 / FFNN 语言模型）：留下「窗口外的词等于不存在」的死角，处理不了长距离指代。
• 这一课（RNN）：补上会循环传递的记忆向量 h，理论上能携带任意长上下文，不限制句子长度。
• 下一课（LSTM）：解决刚暴露的不足——记忆每步被稀释、梯度随距离消失，办法是装「忘记阀」「写入阀」，让网络自己决定记什么、忘什么。

7. 自测 6 题（附答案）

Q1「小猫没有过马路，因为＿＿太害怕了」，固定窗口只看最近 5 个词时，最大麻烦是什么？ A 词向量维度不够　B 看不到窗口外的「小猫」，不知道主语是谁　C 不会用 tanh　D 参数太多 答案：B｜解析：最近 5 个词落在「因为／太／害怕／了」一带，不含「小猫」，没法判断怕的是猫、人还是狗。A、C、D 都不是固定窗口的定义性毛病。

Q2 用 h新 = tanh(0.6×h旧 + x)、x=0、h旧=0.50，下一步 h 约是多少？ A 0.50　B 0.30　C ≈0.29　D 0.90 答案：C｜解析：0.6×0.50=0.30，再取 tanh(0.30)≈0.29。B 忘了套 tanh；A 没乘 0.6；D 把「小猫」那步记混了。

Q3 隔 20 个无关词后，「小猫」的信号约剩多少？ A 约 11%　B 约 50%　C 0.6²⁰≈0.00004，几乎归零　D 保持不变 答案：C｜解析：11% 是隔 5 个词（0.10÷0.90）的残留，别和 20 步混淆；每步连乘 0.6，20 次后趋近于 0。

Q4（判断） RNN 处理 100 个词，需要比 10 个词更多的参数。 答案：错｜解析：每步共用同一套 W、b，参数量与句长无关，变的只是执行步数。这也是 RNN 比固定窗口省的地方。

Q5 RNN 学不到远距离依赖，训练层面的直接原因是什么？ A 学习率太大　B 梯度沿时间反向连乘、趋于零（梯度消失）　C 词表太小　D 没用 Softmax 答案：B｜解析：第 13 课的链式法则沿几十步连乘，稍小于 1 的数连乘后几乎为零，浅层拿不到更新信号。A、C、D 都和「距离」无关，解释不了为什么偏偏远处学不会。

Q6（判断） 把记忆向量换成更大维度，就能根治 RNN 记不住远处的问题。 答案：错｜解析：病根是每步「旧记忆 × 系数 + 新词」的连乘稀释，与维度无关，得靠有选择的更新机制才能治本。

8. 一页速记

• RNN = 线性变换 + 激活接成环：上一步输出喂回下一步当输入。
• 记忆是「摘要」不是「备份」，每读一个词刷新一次。
• 稀释是距离的函数，不是程序 bug，是连乘的必然。
• 下一课用「阀门」让重要的多留、无关的少写。

一句话：给记忆装上「忘记阀」和「写入阀」，让网络自己决定记什么、忘什么，把重要信息守到几十步之后。

难度：★★☆　　预计：约 15 分钟

原文：第 18 课 · LSTM 长短期记忆网络

0. 先记住这三句

• RNN 坏在「不会主动」：每步把重要的和无关的一起稀释，隔 20 词只剩 0.6²⁰≈0.00004。
• LSTM 把记忆拆成两条线：长期记忆 C 走高速公路，短期记忆 h 是每步重算的工作台；再用忘记 / 写入 / 读出三个阀门管住进出。
• 核心只有一行 C ← 忘记阀×旧记忆 + 写入阀×新内容：忘记阀≈1，重要信息就能几乎无损地传几十上百步；代价是必须顺序读词、无法并行。

1. 这一课在补哪个洞

上一课手算出了 RNN 的病：每读一个词，旧记忆就被「×0.6 再混入新词」稀释一次，读 20 个词，20 步前的信息 0.6²⁰≈0.00004，几乎归零。想象读一本小说，第 1 章写「主角害怕黑暗」，第 30 章主角走进地下室，这时你需要想起第 1 章那句话。你不会把中间 30 章每个细节都死记，但会主动记住对后面重要的事——因为你早判断出「主角害怕黑暗」值得留着。

如果记忆只会被动稀释会怎样？凡是需要跨很远呼应的任务，模型一律接不上：长句指代、段落伏笔、翻译里隔着半句的主谓，统统学不会。RNN 坏就坏在不会「主动」，它每步机械地混合所有内容。解药是给记忆装阀门——几个开关分别管「忘掉多少旧的」「写入多少新的」「读出多少给当前用」，让保留与丢弃由网络自己根据当前词说了算。

2. 概念逐层拆

两条记忆：高速公路 + 工作台

大白话：一条专门长期搬运、轻易不改；一条管当下这一步输出什么。正式定义：LSTM（长短期记忆网络，1997 年提出）把记忆拆成长期记忆 C（Cell State，细胞状态）和短期记忆 h（Hidden State，隐藏状态）。C 像高速公路，信息几乎不受干扰地从首开到尾，新内容想挤进来必须先过阀门；h 是每步根据 C 和当前词重算的工作台，正是 RNN 里那个 h，用来预测下一个词。

三个阀门：忘记 / 写入 / 读出

大白话：三个水龙头，分别决定旧记忆留多少、新内容进多少、往外放多少。正式定义：忘记阀（Forget Gate）管旧内容保留比例，写入阀（Input Gate）管当前词新信息写入比例，读出阀（Output Gate）管从 C 里读多少当作这一步的 h。

阀门值：一个 0 到 1 之间的数

大白话：阀门就是个开度，1 全开、0 全关、0.6 放 60% 过去。正式定义：这个数由「当前词 + 当前短期记忆」经 Sigmoid 算出，σ 把任意值压到 0~1，靠训练数据反复优化，直到学会该开时开、该关时关。这里有个漂亮的反转：第 8 课里 Sigmoid 把值压平、导致梯度消失是缺点；搬到这儿，「0 到 1」恰恰天生就是阀门开度，缺点摇身变成优点。

核心公式：只盯中间一行

大白话：新记忆 = 留着的旧记忆 + 放进来的新内容。正式定义：Ct = f⊙Ct−1 + i⊙g，其中 f、i 是忘记阀与写入阀，g 是候选写入内容，⊙ 表示逐元素相乘（对应位置相乘）。其余几行都是配套：f=σ(Wf·[ht−1,xt]+bf)、i=σ(Wi·[ht−1,xt]+bi)、g=tanh(Wg·[ht−1,xt]+bg)、o=σ(Wo·[ht−1,xt]+bo)、ht=o⊙tanh(Ct)。σ 负责生阀门，⊙ 负责掐流量。

3. 亲手算一遍

还是用上一课那把尺子：让长期记忆 C 就是一个数，记「主角怕不怕黑」，只用核心那行 C ← f·C + i·g。网络已经学会——读到重要词时 f=0.9、i=0.9、候选 g≈0.95；读到无关词时 f=0.99、i=0.04（几乎不动旧记忆）。从 C₀=0 开始：

0.855 → 0.854 → 0.854 → … → 0.851

关键在第 ② 步往后：忘记阀≈0.99 意味着旧记忆几乎原样带过去，写入阀≈0.04 意味着无关词几乎挤不进来。9 个词读下来，长期记忆只从 0.855 掉到 0.851。算一下残存比例：0.851 ÷ 0.855 ≈ 0.995，也就是还剩约 99%。

所以结论是：同样一句话，LSTM 9 个词后还剩约 99%，RNN 只剩不到 2%，「害怕」早被冲没了；隔 30 个词，RNN 是 0.6³⁰≈2×10⁻⁷ 彻底没了，LSTM 按 0.99 算是 0.99³⁰≈0.74，还留着 74%。这个数说明阀门把「每步强制稀释」改成了「按需要决定稀释多少」，长期记忆和沿它回传的梯度都能近乎无损地走很远；实验中 LSTM 能可靠记住 50~100 步前的信息，2010~2017 年间语音识别、机器翻译、文本生成的主力都是它。

4. 一个类比就够了

带阀门的高速公路加工作台：C 像一条从城东直通城西的高速，沿途没有岔路干扰，重要货物一口气送到；h 像每个出口旁的工作台，每次按当下需要从高速上取一点货来用。

类比的边界：像的是「一条几乎不被改写的通道 + 一个每步重算的输出」；不像的是，真高速的阀门由人拧，LSTM 的三个阀门是网络用 Sigmoid 自己算、靠训练学出来的，而且 C 每步仍会被 f 乘一次（只是 f≈1 时几乎不变），并非绝对一字不改。别把它想成一块只读硬盘。

5. 五个常见误区

误区 1：LSTM 靠把记忆向量加宽才记得远 → ❌ 错 → ✅ 正解：关键是门控机制与 f·C 这条近无损通路，不是维度变大；RNN 加宽同样会被连乘稀释。

误区 2：阀门值是人工设定的规则 → ❌ 错 → ✅ 正解：f、i、o 由当前词和当前 h 经 Sigmoid 算出，参数靠训练优化，分工是自己「长」出来的。

误区 3：Sigmoid 在 LSTM 里还是会害死梯度 → ❌ 错。第 8 课的顾虑是它被用在主信息通路上把值压平 → ✅ 正解：这里 Sigmoid 只生成 0~1 的开度，主通路是「f×C + i×g」的加法，f≈1 时梯度近乎无损，反而缓解了梯度消失。

误区 4：有了 LSTM，长距离依赖就彻底解决了 → ❌ 错 → ✅ 正解：它缓解了遗忘，却仍要一个词一个词顺序读，ht 依赖 ht−1，100 个词必须做 100 步串行，GPU 上千万核心没法同时开工。

误区 5：C 和 h 是一回事，只是两个名字 → ❌ 错 → ✅ 正解：C 是跨步传递的长期记忆，h 是每步由 o⊙tanh(Ct) 重算、用于当下预测的工作台；RNN 里只有相当于 h 的那一条。

6. 和前后课的接口

• 上一课（RNN）：用记忆向量 h 解决了「窗口外等于不存在」，却留下记忆每步稀释、梯度随距离消失、学不到远依赖。
• 这一课（LSTM）：补上长期记忆 C 与三个阀门，让重要信息近乎无损地传几十上百步，把远依赖真正学到手。
• 下一课（注意力机制）：来解决 LSTM 剩下的硬伤——顺序计算无法并行，办法是不按顺序读词，让每个词同时看全句。

7. 自测 6 题（附答案）

Q1 小说第 1 章「主角害怕黑暗」、第 30 章「走进地下室」，RNN 为什么接不上？ A 词表不够大　B 中间每步 ×0.6，20 步后 0.6²⁰≈0.00004，信息归零　C 没有用 Softmax　D 学习率太小 答案：B｜解析：病根是机械混合导致的连乘稀释，与词表、Softmax、学习率无关；A、C、D 都解释不了「距离越远越记不住」。

Q2 用 C ← f·C + i·g，重要词 f=0.9、i=0.9、g=0.95、C₀=0，第 ① 步 C 是多少？ A 0.90　B 0.95　C 0.855　D 1.71 答案：C｜解析：0.9×0 + 0.9×0.95 = 0.855。A、B 各漏了一项；D 错把两项直接相加而没乘阀门。

Q3 无关词 f=0.99、i=0.04 的作用是什么？ A 彻底清空记忆　B 旧记忆几乎原样保留、新内容几乎挤不进来　C 把记忆翻倍　D 关闭所有输出 答案：B｜解析：f≈1 让 f·C 近乎等于 C，i≈0 让 i·g 近乎为零，于是 C 几乎不动。A、C、D 与阀门含义相反。

Q4（判断） 隔 30 个词，LSTM 按 0.99 算残留 0.99³⁰≈0.74，而 RNN 是 0.6³⁰≈2×10⁻⁷。 答案：对｜解析：这正是同一句话喂给两台机器的对照：约 74% 对近乎 0，差别全在阀门。

Q5 LSTM 至今仍绕不开的硬伤是什么？ A 参数太少　B 必须顺序读词，无法并行，模型越大越拖慢训练　C 不能处理中文　D 只能读 5 个词 答案：B｜解析：ht 依赖 ht−1，100 词要串行 100 步。A、C 与事实不符；D 是原始 RNN 的实践局限，不是 LSTM 的。

Q6（判断） 2017 年 Google 提出 Transformer，把大模型训练时间从「几个月」压到「几天」，靠的是让每个词同时看全句。 答案：对｜解析：不按顺序读词就天生可并行，正好补上 LSTM 无法并行这道坎，这也是下一册的起点。

8. 一页速记

• 阀门是 0~1 的数，由 Sigmoid 算出、靠训练优化，不是人工规则。
• 忘记阀≈1 时，f·C 让记忆与梯度近乎无损地远传。
• Sigmoid 在这里从「梯度消失的缺点」翻成「阀门开度的优点」。
• 卷三到此收尾：N-gram→词向量→FFNN-LM→RNN→LSTM，每步补上一步的窟窿。

一句话：让每个词带着自己的问题去查全句、按相关性分配目光，再把对应内容混成自己的新含义，从此理解一个词不再靠会遗忘的传话链。

难度：★★★　　预计：约 15 分钟

原文：第 19 课 · 注意力机制

0. 先记住这三句

• 读到「它」时，人会回头扫一眼前文、只挑一个最相关的对象——注意力就是让网络学会这个「回头看、且看得有轻有重」。
• 三步：点积打分 → Softmax 变成加起来等于 1 的百分比 → 按百分比对所有词的 V 加权求和，得到「装好了上下文」的新向量。
• 写成一行就是 Attention(Q,K,V)=softmax(QK⊤/√dk)V；它顺带白送两个好处：全句并行、任意距离一步直达。

1. 这一课在补哪个洞

先读两句几乎一样的话：「小猫没有过马路，因为它太累了」和「小猫没有过马路，因为它太堵了」。两个「它」指的东西完全不同：第一句指小猫，第二句指马路。你几乎无意识就分辨了，靠的是读到「它」时回头扫前文，只在「小猫」和「马路」之间挑一个，其余字几乎忽略。

上一卷的 RNN / LSTM 是怎么办的？从左到右逐词读入，把读过的一切不断压进一个固定大小的向量，像滚雪球，也像一只行李箱。等读到「它」，「小猫」已是五步之前的记忆，在箱里被反复挤压；句子再长一点，开头信息几乎荡然无存。LSTM 的阀门只是缓解遗忘，没解决根本毛病：所有历史共用一条固定宽度的门缝。如果没有一个「不压缩」的方案会怎样？模型永远隔着一层被压扁的摘要看前文，远距离指代、跨句呼应始终隔着毛玻璃。注意力接上的就是这个洞：干脆不压缩，把所有词的向量原样留在桌面上，「它」需要谁就直接去看谁。

2. 概念逐层拆

点积打分：两个向量方向有多一致

大白话：把两个词各自的数字串对应位相乘再相加，得数越大说明它俩越「对味」。正式定义：点积（内积）衡量两个向量方向的一致性，卷一第 2 课讲过。注意力第一步就让它给「它」和每个词各打一个相关分。

Softmax：把一排分数变成百分比

大白话：不管分数多大、多小、有没有负号，都换算成一排加起来正好 100% 的比例。正式定义：Softmax 是第 11 课的归一化函数，把任意实数列映射为和为 1 的概率分布。原文里「它」的目光大致是：小猫 62%、马路 9%、累 13%，剩下的分给其他词。

Q / K / V：一个词的三个分身

大白话：Q 是「我想找什么」的查询单，K 是「我能提供什么」的书脊标签，V 是「匹配后真正取走的内容」。正式定义：直接拿词向量互相点积有个毛病——一个词「想找什么」和「能提供什么」是两回事，「它」作为代词想找前文某个具体事物，能提供给别人的却只是「这里有个代词」。于是让每个词过三个可学习矩阵 WQ、WK、WV，生成 q、k、v 三个分身；打分用「它」的 Q 点积每个词的 K，混合的是每个词的 V。「该注意什么」本身是模型自己学出来的。

缩放与一行公式：顺带白送两个好处

大白话：分数太大时 Softmax 会变得非黑即白，先统一除个数压温和；把所有词摞成矩阵，四步一次算完。正式定义：论文里 q、k 是 dk=64 维，点积是 64 个乘积相加，分数常在 ±16 上下晃，除以 √64=8 缩回 ±2，这一步叫缩放。大写 Q、K、V 是各词分身摞成的矩阵（n 个词 n 行），于是 QK⊤ 打分 → ÷√dk 降温 → softmax 归一 → ×V 混合，一行写成 Attention(Q,K,V)=softmax(QK⊤/√dk)V，正是 2017 年 Google 论文《Attention Is All You Need》（Vaswani 等）3.2.1 节的核心。两个免费赠品：全句同时回头看（矩阵一乘全算完，不像 RNN 排队）；「小猫」离「它」5 个词还是 500 个词都一次直达，行李箱被彻底扔掉。

3. 亲手算一遍

把公式缩到 2 维、用纸笔验算。取句子里最要紧的三个词，直接列出已算好的分身（真实模型里这些数字是训练学出来的）；v 的第 1 维代表「动物味」、第 2 维代表「疲惫味」：

只算「它」这一行，q=[2.0, 0.2]。

第一步 · 打分 QK⊤（q 分别点积三个 k）：

它·小猫 = 2.0×1.2 + 0.2×0.0 = 2.4
它·累   = 2.0×0.0 + 0.2×1.0 = 0.2
它·它   = 2.0×0.1 + 0.2×0.0 = 0.2

对「小猫」的 2.4 把两个 0.2 远远甩开，因为它的查询几乎和「小猫」的 key 指向同一方向。

第二步 · 降温 ÷√dk。这里 dk=2，除以 √2≈1.41：2.4÷1.41=1.70、0.2÷1.41=0.14、0.2÷1.41=0.14。（真实模型 dk=64、除以 8，原理一样。）

第三步 · Softmax 归一。先取 e 的幂再各自除以总和：

e^1.70 ≈ 5.46   e^0.14 ≈ 1.15   e^0.14 ≈ 1.15
总和 = 5.46 + 1.15 + 1.15 = 7.76
小猫 = 5.46÷7.76 = 0.703   累 = 1.15÷7.76 = 0.148   它 = 1.15÷7.76 = 0.148

三个数加起来正好 1：七成目光给了小猫。

第四步 · 混合 ×V，逐维加权相加：

out = 0.703×[1.0, 0.0] + 0.148×[0.0, 1.0] + 0.148×[0.5, 0.5]
第 1 维 = 0.703×1.0 + 0.148×0.0 + 0.148×0.5 = 0.78
第 2 维 = 0.703×0.0 + 0.148×1.0 + 0.148×0.5 = 0.22

所以结论是：「它」的新向量 = [0.78, 0.22]，也就是 0.78 的动物味 + 0.22 的疲惫味——模型算出这个「它」≈ 一只（有点累的）小猫，开头「它指谁」的悬念被四步算术解决了。这个数还说明第四步才是关键：前三步只算出「该看谁、看多少」的计划表，×V 才把「小猫」的内容真的搬进「它」的向量里；少了它，权重只是一份没人读的报告，整层白忙。同一个词换个语境（「马路堵了」）就会偏向马路，这正是「同一词、不同语境、不同向量」，也是 GPT 能读懂上下文的底层机制。

4. 一个类比就够了

图书馆查书：你拿一张查询单（Q）去和每本书的书脊标签（K）对分数，分数最高的那几本取出内容（V）来读，按相关程度掺成自己的笔记。

类比的边界：像的是「用问题匹配标签、按匹配度取内容」；不像的是，图书馆里你一次只借最匹配的一本，而注意力是给所有词都分一点权重、做软性的加权平均，连分数低的词也贡献了一小份；而且 Q、K、V 不是书里自带的，是同一个词经三个矩阵现算出来的分身。别把它想成硬检索。

5. 五个常见误区

误区 1：注意力就是「挑出最相关的那个词」 → ❌ 错 → ✅ 正解：它是 Softmax 后的软权重，所有词按比例混合（小猫 70.3%、累和它各 14.8%），不是只取一个。

误区 2：Q、K、V 是词向量本身 → ❌ 错 → ✅ 正解：它们是原始词向量经三个可学习矩阵 WQ、WK、WV 生成的三个分身，「找什么」和「给什么」被拆开了。

误区 3：÷√dk 可有可无 → ❌ 错。dk=64 时点积分数常到 ±16，直接喂 Softmax 会饱和成近似 [1,0,0,…]，注意力非黑即白、梯度近零 → ✅ 正解：除以 8 把分数压回 ±2，才「有轻有重」。

误区 4：算出权重就等于理解了上下文 → ❌ 错 → ✅ 正解：权重只是计划表，必须再 ×V 把内容搬进词向量；「它」从空洞变成 [0.78, 0.22] 靠的是第四步。

误区 5：注意力仍要像 RNN 那样逐词排队 → ❌ 错 → ✅ 正解：矩阵一乘就把 n×n 张分数表全算完，全句并行，且任意距离一次直达。

6. 和前后课的接口

• 上一课（LSTM）：用阀门守住了长期记忆，却仍把所有历史压进一条固定宽度的门缝，且必须顺序读词、无法并行。
• 这一课（注意力机制）：不再压缩，让每个词直接回头看全句、按相关性混合内容，顺带拿到并行与「任意距离一步直达」。
• 下一课（多头注意力）：来解决新不足——一套 Q/K/V 只问得出「谁最相关」这一个问题，可一句话里还有指代、语法、情感好几种关系。

7. 自测 6 题（附答案）

Q1「因为它太累了」与「因为它太堵了」，两个「它」分别指什么？ A 都指小猫　B 分别指小猫、马路　C 都指马路　D 指「因为」 答案：B｜解析：决定目光去向的是「累 / 堵」这一个字的差别：累的是小猫，堵的是马路。切换句子时最大权重会从「小猫」跳到「马路」。

Q2 手算例里，「它」对「小猫」的打分为什么是 2.4、远高于另两个 0.2？ A 因为小猫排在最前　B 因为 q=[2.0,0.2] 与「小猫」的 k=[1.2,0.0] 方向最一致，点积最大　C 因为随机　D 因为 v 最大 答案：B｜解析：2.0×1.2+0.2×0.0=2.4，另两个 k 在第 1 维几乎是 0，点积只剩 0.2。打分看 q 与 k 的点积，与顺序、v 无关。

Q3 降温后的 [1.70, 0.14, 0.14] 经 Softmax 后，小猫的权重约是多少？ A 0.62　B 0.703　C 0.90　D 0.148 答案：B｜解析：e^1.70≈5.46，总和 7.76，5.46÷7.76≈0.703。0.62 是原文另一处举例的百分比，别混；0.148 是「累」和「它」的权重。

Q4（判断） 混合后「它」=[0.78, 0.22]，说明模型把它理解成「纯疲惫、没有动物味」。 答案：错｜解析：第 1 维是动物味、第 2 维是疲惫味，0.78 远大于 0.22，应读作「主要是小猫、掺了点累」。

Q5 为什么要除以 √dk？ A 让分数变大　B 防止高维点积撑爆 Softmax、使其饱和成非黑即白　C 减少参数　D 为了取整 答案：B｜解析：dk=64 时分数常到 ±16，除以 8 压回 ±2。A、C、D 都不是缩放的目的。

Q6（判断） 只要算出 Softmax 权重，「它」的向量就自动带上了「小猫」的信息。 答案：错｜解析：权重只是「该看谁」的计划，必须第四步 ×V 才把内容真正搬进向量；少了这一步整层等于白忙。

8. 一页速记

• √dk=8（dk=64），把 ±16 压回 ±2，防止 Softmax 饱和。
• 前三步是计划表，×V 才真正搬运信息。
• 同一个词在不同语境得到不同向量，这是「读懂上下文」的底层。
• 遗留：一套 Q/K/V 只问一个问题 → 下一课多头。

一句话：一句话里指代、语法、情感各派一个「头」去看，再把所见拼成全貌，成本却几乎不变。

难度：★★★　　预计：约 15 分钟

原文：第 20 课 · 多头注意力

0. 先记住这三句

• 一个注意力头只会算一组权重、问一个问题「谁跟我最相关」，碰上「喜欢」既要找主语又要找宾语，就把「他」和「风景画」混成「半个他、半个画」的模糊向量。
• 解法是并排跑 H 个独立的头，各有自己的 Wq/Wk/Wv，各管一种关系；分工不是人工指派，是训练自然长出来的。
• 关键一笔账：512 维切成 8 份，每头 64 维，8×64 拼回 512，总计算量≈单头，却白多看了 7 种关系。

1. 这一课在补哪个洞

读「小明告诉小红，他喜欢她画的那幅风景画」。为了读懂它，大脑同时在追好几条不同性质的线：指代（他=小明、她=小红、那幅=风景画）、主谓（「喜欢」的施动者是「他」）、动宾（「喜欢」的对象是「风景画」）。光盯「喜欢」一个词，它既要往左找主语、又要往右找宾语——这是两种关系，要看向两个不同的地方。

上一课的注意力，整套 Q/K/V 只有一份，一个词只能算出一组权重、问一个问题。那把主语和宾语都算成「相关」、一起加权进来行不行？加权平均会混出一个「半个他、半个画」的向量，语义反而模糊：一头只擅长一种关系。如果没有多份独立的视角会怎样？模型被迫把指代、语法、情感全挤进同一组百分比里，谁都照顾不周，句子越复杂越糊。多头注意力接上的就是这个洞：既然一个头只擅长一种关系，那就同时跑好几个头，各看各的，再拼成全貌。

2. 概念逐层拆

一个「头」：一套独立的 Q/K/V

大白话：头就是一次完整的注意力计算，像派一个观察员去看句子。正式定义：每个头有自己独立的一套 Wq、Wk、Wv，独立打分、独立算权重、独立混合，互不干扰。让「喜欢」往左看主语的是一个头，往右看宾语的是另一个头，两种关系各算各的。原文里头 A 重重压在主语「他」(62)，头 B 重重压在宾语「风景画」(59)。

H 个头并排：分工自己长出来

大白话：不是谁事先规定「1 号头管语法、2 号头管指代」，而是各学各的，学完自然各占一摊。正式定义：并排跑 H 个头，每个头的 Wq/Wk/Wv 都从海量文本独立训练，训练完一看，有的管指代、有的抠语法、有的盯情感。论文标配 8 个头，大模型动辄几十上百个。

切维投影：切的是工作空间，不是信息

大白话：8 个头不是把 512 维输入剁成 8 段、每头只准看其中一段；每个头都把完整的 512 维从头读到尾。正式定义：Wqi 是一个 512 行、64 列的矩阵，输入 x 是完整 512 维，Qi = x·Wqi 意味着每个头用自己那把「镜头」把全文压进 64 维工作空间。所以「切」切的是每个头工作空间的大小，信息一点没丢；而且这把镜头是学出来的，每个头可以自由地从 512 个特征里线性组合出对自己这摊关系最有用的 64 维。

拼接 + 收尾：末尾才汇合一次

大白话：8 份小结果首尾接起来，再过一道线性层让它们互相通气。正式定义：Hi = softmax(QiKi⊤/√dk)Vi，MultiHead(x) = Concat(H1,…,H8)Wo。8 个 64 维结果拼回 512 维，一维不少，再过 Wo 融合。注意头与头之间全程不通气，只有最末尾这一步才汇合一次。

3. 亲手算一遍

把「多头会不会多花 8 倍钱」这笔账用论文的设置算清楚。输入词向量 512 维，头数 H=8。

① 每头分到维度：512 ÷ 8 = 64
② 8 个头工作空间总和：8 × 64 = 512
③ 拼接回输出：Concat(H1,…,H8) = 8 × 64 = 512 维
④ 对照「每个头都用满 512 维」：8 × 512 = 4096 维，是 512 的 8 倍

所以结论是：多头不是「8 个 512 维的头」，而是「8 个 64 维的头」，总维度 512 和单头一模一样，计算量基本持平，却换来了同时建模 8 种关系的能力——等于免费多看了 7 种关系。这个数还回答了那个最扎心的疑问：把 512 切成 8 份是不是丢了八分之七的信息？没有。Wqi∈R^512×64 说明每个头读的是完整 512 维，只是把它压进 64 维的小空间；而一个头只干「这个动词的主语是谁」这类窄活，64 维绰绰有余。把一个 512 维「通才」拆成 8 个 64 维「专才」，反而比第 1 站那个「半个他、半个画」的四不像更清楚。

顺带看一组真实规模：原始 Transformer（2017）8 头、每头 64 维；BERT-base / GPT-2-small 12 头、64 维；BERT-large 16 头、64 维；GPT-3（175B）96 头、128 维；LLaMA-2/3 70B 有 64 个查询头、128 维。规律是每头维度常年稳在 64–128，模型想变强多半靠「加头」而不是「把头加宽」。

4. 一个类比就够了

多个专才侦探分工查案：一个盯不在场证明（指代），一个查作案工具（语法），一个盘问动机（情感），各查各的，最后把线索汇总成一份报告。

类比的边界：像的是「并排分工、末尾汇总」；不像的是，侦探们中途会互相通气、随时改方向，而注意力头从头到尾各算各的，只有末尾 Wo 才汇合一次，那种「边看边商量」的关系（比如「它」既是小猫的代词、又要当后半句主语）只能靠最后勉强缝合。另外分工是训练长出来的，不是主管派活的。

5. 五个常见误区

误区 1：多头就是复制 8 份一模一样的注意力 → ❌ 错 → ✅ 正解：每个头有独立可学的 Wq/Wk/Wv，训练后分化出不同角色，不是复制品。

误区 2：8 个头要花 8 倍计算 → ❌ 错 → ✅ 正解：每头只用 512÷8=64 维，8×64=512，总成本≈单个 512 维头。

误区 3：把 512 维切成 8 段，每头只看到八分之一信息 → ❌ 错 → ✅ 正解：切的是工作空间不是输入；每个头用 512×64 的投影矩阵读完整 512 维。

误区 4：头越多、损失一定越小 → ❌ 错 → ✅ 正解：头数要与每头维度配套（总维度守恒），且头间不通气会限制表达力，不是越多越好。

误区 5：分工是人工指定的 → ❌ 错 → ✅ 正解：每个头独立训练，管指代、抠语法、盯情感都是自己「长」出来的；连「归纳头」也是训练后涌现的。

6. 和前后课的接口

• 上一课（注意力机制）：用一套 Q/K/V 让每个词回头看全句，解决了指代，却只能问「谁最相关」这一个问题。
• 这一课（多头注意力）：并排跑 H 个独立的头，指代、语法、情感各管一摊，靠切维让成本几乎不变。
• 下一课（Transformer 架构）：注意力、多头都还只是零件，来解决「怎么把它们和 FFN、残差拼成一台真能预测下一个词的语言模型」。

7. 自测 6 题（附答案）

Q1「小明告诉小红，他喜欢她画的那幅风景画」里，「喜欢」为什么要看向两个地方？ A 它有两个意思　B 既要往左找主语「他」，又要往右找宾语「风景画」，是两种关系　C 句子太长　D 它是不及物动词 答案：B｜解析：主谓和动宾是两种性质的关系，各要一个焦点；A、C、D 都没说到「一个词牵多条线」这个关键。

Q2 一个头被迫同时盯主语和宾语，结果会怎样？ A 两个都抓得很准　B 加权平均混出「半个他、半个画」的模糊向量　C 自动变成两个头　D 直接报错 答案：B｜解析：一组权重只能做一次加权平均，多个焦点会互相稀释，这正是单头的死穴。

Q3 论文设置 512 维、8 头，每个头分到多少维？ A 512　B 128　C 64　D 8 答案：C｜解析：512÷8=64。B 是 GPT-3 那类大模型的每头维度；A 是没切维的错误做法。

Q4（判断） 8 个 64 维头拼接回来是 512 维，总计算量约为单个 512 维头的 8 倍。 答案：错｜解析：8×64=512，与单头总维度相同，成本≈1 倍；8 倍是「每头都用满 512 维」才会出现的错误算法。

Q5 关于「切维」，下面哪种说法正确？ A 每个头只准看 512 维里的 64 维　B 每个头读完整 512 维，用 512×64 的投影矩阵压进 64 维工作空间　C 输入被随机打乱　D 每头维度越大越好 答案：B｜解析：Wqi∈R^512×64 决定了输入是全文，切的是工作空间；A 是最常见的误解。

Q6（判断） 训练完把注意力画成热力图，能发现头分化出「盯前一个词」「抓句法」「消解指代」乃至「归纳头」等角色。 答案：对｜解析：归纳头能补全「A B 后又见 A，下一个多半是 B」，被很多人视为上下文学习（给几个例子就照着做）的由来。

8. 一页速记

• 分工不是人工指派，是各头独立训练自然长出来的。
• 512 维通才拆成 8 个 64 维专才，窄活反而看得更清。
• 归纳头撑起「给例子就照着做」的上下文学习。
• 零件齐了，下一课把它们拼成能预测下一个词的 Transformer。

一句话：把注意力、FFN、位置编码拼成一块可堆叠的 block，接上线性层和 Softmax，就是一台能一步步预测下一个词的语言模型。

难度：★★☆　　预计：约 15 分钟

原文：第 21 课 · Transformer 架构

0. 先记住这三句

• 注意力再强也只是把别人的 V 按权重做加权平均，是「混合」不是「深加工」；光叠注意力，模型只会收集材料、不会整理材料。
• 一台最简 Transformer 至少三样：注意力管词与词通信、FFN 管每个词拿到上下文后自己再加工、位置编码把顺序塞回输入。
• block 输入输出形状一样（n×512 进、n×512 出），所以能一层层往上叠；取最后一个位置的向量接线性层 + Softmax，就是「预测下一个词」。

1. 这一课在补哪个洞

前两课造出了很厉害的部件：注意力让每个词回头看别的词，「它」终于知道自己指谁；再加上多头，还能同时盯指代、语法、情绪。一个很自然的问题来了：既然注意力已经能让词彼此看见，为什么还要加别的零件？为什么不是「几层注意力一叠」就完事？

盯着「我 是 一只 小 ___」这句最简的话想：预测空格后面接什么，确实需要前文信息，「我 / 是 / 一只 / 小」看完整体，模型大概率觉得「猫」「狗」「鸟」比较像答案。但问题正卡在这里——注意力算到最后，每个词拿到的新向量，本质是别的词的 V 按权重做的一次加权平均，更像在已有信息之间重新分配比重，而不是凭空造出一个全新的判断。它把「我」「是」「一只」「小」这些线索拉到一起了，却还没有一个部件把线索整理成「这大概率在说某种小动物」这种明确特征。这和第 16 课的处境一模一样：N-gram 只会查表、查到之后不会推断，所以才接一个全连接网络把查来的数字再加工一遍。如果没有这个「加工器」会怎样？模型永远停留在「把相关词找来混一混」，线索挤成一团没被读出来，预测自然不准。这一课就是把注意力、FFN、位置编码拼成一台能跑的主干。

2. 概念逐层拆

注意力只管「混合」，不管「加工」

大白话：它像把几份材料倒进一个碗里搅匀，能把相关的都找来，但不会替你下结论。正式定义：注意力输出是各词 V 的加权平均，是已有信息的重新分配，不产生新的非线性判断。所以 attention 管通信，不管加工。

FFN：每个词各自再想一遍

大白话：收集完材料，让每个词关起门来自己再算一轮，把线索读成结论。正式定义：FFN（前馈网络）FFN(x)=W2·ReLU(W1·x+b1)+b2，不是让词和词通信，而是每个词各自做一轮「加权 → 过非线性 → 压成新表示」的内部加工。论文里常写成 512 → 2048 → 512：先撑大到 4 倍，过一道 ReLU，再压回原样。撑大，是因为 512 维塞不下几千个「小检测器」（有没有「一只」、有没有「小」、像不像宠物）；ReLU 把查到的留下、没查到的清零；压回，是因为下一个 block 接的就是 512 维。至于偏偏 4 倍，是试出来的经验值。模型很多「内部知识」也沉在 FFN 的参数里。

位置编码：把顺序塞回输入

大白话：给每个词发一张「我是第几个」的号码牌，和词向量加在一起再送进去。正式定义：并行处理有副作用——只给词向量，注意力本身并不知道顺序。「猫 追 狗」和「狗 追 猫」用的是同一批词，意思却完全反过来。于是真正的输入 = 词向量 + 位置向量，「猫@位置0」和「猫@位置2」就不再是同一个向量。原始论文用正弦/余弦位置编码，后来还有可学习位置向量、RoPE，做法可变，目的始终是告诉模型「词不只有同时出现，还有先后」。

一块 block：横向通信 + 纵向加工

大白话：一个词进来先和别的词交换信息，再自己做一轮加工，两步首尾接起来就是一块积木。正式定义：Transformer block = attention（横向去看别人）+ FFN（纵向自己想一遍）。最妙的是输入输出维度一样：这里说的「输入」是一整排词向量，不是汉字本身；「输出」是这排向量各自过完 attention 和 FFN 的新版本。形状没变，输出才能原封不动送进下一个 block，天然适合一层层叠。

3. 亲手算一遍

用「我 / 是 / 一只 / 小」这句话，把一台最简 Transformer 的形状和生成过程算一遍。设每个词向量 512 维。

① 输入排：4 个 token × 512 维 = 4×512 = 2048 个数
② 过 1 个 block（attention + FFN）后：仍是 4×512 = 2048 个数，形状不变
③ FFN 内部放大：512 → 512×4 = 2048 → 512
④ 叠 L 层 block：形状始终 n×512，n 不变、512 不变
⑤ 末尾只取最后位置那 512 维 → 词表概率：猫 31%、狗 22%、鸟 12%
   这三项合计 31+22+12 = 65%，剩下 35% 分给其他词
⑥ 挑概率最高的「猫」接到句尾：4 个 token → 5 个 token，整句重送进去即 5×512

所以结论是：block 输入输出同形（4×512 进、4×512 出），这是它能一层层叠上去的全部理由，叠深也不破坏结构；4 只是这句例子的长度，一般地处理的是 n×512，n 是实际喂进去的 token 数，唯一限制是不能超过模型允许的最大上下文长度。而「猫 31%、狗 22%、鸟 12%」加起来 65%、其余 35% 分给别的词，说明预测输出是一张概率表，挑一个接上再把整句重送进去——GPT 式生成就是这样一个词一个词长出来的。

4. 一个类比就够了

流水线上的两道工序：第一道是「开会把各组的材料汇总到本工位」（注意力），第二道是「本工位关起门来把材料加工成半成品」（FFN）。每道工序做完，工件还是那个规格，所以能一道接一道排很多层。

类比的边界：像的是「横向收集 + 纵向加工 + 规格不变可叠」；不像的是，真实 block 里每个词是同时被处理的（并行），不是流水线上一个等一个；而且这节课为突出主线，有意省掉了 Add & Norm 稳定器和生成时的掩码，真实块比这两步多。别以为一台完整 Transformer 就只有这两块。

5. 五个常见误区

误区 1：Transformer 就是「几层注意力一叠」 → ❌ 错 → ✅ 正解：至少还有 FFN 和位置编码，真实块还有 Add & Norm、掩码；只叠注意力缺了「汇总后加工」。

误区 2：注意力输出已经是深加工后的判断 → ❌ 错 → ✅ 正解：它是各词 V 的加权平均，只重新分配比重，不产生新判断。

误区 3：FFN 是让词与词通信的 → ❌ 错 → ✅ 正解：通信归注意力，FFN 是每个词各自在自己的 512 维里做非线性加工。

误区 4：并行让模型天然知道谁在前谁在后 → ❌ 错。恰恰相反，同时送进去会丢掉顺序 → ✅ 正解：必须额外加位置编码，否则分不清「猫追狗」和「狗追猫」。

误区 5：block 输入 4 个词，就输出 4 个「下一个词」 → ❌ 错 → ✅ 正解：输出仍是 4×512 的一排向量，只取最后一个位置去预测下一个词；4 也只是例子长度，不是固定值。

6. 和前后课的接口

• 上一课（多头注意力）：把注意力做成了能同时看多种关系的强零件，但它和 FFN、位置编码一样，还都只是散件。
• 这一课（Transformer 架构）：用「注意力 + FFN」拼出同形可堆叠的 block，补上位置编码，接末尾线性层 + Softmax，第一次凑成能预测下一个词的完整主干。
• 下一课（Tokenizer）：这几课一直假设「词可以直接变成向量」，来解决这个被跳过的入口——模型真正看到的单位到底是什么。

7. 自测 6 题（附答案）

Q1 为什么只叠注意力还不够？ A 参数太少　B 注意力输出是各词 V 的加权平均，只混合不深加工　C 不能并行　D 没有 Softmax 答案：B｜解析：它擅长把相关词拉到一起，却不会把线索整理成新判断。A、C、D 都不是「缺加工」这个缺口。

Q2 FFN 在一块 block 里的职责是什么？ A 让词与词通信　B 每个词各自做一轮非线性加工　C 提供位置信息　D 切分 token 答案：B｜解析：通信归注意力（横向），FFN 是纵向的逐词加工；C 是位置编码，D 是 Tokenizer 的活。

Q3 论文里 FFN 的常见维度写法是？ A 512→512→512　B 512→2048→512　C 512→128→512　D 2048→512→2048 答案：B｜解析：先放大到 4 倍（2048）过 ReLU，再压回 512 以便接下一个 block；4 倍是经验值。

Q4（判断） 不加位置编码，「猫追狗」和「狗追猫」在模型眼里可能是同一批词。 答案：对｜解析：并行处理只看得到一袋词向量，顺序信息必须靠「词向量 + 位置向量」额外补回。

Q5 一个 block 吃进 4×512，吐出来是什么形状？ A 1×512　B 4×512　C 4×2048　D 随层数变化 答案：B｜解析：输入输出同形正是能堆叠的原因；A 是误把「只取末位置」当成整层输出，C 是 FFN 内部临时维度。

Q6（判断） 生成时算出「猫 31%、狗 22%、鸟 12%」，挑「猫」接到句尾，再把整句重新送进去继续预测。 答案：对｜解析：这就是 GPT 式自回归生成，文本一个词一个词往外长，每接一个词 n 就加 1。

8. 一页速记

• attention 管通信、FFN 管加工，谁也替不了谁。
• 位置编码不增加词义，只把顺序塞回输入。
• 「我/是/一只/小」的 4 只是例子长度，一般是 n×512。
• 零件拼好了，下一课补上「文字怎么变成向量」这个入口。

一句话：模型看到的不是文字，而是 token 的整数编号；按词切会爆词表、按字符切序列太长，BPE 用「反复合并最常见的一对」折中。

难度：★★☆　　预计：约 15 分钟

原文：第 22 课 · Tokenizer 分词器

0. 先记住这三句

• 前几课一直摆弄「词向量」，可键盘敲进去的是文字；中间缺的一步，是先把文字切成表里查得到的单元，这一步叫分词（tokenize），切出来每块叫一个 Token。
• 按「词」切会爆词表、撞上 [UNK]，按「字符」切序列暴长、注意力 O(n²) 成本翻四倍；子词（subword）折中：常见词整块、生僻词拆片段、永不「完全不认识」。
• 「strawberry 数不清 r」不是笨：它常被切成 token、变成整数，字母从一开始就不在模型的视野里。

1. 这一课在补哪个洞

前几课摆弄的都是「词向量」——一串数字，可你敲进去的「我 是 一只 小猫」是文字。模型内部藏着一张事先定死的对照表：列着几万个「单元」，每个预先配好一个向量；文字进来并不逐字「理解」，而是拿它到表里查，取出对应那一行向量送进注意力。

关键在于：这张表必须有限，不可能为每种文字串都留一行。所以文字进门第一步，必须先切成「表里查得到的单元」。如果没有这一步，没登记过的词模型都接不住，整条链路从入口就断了。这套机制还有个常被嘲笑的副作用：问顶尖大模型「strawberry 里有几个字母 r」，它常答「2 个」，正确答案是 3 个。不是语文没学好——strawberry 常常整个就是表里一个不可分割的 token，模型眼里它不是 10 个字母而是一坨整体，就像把「中国」当一个词、从不会去数笔画；那 3 个 r 藏在整体内部，对它根本不可见。

2. 概念逐层拆

Token 与词表：模型只认编号

大白话：Token 就是文字被切成的「小块」，词表就是一本「小块 ↔ 编号」的字典。正式定义：分词把文本切成词表里存在的单元；每个 token 在词表里有一个固定编号（ID），模型真正吃进去的是一串整数，每个 ID 再去一张巨大的嵌入表里取出自己那一行数字——这就是第 15 课的词向量，大模型里叫 embedding。所以完整入口是：文本 → token → 整数 ID → 查嵌入表得向量 → 加位置 → 进注意力。

两条朴素路：按词切、按字符切

大白话：要么一个词一块，要么一个字母（汉字）一块，两头都不划算。正式定义：按「词」切看着自然，可英语词形几乎无穷（单复数、时态、人名、拼写错误、新造词），词表开到上百万都兜不住；遇到没登记的词只能吐「未知」占位符 [UNK]，信息全丢；中文更没有空格告诉词边界。按「字符」切，词表小到几千（汉字）甚至 256（字节），再不会有「不认识的词」，但序列暴长：「understanding」=13 个 token，而注意力账单是 O(n²)，序列翻倍成本翻四倍；模型还得从头学会「c-a-t 合起来才是猫」。

子词与 BPE：数频率、合并最常见的一对

大白话：常见整词当一个 token，生僻长词拆成几个常见片段，实在没见过的退到字符/字节。正式定义：BPE（字节对编码）是现代大模型几乎都用的造表法，像玩积木——先把所有词拆到最小单位，扫语料数哪一对相邻 token 最频繁，把这一对合并成新 token 加进词表，再数、再合并，重复几万轮直到词表攒到目标大小（比如 5 万）。同一个长词 internationalization，按词切要么独占一个 token、要么直接 [UNK]，按字符切碎成 20 个，子词切法折中成 inter / nation / al / ization。

真正的输入：一串整数

大白话：文字进了门就变成编号，从此模型只跟数字打交道，再也回不到字母。正式定义：token 并不以「文字」的样子走进模型。原文里 strawberry 被切成「straw」+「berry」两个 token、变成两个整数（ID 7124 与 15717），字母 r 的数量信息就是在这一步丢掉的。它答不准 r 的个数，不是笨，是因为这道题问的东西，在它的输入里压根不存在。

3. 亲手算一遍

拿三句真实的话当迷你语料，手动走两轮 BPE 的「数 → 合并」：

① 我爱吃苹果，苹果很甜。
② 红苹果和绿苹果都是水果。
③ 水果店卖水果。

第 1 轮：先把所有词全拆成单字，数所有相邻字对。「苹 果」最多——① 里出现 2 次、② 里出现 2 次，共 4 次。于是合并 苹 果 → 苹果，词表多一个 token。

第 2 轮：重新数，这次「水 果」跟上——② 里 1 次、③ 里 2 次，共 3 次，最多。于是合并 水 果 → 水果。

把刚学到的这两步合并依次套回「苹果是水果」这句话：

原来：苹 / 果 / 是 / 水 / 果　　共 5 个单字
先并「苹果」：苹果 / 是 / 水 / 果
再并「水果」：苹果 / 是 / 水果　　共 3 个 token

所以结论是：5 个单字并成 3 个 token「苹果 / 是 / 水果」，token 数从 5 降到 3，约省 40%。这个数说明 BPE 的合并确实在压短序列——几万轮后，高频词整个变单 token，中频词留几个片段，生僻字才碎到单字，正好卡在按词切和按字符切之间。顺带记住：序列每翻一倍，注意力 O(n²) 成本就翻四倍，能少一个 token 都是实打实地省。

4. 一个类比就够了

把「中国」当成一个整体来认：你看到这两个字，直接想到国家，不会去数它有几笔、有几个横。模型看 strawberry 也是这样，一整块就是一个 token，内部字母对它不可见。

类比的边界：像的是「整体被当作一个单元、内部细节不可见」；不像的是，人随时能把「中国」拆开数笔画，而模型拿到的是编号和向量，没法回头查看 token 内部有哪些字母。也正因如此，数字母、逆序拼写（HELLO 倒成 OLLEH）、押韵藏头这类只跟字母有关的任务，模型会栽在人类绝不会犯的错上——根源都是 token 内部的字符不可见，这是固有盲区，不是智力问题。

5. 五个常见误区

误区 1：模型是一个字母一个字母读文本的 → ❌ 错 → ✅ 正解：它读的是 token 的整数 ID，再查嵌入表得向量；字母从未单独进过模型。

误区 2：strawberry 答「2 个 r」是因为模型没学好英文或算术差 → ❌ 错 → ✅ 正解：它被切成 token、字符级信息被打包隐藏，这道题问的东西在输入里不存在。

误区 3：按字符切最好，因为永远不会遇到未知词 → ❌ 错 → ✅ 正解：序列暴长，understanding=13 个 token，注意力 O(n²) 成本随长度翻四倍，模型还得自己学拼词。

误区 4：按词切最自然，词表开大点就行 → ❌ 错 → ✅ 正解：词形无穷，上百万也兜不住，[UNK] 会把信息全丢，中文更没有空格可依。

误区 5：BPE 的片段是语言学家手工定的规则 → ❌ 错 → ✅ 正解：从语料里统计相邻对频率、反复合并最常见的一对，几万轮自动攒出词表。

6. 和前后课的接口

• 上一课（Transformer 架构）：拼出了「词向量 + 位置 → 多层 block → 预测下一个词」的主干，却一直默认「词能直接变成向量」。
• 这一课（Tokenizer）：补上被跳过的入口——文字先切成 token、变成整数 ID，才查得到向量；顺带解释了「数不清 r」这类盲区。
• 下一课（编码器、解码器与大语言模型）：入口和 block 都齐了，来解决「同样基于 Transformer，为什么 BERT 不能写文章、GPT 不擅长填空」的架构分流。

7. 自测 6 题（附答案）

Q1 大模型数不对「strawberry 里有几个 r」，根本原因是什么？ A 模型故意答错　B 它看到的是若干 token（子词块），而非一个个独立字母，字符级信息被打包隐藏　C r 是特殊字符　D 没学过英文 答案：B｜解析：字母 r 从分词那一步就没进过模型视野，和「故意」「特殊字符」「学没学过」都无关。

Q2 按字符切分的主要代价是什么？ A 词表太大　B 序列暴长，注意力 O(n²) 成本随长度翻四倍　C 会产生 [UNK]　D 不能处理中文 答案：B｜解析：按字符切词表反而最小，也不会有 [UNK]；真正的代价是 token 数翻好几倍，而注意力账单是平方级。

Q3 迷你语料第 1 轮里，「苹 果」这个相邻对共出现几次？ A 2　B 3　C 4　D 5 答案：C｜解析：① 里 2 次 + ② 里 2 次 = 4 次，是全场最高频，所以先合并它；3 次是第 2 轮「水 果」的次数。

Q4（判断）「苹果是水果」经两步合并后，从 5 个单字变成 3 个 token「苹果 / 是 / 水果」。 答案：对｜解析：先并「苹果」再并「水果」，5→3，省了约 40%，正是 BPE 压短序列的效果。

Q5 模型真正吃进去的是什么？ A 文字本身　B 一串整数 ID，再查嵌入表取出对应向量　C 拼音　D 图片 答案：B｜解析：token 有固定编号，编号查 embedding 得词向量，此后一路都是数字；A、C、D 都不是模型输入。

Q6（判断） GPT-4 的 tiktoken 词表约 10 万 token、以英文为主，中文同义句往往比英文更费 token。 答案：对｜解析：原文对照是「The quick brown fox」=4 tokens，中文同义句可能要 8 tokens；上下文窗口能装的汉字更少，按 token 计费也更贵。

8. 一页速记

• 词表必须有限，所以文字进门第一步一定是切块。
• 模型只跟编号和向量打交道，回不到 s-t-r-a-w 那串字母。
• 「数不清 r」不是智力问题，是输入里压根没有字母。
• 缓解思路（字符级信息 / 字节级 tokenizer）代价又回到「序列太长」那堵墙。

一句话：同样基于 Transformer，BERT 不能写文章、GPT 不擅长填空，差别不在骨架，而在「当前位置能看见哪些位置」。

难度：★★☆　　预计：约 15 分钟

原文：第 23 课 · 编码器、解码器与大语言模型

0. 先记住这三句

• 语言任务分两类：理解（整句读完再判断）要「前后都看」，生成（根据开头往下写）必须「遮住未来」；而「前后左右」的参照物不是整句话，是当前正在处理的那个位置。
• 编码器双向、适合读懂（BERT）；解码器单向、适合续写（GPT）；合起来是「先读题、再答题」的编码器-解码器（T5）。
• 今天偏爱纯解码器，因为「生成」太统一：情感、翻译、问答、写代码都能改写成「给上下文、补后面」。

1. 这一课在补哪个洞

语言任务大致只有两类：理解（「这部电影真的让我很失望」→ 判断负面）和生成（「从前有一只小猫，它每天最喜欢做的事就是」→ 续写）。理解像阅读理解，整句读完才下结论；生成像接龙，只能按已写出的内容决定下一个词。

于是问题是：同一个 Transformer 该「前后都看」还是「只能往左看」？这里最容易糊涂的是参照物——「前后左右」不是指整句话，而是当前正在处理的那个位置。模型对每个位置分别决定它能看见哪些位置：比如「猫 / 追 / 球」里的「追」，双向就能看左边的「猫」和右边的「球」，单向只许看左边。如果没有这套规矩，前后都能看的模型拿去生成会偷看标准答案；只能往左看的模型做情感判断，又看不到后半句的转折。

2. 概念逐层拆

参照物：不是整句，是「当前位置」

大白话：说「能看右边」时，问的是「正在算的这个字能不能看它右边的字」，不是「模型能不能看整句话」。正式定义：注意力按位置逐一计算可见范围；编码器对每个位置开放全部位置，解码器只开放它左侧（含自身）的位置。视野是逐位置定义的。

编码器：双向，任务是「读懂」

大白话：把一句自然语言读进去，变成内部更好用的一排表示。正式定义：编码器（Encoder）对每个位置都允许它看见整句所有位置，没有遮挡；输出不是「下一个词」，而是每个位置一个已融入上下文的向量，像「读后笔记」。代表是 BERT，训练方式是完形填空：把「巴黎是法国的 [MASK]」挖掉一个词，让它同时利用左右两边猜回来。所以 BERT 擅长读懂后做判断，不擅长往下写文章——它压根不是按那个方向训练的。

解码器：单向，任务是「往下写」

大白话：手里有前文，把内部表示一步步还原成文字，一个词一个词往外吐。正式定义：解码器（Decoder）和编码器最大的不同不是 block 长相，而是注意力多一条规矩——当前位置不能看右边未来的位置，否则训练时会偷看标准答案。续写「它最爱晒太阳」时：第 1 个位置猜「它」，第 2 个看见「它」猜「最」，第 3 个看见「它 最」猜「爱」。这个目标正是 GPT 的核心。工程上还有个漂亮点：训练时整句都喂进去了，一次前向就能同时算出每个位置的「下一词预测题」，既守单向规则又能并行训练。

三种结构与「续写统一框架」

大白话：只理解、只生成、先理解后生成，三种活对应三种拼法。正式定义：只有编码器 → 先读懂再判断（BERT）；只有解码器 → 给开头继续写（GPT）；编码器 + 解码器 → 先读懂输入、再生成输出（原始 Transformer、T5），即「编码器先读题，解码器再答题」。今天偏爱纯解码器，因为「生成」非常统一，很多任务都能改写成续写：情感分析「这条评论是正面还是负面？答：负面」、翻译「把…翻成英文：This kitten loves sunbathing.」、问答「法国的首都是：巴黎」。把「继续往下写」练到极致，还顺带学会照着提示里的例子做下去，这就是上下文学习，也是 prompt、few-shot 的本质。

3. 亲手算一遍

拿「它 最 爱 晒 太 阳」这 6 个位置，把「遮住未来」到底遮掉多少算清楚。约定一个位置也算能看见自己。

编码器（双向，无遮挡）：每个位置能看全部 6 个位置
  可见连接 = 6 × 6 = 36
解码器（单向，只能看左侧和自身）：第 k 个位置能看 k 个
  可见连接 = 1 + 2 + 3 + 4 + 5 + 6 = 21
被遮掉的 = 36 − 21 = 15
遮掉比例 = 15 ÷ 36 ≈ 0.42，也就是约 42%

再按原文那三行，看解码器怎么一个词一个词往外写：

所以结论是：解码器以约 42% 的连接被遮住为代价，换来「不偷看标准答案」；整句都喂进去，一次前向就能同时算出每个位置的「下一词预测题」，既守单向规则又能并行训练。这个数也说明 BERT 与 GPT 的差别不在 block 长相，而在「当前位置能看见哪些位置」——理解任务要那 15 个连接看后半句，生成任务必须关掉它们。

4. 一个类比就够了

编码器像「阅读理解」：整篇文章都摊在眼前，读完才作答；解码器像「接龙作文」：只能看着已经写出的上一句，决定下一句写什么，不许翻到后面看答案。

类比的边界：像的是「能不能看后文」；不像的是，人做阅读理解会反复回看，而编码器一次性把整句所有位置同时算完；接龙的人还能回头改前面的字，解码器不能修改已生成的词（自回归）。另外别把它们想成两台不同的机器，它们是同一套 Transformer 块、只是可见范围不同。

5. 五个常见误区

误区 1：「前后都看」是指模型把整句一起扫一眼 → ❌ 错 → ✅ 正解：是对每个位置分别决定可见范围，参照物是当前位置。

误区 2：BERT 也能写文章，只是写得短一点 → ❌ 错 → ✅ 正解：它按「完形填空」训练，压根不擅长生成。

误区 3：解码器靠把未来词从输入里删掉来遮住未来 → ❌ 错 → ✅ 正解：整句都喂进去了，是在注意力上加掩码；正因整句都在，才能一次前向并行算所有位置的预测题。

误区 4：编码器-解码器是两个独立模型硬拼起来 → ❌ 错 → ✅ 正解：是同一套 Transformer 的两种用法，一个读题、一个答题。

误区 5：今天偏爱解码器，是因为编码器被证明没用 → ❌ 错 → ✅ 正解：是「生成」框架太统一，一套架构一个目标就能覆盖大部分任务。

6. 和前后课的接口

• 上一课（Tokenizer）：补上「文字 → token → ID → 向量」的入口，主干齐备。
• 这一课（编码器、解码器与大语言模型）：按「当前位置能看见哪些位置」分成双向 / 单向 / 合体三种结构，解释 BERT 与 GPT 的分流。
• 下一课（残差与层归一化）：解码器能叠得很深（GPT-3 有 96 层），来解决「这么深怎么还训得动」。

7. 自测 6 题（附答案）

Q1 说解码器「只能往左看」时，「前后左右」的参照物是什么？ A 整句话　B 当前正在处理的那个位置　C 第一个词　D 最后一个词 答案：B｜解析：视野是逐位置定义的；「猫/追/球」里的「追」能不能看右边的「球」，问的正是这个位置。A 是最常见的糊涂点。

Q2 同样基于 Transformer，BERT 与 GPT 最关键的区别是什么？ A BERT 用注意力、GPT 不用　B BERT 是双向编码（能同时看左右文），GPT 是自回归、只能看左侧已生成内容　C BERT 参数一定比 GPT 多　D 两者完全相同 答案：B｜解析：两者都用注意力，差别在可见范围；C 与事实无关，D 显然错。

Q3（判断） 解码器训练时必须把未来词从输入里删掉，否则会偷看答案。 答案：错｜解析：整句都喂进去，靠注意力掩码遮住未来；正因为整句都在，才能一次前向并行算出每个位置的下一词预测。

Q4 按本课文的算例，6 个位置里解码器相对编码器约遮掉了多少可见连接？ A 21%　B 42%　C 58%　D 75% 答案：B｜解析：编码器 6×6=36，解码器 1+2+3+4+5+6=21，遮掉 15，15÷36≈0.42。21 是剩下的连接数，不是比例。

Q5 为什么今天的大模型大多走纯解码器路线？ A 编码器被证明无效　B 很多任务都能统一改写成「续写」，一套架构一个目标就能覆盖大部分任务　C 解码器参数更少　D 只有解码器能并行 答案：B｜解析：情感、翻译、问答、写代码都能塞进「给上下文、补后面」；编码器在理解任务上依然好用。

Q6（判断） 编码器-解码器结构适合翻译：编码器先把输入整句读懂，解码器再一个词一个词写出译文。 答案：对｜解析：这正是「先读题、再答题」，代表是原始 Transformer 与 T5。

8. 一页速记

• 编码器先读题，解码器再答题；两者是同一积木的两种视野。
• 掩码不是删词，整句都在，一次前向并行算所有位置。
• 「把后面补出来」练到极致，就涌现出 few-shot 上下文学习；下一课解决「叠到 96 层还能稳稳训练」。

一句话：给梯度修一条不衰减的高速路（残差），再把每层数值拉回标准量级（LayerNorm），96 层深的 Transformer 才训得动。

难度：★★★　　预计：约 15 分钟

原文：第 24 课 · 残差连接与层归一化

0. 先记住这三句

• 96 层连乘是道诅咒：每层导数平均 0.9 时 0.9⁹⁶≈0.00006（梯度消失），平均 1.1 时 1.1⁹⁶≈12000（梯度爆炸），极难刚好停在 1。
• 残差连接 y = f(x) + x 求导多出一个「+1」，把每层梯度钉在 1 附近；LayerNorm 把每条向量拉回均值 0、标准差 1，挡住数值漂移。
• 还有个讲究：Norm 放前还是放后决定成败——Pre-LN 让残差主路保持纯净，才有了今天能稳稳堆到上百层的深层模型。

1. 这一课在补哪个洞

GPT-3 有 96 层 Transformer Block。训练时损失在最后一层算出，梯度要一路反向传播，从第 96 层传回第 1 层。第 13 课讲过，梯度每穿一层就要乘一次那层的导数：假设每层导数平均是 0.9，经过 96 层就是 0.9⁹⁶≈0.00006，第 1 层收到的梯度只有原来的万分之零点六，参数得不到有效更新，等于白占内存；反过来要是每层 1.1，1.1⁹⁶≈12000，梯度爆炸、数值溢出，训练当场崩盘。连乘这件事，要么把梯度碾成零，要么把它吹上天。

这个敌人你已撞见过两回：第 13 课反向传播沿链式法则连乘，第 17 课 RNN 沿「时间」连乘几十步导致记忆消退；这次只是换成沿「深度」连乘 96 层，解法灵魂和给 LSTM 修「记忆高速公路」如出一辙。如果没有能让梯度绕过的捷径，网络根本堆不深，浅层要么学不动、要么数值炸掉。这一课补上的正是两个稳定器：残差连接与层归一化，也就是第 21 课一笔带过的「Add & Norm」。

2. 概念逐层拆

深度连乘：梯度的诅咒

大白话：一条很长的乘法链，每个因子比 1 小一点，乘到最后就趋近于零；比 1 大一点就涨到吓人。正式定义：梯度沿深度按链式法则逐层连乘，96 个 0.9 得约 0.00006，96 个 1.1 得约 12000，靠「把每层导数调得刚好」根本不现实。

残差连接：给梯度修一条高速路

大白话：把这一层的输入原样加到输出上，等于给信息开了一条不用经过这层运算的直通路。正式定义：普通层 y = f(x)，残差层 y = f(x) + x。把 x 加回去会改输出吗？会变，但不会变坏——f 是训练出来的，原来它得亲手算出完整目标 H(x)，现在只需算「目标与输入的差」f(x) = H(x) − x，最后 f(x)+x 又自动拼回 H(x)；训练时网络早把这条「+x」算在内，会主动调整 f 去配合。这正是「残差」（residual = 余项、差值）的由来。更妙的是「按需微调」变得极廉价：某层最该做的是「别添乱、把输入原样传下去」，普通层得逼一整组权重恰好凑出恒等映射，意外地难；残差层只要 f(x)≈0 就行，什么都不学反而是最容易的默认。唯一前提是 x 与 f(x) 形状相同，而 Transformer 每个子层都保持同样的 dmodel 维，这一加天然成立。

LayerNorm：把数值拉回标准量级

大白话：每过一块就把这条向量重新「校准」一次，别让某些数字越滚越大、某些越缩越小。正式定义：深层网络的激活值尺度会到处乱跑，本来就是通病，早在没有残差的年代就存在；残差只是让它以「单调膨胀」这种显眼方式冒出来。所以归一化不是专门给残差打的补丁，而是深层网络通用的稳压器。记号先交代两个：xℓ 表示数据流过第 ℓ 块后的向量，残差累加写成 xℓ+1 = xℓ + fℓ(xℓ)；‖x‖ 是向量的长度，叫范数，各分量平方求和再开根号。若起步 ‖x‖≈1，每过一块被 +f 顶大一点，示意里 4 块就到 6.6 倍、第 12 块近 30 倍。量级一失控会撞两堵墙：其一，16 位浮点位数有限，要么溢出成 inf/NaN 训练崩盘，要么大数把小数吃掉（10000 和 0.001 相加，0.001 直接被舍没）；其二，第 11 课的 Softmax 对输入大小极敏感，数过大输出就挤成非 0 即 1，注意力只死盯一个词、梯度近零。LayerNorm 对每个词向量单独做三步：① 求均值 μ=mean(x)、标准差 σ=std(x)；② 归一到均值 0、标准差 1 的 x̂=(x−μ)/σ；③ 再缩放平移 output=γx̂+β，γ、β 可学习——归一化是死规矩，但网络能把分布再「拧」回它真正想要的范围。

Pre-LN vs Post-LN：Norm 放哪决定能不能训起来

大白话：LayerNorm 摆在残差主路上还是支路上，看似小事，却决定深层模型训不训得动。正式定义：这是 2019 年后才被业界看清的坑。Post-LN 写作 y = LN(x + f(x))，x 被 LN 二次加工，主路受扰，深层梯度仍不稳，得靠脆弱的「学习率预热」哄着训；Pre-LN 写作 y = x + f(LN(x))，x 原样直通，只在支路上 Norm，残差主路全程畅通——这才是 GPT 能稳稳堆到几十上百层的关键。还有个更省的变体 RMSNorm（LLaMA 等在用）：连均值都不减，只把向量除以自己的「均方根」来定量级（x/RMS(x)·γ），少算一步、参数更少，效果却几乎一样。

3. 亲手算一遍

分两笔账。先算梯度：普通 96 层与残差 96 层的差别。

普通层（每层导数 0.9）：0.9⁹⁶ ≈ 0.00006        ← 梯度消失
普通层（每层导数 1.1）：1.1⁹⁶ ≈ 12000         ← 梯度爆炸
残差层求导：∂y/∂x = ∂f/∂x + 1
  哪怕 ∂f/∂x 小到 0.01，这层总梯度 = 1.01
  96 层连乘：1.01⁹⁶ ≈ 2.6                    ← 温和，既不消失也不爆炸

再手算一次 LayerNorm，输入一条 4 维向量 x = [8, 2, 2, 4]：

① 均值   μ = (8+2+2+4)/4 = 4
② 方差   = [(8−4)² + (2−4)² + (2−4)² + (4−4)²]/4
         = (16 + 4 + 4 + 0)/4 = 6   →  σ = √6 ≈ 2.45
③ 归一化 x̂ = [(8−4)/2.45, (2−4)/2.45, (2−4)/2.45, 0]
         ≈ [1.63, −0.82, −0.82, 0]
④ 输出   = γ·x̂ + β（γ、β 由训练学习）

所以结论是：一条原本 [8,2,2,4]、量级乱七八糟的向量，被拉成均值 0、标准差 1 的 [1.63, −0.82, −0.82, 0]；配合残差那条「+1」的高速路，梯度从 0.00006 的绝境变成 1.01⁹⁶≈2.6 的温和值。这两个数说明：残差解决「梯度能不能传回去」，LayerNorm 解决「一路上数值会不会涨到失控」，一个管通路、一个管量级，缺一不可，深层网络才得以稳稳叠到 96 层。

4. 一个类比就够了

残差像给高楼装了一部「直达电梯」：货物（梯度）可以逐层搬运，也可以坐电梯一路直回一楼，不必每层都过一道会缩水的检查；LayerNorm 像每层楼门口的「校准台」，把进来的货物重新量一次尺寸，别让箱子越叠越大把楼道堵死。

类比的边界：像的是「一条不衰减的直通路 + 每层一次量级校准」；不像的是，电梯里货物完全不变，而残差主路每步仍会加上一个小增量 f（只是 f≈0 时几乎不变）；校准台也不是把货物强行改成统一规格就完事，γ、β 还能把分布拧回网络想要的范围。别把 LayerNorm 想成把信息抹平，它只是把尺度拉回正常。

5. 五个常见误区

误区 1：把输入 x 加回去会改坏这一层的输出 → ❌ 错 → ✅ 正解：f 是训练出来的，分工从「算完整 H(x)」变成「算差值 H(x)−x」，最后 f(x)+x 自动拼回 H(x)，该输出什么还是什么。

误区 2：残差只是让网络更深、参数更多 → ❌ 错 → ✅ 正解：核心是 ∂y/∂x = ∂f/∂x + 1 里那个「+1」，给梯度留一条恒为 1、不衰减的捷径。

误区 3：LayerNorm 是专门给残差打的补丁 → ❌ 错 → ✅ 正解：激活值尺度漂移是深层网络的老通病，没有残差的年代也存在；归一化是通用稳压器，残差只是让它以单调膨胀的方式更显眼。

误区 4：归一化把向量压成固定值，损失了表达力 → ❌ 错 → ✅ 正解：第 ③ 步的 γ、β 可学习，网络能把标准分布再拧回真正想要的范围，既享受稳定又不丢灵活。

误区 5：Norm 放前放后无所谓 → ❌ 错 → ✅ 正解：Post-LN 的 LN(x+f(x)) 让主路被二次加工，深层梯度仍不稳、要靠学习率预热；Pre-LN 的 x+f(LN(x)) 让主路纯净，才撑得起上百层。

6. 和前后课的接口

• 上一课（编码器、解码器与大语言模型）：定下了纯解码器这条主流结构，也带出新问题——GPT-3 有 96 层，这么深怎么还训得动。
• 这一课（残差连接与层归一化）：补上两个稳定器，残差用「+1」修通梯度高速路，LayerNorm 用均值 0 / 标准差 1 挡住数值漂移，并点明 Pre-LN 才是能堆深的关键。
• 下一课（预训练 · 监督微调 · 强化学习）：骨架、零件、稳定器都齐了，来解决「一个只会预测下一个词的模型，怎么变成会回答、会帮忙的 ChatGPT」。

7. 自测 6 题（附答案）

Q1 96 层网络、每层导数平均 0.9，第 1 层收到的梯度约是多少？ A 0.9　B 0.00006　C 12000　D 2.6 答案：B｜解析：0.9⁹⁶≈0.00006，几乎为零。C 是每层 1.1 的爆炸值，D 是加了残差后 1.01⁹⁶ 的温和值。

Q2 残差连接 y=f(x)+x 求导后，最关键多出来的是哪一项？ A +x　B +1　C ×0.9　D σ 答案：B｜解析：∂y/∂x = ∂f/∂x + 1，那个恒为 1 的项是梯度不衰减的命根子；A 是前向加的量，不是导数项。

Q3 手算 x=[8,2,2,4] 的均值 μ 是多少？ A 2　B 4　C 6　D 2.45 答案：B｜解析：(8+2+2+4)/4=4。C 是方差 6，D 是标准差 √6≈2.45，别把三者混了。

Q4（判断） 该例方差为 6、σ=√6≈2.45，归一化后约为 [1.63, −0.82, −0.82, 0]。 答案：对｜解析：各分量先减 4 得 [4,−2,−2,0]，再除以 2.45 即得该结果，均值 0、标准差 1。

Q5 Pre-LN 的正确写法是？ A LN(x+f(x))　B x+f(LN(x))　C f(x)+LN(x)　D LN(f(x)) 答案：B｜解析：Norm 只作用在支路上，x 原样直通；A 是 Post-LN，主路被二次加工，深层不稳。

Q6（判断） RMSNorm（LLaMA 等）连均值都不减，只把向量除以自己的均方根来定量级，少算一步、效果几乎一样。 答案：对｜解析：写作 x/RMS(x)·γ，是「能简则简」的又一例，参数更少、效果相近。

8. 一页速记

• 残差管「梯度能不能传回」，LayerNorm 管「数值会不会失控」。
• 「+1」让「什么都不学」（f≈0）成为最容易的默认，深层不怕被搅乱。
• 16 位浮点下，量级失控会溢出或把小数吃掉，Softmax 也会饱和。
• 稳定器齐了，下一课讲「会预测下一个词」怎么变成「会帮忙」。

一句话：把一台只会「接话」的续写机器，用预训练、监督微调、强化学习三步，炼成会回答、合口味的助手。

难度：★★☆　　预计：约 15 分钟

原文：第 25 课 · 预训练 · 监督微调 · 强化学习

0. 先记住这三句

• 刚预训练完的裸模型只会续写：它把你的请求当成网文开头往下接，并不打算帮你把事办完。
• 三步各管一头：预训练给才华，SFT 给礼仪（指令范例 + 损失只算回答段），RLHF 给价值观（把人类偏好炼成打分器再回头拧模型）。
• 优化时要拴一根 KL 缰绳「别离 SFT 模型太远」，否则模型会钻打分空子、复读高分废话。

1. 这一课在补哪个洞

上一课骨架、零件、稳定器都齐了，我们有了在海量文字上练过「预测下一个词」的 GPT。可你敲下「帮我写一封向房东投诉漏水的邮件」，它回的却是「——这是很多租客都会遇到的烦恼。在动笔之前，你需要先确认几件事……」。它在续写你这句话，因为互联网上满是「提个问题、然后展开议论」的文章，它脑子里只有「下一个词最可能是什么」，压根没有「替用户完成一件事」的概念。

如果没有这三步，模型永远停在接话机器；缺了第三步，就算学会按格式开口，也不知道两个都「格式正确」的回答里哪个更有帮助、更诚实、更安全——更别提你没法给每种刁钻问题都写出范例。光靠模仿，到头了。

2. 概念逐层拆

预训练：规模变了，目标没变

大白话：让模型把海量文字读一遍，反复玩「给定前 k 个词猜第 k+1 个」的填空。 正式定义：自监督语言建模，目标与第 14 课 N-gram 一模一样，只把规模放大。GPT-3 约 3000 亿 token，Llama-3 约 15 万亿 token（相当于把整个互联网读了好多遍），一次训练算力按今天价码动辄上千万美元——三步里唯一烧钱到这个量级的。 最小例子：「太阳从＿＿升起」要填「东」得懂地球自转，「快速排序的平均复杂度是 O(n＿＿n)」要填「log」得真懂算法。想猜准下一个词，被迫理解世界，于是语言、事实、推理、代码被悄悄压进几千亿个参数——但学到的是「续写」，不是「听话」。

SFT：换教材，更换「损失算在哪一段」

大白话：雇人写几万到几十万条「指令 → 理想回答」，让模型学「轮到我说话时该怎么说」。 正式定义：把对话套进固定模板（用户段 / 回答段），损失只在回答段计算，用户段当已知条件不计损失。模型学的不是续写整段对话，而是看到请求、按回答格式开口。 最小例子：模板里 user 段提问不参与损失，只有 assistant 段参与。就这点改动，续写机器变成对话助手。可 SFT 只教会格式，没教会好坏：标注员范例风格五花八门，而「好回答」本就没有唯一标准答案。

奖励模型：把「说不清的好」炼成一个分数

大白话：不让人写标准答案，只让人做选择题——同一问题给两个回答 A、B，问「哪个更好？」 正式定义：收集几十万条「A 比 B 好」，训练一个奖励模型：本质是另一个 Transformer，顶上换打分头，输入任意回答、输出一个分数。目标是让被选中的分更高，损失 L = −log σ(r(好回答) − r(差回答))。 最小例子：r(好)=2.0、r(差)=0.5 时差 1.5，损失约 0.20（第 3 节细算）。「说不清的好」就这样被量化成可计算的分数。

RLHF 下半场与两根缰绳

大白话：让模型多说高分的话，但不许为了高分走火入魔。 正式定义：真正奖励 = r(x,y) − β·KL(新模型 ∥ SFT 模型)，经典方案是 PPO。一味追高分会出现「奖励欺骗」（reward hacking）：找到打分器误判为高分、人读起来却是车轱辘废话的套路疯狂复读。PPO 要同时伺候语言模型、奖励模型、参考模型好几个网络，又笨重又难调；2023 年的 DPO 跳过单独奖励模型和整套 RL 循环，直接在偏好数据上一步拧到位——又一次「能简则简」，如今很多开源模型都改用了它。

3. 亲手算一遍

输入：某条偏好比较，人类选了好回答 A、差回答 B；奖励模型当前给分 r(A)=2.0、r(B)=0.5。算损失 L = −log σ(r(A) − r(B))。

第 1 步 求分差：Δ = 2.0 − 0.5 = 1.5。 第 2 步 算 sigmoid：σ(1.5) = 1/(1+e^(−1.5)) = 1/(1+0.2231) = 1/1.2231 ≈ 0.8176。 第 3 步 取负对数：L = −log(0.8176) ≈ 0.2013（自然对数）。 第 4 步 对照判反的情形：r(A)=0.5、r(B)=2.0，则 Δ=−1.5，σ(−1.5) ≈ 0.1824，L = −log(0.1824) ≈ 1.701。

所以结论是：判对损失约 0.20、判反约 1.70，差了 8 倍多。这个数说明「让被选中的回答分更高」这条训练信号非常硬：优化器会拼命把好回答的分推上去、把差回答压下去，几十万条比较累加，打分器就学会了人类口味。也正因语言模型会「追着分数跑」，才需要那根 KL 缰绳，别让它为了刷分复读废话。

4. 一个类比就够了

把三步想成培养客服：预训练像把人丢进图书馆读一辈子书，知识渊博却没练过服务；SFT 像老员工示范几十次「顾客说这句、你该这样答」；RLHF 像主管每次听完录音只给一句「这趟比上趟舒服」，车队据此调整口径。

边界要划清：像的是「用反馈逐步塑形、越往后反馈越不具体」；不像的是，真实 RLHF 的反馈被压成一个标量分数、还乘了「别离原模型太远」的 KL 惩罚，人不会给「0.82 分」，也不会因「和昨天差太多」被扣分。别把类比当成机制本身。

5. 五个常见误区

误区 1：预训练已教会模型听懂并帮忙 → ❌ 预训练目标只有「预测下一个词」，学到的是续写。 → ✅ 帮忙是 SFT 加格式、RLHF 加价值观之后才有的，三步缺一不可。

误区 2：SFT 要给每种刁钻问题写标准范例 → ❌ 好回答本就没有唯一标准答案，也写不全。 → ✅ SFT 只教格式，好坏交给第三步的偏好数据。

误区 3：RLHF 里人要逐条写出「理想回答」 → ❌ 写好答案又难又主观。 → ✅ 人只做「A 还是 B」的两两比较，选择题谁都答得上来。

误区 4：奖励模型打的分越高，回答越好 → ❌ 打分器会被钻空子，出现奖励欺骗、复读废话。 → ✅ 要减 β·KL 把模型拴在 SFT 模型附近。

误区 5：DPO 是一种更猛的强化学习 → ❌ 它跳过了单独奖励模型和整套 RL 循环。 → ✅ DPO 直接在偏好数据上优化语言模型，比 PPO 简单得多。

6. 和前后课的接口

• 上一课（第 24 课）留下了：残差 + LayerNorm 让 96 层网络稳稳训起来，骨架、零件、稳定器全都齐了。
• 这一课补上了：一台只会续写的裸模型怎样变成会回答、合口味的助手——预训练 / SFT / RLHF 三阶段。
• 下一课（第 26 课）来解决：模型能用了，可注意力 O(n²) 的账单让长上下文贵得吓人。

7. 自测 6 题（附答案）

Q1 你问「帮我写封投诉漏水的邮件」，刚预训练完的模型最可能？ A. 直接把邮件写好　B. 把请求当成文章开头往下续写议论　C. 拒绝回答　D. 先反问你房东姓名 答案：B｜解析：A 是 SFT/RLHF 之后才有的；预训练只学「下一个词最可能是什么」，「提问+展开议论」的体裁让它接着写。C、D 都不是续写模型的默认行为。

Q2 预训练阶段的核心目标是？ A. 学会礼貌用语　B. 在海量无标注文本上反复预测「下一个词」　C. 记住人工规则　D. 只做数学计算 答案：B｜解析：从第 14 课 N-gram 到上百层 Transformer，目标从头到尾没变，只是估计概率的工具越来越强。A 属 SFT；C、D 与自监督语言建模无关。

Q3 SFT 里那个「不起眼却关键的机关」是？ A. 换更大的学习率　B. 换更大的词表　C. 对话套进固定模板、且损失只算回答段　D. 多堆几十层 答案：C｜解析：用户段当已知条件不计损失，模型才学会「轮到我说话时按回答格式开口」，而不是续写整段对话。A、B、D 都不是定义性改动。

Q4 奖励模型的训练信号来自？ A. 人工逐条写出的满分答案　B. 人类对「A / B 哪个更好」的两两比较　C. 模型自己的损失曲线　D. 词频统计 答案：B｜解析：好回答写不全、说不清，于是改问选择题。A 是 SFT 思路；C 是训练诊断、D 是第 14 课 N-gram 做法，都与人类偏好无关。

Q5 训练时为什么要减一项 β·KL(新模型 ∥ SFT 模型)？ A. 让模型参数更多　B. 防止一味追高分、复读废话的奖励欺骗　C. 加快分词速度　D. 提高机器翻译 BLEU 答案：B｜解析：KL 把模型拴在 SFT 附近，堵住打分器漏洞。A、C 与优化目标无关；D 是第 32 课论文里的翻译指标。

Q6 关于 DPO，哪一项对？ A. 它要同时伺候四个网络　B. 它是 PPO 的更复杂版本　C. 它跳过单独奖励模型与 RL 循环，直接在偏好数据上优化　D. 它只能用于 7B 小模型 答案：C｜解析：原文明确 DPO 是 2023 年的聪明简化版。A 是 PPO「又笨重又难调」之处；B 说反了；D 无依据。

8. 一页速记

• 主线未变：从第 14 课到第 25 课，目标始终是「预测下一个词」，变的只是估计概率的工具。
• 判对损失约 0.20、判反约 1.70，差 8 倍多，偏好信号很硬。
• 真正奖励 = r(x,y) − β·KL，这根缰绳专治奖励欺骗；PPO 笨重，DPO 跳过 RL 循环。

一句话：注意力是 O(n²) 的，工程师用「少算、不重算、少搬」三种手段，把长上下文从妄想变成日常。

难度：★★★　　预计：约 15 分钟

原文：第 26 课 · KV 缓存、稀疏注意力与 FlashAttention

0. 先记住这三句

• 注意力让每个 token 与所有 token 两两比较，n 个 token 就是 n×n 个格子，序列一长这张表大到装不下。
• 三条路各管一件事：稀疏注意力「少算」（近似、会丢远处）、KV 缓存「不重算」（生成时存下旧词 K/V）、FlashAttention「不减计算、只改搬运」（在线 softmax，结果精确）。
• 128k 上下文一层就有约 164 亿个格子，乘上约 120 层；正是这些工程把 128k+ 的长上下文跑了起来。

1. 这一课在补哪个洞

第 21 课结尾记了一笔账没还：注意力要让每个 token 和所有 token 两两比较，n 个 token 就有 n×n 个格子。到第 25 课模型能用了，可真要读完整本书、一整个代码库时，这笔账单就压到脸上来了。

把数字摆具体：GPT-4 上下文 128k token，若全用标准注意力，一层的注意力表就有 128000² ≈ 164 亿 个格子，乘上约 120 层——一次推理光注意力就得算两万亿次，FFN 还没算进去。32k token（约一本书）也有 10 亿个格子，而且每一层都要重算一遍。还有一笔纯属浪费的重复账：自回归生成时每吐一个词就把前面所有词的 K、V 从头又算一次，可那些词没变啊，「I」的 K、V 在第 2 步、第 3 步、第 100 步都是同一个值。如果不摁下这两笔账，长上下文要么慢到没法用，要么显存直接爆。

2. 概念逐层拆

O(n²) 账单

大白话：n 个词两两握一次手，握手次数是 n 乘 n，人一多就爆炸。 正式定义：注意力矩阵是 n×n，计算与内存都随序列长度平方增长，且每层各算一遍。 最小例子：4 个 token 是 4×4=16 格，翻到 8 个就是 64 格——长度翻倍、格子翻 4 倍。这就是 128k 会算出 164 亿格的原因。

稀疏注意力：干脆别算那么多

大白话：每个词别看全句，只看左右 W 个邻居，大片空格直接跳过。 正式定义：滑动窗口注意力，计算量从 O(n²) 降到 O(n·W)（W 固定，相当于随 n 线性增长）。只看邻居会看不到远处，所以实战打几个补丁：留几个「全局 token」（比如开头的指令）让所有位置都能看到它、它也能看全文；或让窗口「跳着看」（膨胀窗口）。Longformer（2020）、Mistral（2023）靠这类组合把上下文撑到几十万 token。 最小例子：n=10000、W=512，从 1 亿格降到约 512 万格。但这条路是近似——它赌「远处不重要」，赌对了省钱、赌错了漏信息，改变了数学结果。

KV 缓存：别重算没变的东西

大白话：算过的 K、V 存起来，下一步只算新来的那一个词，其余直接从缓存取。 正式定义：已生成 token 的 Key/Value 不再变化，缓存后每生成一个新词，只为该词算 K/V，再拿它的 Query 去和「缓存里全部 K/V」做注意力，每步开销从 O(n²) 降到 O(n)。这是所有大模型推理的标配加速。 最小例子：生成到第 100 步时，前 99 个词的 K/V 一次都不用重算。代价是拿显存换速度，缓存一直占着内存，超长对话特别吃显存；后来的 MQA / GQA（第 20 课提过的多头变体）让多个头共享同一份 K、V，缓存立刻小一大截。

FlashAttention：不减计算，只改顺序

大白话：一格都不少算，结果和标准注意力分毫不差，却能快好几倍——秘密不在「算」，在「搬」。 正式定义：GPU 有两层存储，HBM（显存）几十 GB 但读写慢，SRAM（片上缓存）只有几十 MB 却快十几倍。标准注意力的真正瓶颈是那张 n×n 大矩阵塞不进 SRAM，只能写进 HBM、读回来做 softmax、再写回去。FlashAttention（2022，斯坦福）用「在线 softmax」边读边修：靠一个 running 最大值 m 和一个 running 分母 ℓ，把行切成小块流着算，发现更大的数就把已算部分按新旧最大之差等比缩小，于是大矩阵压根不用落地到 HBM。快 2~4 倍、显存省好几倍，且结果精确。 最小例子：一行分数 [2, 1, 4, 0] 分两块送进来，照样算出正确的分母（第 3 节细算）。

3. 亲手算一遍

输入：一行注意力分数 [2, 1, 4, 0]，但每次只送来两个数（模拟分块进 SRAM）。目标：求 softmax 的分母 ℓ = Σ e^(分数 − 整行最大值)。

第 1 步 来第一块 [2, 1]：当前最大 m = 2；ℓ = e^(2−2) + e^(1−2) = 1 + 0.37 = 1.37。 第 2 步 来第二块 [4, 0]：发现 4 比旧最大 2 还大，新 m = 4。旧账按 e^(2−4) = e^(−2) ≈ 0.14 缩小：1.37 × 0.14 = 0.19。 第 3 步 接上新块：ℓ = 0.19 + e^(4−4) + e^(0−4) = 0.19 + 1 + 0.02 = 1.21。 第 4 步 对照整行一次算：整行最大是 4，ℓ = e^(2−4) + e^(1−4) + e^(4−4) + e^(0−4) = 0.14 + 0.05 + 1 + 0.02 = 1.21 ✓ 完全一致。

所以结论是：分两块流着算，得到的分母 1.21 与整行一次算出的 1.21 一字不差。这个数说明 softmax 不必一次看到整行也能算得精确——只要记住 running 最大值与 running 分母，遇到更大的数就把旧账等比缩小。正因为结果精确，FlashAttention 才敢把注意力分块塞进 SRAM 算完就走，那张 164 亿格的大矩阵从不写进慢速 HBM。它不改变结果、不丢信息，因此成了「无脑就该开」的默认项，今天 PyTorch、各大训练框架都内置了它。

4. 一个类比就够了

把算注意力想成填一张全班 n 人两两互评的大表：稀疏注意力 = 只让同桌前后几人互评（省纸，但看不到教室另一头）；KV 缓存 = 评过的人把评语抄进笔记本，新来一人只评他、不再重抄全班；FlashAttention = 题不换、格不减，只是别把大表搬去遥远仓库再搬回来，改在手边小桌上一块块算完。

边界要划清：像的是「都在省时间或省空间」；不像的是，真实 GPU 的 HBM 与 SRAM 有明确容量与速度差（几十 GB 对几十 MB、快十几倍），而且 FlashAttention 靠的是在线 softmax 这个数学技巧。尤其别把「少搬运」听成「少计算」——它一格都没少算。

5. 五个常见误区

误区 1：稀疏注意力和 FlashAttention 都是「少算一点」的近似 → ❌ 稀疏改数学结果，Flash 不改。 → ✅ 前者省算但会丢远处，后者省搬且精确，二者还能叠加。

误区 2：KV 缓存是训练时的加速 → ❌ 训练时整句一次喂全，没有「逐词再跑一遍」。 → ✅ 它是自回归生成阶段专用的，缓存的是不再变化的旧 K/V。

误区 3：KV 缓存省显存 → ❌ 缓存要一直占着内存，序列越长占得越多。 → ✅ 它拿显存换速度；真正缩小缓存的是 MQA / GQA 让多头共享 K/V。

误区 4：FlashAttention 靠降低注意力精度来提速 → ❌ 结果与标准注意力分毫不差。 → ✅ 在线 softmax 让分块计算精确，被解决的是「搬运」这个瓶颈。

误区 5：滑动窗口的 W 越大越好 → ❌ W 一大就退回 O(n²) 了。 → ✅ 省算的代价正是「看不到远处」，所以才要全局 token、膨胀窗口打补丁。

6. 和前后课的接口

• 上一课（第 25 课）留下了：三阶段训练把续写机器变成会帮忙的助手，模型能用了。
• 这一课补上了：还掉第 21 课欠的 O(n²) 账单，用少算 / 不重算 / 少搬三招让长上下文真正跑得起来。
• 下一课（第 27 课）来解决：长上下文能跑了，但「参数越多越慢」的另一堵墙还在。

7. 自测 6 题（附答案）

Q1 标准自注意力处理长度 n 的序列，计算/内存开销大致是？ A. O(n)　B. O(n²)　C. O(1)　D. O(log n) 答案：B｜解析：每个词都要和所有词两两比较，共 n×n 个格子。A 是滑动窗口近似后随 n 线性的结果；C、D 都不符合 n×n 这张表。

Q2 128k token、标准注意力，一层的注意力表约有多少格子？ A. 16 万　B. 1.64 亿　C. 164 亿　D. 两万亿 答案：C｜解析：128000² = 1.6384×10¹⁰ ≈ 164 亿。D 是再乘约 120 层之后「一次推理约两万亿次」的量级；A、B 都少算了一两个数量级。

Q3 生成时「避免重复计算已处理 token 的 Key/Value」靠哪一项？ A. 层归一化　B. KV 缓存　C. 词向量　D. 交叉熵损失 答案：B｜解析：旧词 K/V 不变，存起来即可。A 是第 24 课的数值稳定器，C 是第 15/22 课的入口，D 是第 10 课的损失，都与缓存无关。

Q4 关于 FlashAttention，哪一项对？ A. 减少计算量、结果是近似　B. 把大矩阵写进 HBM 反而更快　C. 用在线 softmax 让分块在 SRAM 算完，结果精确、快 2~4 倍　D. 只在训练时用 答案：C｜解析：A 把「省搬」说成「省算」；B 恰好反了，大矩阵从不落地 HBM；D 无依据。它不改变数学结果，所以是默认项。

Q5 在线 softmax 分两块处理 [2,1,4,0]，最终分母是？ A. 1.37　B. 0.19　C. 1.21　D. 7.76 答案：C｜解析：1.37 是只看第一块的中间值，0.19 是缩小后的旧账，7.76 是第 19 课另一个例子的总和。流式与整行一次算都得 1.21。

Q6 想要「完整精确的注意力、一格不漏，只是嫌它太慢太占内存」，该选哪条路？ A. 滑动窗口　B. 稀疏注意力　C. FlashAttention　D. 减少层数 答案：C｜解析：A、B 是近似，会丢远处信息；D 改了模型能力。只有 FlashAttention 结果分毫不差又提速。

8. 一页速记

• 账单：32k 约 10 亿格；128k 一层约 164 亿格，乘约 120 层 ≈ 两万亿次。
• 在线 softmax 口诀：记住 running 最大 m 与分母 ℓ，遇到更大的数把旧账乘 e^(旧m−新m) 缩小。
• [2,1,4,0] 流式与整行都得分母 1.21 ✓；稀疏（省算）与 Flash（省搬）可叠加。

一句话：把占约三分之二参数的 FFN 换成一群专家加一个路由器，每个 token 只激活少数几个——知识容量按总参数走，算力按激活参数走。

难度：★★☆　　预计：约 15 分钟

原文：第 27 课 · MoE 混合专家架构

0. 先记住这三句

• 缩放定律说参数越多越强，可标准 Transformer 每生成一个 token 全部参数都要参与一次计算：参数翻 10 倍，每 token 成本也老实翻 10 倍。
• MoE = N 个专家 FFN + 一个路由器，每个 token 只走 Top-K 个（通常 K=2）；「8 倍参数、约 1 倍算力」不是矛盾修辞，是分诊换来的。
• Mixtral 8×7B 总参数约 47B、每 token 只激活约 13B；GPT-4 据传约 1.8 万亿总参数（16 专家、每次激活 2）。

1. 这一课在补哪个洞

上一课把注意力的 O(n²) 账单摁下去了，长上下文跑得起来。可另一堵墙纹丝不动：想更聪明就得堆参数。GPT-2（1.5B）→ GPT-3（175B）→ GPT-4，能力的台阶基本是用参数量堆出来的。堆参数有个躲不开的账：标准 Transformer 里每生成一个 token，全部参数都得参与一次计算；参数翻 10 倍，每 token 推理成本也翻 10 倍；175B 的 GPT-3 一张显卡装不下，得好几张卡接力。

如果没有 MoE，长上下文省下的算力又会被膨胀的参数吃回去，我们只能在「强」和「快」之间二选一。这一课问的是：能不能不必让所有参数都参与每一次计算，既拥有海量参数，又保持低成本？

2. 概念逐层拆

先找最肥的那块肉：FFN

大白话：要「只唤醒一部分」，得先看哪块零件最占地儿、最值得拆。 正式定义：回到第 21 课的 Block 数参数——注意力层 Q、K、V、O 四个 d×d 矩阵约 4d²；FFN 先放大 4 倍再缩回（d→4d→d），两个大矩阵约 8d²。合计约 12d²，所以 FFN 占了约 2/3 的参数。 最小例子：8d² / 12d² = 2/3。而第 21 课说过，FFN 是模型的「知识仓库」，大半事实都编码在它权重里。可标准做法是所有 token 都挤过同一个 FFN——不管你是一段代码、一句诗，还是一个数学公式，都去同一个仓库里翻。处理代码和处理诗歌需要的知识天差地别，凭什么塞在一个 FFN 里？要拆，就拆它。

路由器（分诊台）与稀疏激活

大白话：一个轻量的小网络给每个 token 打分，挑出最合适的几个专家，其余这次不干活。 正式定义：把每层那一个 FFN 复制成 N 个平行的专家 FFN（比如 N=8），前面加一个线性层当路由器，输出 N 个 logits，softmax 成概率后取 Top-K（通常 K=2）；token 只穿过这 K 个专家，其余 N−K 个本次不参与；K 个专家的输出按路由器给的权重加权求和。 最小例子：4 个专家、选 Top-2，logits [3.1, 0.5, 2.4, −1.0] 的完整账见第 3 节。这套「分工 + 只激活相关部分」和第 20 课的多头注意力是同一种智慧的两个方向：多头把注意力拆成几个头各看一种关系，MoE 把 FFN 拆成一群专家各管一类输入——一个切「注意」、一个切「记忆」。

一笔魔法账本，与两个现实坑

大白话：知识容量按总参数算，推理成本按激活参数算，两者被路由器拆开了。 正式定义：拿 Mixtral 8×7B（Mistral AI）算——注意「8×7B」很容易被误会成 56B，其实注意力层、嵌入表是所有专家共享、只数一次，总参数约 47B；每个 token 只走 2 个专家，实际激活约 13B。DeepSeek-V3 更激进：256 个专家、每次只激活 8 个，总参数 671B，单 token 激活仅约 37B。 坑一「旱涝不均」：路由器老往两三个专家派活，剩下的学不到东西、白占参数，所以训练要加「负载均衡损失」把 token 摊匀；还有个硬限制叫容量，每个专家每批最多收这么多 token，挤爆的多余 token 会被丢弃（该层只靠残差直通）。坑二「省算力没省显存」：不参与计算 ≠ 不占地方，全部 N 个专家参数都得常驻显存随时待命；专家常分散在不同 GPU 上，路由时 token 要跨卡跑，通信能成为新瓶颈，DeepSeek 等靠「节点内优先路由」摁住它。

3. 亲手算一遍

输入：某 token 过路由器，得到 4 个专家的打分 logits [3.1, 0.5, 2.4, −1.0]；设定 4 个专家、选 Top-2。把原文那本账摊开算。

第 1 步 softmax 成概率：取近似值 e^3.1 ≈ 22.20、e^0.5 ≈ 1.65、e^2.4 ≈ 11.02、e^(−1.0) ≈ 0.37，总和 ≈ 22.20+1.65+11.02+0.37 = 35.24。逐项除总和得 [0.63, 0.05, 0.31, 0.01]（例如 22.20/35.24 ≈ 0.63）。 第 2 步 选 Top-2：最高的两个是专家1（0.63）与专家3（0.31），专家2、专家4 本次空转。 第 3 步 权重重新归一（只在这两个里分）：0.63/(0.63+0.31) = 0.63/0.94 ≈ 0.67，0.31/0.94 ≈ 0.33。 第 4 步 加权求和：设两个专家对该 token 的输出为 E1、E3，则 输出 = 0.67 × E1(x) + 0.33 × E3(x)。 第 5 步 算算力账：本次只穿过 2 个专家、总共 4 个，即花掉 2/4 = 50% 的专家算力；但 4 个专家的参数仍全部常驻显存待命。

所以结论是：路由器把「知识容量」和「单次算力」拆开了——总参数按专家数（4 个）算，计算只按激活数（2 个）算。这正是 Mixtral 8×7B 那本账的缩影：装着 47B 的知识容量，每个 token 却只花 13B 的算力。想更聪明就多加专家把总参数堆上去，想更快就把每次激活的 K 压低，两个旋钮从此互不绑架。

4. 一个类比就够了

把 MoE 想成大医院的分诊台：病人（token）进门，护士（路由器）不问病情全貌，只看几个指标就把他指到最对口的 2 个科室（专家），其余科室这次不接诊；两个科室各出一份意见，按护士给的可信度加权汇总成诊断。

边界要划清：像的是「一个入口、挑少数处理者、结果加权汇总」；不像的是，真实专家并不按人类能命名的科室分工——路由器是训练中自己学出来的，分派往往跟着词法、句法这类表层特征走（标点、词形、某类 token），大多叫不出名字。而且不接诊的科室照样要付房租：全部专家参数常驻显存。别把「法律专家 / 代码专家」的标签当成机制本身。

5. 五个常见误区

误区 1：MoE 是把模型压缩成更小的文件 → ❌ 总参数反而更多了。 → ✅ 它是稀疏激活：参数海量，每次只用其中一小部分，省的是计算不是参数。

误区 2：Mixtral 8×7B 就是 56B 参数 → ❌ 注意力层、嵌入表共享，只数一次。 → ✅ 总参数约 47B，每个 token 只走 2 个专家、激活约 13B。

误区 3：专家会分化成「数学专家」「代码专家」这种能读懂的主题 → ❌ 路由器是训练中自己长出来的，多跟着表层特征走。 → ✅ 专家确实会分化，但那种分化大多没有一个我们能命名的标签，更像「8 条各有侧重、说不清侧重啥的流水线」。

误区 4：MoE 既省算力又省显存 → ❌ 不参与计算 ≠ 不占地方。 → ✅ 全部 N 个专家都得常驻显存；跨卡搬运 token 的通信还会成为新瓶颈。

误区 5：负载不均无所谓，反正专家多 → ❌ 路由器老派给两三个，其余学不到东西、白占参数。 → ✅ 要加负载均衡损失摊匀，还有容量上限，挤爆的 token 会被丢弃。

6. 和前后课的接口

• 上一课（第 26 课）留下了：少算 / 不重算 / 少搬三招摁下了注意力的 O(n²) 账单。
• 这一课补上了：解决「参数越多越慢」的另一堵墙，用路由器把总参数与激活算力拆成两个互不绑架的旋钮。
• 下一课（第 28 课）来解决：MoE 让大模型「又大又快」，可再快也是庞然大物、部署仍贵。

7. 自测 6 题（附答案）

Q1 MoE 能做到「总参数上万亿，每次推理只用一小部分」，靠的是什么？ A. 把模型压缩成更小的文件　B. 一个路由器为每个 token 只选少数专家参与计算（稀疏激活）　C. 每次随机删掉一半参数　D. 让所有专家同时全开 答案：B｜解析：A 让总参数变少，与事实相反；C 是随机丢弃、不是按输入分诊；D 是稠密模型。只有 B 改变了「全部参数参与每次计算」这条规则。

Q2 一个标准 Transformer Block 里，FFN 约占多少参数？ A. 1/3　B. 1/2　C. 2/3　D. 全部 答案：C｜解析：注意力约 4d²、FFN 约 8d²，合计 12d²，8/12 = 2/3。正因为最肥、又是「知识仓库」，MoE 才专挑 FFN 来拆。

Q3 MoE 中的路由器起什么作用？ A. 决定网络有几层　B. 为每个输入 token 决定该送给哪几个专家　C. 负责把文本切成 token　D. 计算最终的损失值 答案：B｜解析：C 是第 22 课分词器的活；A 属于架构超参、D 属于训练目标。它是个小小的线性层，输出各专家的打分。

Q4 logits [3.1, 0.5, 2.4, −1.0] 选 Top-2 并重新归一后，权重约为？ A. 0.63 / 0.31　B. 0.67 / 0.33　C. 0.50 / 0.50　D. 0.99 / 0.01 答案：B｜解析：A 是 softmax 后、重新归一之前的两个数；只在选中的两个里再分一次才得 0.63/0.94≈0.67 与 0.31/0.94≈0.33。C、D 都没有计算依据。

Q5 关于 Mixtral 8×7B，哪一项对？ A. 总参数 56B　B. 总参数约 47B、每 token 激活约 13B　C. 每次 8 个专家全开　D. 显存需求比同规模稠密模型小很多 答案：B｜解析：A 忘了共享部分只数一次；C 与 K=2 矛盾；D 忽略了「全部专家常驻显存」。

Q6 训练 MoE 为什么要额外加「负载均衡损失」？ A. 逼专家按人类能读懂的主题分工　B. 防止路由器总派给少数专家、其余学不到东西　C. 减少网络层数　D. 提高 softmax 的温度 答案：B｜解析：针对的是「旱涝不均」。A 是常见误会，分工是训练自己长出来的、且多非主题；C、D 与把 token 摊匀无关。

8. 一页速记

• 魔法账本：知识容量按总参数走，推理成本按激活参数走，被路由器拆开。
• 多头切「注意」、MoE 切「记忆」，都是「与其让大块什么都干，不如拆成小块各管一摊」。
• 专家不按可读主题分工；要防旱涝不均（负载均衡损失、容量、token 丢弃）；省算力不省显存。

一句话：让小模型模仿大模型的完整输出分布，而不只是抄正确答案——靠温度把软标签里的「暗知识」逼出来，把本事教给便宜的小模型。

难度：★★☆　　预计：约 15 分钟

原文：第 28 课 · 模型蒸馏

0. 先记住这三句

• 大模型聪明但烧钱（每 1000 token 约 0.03 美元），7B 小模型便宜但平庸；蒸馏让小模型接近大模型的水平。
• 软标签藏着硬答案没有的「暗知识」：错误项之间的相对高低（伦敦比罗马更像首都），硬标签只有一个比特的对/错。
• 温度 T 升温把被压扁的暗知识拉出来；损失 = α·KL（贴近升温教师）+ (1−α)·交叉熵（对照真答案），α 常取 0.5~0.9。

1. 这一课在补哪个洞

到第 27 课，我们既能造出 GPT-4 级别的庞然大物，又能用 MoE 让它「又大又快」。可它太贵：每生成 1000 个 token 约 0.03 美元，一家中型公司拿它扛下全部客服对话，一年 API 账单轻松上百万美元。而一个 7B 的小模型，在一张消费级显卡（16GB 显存）上就能跑，成本是前者的几百分之一——但它笨得多，尤其在推理、写作、代码这些硬任务上。

如果没有蒸馏，就只能在「聪明但烧钱」和「便宜但平庸」之间二选一。更关键的是，最朴素的「用大模型给一堆问题生成标准答案、再拿这批数据训小模型」漏了东西：它只抄了结论，把教师完整概率分布里那层「错得有讲究」的信息全丢了。这一课补的就是这层信息，以及把它逼出来的旋钮。

2. 概念逐层拆

硬标签 vs 软标签（暗知识）

大白话：告诉学生答案有两种讲法——只说「选 A」，或把四个选项各自的可能性都摊开。 正式定义：硬标签只传了一个比特：对，还是错；软标签是教师在整个类别上的完整概率分布。Hinton（深度学习三位先驱之一）2014 年提出的知识蒸馏，让小模型（学生）去模仿大模型（教师）的输出分布，学的是教师的「判断纹理」，不只是结论。 最小例子：考题「法国的首都是？A 巴黎 B 伦敦 C 罗马 D 柏林」，硬标签是「选 A」；软标签是「A 99.6%、B 0.25%、C 0.09%、D 0.05%」，还顺带告诉你错误项里伦敦比罗马、柏林更像个首都。这层信息硬标签里完全没有，Hinton 叫它「暗知识」（dark knowledge）。

温度 T：把暗知识逼出来

大白话：教师太自信了，错误项小到 0.05%，学生几乎看不见；把分数「升温」软化一下，纹理就露出来。 正式定义：softmax 之前把每个 logit 都除以 T，T 越大分布越「软」。升温不改变谁高谁低，却把被压扁的差距拉开成学生看得见、学得到的信号——这正是第 11 课那个调软硬的老旋钮。 最小例子：logits [8, 2, 1, 0.5] 在 T=1 被压成 [99.6%, 0.25%, 0.09%, 0.05%]，在 T=4 变成 [64%, 14%, 11%, 10%]（第 3 节细算）。

损失、两种蒸馏与天花板

大白话：学生同时背两个目标——既要像被升温软化的教师，也要答对真答案。 正式定义：L = α·L_soft + (1−α)·L_hard，前者是 KL 散度（对齐 T>1 的教师分布），后者是交叉熵（对照真答案），α 调两者轻重、常取 0.5~0.9，以软标签为主。三件工具没一件是新的：软标签是第 11 课 softmax 的概率分布，温度 T 是第 11 课的旋钮，KL 散度是第 6 课量「两个分布差多远」的尺子。 白盒 / 黑盒：经典版要拿到教师每一步、整个词表的概率分布，只有自己拥有教师（白盒）才行；只能通过 API 调 GPT-4 时（黑盒），只能拿教师生成的文本做普通 SFT，即序列蒸馏。2024 年火热的推理蒸馏正走这条路：让 DeepSeek-R1、o1 把完整思维链写出来，小模型照着训，DeepSeek-R1-Distill 把推理能力蒸进 7B/14B。 天花板：学生的上限就是教师，它在模仿、不会凭空超越源头；参数量是硬约束，小模型容量就那么点，细节处终会露怯。

3. 亲手算一遍

输入：教师对四个选项（巴黎 / 伦敦 / 罗马 / 柏林）的打分 logits [8, 2, 1, 0.5]。分别用 T=1 与 T=4 做 softmax，看暗知识怎么浮出来。

第 1 步 T=1，直接算：先都减最大值 8 得 [0, −6, −7, −7.5]，取幂约 [1, 0.0025, 0.0009, 0.00055]，总和约 1.004，归一化得 [99.6%, 0.25%, 0.09%, 0.05%]。三个错误项被压到小数点后好几位，学生几乎看不见。 第 2 步 T=4，先每个 logit 除以 4：[2, 0.5, 0.25, 0.125]。 第 3 步 对这排数 softmax：减最大值 2 得 [0, −1.5, −1.75, −1.875]，取幂约 [1, 0.223, 0.174, 0.153]，总和约 1.550，归一化约 [64%, 14%, 11%, 10%]。 第 4 步 读出纹理：巴黎仍最高，但「伦敦 14% > 罗马 11% > 柏林 10%」的相对高低清清楚楚露了出来。

所以结论是：升温不改变谁高谁低，却把 T=1 时被压成 0.25%/0.09%/0.05% 的三个错误项，拉成 14%/11%/10% 这种学生看得见、学得到的信号。这个数说明「暗知识」一直都在，只是藏在小数点后面；温度把它放大，KL 散度才有东西可对齐。也正因为 α 常取 0.5~0.9、以软标签为主，学生学到的才是教师的判断纹理，而不仅仅是「选 A」。

4. 一个类比就够了

把蒸馏想成老厨师带徒弟：只给菜谱上写「盐少许」，徒弟只知道要放盐（硬标签）；老厨师把自己尝味时「咸了三成、酸了两成、还差一点甜」的整套判断都讲出来（软标签），徒弟才学会为什么是这个比例。温度像把老厨师含糊的嘟囔放大成清楚的评语。

边界要划清：像的是「模仿者学到的比结论更多」；不像的是，真实学生是一个固定容量的神经网络，对齐的是整个词表的概率分布、并用 KL 度量差距，不是人能听懂的评语；而且学生翻不过教师这座山，它在模仿、不会凭空超越源头。别把「教」理解成能教出比老师更强的学生。

5. 五个常见误区

误区 1：蒸馏就是拿大模型生成的标准答案做 SFT → ❌ 那只用到硬标签，漏了分布里的暗知识。 → ✅ 经典蒸馏要对齐教师完整概率分布（白盒才行）；黑盒 API 场景只能退而求其次做序列蒸馏，两者别混。

误区 2：温度 T 越高，模型答得越准 → ❌ 升温是训练时把分布软化、暴露暗知识用的。 → ✅ 它不改变谁高谁低，推理答题并不靠高温提准确率；把概率变成 0/1 反而是低温干的事。

误区 3：软标签只是「更细一点的硬标签」 → ❌ 硬标签只有对错一个比特。 → ✅ 软标签还带着错误项之间相对高低这类类别关系信息，这才是暗知识。

误区 4：蒸馏能让学生超过教师 → ❌ 铁律是「学生的上限就是教师」。 → ✅ 它在模仿，不会凭空超越源头；且小模型容量装不下教师那么多知识。

误区 5：蒸馏零成本 → ❌ 要生成软标签或大量高质量文本，得让昂贵教师把整个训练集跑一遍。 → ✅ 它是把「一次性的教师推理成本」提前付掉，换日后廉价部署；划不划算，要看之后要跑多少次。

6. 和前后课的接口

• 上一课（第 27 课）留下了：MoE 让大模型「又大又快」，但再快也是庞然大物、部署仍贵。
• 这一课补上了：换一条思路，不改大模型本身，而是把它的本事教给小得多的模型，把成本压到消费级显卡上。
• 下一课（第 29 课）来解决：到这里大语言模型的核心技术栈拼齐了；下一课不引入新概念，只把从 N-gram 到 Transformer 的整条线串成一条项链。

7. 自测 6 题（附答案）

Q1 模型蒸馏让小模型「学」大模型的能力，关键依赖大模型输出的什么？ A. 只用非对即错的硬标签　B. 「软标签」——完整概率分布里的暗知识　C. 大模型的参数文件　D. 大模型的训练日志 答案：B｜解析：C、D 既拿不到也不是学习信号；A 正是开篇被指出「漏了什么」的朴素做法。软标签连错误项之间的相对高低都带着信息。

Q2 蒸馏中常对 Softmax 使用较高温度 T，目的是什么？ A. 让训练更慢　B. 软化分布、放大很小的非目标类别概率，暴露暗知识　C. 让大模型变得更大　D. 把概率全部变成 0 或 1 答案：B｜解析：D 恰好相反，高温让分布更平、更软；A、C 与升温无关。它是第 11 课那个旋钮的复用。

Q3 logits [8, 2, 1, 0.5] 在 T=4 下约为？ A. [99.6%, 0.25%, 0.09%, 0.05%]　B. [64%, 14%, 11%, 10%]　C. [25%, 25%, 25%, 25%]　D. [100%, 0, 0, 0] 答案：B｜解析：A 是 T=1 的结果；先除以 4 得 [2, 0.5, 0.25, 0.125] 再 softmax 就是 B。C 要更高温才趋近，D 是极低温的极端。

Q4 蒸馏的训练损失通常写成？ A. 只有交叉熵　B. α·KL（对齐升温教师）+ (1−α)·交叉熵（对照真答案）　C. 只有 KL　D. 均方误差 MSE 答案：B｜解析：学生同时背两个目标，α 常取 0.5~0.9、以软标签为主。A、C 各漏一半；D 不是这套损失。

Q5 只能通过 API 调 GPT-4、拿不到内部分布时，该走哪条路？ A. 白盒分布蒸馏　B. 黑盒序列蒸馏（拿教师生成的文本做 SFT）　C. 直接复制教师权重　D. 完全无法蒸馏 答案：B｜解析：A 要拥有教师内部；C 不可行；D 太绝对，2024 年起火热的推理蒸馏（DeepSeek-R1-Distill 7B/14B）正是这条路的成果。

Q6 关于蒸馏的天花板，哪一项对？ A. 学生必然超过教师　B. 学生的上限就是教师，且小模型容量有限　C. 与参数量无关　D. 数据够多就能超越 答案：B｜解析：它在模仿、不会凭空超越源头，参数量是硬约束。A、C、D 都违背了「翻不过教师这座山」这条铁律。

8. 一页速记

• 三件工具都不是新的：softmax（第 11 课）、温度 T（第 11 课）、KL 散度（第 6 课）——临近终点，零件来了一次会师。
• 白盒做分布蒸馏（信息最全），黑盒做序列蒸馏（一个 API 就够，含推理蒸馏）。
• 学生翻不过教师；教师推理本身有成本，是提前付掉的一次性开销。

一句话：不引入任何新概念，只把学过的六代零件串成一条线——每一代技术，都是来解上一代留下的死结的。

难度：★☆☆　　预计：约 15 分钟

原文：第 29 课 · 串讲：从 N-gram 到 Transformer

0. 先记住这三句

• 语言的难可以归成三句话：序列（词有先后）、上下文（一个词的意思取决于周围）、稀疏（能组成的句子近乎无限，语料只见过极小一撮）。
• 六代接力：N-gram → 词向量 → 神经语言模型 → RNN → LSTM → Transformer，每一代解一个老死结，又亲手冒出一个新死结。
• 这条链到 Transformer 并没停：O(n²) 的开销、静态的知识、纯文本的局限，正是下一课前沿仍在攻打的新麻烦。

1. 这一课在补哪个洞

到上一课为止，你已亲手「逼出」从 N-gram 到 Transformer 的每一块零件。可零件多了，细节难免忘——N-gram 为什么不行？词向量到底神在哪？RNN 和 LSTM 差在哪一步？这一课不引入任何新概念，只把这些珠子重新串成一条项链。

如果没有这条线，前面 28 课就只是一袋散落的零件，看不出「技术是被问题逼出来的」这条主线；下次新闻里冒出一个新名词，你也没法判断它在补哪个洞。串这条线只需记住一个母题：语言难在哪，每一代就在补哪一刀。六站接力，每一站都是「死结 → 解药 → 新死结」。

2. 概念逐层拆

起点：N-gram 数数，撞上稀疏这堵墙

大白话：不懂语法语义，只会数搭配频率，赌「下一个词只跟前面紧挨着那几个词有关」（马尔可夫假设）。 正式定义：用词序列的统计频率估计下一词概率；只看前 1 个词叫 2-gram，看前 2 个叫 3-gram。 最小例子：接「今天天气很 ___」，数出「很」后面「好」38%、「冷」21%、「热」15%、「大」9%，赌概率最高的「好」。这招撑起手机输入法几十年，却留下三道硬伤：稀疏（词表五万时 3-gram 组合 5万³ ≈ 125 万亿 种，没见过的合理组合频率直接为 0，整句被判「不可能」，平滑治标不治本）、记性短（只回头瞄两三个词）、符号孤立（「猫」和「小猫」当成毫不相干的两个符号）。

中段：词向量、神经语言模型、RNN、LSTM

大白话：先给词义一个坐标，再借它绕开稀疏，然后给网络装记忆、让记忆传得远。 正式定义：词向量（第 15 课）把每个词变成一组数字，让意思相近的词向量也相近；神经语言模型（NNLM，Bengio 等 2003）把前几个词的向量喂进网络、用 Softmax 吐下一词概率；RNN（第 17 课）逐词阅读、把「这个词 + 上一刻记忆」揉成新记忆；LSTM（第 18 课）给记忆装三道取值 0~1 的阀门加一条细胞状态传送带。 最小例子：国王 − 男人 + 女人 ≈ 女王、北京 − 中国 + 法国 ≈ 巴黎，关系从语料里自然浮现；N-gram 见过「我吃苹果」碰到「我吃梨」傻眼，NNLM 知道两者向量很近、本事自动迁移，稀疏被绕开；LSTM 能把「我在法国长大」里的「法国」守到句尾接对「法语」。可每一步又留新洞：词向量静态、且只是零件；NNLM 窗口固定；RNN 梯度连乘几十步后衰减到几乎为零、且天生串行；LSTM 让记忆传远了，却仍要逐词算、无法并行——规模天花板纹丝不动。

终点：Transformer 扔掉循环

大白话：让每个词直接「查询」句中所有词，拿自己的 Query 对所有 Key 比对算权重，再按权重汇总 Value。 正式定义：自注意力（第 19 课，2017）砸开串行这道墙：任意两词一步直达、依赖不衰减，且计算完全并行，正好喂饱 GPU。配上多头、FFN、残差与层归一化（第 20~24 课）叠几十上百层，再加分词器（第 22 课）与三阶段训练（第 25 课），就长成 ChatGPT。 最小例子：「它太累了」里的「它」指谁？让「它」自己把注意力投到那个名词上就行。可它留下新麻烦：每个词都看所有词，代价是 O(n²)（第 26 课）。

3. 亲手算一遍

输入：一个迷你语料里，词「很」一共出现 100 次，后面紧跟的词统计如下（把原文给的百分比还原成次数，方便复算）：好 38 次、冷 21 次、热 15 次、大 9 次、其余合计 17 次，共 100 次。

第 1 步 算频率：P(好|很) = 38/100 = 0.38，同理 P(冷|很)=0.21、P(热|很)=0.15、P(大|很)=0.09，其余合计 0.17。与原文「好 38%、冷 21%、热 15%、大 9%」一一对应。 第 2 步 做预测：接「今天天气很 ___」，取最大者，模型赌「好」。 第 3 步 看稀疏这一刀：设词表大小 V = 50000，一个 3-gram 的可能组合数是 V³ = 50000³ = 1.25×10¹⁴，即 125 万亿种（原文数字）。 第 4 步 对照语料：就算语料里真有 1 亿个不同的 3-gram，覆盖率也只有 1×10⁸ / 1.25×10¹⁴ = 8×10⁻⁷，不到百万分之一。随口说一句没人说过的话，它数出来的频率就是 0，整句被判「不可能」。

所以结论是：靠数频率给出「好」又简单又可解释，但覆盖率不到百万分之一这个数，把「稀疏」这堵墙量化了。这正是后面几代拼命要绕开的死结：词向量用相似性让没见过的组合也有合理概率，RNN/LSTM 用记忆补记性短，Transformer 用并行把规模做上去。每一代都不是凭空冒出来的，而是被上一代那个具体的 0 逼出来的。

4. 一个类比就够了

把整部 NLP 演变史想成一场接力赛：每一棒选手接过时，手里都攥着上一棒留下的「没解决的问题」，跑完一段又把一个新问题交出去。N-gram 交出「稀疏、记性短、符号孤立」，词向量接过来只补了符号孤立，剩下的继续往下传。

边界要划清：像的是「问题驱动、逐代传递」；不像的是，真实技术史并非一条单线，很多方案并存、反复、后来才被淘汰。别把它当成严格的编年史。

5. 五个常见误区

误区 1：这一课要教一个新模型 → ❌ 原文开宗明义「不引入任何新概念」。 → ✅ 只把学过的零件串成「死结 → 解药 → 新死结」的链。

误区 2：词向量本身就是一个语言模型 → ❌ 它只是零件，本身还不会预测下一个词。 → ✅ 要接上神经网络（NNLM）才成语言模型；且它是静态的，分不清「苹果」的水果和公司。

误区 3：LSTM 解决了「无法并行」 → ❌ 门控只让记忆传得更远。 → ✅ 串行这道最硬的墙纹丝不动，正因如此才被 Transformer 取代。

误区 4：Transformer 赢在「更准地数频率」 → ❌ 它根本不数频率。 → ✅ 赢在一步直达的长依赖 + 大规模并行；并行解锁规模，规模带来推理、翻译、写代码等涌现能力。

误区 5：这条链到 Transformer 就终止了 → ❌ 它留下 O(n²) 这个新死结。 → ✅ 长上下文开销、静态知识、纯文本局限，正是下一课前沿仍在攻打的难题。

6. 和前后课的接口

• 上一课（第 28 课）留下了：用蒸馏把大模型本事压进小模型，大语言模型的核心技术栈到此拼齐。
• 这一课补上了：不添零件，把从 N-gram 到 Transformer 的六代技术用「每一代解上一代死结」串成一条项链。
• 下一课（第 30 课）来解决：顺着这条还在延伸的链，走进「正在发生」的前沿。

7. 自测 6 题（附答案）

Q1 这一课把整条 NLP 演变史串成一句话，哪种概括最贴合？ A. 每一代技术都比上一代参数更多　B. 每一代技术，都是为了解开上一代留下的「死结」而诞生的　C. 每一代都换了编程语言　D. 技术演变是随机的 答案：B｜解析：A 只是 Transformer 之后的表象，C、D 都否定了内在逻辑；原文母题正是「问题 → 解药 → 新问题」不断咬合的链。

Q2 按「问题 → 解药」对应，下面哪一组正确？ A. RNN 必须串行 → 由 LSTM 解决　B. N-gram 把「猫」「小猫」当无关符号 → 由词向量解决　C. 注意力 O(n²) → 由 N-gram 解决　D. 词向量的稀疏 → 由 Transformer 解决 答案：B｜解析：A 错，串行恰是 LSTM 没解决、留给 Transformer 的；C 方向反了；D 错，稀疏是 NNLM 借词向量相似性绕开的。

Q3 接「今天天气很 ___」，N-gram 为什么赌「好」？ A. 它懂语法　B. 语料里「很」后面「好」的频率最高（38%）　C. 它用了注意力　D. 它查了词典 答案：B｜解析：N-gram 不懂语义，只数频率；A、C、D 都是后面几代才有的本事。

Q4 RNN 相比前馈神经网络语言模型，最关键的进步是？ A. 参数更多　B. 用循环隐藏状态当记忆、处理变长序列　C. 用了 Softmax　D. 能并行计算 答案：B｜解析：A 不是要点，C 是 NNLM 就有的，D 恰好相反（RNN 天生串行、正是死穴）。

Q5 LSTM 与第 24 课残差连接被说成「同一个灵魂」，指的是？ A. 都用了 Softmax　B. 都给信息留一条少受干扰的直通道（记忆高速路 / 梯度高速路）　C. 都是分词器　D. 都不需要训练 答案：B｜解析：细胞状态传送带与残差捷径，都是对抗「连乘导致信息衰减」；A、C、D 都不沾边。

Q6 Transformer 留下的「新麻烦」是？ A. 梯度消失　B. 必须串行　C. 注意力 O(n²)、长序列代价高昂　D. 词向量是静态的 答案：C｜解析：A 是 RNN 的、B 是 RNN/LSTM 的、D 是词向量的旧疾；只有 C 是原文点名「当下前沿仍在攻打」的那道账单。

8. 一页速记

• 语言难在三句：序列、上下文、稀疏；每一代补其中一刀。
• 3-gram 组合 5万³ ≈ 125 万亿；1 亿个已见组合覆盖率不到百万分之一。
• 螺旋：解一个老问题，又亲手造一个新问题，下一代冲着新问题来。

一句话：历史讲完了，给「正在发生」和「可能发生」的事画一张地图——五条探索线、几道硬墙，外加三个能一直管用的老问题。

难度：★☆☆　　预计：约 15 分钟

原文：第 30 课 · 前沿与未来：下一程

0. 先记住这三句

• 前面 29 课是已定型的历史，这一课看「正在发生」和「可能发生」的事：不求记住结论，只求建立一张地图。
• 五条线：想得更深（推理 / 测试时计算）、看得更广（多模态）、做得更多（智能体）、记得更牢（长上下文 + 外部记忆）、跑得更省（MoE / 量化 / 蒸馏），外加几道绕不开的硬墙。
• 面对任何新名词，追问三个老问题：它为什么诞生？解决了上一代的什么死结？又会留下什么新麻烦？

1. 这一课在补哪个洞

前面 29 课讲的，是一段已经定型的历史——从向量到 ChatGPT，每一步都有清晰的因果。可历史讲完，读者一抬头看新闻，满眼「推理模型」「多模态」「Agent」「Mamba」，全是教程里没出现过的新词，容易慌。

这一课不补某个技术洞，补的是「怎么读未来」的方法。先打个预防针：前沿之所以叫前沿，就是因为它还没有标准答案，有的方向已落地、有的还在争论、有的可能两年后被证伪。所以这一课不求「记住结论」，只求你建立一张地图：知道大家在往哪几个方向使劲、各自解决什么问题。没有这张地图，前面的技术史就只是一门「过去完成时」的课。

2. 概念逐层拆

想得更深：让模型「先想一会儿」再回答

大白话：早期模型脱口而出，推理模型则先生成一长串「思维链」再给答案。 正式定义：难题正确率因此大幅提升。观念转变在于：以前靠训练时砸算力，现在发现推理时多花算力让模型「多想几步」同样换能力，这叫测试时计算（test-time compute）。训练「会想」常用答对了才给分的可验证奖励（RLVR）。 最小例子：同一个难题，「脱口而出」与「先想一长串再答」的正确率差距（原文图 30-1 示意）——不改模型，只是推理时多花算力。

看得更广 / 做得更多

大白话：把图像、声音、视频也切成 token、变成向量，和文字一起喂进同一个 Transformer；再给模型装上手脚，让它调工具、把大任务拆成多步。 正式定义：多模态沿用第 1 课「万物皆向量」、第 22 课「文字先切成 token」的老思路，文字是人类对世界的二手转述，图像视频更接近世界本身。智能体（Agent）能调用搜索、运行代码、读写文件、调 API，看结果再决定下一步。 最小例子：从「帮我写封邮件」到「帮我把这个项目从头跑通」，难点在长链条里少犯错、能纠错、不偏航——这是「边做边想」，也是当下落地最热的方向。

记得更牢 / 跑得更省

大白话：一头把上下文窗口拉到上百万、再外接检索记忆；另一头把模型压到能跑进笔记本、手机。 正式定义：长上下文 + 外部记忆（RAG 即时翻查、跨会话记住你是谁），补的仍是注意力 O(n²)（第 26 课）这个老毛病。轻量化靠三件旧武器：MoE（第 27 课）、量化（更少位数存权重）、蒸馏（第 28 课）。 最小例子：智能越廉价，能渗透的角落就越多。

几道绕不开的硬墙

大白话：能力一路狂奔，但前方有几堵难啃的墙。 正式定义：数据墙（高质量文本有限，合成数据怕「近亲繁殖」式退化）、对齐与安全（模型越强，可信可控越关键，且我们至今看不懂几千亿参数在算什么）、架构墙（O(n²) 悬在头顶，线性注意力、状态空间模型如 Mamba 想绕开它，Transformer 未必是终点）、评测墙（模型在多数考试超过人类，旧标准纷纷失效）。

3. 亲手算一遍

说明：以下数字是为把原文「注意力是 O(n²)」这笔账算具体而设的教学简化示意，不是某个模型的实测值；计算规则完全来自第 26 课。

输入：标准自注意力的格子数 = 序列长度 n 的平方。比较三种上下文长度。

第 1 步 n = 2000：2000² = 4,000,000 格（400 万）。 第 2 步 n = 4000（翻一倍）：4000² = 16,000,000 格（1600 万）。比值 16,000,000 / 4,000,000 = 4 ——长度翻倍，格子翻 4 倍。 第 3 步 n = 1,000,000（原文说的「上百万」）：(10⁶)² = 10¹² 格，即 1 万亿格。与 n=2000 相比是 10¹² / (4×10⁶) = 250,000 倍。 第 4 步 按第 26 课 GPT-4 约 120 层类比，光注意力表就要以万亿格计，FFN 还没算进去。

所以结论是：上下文从几千拉到上百万，不是「多存点字」这么轻松，注意力开销按平方涨到 25 万倍。这个数说明两件事：一是「记得更牢」为什么必须配外部记忆（RAG）、而不能一味往窗口里塞；二是「架构墙」为什么躲不掉——线性注意力、状态空间模型（Mamba）想绕开的正是这条平方曲线。也呼应了整门课的主线：Transformer 解决了串行的死结，却亲手留下 O(n²) 这个新死结，前沿不过是在继续解它。

4. 一个类比就够了

把这一课想成发给你一张地图和一副望远镜，而不是又一台拆开的机器：地图上标着几条正在修的路（五条线）和几处塌方（硬墙），望远镜用来看远处新冒出来的名词。

边界要划清：像的是「都不提供标准答案、只帮你知道往哪看」；不像的是，真实前沿的方向会合并、会被证伪，地图没有「背下来就对」这一说。别把五条线当成默写的分类表。

5. 五个常见误区

误区 1：前沿方向都已有定论，背下来即可 → ❌ 原文开头就打预防针：还没有标准答案。 → ✅ 只求建立地图，知道大家在往哪几个方向使劲。

误区 2：测试时计算就是训练时堆更多算力和数据 → ❌ 它恰恰把算力从训练挪到推理。 → ✅ 是推理阶段让模型「多想几步」（思维链）来换正确率，模型本身不改。

误区 3：多模态是给 Transformer 外挂一个图像模块 → ❌ 思路是把图像 / 音频 / 视频也切成 token、变成向量。 → ✅ 统一进同一个 Transformer，是「万物皆向量」老思路的延伸。

误区 4：上下文窗口够长，就不需要外部记忆了 → ❌ 注意力 O(n²)，越长越贵，且窗口管不着跨会话。 → ✅ 还要 RAG 即时翻查资料、跨会话记住你是谁。

误区 5：Transformer 是终极架构，不会再被替代 → ❌ O(n²) 成本一直悬在头顶。 → ✅ 线性注意力、状态空间模型（Mamba）等新架构正想绕开它，原文明确「Transformer 未必是终点」。

6. 和前后课的接口

• 上一课（第 29 课）留下了：把从 N-gram 到 Transformer 的六代串成「死结 → 解药 → 新死结」的链，并指出链并没有停。
• 这一课补上了：顺着这条还在延伸的链，给「正在发生」的前沿画一张地图，并把那三个老问题交到你手里当读未来的工具。
• 下一课（附录 1）来解决：历史与前沿都看完了，回到最核心的那台机器，用一张可交互的 3D 计算图把 Transformer 所有零件拼回去。

7. 自测 6 题（附答案）

Q1 「测试时计算（test-time compute）」指的是什么思路？ A. 只在训练阶段堆更多算力和数据　B. 在推理阶段让模型「多想几步」（如生成思维链）来换取更高的正确率　C. 测试模型跑得快不快　D. 把模型部署到更多服务器上 答案：B｜解析：A 是被转变的旧观念；C 是软件测试、D 是扩容。关键正是「把算力从训练挪到推理」。

Q2 关于大模型前沿，下面哪种说法符合这一课的态度？ A. 前沿方向都已有定论，背下来即可　B. 面对任何新技术，都可以追问「它为什么诞生、解决了什么死结、又留下什么新麻烦」　C. Transformer 是终极架构　D. 多模态、智能体只是噱头 答案：B｜解析：A 违背开头的预防针；C 与「架构墙 / Mamba」矛盾；D 与「当下落地最热」矛盾。

Q3 训练「会想」的推理模型，常用的朴素而有效的奖励是？ A. 答对了才给分的可验证奖励（RLVR）　B. 答得越长分越高　C. 随机给分　D. 按生成 token 数收费 答案：A｜解析：让模型在反复试错中自己摸索出好的推理路径。B 会鼓励灌水，C 没有学习信号，D 是计费方式。

Q4 「把图像、音频、视频也切成 token，统一进同一个 Transformer」对应哪条线？ A. 想得更深　B. 看得更广（多模态）　C. 跑得更省　D. 记得更牢 答案：B｜解析：A 是思维链 / 测试时计算，C 是 MoE / 量化 / 蒸馏，D 是长上下文 + 外部记忆。

Q5 上下文从 2000 token 翻到 4000 token，标准注意力的格子数变为原来的？ A. 2 倍　B. 4 倍　C. 16 倍　D. 不变 答案：B｜解析：n² 决定长度翻倍、格子翻 4 倍（400 万 → 1600 万）。A 是线性增长的错觉，C 把倍数又平方了一次。

Q6 哪一项不属于这一课点名的「硬墙」？ A. 数据耗尽　B. 对齐与安全　C. BPE 分词规则　D. O(n²) 架构与评测失效 答案：C｜解析：BPE 是第 22 课已经讲清的分词问题，不是前沿硬墙。A、B、D 正对应 DATA WALL、ALIGNMENT、ARCHITECTURE 与 EVALUATION。

8. 一页速记

• 前沿不求记结论，只求建立地图；有的方向可能两年后被证伪。
• O(n²) 账：n=2000 → 400 万格，n=4000 → 1600 万格（4 倍），n=100 万 → 1 万亿格。
• 三个老问题：为什么诞生 / 解决什么死结 / 留下什么新麻烦，从第 1 课管到以后。

一句话：不给新零件，只把 19~24 课的所有模块拼回一张可播放的计算图，看清每个模块在做什么、token 数据怎么流动、下一个词怎么生成。

难度：★★★　　预计：约 15 分钟

原文：第 31 课 · Transformer全景图（附录1）

0. 先记住这三句

• 主干数据流是固定的：文本 → 分词 → 整数 ID → 查嵌入表得向量 → 加位置编码 → 多层 Block（掩码多头注意力 → Add&Norm → FFN → Add&Norm）→ 末位置线性层 + softmax → 下一个词概率 → 接回句尾自回归循环。
• 注意力管「横向去看别人」，FFN 管「纵向自己再加工」，残差与 LayerNorm 管「稳稳地堆深」——三件事别混。
• 形状始终不变：3 个 token、每个 d_model=4 维，进去是 3×4，出来还是 3×4，所以 Block 才能一层层往上叠。

1. 这一课在补哪个洞

前面把每个零件都单独拆过了：第 19 课注意力、第 20 课多头、第 21 课架构与 FFN / 位置编码、第 22 课分词、第 23 课编码器与解码器、第 24 课残差与 LayerNorm。可它们是一颗颗散落的珠子。真正读一台模型时，你需要知道「数据先到哪、再被谁加工、最后从哪出来」。

这一课的交互 3D 计算图就是干这个的：播放数据流、切换注意力头与计算层，亲眼观察下一个词如何生成。没有这张全景图，很容易把「注意力」当成整台模型，或误以为 FFN 在词与词之间传话——其实一个管横向通信、一个管纵向加工。这一课不引入新概念，只把旧零件按真实顺序接起来。

2. 概念逐层拆

入口：分词 → ID → 嵌入 → 位置编码

大白话：模型读不了文字，先把句子切成表里查得到的单元，换成数字，再告诉它每个词排第几。 正式定义：Tokenizer（第 22 课）把文本切成 token、映射成整数 ID；嵌入表取出每个 ID 对应的 d_model 维向量；再逐元素加上位置编码（第 21 课，原始论文用正弦/余弦），把「同时处理」丢掉的顺序补回来。 数据流：文本 → 一串整数 → 一张 n×d_model 的向量表。最小例子：3 个 token 得到 3×4 的表（第 3 节给具体数字）。

掩码多头自注意力：横向通信

大白话：每个词带着自己的问题（Q）去查所有词的标签（K），按匹配程度分配目光，把对应的内容（V）按比例混成自己的新含义。 正式定义：Attention(Q,K,V) = softmax(QKᵀ/√d_k) V（第 19 课）；多头（第 20 课）是并排跑 H 个头、各管一种关系，拼接后过线性层收尾。解码器（GPT，第 23 课）还要加因果掩码：把当前位置右边的分数设成负无穷，保证只根据左边已生成的内容预测下一个词。 数据流：3×4 进、3×4 出；每行是一个词「看过允许范围内所有词之后」的新向量。

Add & Norm 与 FFN：稳定 + 纵向加工

大白话：残差把输入原样加回输出，给梯度留一条不衰减的高速路；LayerNorm 把每条向量拉回均值 0、标准差 1；FFN 让每个词把收集来的信息再加工一遍。 正式定义：y = x + f(LN(x))（Pre-LN，第 24 课）；FFN 是 d→4d→d 两个线性变换夹 ReLU（第 21 课，论文里 512→2048→512）。注意力管「去看别人」，FFN 管「拿到信息后自己再想一遍」，两者都不改变形状，所以 Block 可以堆叠。 数据流：注意力输出 → 加回输入 → 归一化 → FFN → 再加回 → 再归一化，仍是 3×4。

出口与自回归循环

大白话：只取最后一个位置的向量，过线性层 + softmax，变成「下一个词是谁」的概率表；挑一个接到句尾，整句重新送进去。 正式定义：末位置向量投影到词表大小，softmax 得概率分布；生成时配合 KV 缓存（第 26 课）只算新词的 K/V。 数据流：3×4 → 1×词表 → 一个 token → 变成 4 个 token 再走一遍。最小例子：第 21 课「猫 31%、狗 22%、鸟 12%……」。

3. 亲手算一遍

明确声明：下面是一套为教学自设的简化数字，不是任何真实模型的参数。真实模型的维度是 512 甚至更多、值由训练学出；这里只把维度压到 4、token 压到 3，好让每一步都能用计算器复算。原文这一课本身只有一个交互 3D 计算图，没有具体数值。

设定：句子 3 个 token「小猫 / 追 / 它」，d_model = 4，1 个注意力头，d_k = 4，缩放因子 √d_k = √4 = 2。为省去投影矩阵的冗长乘法，直接给出算好的 Q、K、V（就像第 19 课那样直接列分身），并约定 V 的第 1 维是「动物味」、第 2 维「动作味」、第 3 维「指代味」、第 4 维「其他」。

Q = [ [1,0,0,0],      K = [ [2,0,0,0],      V = [ [1,0,0,0],
      [0,1,0,0],            [0,2,0,0],            [0,1,0,0],
      [2,0,0,0] ]           [0,0,2,0] ]           [0,0,0,1] ]

（第 3 个 token「它」的查询 q=[2,0,0,0] 刻意指向「小猫」的标签方向，为演示指代；这也是教学简化。）

第 1 步 打分 QKᵀ（3×3）：

• 行1（小猫）：[1·2, 0, 0] = [2, 0, 0]
• 行2（追）：[0, 2, 0]
• 行3（它）：[4, 0, 0]

第 2 步 缩放 ÷2 并加因果掩码（右上三角设 −∞）：

缩放后 = [ [1, 0, 0],      掩码后 = [ [1,   −∞,  −∞],
           [0, 1, 0],                 [0,    1,  −∞],
           [2, 0, 0] ]                [2,    0,   0] ]

第 3 步 逐行 softmax（−∞ 的项为 0）：

• 行1 [1, −∞, −∞]：e^1=2.72，其余 0 → [1.00, 0, 0]
• 行2 [0, 1, −∞]：e^0=1, e^1=2.72，和 3.72 → [0.27, 0.73, 0]
• 行3 [2, 0, 0]：e^2=7.39, e^0=1, e^0=1，和 9.39 → [0.79, 0.11, 0.11]

第 4 步 混合 V（权重 × V，逐维相加）。看第 3 行「它」： out3 = 0.79×[1,0,0,0] + 0.11×[0,1,0,0] + 0.11×[0,0,0,1] = [0.79, 0.11, 0, 0.11]

第 5 步 残差与形状：把输入 x3=[0,0,0,1] 原样加回，得 [0.79, 0.11, 0, 1.11]，仍是 4 维。三个位置都一样，所以整张表还是 3×4。随后 LayerNorm 把每条向量拉回均值 0、标准差 1（第 24 课对 [8,2,2,4] 的做法），FFN 再 4→16→4 加工，形状依旧 3×4——这就是「能一层层叠」的全部理由。

第 6 步 出口：取末位置向量过线性层 + softmax 得概率表，挑一个接回句尾，重新走一遍。

所以结论是：「它」经过一层注意力，新向量里 0.79 是动物味（来自「小猫」的 V），而因果掩码让它根本看不到未来——它已经被模型理解成「一只小猫」了。这个数说明计算图里真正搬运信息的是「×V」这一步，前面打分、缩放、掩码、softmax 只是算出「该看谁、看多少」的计划表。整条数据流 3×4 进、3×4 出，形状不变，所以 Block 才能叠到 96 层。

4. 一个类比就够了

把计算图想成一条装配流水线：token 是待加工的零件，先贴两张标签（是什么词 / 排第几），再进「互相通气」车间（注意力，零件之间交换信息），接着进「各自打磨」车间（FFN，每件自己精修），两道车间出口都有质检员把尺寸拉回标准（Add&Norm），最后末端那件被送到贴标台（线性层 + softmax）盖上「下一个词」的章，新零件又被送回流水线开头。

边界要划清：像的是「固定顺序、形状不变、可反复循环」；不像的是，真实模型是几十上百层、几百维、多个头并行，而且所有 token 的注意力是矩阵一次同时算完，并不真的像流水线那样一件件排队——恰恰是「同时算」才让 GPU 喂得饱。别把 3×4 的迷你例子当成真实规模。

5. 五个常见误区

误区 1：Transformer 就是注意力 → ❌ 注意力只管横向通信。 → ✅ 还要 FFN、位置编码、Add&Norm、线性层 + softmax 出口，缺一不可。

误区 2：FFN 让词与词之间交换信息 → ❌ 那是注意力的活。 → ✅ FFN 对每个位置分别且相同地加工，词与词之间不通信。

误区 3：解码器生成时能看到整句 → ❌ 因果掩码把右边未来位置设成负无穷。 → ✅ 每个位置只能看左边已生成的内容，否则训练时会偷看标准答案。

误区 4：注意力权重本身就是这一层的输出 → ❌ 打分、缩放、掩码、softmax 只是「该看谁」的计划表。 → ✅ 真正把信息搬进词里的是最后乘 V 那一步。

误区 5：一层 Block 出来形状会变 → ❌ 输入输出都是 n×d_model。 → ✅ 正因为形状不变，才能把同一个 Block 一层层叠到 96 层。

6. 和前后课的接口

• 上一课（第 30 课）留下了：给前沿画了地图，也把「三个老问题」交到你手里当读未来的工具。
• 这一课补上了：回到最核心的那台机器，把 19~24 课的零件拼成一张可播放的计算图，看清数据怎么流动、下一个词怎么生成。
• 下一课（附录 2）来解决：顺着这张图回到 2017 年的起点，逐节读《Attention Is All You Need》原文。

7. 自测 6 题（附答案）

Q1 3 个 token、d_model=4，一个 Block 输入输出的形状是？ A. 3×4 进、4×4 出　B. 3×4 进、3×4 出　C. 1×4 进、1×4 出　D. 3×4 进、3×词表 出 答案：B｜解析：形状不变才能堆叠；A 改了行数，C 丢了位置维度，D 是末端线性层之后的事。

Q2 计算图里「让词与词交换信息」的是哪一步？ A. FFN　B. LayerNorm　C. 掩码多头自注意力　D. 位置编码 答案：C｜解析：A 是逐位置纵向加工，B 稳定数值，D 补回顺序；只有注意力横向汇总别的词的 V。

Q3 因果掩码把哪些位置的注意力分数设成负无穷？ A. 左边已生成　B. 右边未来　C. 全部　D. 对角线 答案：B｜解析：解码器必须遮住未来，否则训练时偷看答案；A 恰恰是要保留的，C、D 都不符合单向往右写。

Q4 迷你例子里 d_k=4，缩放因子是？ A. 2　B. 4　C. 8　D. 16 答案：A｜解析：√d_k = √4 = 2；论文里 d_k=64 时是 8（第 19 课）。B 是 d_k 本身，C、D 把维度或平方搞混了。

Q5 「它」那行权重约 [0.79,0.11,0.11]，混合 V 后得 [0.79,0.11,0,0.11]，说明什么？ A. 它学会了语法　B. 向量里 0.79 是动物味，被理解成小猫　C. 输出变成 4 个 token　D. 掩码失效了 答案：B｜解析：0.79 来自「小猫」的 V=[1,0,0,0]；A 无依据，C 曲解了形状，D 与「看不到未来」矛盾。

Q6 关于附录 1 的这套迷你例子，哪一项对？ A. 数字来自真实 GPT　B. 是为教学自设的简化，真实维度是 512 甚至更多、值由训练学出　C. 只能用于编码器　D. 与第 19 课的四步流程不同 答案：B｜解析：原文这一课只有一个交互 3D 图，3 token / d_model=4 是教学简化；流程与第 19 课「打分→缩放→归一→混合」完全一致，只是数字更小。

8. 一页速记

• 附录 1 不给新零件，只把 19~24 课拼回一张可播放的计算图。
• 3 token / d_model=4 是教学简化；真实 d_model=512、N=6、h=8、d_k=64（附录 2）。
• 注意力四步：打分 QKᵀ → 缩放 ÷√d_k → 掩码 → softmax → 乘 V；真正搬运信息的是乘 V。
• 形状始终不变，所以 Block 能叠到 96 层；解码器靠掩码防偷看。

一句话：回到 2017 年的起点逐段读论文，学会「每节在回答什么问题、关键公式与实验数字怎么读」。

难度：★★★　　预计：约 15 分钟

原文：第 32 课 · 《Attention Is All You Need》原文（附录2）

0. 先记住这三句

• 附录 2 不是新课，是原始凭证；读论文的正确姿势是每节先问「它在回答什么问题」，别一头扎进公式。
• 两条关键公式：Attention(Q,K,V)=softmax(QKᵀ/√d_k)V 与 MultiHead=Concat(head₁,…,head_h)Wᴼ；关键配置 N=6, d_model=512, h=8, d_k=d_v=64, d_ff=2048。
• 实验数字要连着读：英德 28.4 BLEU、英法 41.0 BLEU，8 块 P100 上 base 约 12 小时、big 3.5 天，成本只有此前最佳模型的一小部分。

1. 这一课在补哪个洞

附录 1 把 Transformer 拼成了一张可播放的计算图，可「为什么偏偏是这些数字、这些模块靠什么实验站住脚」，只有回到论文原文才答得清。前面 19~24 课是「给新手讲明白」的重述，论文是 2017 年那份原始凭证：作者 8 人，来自 Google Brain、Google Research、University of Toronto 等，发表于 NIPS 2017（美国加州长滩）。

没有这一课，你会把 512 / 8 / 64 当成天经地义的默认值，也不知道 28.4 BLEU 是怎么比出来的。读论文最容易卡在两处：被各节公式吓住，以及把表 2、表 3 的数字当成孤立的成绩单。这一课专门补「各节在回答什么问题、公式与实验数字怎么读」。

2. 概念逐层拆

摘要 / 引言 / 背景：回答「为什么要另起炉灶」

大白话：当时主流是 RNN/LSTM 加注意力，可循环结构必须一个词接一个词算，训练没法并行。 正式定义：论文提出 Transformer——完全基于注意力、彻底舍弃循环和卷积。摘要先亮结果：WMT 2014 英德 28.4 BLEU（比含集成模型的既有最佳高超过 2 个 BLEU），英法 41.0 BLEU（8 块 GPU 训练 3.5 天）。背景节把「减少顺序计算」接上 Extended Neural GPU、ByteNet、ConvS2S：卷积关联两个远距离位置所需操作数随距离增长（线性 / 对数），Transformer 把它压成常数，代价是注意力加权平均降低分辨率，用多头注意力抵消。 最小例子：引言里「只需在 8 块 P100 GPU 上训练短短 12 小时」，正是后文训练节的伏笔。

第 3 节模型架构：回答「机器长什么样」

大白话：编码器读整句、解码器逐词写，各叠 6 层，每层两个子层外加残差与层归一化。 正式定义：N = 6 个相同层；所有子层与嵌入层输出维度 d_model = 512（残差相加形状天然成立）；每子层输出 LayerNorm(x + Sublayer(x))。解码器多插一个对编码器输出做多头注意力的第三子层，并给自注意力加掩码，保证位置 i 的预测只依赖小于 i 的已知输出。FFN 为 FFN(x)=max(0, xW₁+b₁)W₂+b₂，d_ff = 2048；嵌入层权重乘 √d_model；位置编码用不同频率的正弦/余弦 PE(pos,2i)=sin(pos/10000^(2i/d_model))、PE(pos,2i+1)=cos(...)，波长形成从 2π 到 10000·2π 的几何级数。 最小例子：512 ÷ 8 = 64，所以 h=8 个头时 d_k = d_v = 64，总计算成本与单头全维度相近。

第 3.2 / 4 节：回答「为什么用自注意力、为什么除以 √d_k」

大白话：点积在高维下会变得很大，把 softmax 推进梯度极小的区域，所以要先降温。 正式定义：Attention(Q,K,V)=softmax(QKᵀ/√d_k)V。论文给的理由是：若 q、k 各分量独立、均值 0 方差 1，则点积 q·k 的方差为 d_k，故除以 √d_k 拉回单位量级。多头 MultiHead=Concat(head₁,…,head_h)Wᴼ，head_i=Attention(QWᵢ^Q, KWᵢ^K, VWᵢ^V)。第 4 节表 1 用三个指标比较层类型：自注意力每层 O(n²·d)、顺序操作 O(1)、最大路径长度 O(1)；循环层分别是 O(n·d²)、O(n)、O(n)——路径越短，长程依赖越好学。 最小例子：d_k=64 → √64 = 8，分数从常在 ±16 的量级缩回 ±2（第 19 课同款解释）。

第 5 / 6 节：回答「怎么训、结果怎么读」

大白话：训练节交代数据、硬件、优化器、正则化；结果节把 BLEU 与训练成本摆进表 2，用表 3 做消融。 正式定义：WMT 2014 英德约 450 万句对、BPE 共享约 37000 token 词表；英法 3600 万句、32000 word-piece；每批约 25000 源 token + 25000 目标 token。8 块 P100，base 每步约 0.4 秒、共 100000 步、约 12 小时；big 每步 1.0 秒、300000 步、约 3.5 天。Adam：β₁=0.9, β₂=0.98, ε=10⁻⁹，warmup_steps=4000，学习率 lrate = d_model^(−0.5)·min(step_num^(−0.5), step_num·warmup_steps^(−1.5))；残差 dropout 与标签平滑 ε_ls=0.1（base P_drop=0.1）。表 2：Transformer(base) 27.3 / 38.1 BLEU、成本 3.3×10¹⁸；Transformer(big) 28.4 / 41.0、2.3×10¹⁹。表 3 消融：base 为 PPL 4.92 / BLEU 25.8 / 65M 参数，big 为 4.33 / 26.4 / 213M；单头（h=1）比最佳设置差 0.9 BLEU，头数过多也下降；用学习位置嵌入替代正弦编码，结果几乎相同。 最小例子：beam search 用 beam size=4、长度惩罚 α=0.6，base 平均最后 5 个检查点、big 平均最后 20 个。

3. 亲手算一遍

说明：全部数字取自论文原文（表 2、第 5 节），这里只做加减乘除，把「28.4」「3.5 天」这些结论复算一遍。

第 1 步 核对「提高超过 2 个 BLEU」：表 2 里此前最好的英德集成模型 ConvS2S Ensemble 是 26.36，Transformer(big) 是 28.4。28.4 − 26.36 = 2.04 ≥ 2 ✓，与摘要「比包括集成模型在内的既有最佳结果提高超过 2 个 BLEU」对上了。 第 2 步 核对 base 时长：100000 步 × 0.4 秒/步 = 40000 秒，40000 / 3600 ≈ 11.1 小时 ≈ 论文的「约 12 小时」✓。 第 3 步 核对 big 时长：300000 步 × 1.0 秒/步 = 300000 秒，300000 / 3600 ≈ 83.3 小时，再 83.3 / 24 ≈ 3.47 天 ≈ 论文的「3.5 天」✓。 第 4 步 读训练成本：表 2 里 Transformer(base) 是 3.3×10¹⁸ FLOPs，此前 GNMT+RL 是 2.3×10¹⁹。2.3×10¹⁹ / 3.3×10¹⁸ ≈ 7.0，即 base 只花约七分之一算力就超过了它——这正是摘要「训练成本的一小部分」的量化依据。 第 5 步 核对多头维度：d_model / h = 512 / 8 = 64 = d_k = d_v ✓；8 × 64 = 512，与单头全维度持平，所以「头多却不更贵」。

所以结论是：论文里「约 12 小时」「3.5 天」「超过 2 个 BLEU」都不是含糊的形容词，而是能从「步数 × 每步秒数」和表 2 的 BLEU 列一步步复算出来的。这个数说明读实验结果要连着三列一起看：BLEU（质量）、训练成本（代价）、配置（表 3 消融）。孤立地盯一个 28.4，学不到论文的论证方式——它的说服力恰恰在「更好，而且更便宜」。

4. 一个类比就够了

把读论文想成看一份实验报告：摘要是结论摘要，引言是「别人卡在哪」，第 3 节是装置说明书，第 4 节是「为什么选这种装置」的论证，第 5 节是实验记录（配方、火候、时长），第 6 节是数据表格与对照实验，第 7 节是结语与下一步。表 3 的消融尤其像「逐样拆掉一个零件，看成品掉多少分」。

边界要划清：像的是「每节都在回答一个具体问题、结论靠数字支撑」；不像的是，真实论文的公式与推导比报告严谨得多（例如 q·k 方差为 d_k 那段、表 1 的复杂度分析），而且 BLEU 只是机器翻译的一个自动指标，不等于「译得更好」的全部。别把 28.4 当成模型能力的通用总分。

5. 五个常见误区

误区 1：标题说「Attention Is All You Need」，所以模型只有注意力 → ❌ 第 3 节明确还有 FFN、残差、层归一化、位置编码、嵌入。 → ✅ 「All You Need」是相对「不需要循环和卷积」说的，不是只剩注意力。

误区 2：除以 √d_k 是为了让分数变大、更好比较 → ❌ 恰好相反，是给高维点积降温。 → ✅ d_k=64 时除以 8，防止 softmax 饱和、梯度趋零。

误区 3：h=8 个头就要花 8 倍计算 → ❌ 每头维度被切成 512/8=64。 → ✅ 8×64=512，总计算成本与单头全维度相近，几乎「免费」多看 7 种关系。

误区 4：28.4 BLEU 是「比所有模型高 28.4 分」 → ❌ 它是 Transformer(big) 在英德上的得分。 → ✅ 领先量是 28.4 − 26.36 = 2.04；英法是 41.0；两个任务、两套数字别混。

误区 5：正弦位置编码是唯一选择、效果明显更好 → ❌ 表 3 (E) 行显示改用学习位置嵌入结果几乎相同（PPL 4.92 / BLEU 25.7）。 → ✅ 选正弦是因为「也许能外推到比训练更长的序列」，不是因为分数更高。

6. 和前后课的接口

• 上一课（附录 1）留下了：把 Transformer 所有零件拼成一张可播放的 3D 计算图，看清了数据流与下一个词怎么生成。
• 这一课补上了：回到 2017 年的原始凭证，逐节读《Attention Is All You Need》，把「各节回答什么问题、关键公式与实验数字怎么读」补齐。
• 下一程：原论文也读完了，回到学习地图回望亲手垒过的每一阶——从第 1 课的一根数轴，到这座已登顶的山。结论节说要把 Transformer 用到文本之外的模态、研究受限注意力，正是第 30 课那张前沿地图的伏笔。

7. 自测 6 题（附答案）

Q1 论文第 4 节表 1 里，自注意力层的「顺序操作数」与「最大路径长度」分别是？ A. O(n) / O(n)　B. O(1) / O(1)　C. O(n²·d) / O(log n)　D. O(1) / O(n) 答案：B｜解析：循环层才是 O(n) / O(n)（A）；C 把每层复杂度与卷积路径混在一起。常数级路径正是长程依赖好学的原因。

Q2 d_model=512、h=8，则 d_k 与 d_v 是？ A. 512　B. 256　C. 64　D. 8 答案：C｜解析：512/8 = 64，论文明确 d_k = d_v = d_model/h = 64。A 是单头全维度，B 是 h=2，D 把头数当成了维度。

Q3 论文为什么要除以 √d_k？ A. 让点积变大　B. 抵消高维点积方差为 d_k、防止 softmax 进入梯度极小区域　C. 为了凑 512　D. 减少头数 答案：B｜解析：A 说反了；C、D 与缩放无关。d_k=64 时 √64=8。

Q4 base 模型「约 12 小时」是怎么来的？ A. 100000 步 × 0.4 秒 = 40000 秒 ≈ 11.1 小时　B. 300000 步 × 1.0 秒　C. 8 块 GPU × 1.5 小时　D. 表 2 直接给出 答案：A｜解析：B 是 big 的 3.5 天；C 无依据；D 表 2 给的是 FLOPs 成本，不是时长。

Q5 表 2 中 Transformer(big) 的英德 / 英法 BLEU 是？ A. 27.3 / 38.1　B. 28.4 / 41.0　C. 26.36 / 41.29　D. 4.33 / 26.4 答案：B｜解析：A 是 base，C 是此前 ConvS2S Ensemble，D 是表 3 big 的 PPL / BLEU(dev)。注意 dev 与 test、base 与 big 别串。

Q6 表 3 (E) 行把正弦位置编码换成学习位置嵌入，结果如何？ A. 大幅下降　B. 几乎相同（PPL 4.92 / BLEU 25.7）　C. 翻倍　D. 无法训练 答案：B｜解析：原文说「两个版本产生的结果几乎相同」，选正弦是因为也许能外推到更长序列，不是因为分数更高；A、C、D 都不符。

8. 一页速记

• 读论文先问「这一节在回答什么问题」，别一头扎进公式。
• 三个可复算的账：28.4−26.36=2.04、100000×0.4÷3600≈11.1 小时、300000×1.0÷3600÷24≈3.47 天。
• 表 2 三列一起读：BLEU（质量）、训练成本（代价）、配置（表 3 消融）。
• h=8 不多花钱，因为 512÷8=64，8×64=512。
• 结论节预告了文本之外的模态与受限注意力，正是第 30 课前沿地图的伏笔。