深度学习 on Zewang's Blog

华为 8.5 AI 方向机考复盘：60 分的选择题，错在哪些知识盲区

Sun, 16 Aug 2026 00:00:00 +0000

华为 8.5 AI 方向机考复盘：60 分的选择题，错在哪些知识盲区

题目与官方解析来源：CodeFun2000.com（塔子哥）——华为机考 AI 方向 2026-08-05 场次，AI 算法/应用开发/数据科学等 AI 开头岗位统考，不区分部门。我的成绩：选择题 20 题对 10 题，60/150（15×6 分 + 5×12 分）。

写在前面：这场考试在考什么

这套卷子的知识面比我想象的宽。传统 ML 数学基础（贝叶斯、插值、SVD、余弦相似度）有，但更重的是训练工程实践和大模型前沿：warmup、梯度裁剪、混合精度、端侧推理峰值内存、GSPO、Householder、梯度零空间、在线学习——这些是我平时刷算法题完全接触不到的东西。

我的成绩结构很能说明问题：对的全是 6 分基础题，5 道 12 分大题全错。60 分 = 10 × 6 分，一道 12 分题都没拿到。这说明我的知识结构是"会做题，不懂训练与前沿"——基础数学和概念推导还凑合，但凡涉及深度学习工程和大模型 RL 的就露馅。

先说清楚一个诚实声明：转贴时不少选择题的公式数值没有带过来，但后来我从微信公众号原文的底层 HTML（mdnice 的 data-formula 属性）里把 LaTeX 源码全部提取出来了，本文所有数值与官方解析一致，不是编造的。

一、编程题复盘

第 1 题：基站空间重叠区域识别（150 分，模拟）

这道题是 DBSCAN 的判定子集：只标记每个点的属性（核心点/边界点/噪声点），不做簇扩展和簇编号，所以是个纯模拟题。

核心定义只有三条：

空间邻域：两基站曼哈顿距离 $d = |x_i - x_j| + |y_i - y_j| \le \varepsilon$ 即互为邻域。邻域包含自身——这是最容易漏的点，每个点的邻居数至少为 1。
核心点：邻域内基站总数 $\ge m$（邻域数量门限）。
边界点：自己不是核心点，但邻域内至少有一个核心点。否则是噪声点。

两阶段模拟：第一遍 $O(n^2)$ 统计每个点的邻居数、标记核心点；第二遍非核心点去查核心点集合，距离 $\le \varepsilon$ 就是边界点。总复杂度 $O(n^2)$。原题数据范围：$N \in [1, 2000]$、$\varepsilon \in [0, 10000]$、$MinPts \in [1, N]$、坐标 $[-10000, 10000]$——$O(N^2)$ 最多 400 万对距离计算，完全没问题。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42


import sys

def solve(p, e, m):
 n = len(p)
 core = [False] * n

 # 第一阶段：统计邻域数量（含自身），判定核心点
 for i in range(n):
 cnt = 0
 for j in range(n):
 d = abs(p[i][0] - p[j][0]) + abs(p[i][1] - p[j][1])
 if d <= e:
 cnt += 1
 if cnt >= m:
 core[i] = True

 # 第二阶段：默认全噪声，再标注核心点/边界点
 ans = [2] * n
 for i in range(n):
 if core[i]:
 ans[i] = 0
 else:
 for j in range(n):
 if core[j]:
 d = abs(p[i][0] - p[j][0]) + abs(p[i][1] - p[j][1])
 if d <= e:
 ans[i] = 1
 break
 return ans

def main():
 data = list(map(int, sys.stdin.buffer.read().split()))
 n, e, m = data[0], data[1], data[2]
 p = []
 k = 3
 for _ in range(n):
 p.append((data[k], data[k + 1]))
 k += 2
 sys.stdout.write("\n".join(map(str, solve(p, e, m))))

if __name__ == "__main__":
 main()

这道题在 CodeFun2000 上的原题是 P5198（https://codefun2000.com/ide/P5198），可以上去刷题评测。我自己用 C++ 又写了一遍（机考常用语言，逻辑和 Python 版完全一致）：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38


// 我的 C++ 版 —— CodeFun2000 P5198
#include <iostream>
#include <vector>

using namespace std;

vector<int> solve(const vector<pair<int, int>>& p, int e, int m) {
 int n = p.size();
 vector<bool> core(n, false); // 记录是否是核心

 // 统计每一个基站的邻域数量, 判断是否为核心点
 for (int i = 0; i < n; i++) {
 int cnt = 0;
 for (int j = 0; j < n; j++) {
 int dist = abs(p[i].first - p[j].first) + abs(p[i].second - p[j].second);
 if (dist <= e) cnt++;
 }
 if (cnt >= m) core[i] = true;
 }

 // 默认所有基站均为噪声点
 vector<int> ans(n, 2);
 for (int i = 0; i < n; i++) {
 if (core[i]) ans[i] = 0;
 else {
 for (int j = 0; j < n; j++) {
 if (core[j]) {
 int dist = abs(p[i].first - p[j].first) + abs(p[i].second - p[j].second);
 if (dist <= e) {
 ans[i] = 1;
 break;
 }
 }
 }
 }
 }
 return ans;
}

（main 函数读入 n/e/m 和坐标，逐行输出 solve 的结果即可。）

这道题本身不难，值得记住的是它背后的 DBSCAN：核心点做种子、密度可达做簇扩展。机考只考了属性判定，但理解完整算法才能应对变体。

第 2 题：多 Agent 协作任务调度（300 分，DP 最优+次优状态）

这是本场含金量最高的一道题，也是我想重点记的题。

问题：$n$ 个 Agent，第 $i$ 个每次调用推进 $p_i$ 个百分点、花费 $c_i$ 代价，同一 Agent 可调用任意次但不能连续两次调用同一个，进度 $\ge 100$ 视为完成，求最小总代价。

为什么朴素 DP 不够。最直接的思路是 $dp[s][i]$ = 进度 $s$、最后一次调 Agent $i$ 的最小代价，转移时枚举上一个 Agent $j \ne i$。复杂度 $O(100 \cdot n^2)$，n 稍大就超时。核心矛盾是：转移时我们根本不需要"每个 Agent 的完整代价"，只需要知道"上一个状态最后调的 Agent 是谁"——但朴素 DP 被迫把全部信息都存了下来。

关键洞察：每个进度只需要保留两个状态。对于进度 $s$，设：

$best_1[s]$：最小代价，$id_1[s]$ 是它最后调的 Agent；
$best_2[s]$：代价次小、且 $id_2[s] \ne id_1[s]$ 的状态。

为什么两个就够？因为转移的唯一约束是"下一个 Agent $i$ 不能等于上一个状态的最后 Agent"。所以当我要从进度 $s$ 调 Agent $i$ 时：

若 $id_1[s] \ne i$：直接用最优状态 $best_1[s]$；
若 $id_1[s] = i$：只能用次优状态 $best_2[s]$（它的最后 Agent 必然不是 $i$）。

也就是说，$best_2$ 是专门为"$best_1$ 的最后 Agent 恰好是我们要调的那个"这种冲突准备的备胎。这是经典的"最优+次优"DP 技巧——把 $O(n^2)$ 的枚举压成 $O(1)$ 的取备胎，总复杂度降到 $O(100 \cdot n)$。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57


import sys

INF = 10 ** 30

def update(best1, best2, id1, id2, pos, cost, agent):
 """把「以 agent 结尾、代价 cost」的新状态并入 pos 进度的两个最优状态。"""
 if id1[pos] == agent:
 if cost < best1[pos]:
 best1[pos] = cost
 return
 if id2[pos] == agent:
 if cost < best2[pos]:
 best2[pos] = cost
 if best2[pos] < best1[pos]:
 best1[pos], best2[pos] = best2[pos], best1[pos]
 id1[pos], id2[pos] = id2[pos], id1[pos]
 return
 if cost < best1[pos]:
 best2[pos], id2[pos] = best1[pos], id1[pos]
 best1[pos], id1[pos] = cost, agent
 elif cost < best2[pos]:
 best2[pos], id2[pos] = cost, agent

def min_cost(p, c):
 n = len(p)
 best1 = [INF] * 101
 best2 = [INF] * 101
 id1 = [-2] * 101
 id2 = [-2] * 101

 best1[0] = 0 # 进度 0，代价 0，-1 表示还没调用过任何 Agent
 id1[0] = -1

 for s in range(100):
 if best1[s] == INF:
 continue
 for i in range(n):
 base = best1[s] if id1[s] != i else best2[s]
 if base == INF:
 continue
 t = min(100, s + p[i]) # 进度超过 100 统一压缩为 100
 update(best1, best2, id1, id2, t, base + c[i], i)

 return best1[100] if best1[100] != INF else -1

def main():
 data = list(map(int, sys.stdin.buffer.read().split()))
 n = data[0]
 p, c = [0] * n, [0] * n
 pos = 1
 for i in range(n):
 p[i], c[i] = data[pos], data[pos + 1]
 pos += 2
 print(min_cost(p, c))

if __name__ == "__main__":
 main()

注意两个边界：进度超过 100 统一压到 100（题目允许超额完成）；单 Agent 时无法完成任务输出 -1（样例 1 就是）。

二、选择题复盘（按考点分组）

我把 20 题按知识域分组，对题简讲、错题详讲。✅ = 我答对，❌ = 我答错。

1. 数学基础

#1 Softmax 数值稳定（✅）

当 $x_i$ 较大（如 $>1000$）时直接算 $e^{x_i}$ 会数值溢出，正确的稳定化实现是：对所有 $x_i$ 减去最大值 $x_i' = x_i - \max(x)$ 再算指数。

这题我会。关键在于 exp 的缩放不变性：分子分母同乘 $e^{-M}$ 不改变比值——

$$\text{softmax}(x_i) = \frac{e^{x_i}}{\sum_j e^{x_j}} = \frac{e^{x_i - M}}{\sum_j e^{x_j - M}}, \quad M = \max_j x_j$$

减去最大值后最大的指数项是 $e^0 = 1$，其余都小于 1，不会溢出。FP64 只是缓解不是根治，L2 归一化会改变结果，除以最大值没用——只有减最大值是对的。

#4 欧氏距离（✅）：两个嵌入向量 $u, v$ 的欧氏距离是 $\|u - v\|_2 = \sqrt{\sum_i (u_i - v_i)^2}$，距离越小越相似。原题给 $v_x = [2, 3]^T$、$v_y = [4, 1]^T$：

$$\|v_x - v_y\|_2 = \sqrt{(2-4)^2 + (3-1)^2} = \sqrt{4 + 4} = \sqrt{8}$$

答案 D。干扰项 $\sqrt{5}$ 是把差的平方算成差的绝对值平方，$\sqrt{13}$、$\sqrt{10}$ 是把向量模当距离。

#8 余弦相似度（✅）：$\cos(u, v) = \dfrac{u \cdot v}{\|u\| \|v\|}$，只看方向不看长度。原题 $x = (1, 0, 1)$、$y = (1, 1, 0)$：

$$x^T y = 1 \times 1 + 0 \times 1 + 1 \times 0 = 1, \qquad \|x\| = \|y\| = \sqrt{1^2 + 1^2} = \sqrt{2}$$$$\cos\theta = \frac{1}{\sqrt{2} \times \sqrt{2}} = \frac{1}{2} = 0.5$$

答案 A。干扰项 0.707 是 $\frac{1}{\sqrt{2}}$——把分母错算成一个模。

#9 二次插值（✅）：给定 3 个点可唯一确定二次多项式，代值求解即可（拉格朗日或待定系数法）。原题三点 $(0, 1), (1, 2), (2, 5)$，求 $x = 1.5$ 处值：

$$p(x) = x^2 + 1, \qquad p(1.5) = 1.5^2 + 1 = 2.25 + 1 = 3.25$$

答案 D。这个题最稳的做法是把三点代入 $p(x) = ax^2 + bx + c$ 解出系数——$p(0)=c=1$、$p(1)=a+b+c=2$、$p(2)=4a+2b+c=5$，得 $a=1, b=0, c=1$。

#7 贝叶斯（✅）：经典的两公司次品率题。设 A 供应比例 $P(A)$、次品率 $P(D|A)$，B 同理，抽到次品来自 B 的概率是

$$P(B|D) = \frac{P(D|B)\,P(B)}{P(D|A)\,P(A) + P(D|B)\,P(B)}$$

原题数值：A 公司供应 70%、次品率 2%，B 公司供应 30%、次品率 4%。抽到次品来自 B 的概率

$$P(B|D) = \frac{P(D|B)\,P(B)}{P(D|A)\,P(A) + P(D|B)\,P(B)} = \frac{0.04 \times 0.3}{0.02 \times 0.7 + 0.04 \times 0.3} = \frac{0.012}{0.026} \approx 0.4615$$

答案 C，约 46.2%。注意分子是"B 供应的 30% 里次品的 4%"，分母是两家各自贡献的次品总量——这就是全概率公式的分母。陷阱：不要直接用 $P(D|B) = 4\%$ 当答案，那忽略了 A 公司的次品贡献。

#6 SVD 存储空间减少比例（❌ 我不该错）

用户-短视频评分矩阵 $m \times n$，SVD 保留秩 $k$，存储减少比例约多少？

这是我最懊恼的一道——公式我是知道的，但考场上算错了。

SVD 压缩的原理：$A_{m\times n} \approx U_{m\times k}\, \Sigma_{k\times k}\, V^T_{k\times n}$，存储量从 $mn$ 降到 $k(m+n)+k \approx k(m+n)$。减少比例

$$\text{减少比例} = 1 - \frac{k(m+n)}{mn}$$

原题数值：矩阵 $1000 \times 800$，保留秩 $k = 50$。原矩阵存 $1000 \times 800 = 800000$ 个元素；SVD 后存 $U$（$1000 \times 50$）+ $\Sigma$（$50$）+ $V^T$（$50 \times 800$）= $50000 + 50 + 40000 = 90050$。减少比例

$$1 - \frac{90050}{800000} = 0.8874 \approx 88.74\%$$

答案 A。为什么 SVD 能省空间？因为原始矩阵存的是 $mn$ 个元素，而低秩近似只存"分解出来的骨架"：左奇异向量、奇异值、右奇异向量，三者加起来远小于 $mn$（当 $k \ll \min(m,n)$）。这题的教训是：公式会背 ≠ 考场算对，SVD 存储公式要能当场推一遍而不是凭记忆。

2. 机器学习基础

#11 MLE（✅）：最大似然估计就是"找一个参数 $\theta$，让已观测数据出现的可能性最大"——选 D，逆向思考的表述。这题是概念题，没难度。

#14 集中趋势（✅）：描述中心位置用均值（B）；偏度描述不对称，标准差和方差描述离散程度。概念题。

#5 反向传播（✅）：单神经元 $y = wx + b$，恒等激活，MSE 损失。链式法则：

$$\frac{\partial L}{\partial w} = \frac{\partial L}{\partial y} \cdot \frac{\partial y}{\partial w} = (y - t) \cdot x$$

原题数值：$x = 2, w = 1, b = 0, t = 5$，$L = \frac{1}{2}(y - t)^2$。输出 $y = wx + b = 2$，链式法则：

$$\frac{\partial L}{\partial w} = \frac{\partial L}{\partial y} \cdot \frac{\partial y}{\partial w} = (y - t) \cdot x = (2 - 5) \times 2 = -6$$

答案 C。基础反传导数题，会链式法则就能做；$L$ 带 $\frac{1}{2}$ 系数是为了求导后约掉，这是 MSE 的常见写法。

#3 HRL 分层强化学习 + 级联惩罚（✅）

任务 A→B→C→D 严格顺序依赖，B 失败则 C、D 跳过。A 成功、B 失败，求总奖励。级联惩罚 = 被跳过子任务基础奖励的平均值的负值，只加在失败子任务上。

这题我理解了规则就能算对。通式：若 B 失败（A 已成功），总奖励为

$$R = R_A + P_B - \frac{R_C + R_D}{2}$$

套用原题数值：$R_A = 5$，$R_B = 8$，$P_B = -\frac{R_B}{4} = -2$，$R_C = 12$，$R_D = 16$，级联惩罚为 $-\frac{R_C + R_D}{2} = -\frac{12+16}{2} = -14$。总奖励

$$R = 5 + (-2) + (-14) = -11$$

答案 B。关键陷阱是：被跳过的 C、D 本身不获得任何奖励或惩罚，只是它们的奖励平均值作为级联惩罚扣在 B 头上（注意惩罚是负值累加，不是"扣 C、D 各一半"）。

#12 逻辑回归的评价指标（❌ 基础盲区）

逻辑回归性能评价不包括：A. Log Loss B. AUC C. Accuracy D. 均方误差（MSE）。答案 D。

这题错得很基础。逻辑回归是分类模型，评价用准确率、AUC、对数损失；MSE 是回归指标。当时我大概是"看着四个选项都觉得眼熟"就选错了——这是概念没建起"模型类型 → 评价指标"的映射表。

更值得记的 WHY：逻辑回归训练不用 MSE 而用交叉熵，有两个原因。一是凸性——MSE 对 sigmoid 复合后是非凸函数，交叉熵是凸的，保证收敛到全局最优；二是梯度特性——MSE 在 sigmoid 饱和区梯度趋近于零（梯度消失），交叉熵的梯度 $\hat{y} - y$ 与激活饱和无关。评价指标和损失函数是两回事，但背后的逻辑是相通的。

3. 深度学习与训练工程（4 题全错，最大失分区）

#13 端侧推理峰值内存（❌）

哪项因素最可能导致实际峰值内存显著超过模型文件大小？答案 A：中间激活、临时 buffer 和多分支并发执行。

模型文件只存权重参数，但推理时内存 = 权重 + 中间激活值 + 算子临时 buffer + 并发分支结果。激活值才是内存大头：一个 $1 \times 3 \times H \times W$ 的中间特征图动辄几十 MB，多头/多分支并行时还要同时存多份。所以"模型 100MB，跑起来峰值 1GB+“是常态。我当时选了别的选项，本质是没建立"静态权重 vs 动态激活"的内存心智模型。

#17 早期停止（❌ 多选题）

正确说法：A. 可设 patience 允许连续几轮不下降；B. 根据验证集表现选最佳轮数模型；C. 验证集最优则测试集一定最好（错）；D. 限制训练时间从而限制可学习的数据量（错）。答案 A、B。

C 的陷阱是"一定”——验证集最优不能保证测试集最优（可能有轻微过拟合到验证集）。D 的陷阱更隐蔽：早期停止限制的是继续拟合训练数据的程度（epoch 数），不是"能用的数据量"——数据量是固定的，它限制的是在数据上反复学多少遍。多选陷阱往往藏在绝对化表述（“一定”）和概念偷换（“训练时间” vs “数据量”）里。

#18 梯度矩阵的秩与零空间（❌ 多选题）

已知卷积网络梯度矩阵 $A \in \mathbb{R}^{1000 \times 2000}$，秩 $r(A) = 500$。说法：A. 零空间维度高 → 存在多个方向使梯度投影为零，一阶变化为零，易陷入平坦区/鞍点；B. 零空间维越高 → 有效信息维度越低，无效方向越多；C. 该梯度矩阵零空间维度 = 1500；D. 增大 batch 可直接降低零空间维度（错）。答案 A、B、C。

核心是秩—零空间定理（Rank-Nullity Theorem）：对 $1000 \times 2000$ 矩阵，$\text{rank}(A) + \text{nullity}(A) = 2000$（列数），所以 $\dim N(A) = 2000 - 500 = 1500$——这就是 C 的答案，2000 个参数方向里 1500 个是"无效方向"。零空间里的方向 $v$ 满足 $Av = 0$，意味着沿 $v$ 更新参数时所有样本的梯度贡献都是零——损失函数沿这些方向的一阶变化为零，梯度下降在这些方向上看不到"下坡路"，所以容易卡在鞍点或平坦区。这就是"梯度冗余 → 优化困难"的机理。D 错在：batch 大小影响梯度估计的噪声和矩阵结构，但不能保证零空间维度降低。

这题是线代定理和深度学习优化的交叉题，答错说明我对"零空间"只有名词印象，没有几何直觉。

#20 大模型训练稳定性（❌ 多选题）

常用手段：A. 学习率 warmup；C. 梯度裁剪；D. 混合精度（FP16/BF16）。B. 固定学习率全程（错）。答案 A、C、D。

warmup：训练初期学习率从 0 线性爬升。为什么需要？因为初始权重下 loss 曲面陡峭、梯度的统计量不可靠，一步迈太大直接发散；等梯度统计稳定了再放开学习率。
梯度裁剪：梯度范数超过阈值就缩放回阈值。对抗梯度爆炸（RNN/长序列尤其需要）。
混合精度：FP16/BF16 存权重和激活、FP32 存主权重，配合 loss scaling。省显存、提速度，BF16 的动态范围大所以大模型训练更常用。
固定学习率从头到尾在真实训练里基本不存在——通常会配 warmup + 余弦退火或别的调度。

这题是纯工程知识，我完全没接触过训练大模型，全错不冤。

4. 大模型 / 多模态 / RL（2 题错）

#2 VQA（✅）：视觉问答，输入是图像 + 文本问题，输出是文本答案。多模态入门概念，我会。

#10 RAG 余弦相似度匹配等级（❌）

用户查询向量 vs 历史故障案例向量，算余弦相似度保留 3 位小数，再判断匹配等级（极高/高/中等阈值）。答案：余弦相似度 ≈ 0.989，属于极高匹配。

原题数值：查询向量 $q = [0.8, 1.2, 1.6, 2.0]$，历史案例向量 $c = [1.0, 0.8, 1.4, 1.8]$；阈值：$\ge 0.95$ 极高匹配、$0.85 \sim 0.95$ 高匹配、$< 0.85$ 中等匹配。完整计算：

$$q^T c = 0.8 \times 1.0 + 1.2 \times 0.8 + 1.6 \times 1.4 + 2.0 \times 1.8 = 0.8 + 0.96 + 2.24 + 3.6 = 7.6$$$$\|q\| = \sqrt{0.8^2 + 1.2^2 + 1.6^2 + 2.0^2} = \sqrt{8.64}, \qquad \|c\| = \sqrt{1.0^2 + 0.8^2 + 1.4^2 + 1.8^2} = \sqrt{6.84}$$$$\cos\theta = \frac{q^T c}{\|q\|\|c\|} = \frac{7.6}{\sqrt{8.64} \times \sqrt{6.84}} \approx 0.989$$

答案 B：$\approx 0.989$，$\ge 0.95$ 属于极高匹配。这是"计算 + 阈值判断"两段式题——我公式会但考场上算错，教训是这种题要一步步写：内积、两个模、比值、对照阈值，中间任何一步粗心都会丢分。RAG 检索的核心就是 embedding 向量相似度，这是大模型应用的必考方向，需要练熟。

#15 GSPO 序列级重要性采样（❌）

GSPO 引入序列级（sequence-level）重要性采样比率的主要原因：A. 减少长序列中 token 级比率的高方差问题。答案 A。

GSPO = Group Sequence Policy Optimization（Qwen3 系列使用的 RL 训练算法，arXiv:2507.18071）。这是我完全没接触过的前沿，考场上只能蒙。现在补上了：

在 GRPO 里，重要性采样比率是 token 级的：$r_t = \dfrac{\pi_\theta(y_t|x)}{\pi_{\theta_{old}}(y_t|x)}$。
序列级比率把整个序列的似然比开 $|y_i|$ 次方（长度归一化的几何平均）：

$$s_i(\theta) = \left( \frac{\pi_\theta(y_i|x)}{\pi_{\theta_{old}}(y_i|x)} \right)^{1/|y_i|} = \left( \prod_{t=1}^{|y_i|} r_{i,t} \right)^{1/|y_i|}$$

为什么要序列级：token 级比率在长序列里是逐 token 相乘累积的，方差随序列长度爆炸（乘法累积噪声），而序列级比率对齐了"奖励在序列级给出"的事实，方差更稳定，还天然免疫 MoE 专家路由变化的扰动。所以 GSPO 训练长思维链模型比 GRPO 稳定。

一句话记忆：token 级比率是"有偏但低方差"的简化，序列级比率用长度归一化换稳定性——GSPO 选后者。

5. 数值线性代数（1 题错）

#16 Householder 变换（❌ 多选题）

正确说法：A. Householder 矩阵是正交矩阵；C. Householder QR 比 Gram-Schmidt 数值更稳定；D. Householder 矩阵是对称矩阵。B. 行列式为 +1（错，是 −1）。答案 A、C、D。

Householder 反射矩阵：$H = I - \dfrac{2vv^T}{v^T v}$（$v$ 是单位向量时简化为 $I - 2vv^T$）。性质：

对称：$H^T = H$；
正交：$H^T H = H^2 = I$；
行列式 = −1：它是一次反射（镜面变换），反射改变手性，所以行列式是 −1 而不是 +1。

它把一个向量反射到坐标轴方向，用于 QR 分解时比 Gram-Schmidt 数值稳定——Gram-Schmidt 的经典形式在列向量近似线性相关时会丢失正交性（重正交化开销大），Householder 用反射矩阵逐列消元，数值更稳。当时我连"反射 = 行列式 −1"这个直觉都没有，更别说 QR 稳定性对比了。

6. 在线学习（1 题错）

#19 在线逻辑回归（❌ 多选题）

正确说法：A. 每次一个样本更新 = batch size 1 的 SGD；B. AdaGrad 自适应学习率在稀疏特征场景优于固定学习率；C. 在线学习比批量训练更能适应概念漂移。D. 固定学习率保证收敛到全局最优（错）。答案 A、B、C。

A 是定义：在线学习一次一个样本，就是 $batch=1$ 的随机梯度下降。
B：AdaGrad 对每个参数单独维护累计梯度平方，出现少的特征（稀疏）保持较大学习率，所以适合稀疏场景——固定学习率做不到这种自适应。
C：在线学习持续用新数据更新，分布变了模型跟着变；批量训练用旧数据拟合的模型对概念漂移反应慢。
D：固定学习率参数会在最优点附近震荡，不保证严格收敛。

三、失分结构：60 分是怎么丢的

知识域	题号	我的结果
数学基础	#1 #4 #7 #8 #9 #6	5/6（SVD 计算失误）
机器学习基础	#11 #14 #5 #3 #12	4/5（逻辑回归指标盲区）
深度学习与训练工程	#13 #17 #18 #20	0/4 ❌
大模型 / 多模态 / RL	#2 #10 #15	1/3（VQA 对，RAG 算错，GSPO 盲区）
数值线性代数	#16	0/1 ❌
在线学习	#19	0/1 ❌

三条结论：

基础概念是稳的：贝叶斯、插值、Softmax、反传、MLE 这些传统 ML 数学题全对，说明大学数学底子还在。
计算题要练"考场态"：#6 SVD、#10 RAG 余弦都是"公式会、当场算错"，以后这类题必须动笔一步步写，不心算。
真正的失分大头是知识盲区：训练工程（warmup/混合精度/端侧内存）、大模型对齐（GSPO）、数值线代（Householder/零空间）、在线学习——这四块加起来丢了 5 道 12 分大题中的 4 道。这些是 AI 岗位和普通开发岗的分水岭知识，也是我接下来要补的重点。

四、接下来要补的知识点清单

按优先级和投入产出排序，这些是我后面要逐个补的：

P0（必考高频，先补）

数值线性代数：SVD 低秩近似与存储压缩（会推导）、Householder 反射与 QR、秩—零空间定理及几何直觉（零空间 = 无效更新方向）。来源：任何一本数值分析教材的前三章 + 线性代数复习。
训练稳定性工程：学习率 warmup 与调度（余弦退火）、梯度裁剪、混合精度训练（FP16/BF16 + loss scaling）、端侧/训练峰值内存构成（权重 vs 激活 vs buffer）。来源：大模型训练综述/实践文章。
分类模型评估全家桶：Accuracy / Precision / Recall / F1 / AUC / Log Loss 的适用场景，以及"逻辑回归为什么用交叉熵不用 MSE"（凸性 + 梯度消失）。

P1（AI 岗位特色，补了才有区分度）

大模型 RL 对齐入门：GRPO → GSPO 的演进（token 级 vs 序列级重要性采样、长度归一化、为什么长思维链训练更稳）。来源：arXiv:2507.18071（GSPO）+ 配套解读。
在线学习与自适应优化：SGD 家族、AdaGrad / RMSProp / Adam 的动机与适用场景、概念漂移。

P2（算法题技巧，顺手练）

DP"最优+次优状态"技巧：记住"转移约束只跟最优状态的某个属性冲突时，维护两个最优状态即可"这个模式，多 Agent 调度、股票交易类题都会用到。

来源

题目与官方解析：CodeFun2000.com 华为机考 AI 方向 8 月 5 日场次（塔子哥），原文 https://mp.weixin.qq.com/s/3H3agcturofiMn9pOriZOg
第 1 题（基站空间重叠区域识别）原题刷题入口：https://codefun2000.com/ide/P5198
GSPO 论文：Group Sequence Policy Optimization（Qwen3），https://arxiv.org/abs/2507.18071
备注：选择题 #3-#10 的数值已从微信公众号原文（mdnice 的 data-formula 属性）提取补全，与官方解析一致。

Backprop Ninja：手动反向传播修炼指南

Sun, 19 Jul 2026 00:00:00 +0000

Backprop Ninja：手动反向传播修炼指南

资料源：Andrej Karpathy “Building makemore Part 4: Becoming a Backprop Ninja” YouTube：https://www.youtube.com/watch?v=q8SA3rM6ckI Notebook：https://colab.research.google.com/drive/1WV2oi2fh9XXyldh02wupFQX0wh5ZC-z-

为什么手动做反向传播？

Karpathy 把反向传播称为 “leaky abstraction”（有漏洞的抽象）。

PyTorch 的 loss.backward() 让梯度计算变成了魔法——你搭好网络，调一下 API，梯度就自动出来了。看起来好像"堆砌可微分的乐高积木"就能工作，但现实是：

“It will magically not work or not work optimally, and you will need to understand how it works under the hood if you’re hoping to debug it.”

当你遇到梯度爆炸、梯度消失、训练不收敛时，loss.backward() 不会告诉你哪里出了问题。你需要理解梯度是怎么流经计算图的。

这个视频（和之前的 micrograd）的核心理念：理解 autograd 内部机制，才能有效调试和优化神经网络。

先修知识

视频基于 Part 3 构建的 2 层 MLP（带 BatchNorm），用于字符级语言建模：

输入：32 个样本，每样本 3 个字符（上下文长度）
词嵌入：27 个字符 → 10 维向量
隐藏层：30 维 → 64 个神经元
输出：64 → 27（词汇表大小）

完整数据流如下图所示（前向从左到右，参数在右侧）：

这个网络我们之前用 loss.backward() 自动算梯度。现在我们要关掉 autograd，手写每一步的反向传播。

Exercise 1：Cross-Entropy Loss 反向传播

Softmax 的梯度

输出层是 softmax + 负对数似然。先回顾正向传播：

1
2
3
4
5


# 正向
logits = h2 # (32, 27) batch=32, vocab=27
counts = logits.exp() # 取指数
probs = counts / counts.sum(1, keepdim=True) # 归一化 → 概率
loss = -probs[range(32), ys].log().mean() # 交叉熵

反向传播需要计算 dlogits。这里有两个关键点：

1. 广播（Broadcasting）

counts.sum(1, keepdim=True) 的形状是 (32, 1)，而 counts 是 (32, 27)。PyTorch 会自动把 (32, 1) 广播到 (32, 27)——这意味着一行求和值被复制了 27 份。

反向传播时，广播的反向操作是 sum：梯度需要累加回被广播的维度。

2. Softmax 梯度的简洁形式

经过链式法则推导，cross-entropy + softmax 的反向传播可以简化为一个极其优雅的形式：

1
2
3


dlogits = probs.copy()
dlogits[range(32), ys] -= 1 # 正确类别的概率减 1
dlogits /= 32 # 除以 batch size（因为 loss 取了 mean）

下图展示了从 logits 到 loss 的 8 步正向操作，以及在 Exercise 2 中如何一步合并：

直觉：如果你的模型预测了 [0.2, 0.5, 0.3]，而正确答案是第二个类别（索引 1），那么梯度就是 [0.2, -0.5, 0.3]。负号告诉模型"提高这个类别的分数"，正号说"降低其他类别的分数"。

所有梯度之和为 0——这不是巧合，这是 softmax 输出概率和为 1 的必然结果。

Exercise 2：线性层和 Tanh 的反向传播

MatMul 反向传播

对于 h = x @ W + b，需要计算三个梯度：

1
2
3
4
5


# 正向：h_preact = emb @ W1 + b1 形状： (32, 64) = (32, 30) @ (30, 64) + (64,)
# 反向：
dW1 = emb.T @ dh_preact # (30, 64) = (30, 32) @ (32, 64)
demb = dh_preact @ W1.T # (32, 30) = (32, 64) @ (64, 30)
db1 = dh_preact.sum(0) # (64,) —— 广播的反向操作

关键直觉：矩阵乘法 $C = A @ B$，梯度是：

$dA = dC @ B^T$ —— 误差从输出沿 B 的转置回流到 A
$dB = A^T @ dC$ —— 误差从输出沿 A 的转置回流到 B

Tanh 反向传播

Tanh 的导数是 $1 - \tanh(x)^2$：

1
2


# 正向：h = tanh(h_preact)
# 反向：dh_preact = (1 - h²) * dh # 逐元素相乘

这就是为什么 Tanh 激活容易梯度消失：当 h 接近 ±1 时，$1 - h^2$ 接近 0，梯度被"扼杀"。

嵌入层（Embedding）反向传播

嵌入表 C 是 (27, 30)（27 个字符，每个 30 维）。正向：从 C 中按索引查表。

反向：梯度的形状是 (32, 3, 30)（每个样本有 3 个字符，每个 30 维）。需要把梯度累加回嵌入表：

1
2
3
4
5


dC = torch.zeros_like(C) # (27, 30)
for k in range(32):
 for j in range(3):
 ix = Xb[k, j]
 dC[ix] += demb[k, j]

注意：如果多个样本索引到同一个嵌入向量，梯度要累加，不是覆盖。

插曲：BatchNorm 的 Bessel 校正

BatchNorm 的正向传播：

1
2
3
4


mu = x.mean(0, keepdim=True) # 列均值
sigma_sq = x.var(0, keepdim=True) # 列方差
x_hat = (x - mu) / sigma_sq.sqrt() # 归一化
y = gamma * x_hat + beta # 缩放平移

Karpathy 指出一个常见的"小 bug"：PyTorch 的 x.var() 默认使用了 Bessel’s correction（除以 $n-1$ 而非 $n$），用于无偏估计总体方差。

但在 BatchNorm 中这是不正确的——你希望归一化的是当前 batch 的方差，而不是总体的。除以 $n$ 得到的"有偏"估计才是正确的。

这个 bug 在实际中影响不大（batch size 大时，$n/(n-1) \approx 1$），但原理上值得理解。

Exercise 3：BatchNorm 反向传播

这是视频中最复杂的部分。BatchNorm 的前向有 8 个原子步骤，反向需要从 dhpreact 逆推回 dhprebn。

难点在于 hprebn 出现在三条路径中：

直接路径：hprebn → bndiff → bnraw → hpreact
均值路径：hprebn → bnmeani → bndiff → ... → hpreact
方差路径：hprebn → bnvar → bnvar_inv → bnraw → hpreact

下图展示了这三条路径如何在 dhprebn 处汇合：

反向传播的推导分三步：

第一步：dgamma 和 dbeta（最简单）

1
2


dbeta = dy.sum(0) # (64,)
dgamma = (dy * x_hat).sum(0) # (64,)

第二步：dx_hat（中间步骤）

1

dx_hat = dy * gamma # (32, 64)

第三步：dx（三条路径累加）

x 通过三条路径影响输出，最终的梯度公式为：

1
2
3
4
5
6


N = x.shape[0] # batch size
dx = (1.0 / N) * (1.0 / sigma_sq.sqrt()) * (
 N * dx_hat
 - dx_hat.sum(0)
 - x_hat * (dx_hat * x_hat).sum(0)
)

这个公式的三个项对应三条路径：

路径 1（直接）：$N \cdot d\hat{x}$ —— 标准化后直接传递
路径 2（通过 mu）：$-\sum d\hat{x}$ —— 减去均值影响
路径 3（通过 var）：$-\hat{x} \cdot \sum (d\hat{x} \cdot \hat{x})$ —— 减去方差影响

直觉：BatchNorm 的反向传播本质上是从梯度中移除均值和方差的影响，就像正向传播从数据中移除均值和方差一样。

Exercise 4：整合验证

最后，把所有梯度填入参数更新，验证手动计算的梯度与 PyTorch autograd 的结果一致（数值容差内）。

1
2
3
4


# 参数更新（SGD）
learning_rate = 0.1
for p, g in zip(parameters, grads):
 p.data -= learning_rate * g

Karpathy 的 notebook 验证了所有 26 个张量（包括中间变量）的梯度都 exact 或 approximate 匹配：

1
2
3
4
5
6


logprobs | exact: True | approximate: True | maxdiff: 0.0
probs | exact: True | approximate: True | maxdiff: 0.0
...
W2 | exact: True | approximate: True | maxdiff: 0.0
hprebn | exact: True | approximate: True | maxdiff: 0.0
C | exact: True | approximate: True | maxdiff: 0.0

总结

通过手动执行反向传播，你能获得三个关键洞察：

广播的反向操作是 sum——每次正向广播，反向都要求和。这是 PyTorch 中最容易被忽略的梯度规则
Softmax + CrossEntropy 的梯度出奇地简洁——$\text{softmax}(x) - \text{onehot}(y)$ 的形式背后隐藏了大量链式法则的推导
BatchNorm 的反向传播是对梯度的"二次标准化"——移除梯度中的均值和方差分量，就像正向移除数据中的均值和方差一样

Karpathy 的核心主张：autograd 让你更高效，不理解它让你更脆弱。 当你的神经网络表现异常时，知道梯度从哪里来、往哪里去，是调试的第一道防线。

四句话记住整个流程

操作	反向规则
`y = x @ W + b`	`dx = dy @ W.T`, `dW = x.T @ dy`, `db = dy.sum(0)`
`y = tanh(x)`	`dx = (1 - y²) * dy`
`y = softmax(x)` 后接 CE loss	`dx = (softmax - one_hot) / N`
广播（如 `scaler * tensor`）	对广播源求和

Makemore 完结篇：从 MLP 到 WaveNet，理解语言建模的每一步

Sun, 19 Jul 2026 00:00:00 +0000

Makemore 完结篇：从 MLP 到 WaveNet，理解语言建模的每一步

资料源：Andrej Karpathy “Building makemore” 系列 Part 1-4: https://www.youtube.com/watch?v=q8SA3rM6ckI (P4 Backprop Ninja) Part 5: https://www.youtube.com/watch?v=t3YJ5hKiMQ0 (Building a WaveNet) Notebook: https://github.com/karpathy/nn-zero-to-hero

makemore 系列五章，从最简单的 Bigram 统计模型一步步演进到 WaveNet 风格的层次化架构。这篇文章不是逐视频复述，而是纵向梳理每一层为什么存在、做什么、怎么工作——让你看完后对整个 MLP + 语言建模的全流程有系统性的理解。

全景回顾：五章分别讲了什么

Part	主题	核心贡献
P1	Bigram 语言模型	最简单的"看前一个字符预测下一个"，矩阵统计
P2	MLP 语言模型	Bengio 2003 架构：嵌入 + 线性层 + 交叉熵
P3	激活函数与 BatchNorm	为什么需要 Tanh、初始化技巧、BN 的作用
P4	Backprop Ninja	手动反向传播，理解梯度流动
P5	WaveNet	层次化架构：用树状结构处理长上下文

每一层的角色（纵向总结）

从输入到输出，按数据流顺序：

1. 嵌入层（Embedding）

做什么：把离散的字符索引（0-26）映射为连续向量。

为什么需要：字符本身是 categorical 变量，没有数值意义。嵌入层学习每个字符的"语义向量"——相似字符的向量在空间中靠近。

怎么工作：C 是一个 (vocab_size, n_embd) 的矩阵。C[Xb] 查表取出对应行。

1

emb = C[Xb] # (32, 8, 24) — batch=32, 8个字符, 每字符24维

关键直觉：嵌入层等价于一个 one-hot → Linear 映射，但更高效。每个字符学到一个分布式的特征表示。

2. Flatten / 拼接

做什么：把 (B, T, C) 的张量展平成 (B, T*C) 或 (B, T/n, C*n)。

为什么需要：线性层要求输入是 2D 的 (batch, features)。需要把时间维和特征维合并。

两种策略：

Flat MLP: 把所有 8 个字符拼成一个长向量 → (B, 8*24) = (B, 192)
Hierarchical: 每次合并 2 个 → (B, 4, 48) → (B, 2, 96) → (B, 192)

1
2
3
4
5
6
7
8


# FlattenConsecutive(n): 把相邻 n 个在时间维合并
# (B, T, C) → (B, T//n, C*n)
def __call__(self, x):
 B, T, C = x.shape
 x = x.view(B, T//self.n, C*self.n)
 if x.shape[1] == 1:
 x = x.squeeze(1) # 最后一个时间维也被合并，变成 2D
 return x

3. 线性层（Linear）

做什么：y = x @ W + b，仿射变换。

为什么需要：神经网络的"学习"主要发生在这里。线性层通过调整权重矩阵，提取特征的不同组合。

怎么工作：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10


class Linear:
 def __init__(self, fan_in, fan_out):
 self.weight = torch.randn(fan_in, fan_out) / fan_in**0.5 # Kaiming init
 self.bias = torch.zeros(fan_out)

 def __call__(self, x):
 self.out = x @ self.weight
 if self.bias is not None:
 self.out += self.bias
 return self.out

关键直觉：线性层的每一列是一个"检测器"——它学习在输入中寻找某种模式。多列组合起来形成特征空间。

规模问题：Flat MLP 中，上下文越长，线性层输入维越大。context=8, n_embd=10 时输入是 80 维；context=8, n_embd=24 时输入是 192 维。hidden_size 需要相应增长，参数规模爆炸。

4. BatchNorm 层

做什么：对每个特征列做标准化：减去均值、除以标准差 → 缩放平移。

为什么需要：三个原因：

控制激活值的分布——防止 Tanh 层的输入落入饱和区（梯度消失）
允许更高的学习率——标准化后梯度更稳定
减少对初始化的敏感度——不管前一层的输出怎么变，BN 都把它归一化到标准分布

怎么工作（训练模式）：

1
2
3
4


xmean = x.mean(dim=(0,1), keepdim=True) # 跨 batch + 时间维求均值
xvar = x.var(dim=(0,1), keepdim=True) # 跨 batch + 时间维求方差
xhat = (x - xmean) / (xvar + eps).sqrt() # 标准化
out = gamma * xhat + beta # 缩放平移

对 3D 张量的处理：当 x 是 (B, T, C) 时，BN 需要在 (0, 1) 维上求统计量（batch + 时间），而不是只对 batch。这是 WaveNet 的关键适配——时间维的每个位置共享同样的 BN 参数。

1
2
3
4


if x.ndim == 2:
 dim = 0 # (B, C) — 对 batch 求统计量
elif x.ndim == 3:
 dim = (0, 1) # (B, T, C) — 对 batch + 时间求统计量

5. Tanh 激活函数

做什么：引入非线性。tanh(x) = (e^x - e^{-x}) / (e^x + e^{-x})，输出范围 (-1, 1)。

为什么需要：没有激活函数的线性层堆叠等价于一个线性层。非线性是神经网络表达能力的来源。

为什么是 Tanh 而不是 ReLU：Tanh 是中心对称的（zero-centered），输出在 BN 之后分布更稳定。ReLU 虽然更常见（CV 领域），但在小规模语言模型中 Tanh 效果更好。

梯度消失问题：Tanh 的导数 = 1 - tanh(x)²。当 x 很大时，tanh(x) ≈ ±1，导数 ≈ 0 → 梯度消失。BN 的存在就是为了防止这种情况。

6. Softmax + Cross-Entropy Loss

做什么：Softmax 把 logits 转成概率分布。Cross-Entropy 衡量预测分布和真实分布的差异。

简化的梯度形式（来自 P4 的推导）：

1
2
3


dlogits = F.softmax(logits, 1) # 预测概率
dlogits[range(n), Yb] -= 1 # 正确类别减 1
dlogits /= n # 除以 batch 大小

Flat MLP 的问题：上下文越长，参数越多

回顾 Part 2-4 的网络结构：

1

Embedding(27,10) → Flatten(8) → Linear(80,300) → BN → Tanh → Linear(300,27)

当 context=3 时，Linear 输入是 10*3=30 维，没问题。

当 context=8 时，Linear 输入是 10*8=80 维。如果 n_embd 更大（比如 24），那就是 24*8=192 维。

线性层的参数量 = fan_in * fan_out。输入维每增加一倍，参数量也翻倍。更长的上下文需要更大的网络——这是 Flat MLP 的致命伤。

Part 5 的解法：WaveNet 层次化架构

WaveNet（原用于音频生成）的核心思想：不用一层处理所有上下文，而是逐级合并。

架构对比

下图对比了 Flat MLP 和 Hierarchical WaveNet 的结构：

两个架构最终都输出 (B, 27) 给 softmax，但中间结构完全不同。

树状合并过程

层次化架构的核心是 FlattenConsecutive——每次合并相邻两个时间步：

1
2
3
4
5


初始: (B, 8, 24) — 8 个字符，各 24 维
L1: (B, 4, 128) — Flatten(2): 4 组，每组 48→128 维
L2: (B, 2, 128) — Flatten(2): 2 组，每组 256→128 维
L3: (B, 128) — Flatten(2) + squeeze: 1 组，256→128 维 → 拍平
输出: (B, 27) — Linear 128→27

关键直觉：每一层看到的"视野"变大了，但通道数也变大了。底层负责局部模式（两个字符的组合），顶层负责全局模式（整个 8 字符上下文）。

参数效率对比

架构	参数量	上下文	嵌入维
Flat MLP	~100K+	8	10
Hierarchical	76,579	8	24

层次化架构的嵌入维更大（24 vs 10），但总参数量反而更少。这就是渐进合并的威力。

实现代码

 1
 2
 3
 4
 5
 6
 7
 8
 9
10


n_embd = 24
n_hidden = 128

model = Sequential([
 Embedding(vocab_size, n_embd), # (B,8,24)
 FlattenConsecutive(2), Linear(48, n_hidden, bias=False), BatchNorm1d(n_hidden), Tanh(), # (B,4,128)
 FlattenConsecutive(2), Linear(256, n_hidden, bias=False), BatchNorm1d(n_hidden), Tanh(), # (B,2,128)
 FlattenConsecutive(2), Linear(256, n_hidden, bias=False), BatchNorm1d(n_hidden), Tanh(), # (B,128)
 Linear(n_hidden, vocab_size), # (B,27)
])

注意最后输出层需要做特殊初始化：model.layers[-1].weight *= 0.1，让初始预测更均匀（不自信），防止训练早期 loss 爆炸。

训练过程

训练代码和之前完全一样——SGD + 学习率衰减：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17


max_steps = 200000
batch_size = 32

for i in range(max_steps):
 ix = torch.randint(0, Xtr.shape[0], (batch_size,))
 Xb, Yb = Xtr[ix], Ytr[ix]

 logits = model(Xb)
 loss = F.cross_entropy(logits, Yb)

 for p in parameters:
 p.grad = None
 loss.backward()

 lr = 0.1 if i < 150000 else 0.01 # step decay
 for p in parameters:
 p.data += -lr * p.grad

学习率衰减为什么需要？后期 loss 进入平稳区，小学习率有助于精细调整。

逐形状解读：每一层对 (B, T, C) 做了什么

理解层次化架构的关键是看懂每一层对张量形状 (B, T, C) 的变换。

完整形状变化链（以 batch=4, context=8, n_embd=10, n_hidden=200 为例）：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17


Embedding → (4, 8, 10) 4样本，8字符，每字符10维
FlattenConsecutive(2) → (4, 4, 20) 相邻2字符合并→4组，每组20维
Linear(20→200) → (4, 4, 200) 每组特征从20扩到200
BatchNorm1d → (4, 4, 200) 标准化数值分布
Tanh → (4, 4, 200) 非线性

FlattenConsecutive(2) → (4, 2, 400) 相邻2组合并→2组，每组400维
Linear(400→200) → (4, 2, 200) 每组特征从400压缩到200
BatchNorm1d → (4, 2, 200) 标准化
Tanh → (4, 2, 200) 非线性

FlattenConsecutive(2) → (4, 400) squeeze掉时间维
Linear(400→200) → (4, 200) 压缩到200维
BatchNorm1d → (4, 200) 标准化
Tanh → (4, 200) 非线性

Linear(200→27) → (4, 27) 输出：每个样本对27字符打分

三个维度的含义

维度	记作	含义
第1维	B (batch)	一次处理几个样本
第2维	T (time/token)	字符位置数，逐步减少
第3维	C (channel/feature)	每个位置的信息"宽度"

每个操作的规律

FlattenConsecutive(n): (B, T, C) → (B, T/n, C×n)

时间步 T 除以 n，特征 C 乘以 n
信息重新排列但没有压缩
最终当 T=1 时 squeeze 掉时间维，变成 2D

Linear: (B, T, C_in) → (B, T, C_out)

对每个时间步独立做 x @ W + b
时间步 T 不变
C_in → C_out 可以是升维（扩展信息）或降维（压缩信息）
所有时间步共享同一个权重矩阵 W

BatchNorm1d: (B, T, C) → (B, T, C) 形状不变

跨 batch 和时间的维度求统计量
把数值拉回到均值为0、方差为1的分布
用可学习的 γ 和 β 恢复表达能力

Tanh: 形状不变，数值被夹到 (-1, 1)

树状合并的直觉

把 8 个字符逐步合并到 1 个向量的过程：

1
2
3
4
5
6
7


c0 c1 c2 c3 c4 c5 c6 c7 ← 8个字符位置
 └─┘ └─┘ └─┘ └─┘
 组0 组1 组2 组3 ← T=4, C翻倍
 └─────┘ └─────┘
 组0 组1 ← T=2, C再翻倍
 └──────────────┘
 组0 ← T=1, squeeze成2D

每一层看到的范围更大、信息更丰富，但空间更小。

Flat MLP vs Hierarchical：深层理解

维度	Flat MLP	Hierarchical (WaveNet)
特征提取	一层提取所有上下文特征	逐层提取，底层局部→顶层全局
参数效率	差（输入维 × hidden 大）	好（逐级合并，共享参数模式）
数学本质	全连接：每个输入特征有权重	卷积式：每个时间步共享权重
扩展性	上下文增 → 参数暴增	上下文增 → 增加层级即可
信息流	所有位置直接连接输出	树状：相邻位置先合并，逐级向上

Flat MLP 本质是"长程全连接"——8 个位置的 80 个输入全部连接到 300 个隐藏神经元。这给模型很大的表达能力，但参数效率低。

Hierarchical 本质是"局部→全局"的渐进抽象——底层只看到 2 个字符的局部组合，顶层看到完整的 8 字符上下文。这和人处理语言的方式更接近：先理解词的形态，再理解短语，最后理解句子。

总结：语言建模中每一层的存在理由

层	存在理由（一句话）
Embedding	把离散符号变成连续语义空间
Flatten / FlattenConsecutive	把时间结构变成特征结构，供线性层处理
Linear	学习特征之间的加权组合
BatchNorm	防止激活值失控，稳定训练
Tanh	引入非线性 + 中心对称分布
Softmax + CE	把分数转换成概率 + 衡量预测质量

五章系列的核心演进逻辑：

从统计（Bigram）到学习（MLP）
从手动（梯度）到自动（autograd）再回到手动（Backprop Ninja）
从平面（Flat）到层次（WaveNet）

每解决一个问题，下一个问题就浮现出来——这正是深度学习最迷人的地方。

makemore Part 3：激活函数、梯度消失与 Batch Normalization

Sat, 18 Jul 2026 00:00:00 +0000

makemore Part 3：激活函数、梯度消失与 Batch Normalization

资料源：Andrej Karpathy - Building makemore Part 3: Activations & Gradients, BatchNorm（2026-07-18）前篇：makemore Part 2：MLP 语言模型

Part 2 的遗留问题

Part 2 我们按照 Bengio 2003 的论文，实现了一个 MLP 字符级语言模型——输入几个历史字符的 embedding，拼接后过一层隐藏层（tanh），最后用 softmax 预测下一个字符。

当时我们初始化模型后直接开始训练，损失确实在下降，模型也确实在工作。但我们没有检查的一件事是：网络各层的激活值和梯度分布是什么样的？它们健康吗？

答案是：大概率不健康。这就是 Part 3 要解决的问题。

回顾一下 Part 2 的 MLP 架构：

图：makemore MLP 架构。 输入 3 个字符 → Embedding 表查稠密向量 → 拼接 → 隐藏层（线性变换 + tanh）→ 输出层（线性变换 + softmax）→ 交叉熵损失。

一个理想初始化的标准

当我们初始化一个神经网络时，我们希望输出层的概率分布在训练初期接近 uniform。对于字符级语言模型（27 个字符），这意味着 softmax 输出的每个类别的概率应该在 1/27 ≈ 3.7% 左右，对应的交叉熵损失应该是 -ln(1/27) ≈ 3.3。

如果初始损失远低于 3.3，说明模型一开始就"太自信"了，这通常意味着某些 logits 异常大；如果远高于 3.3，说明输出分布太分散。

但保持初始输出的均匀分布只是第一步。真正的问题是：随着网络加深，激活值的分布会逐层漂移。

Tanh 饱和与梯度消失

Tanh 函数的值域是 (-1, 1)，它有一个关键特性：当输入绝对值很大时（>2 或 <-2），tanh 进入饱和区，输出几乎不变，梯度趋近于 0。

1
2
3
4
5


tanh(x) 的梯度 = 1 - tanh(x)²
当 x=0 时，梯度 = 1
当 x=2 时，梯度 ≈ 0.07
当 x=3 时，梯度 ≈ 0.01
当 x=5 时，梯度 ≈ 0.0002

问题出在多层累积上。假设你有一层线性变换 h = Wx + b，然后过 tanh。如果 W 的初始值太大，h 的方差会很大，导致 tanh 输入进入饱和区。这一层退化为"要么 1 要么 -1"的开关，梯度几乎为零。

更糟的是，梯度会随着层数指数级衰减：每一层把梯度缩小一点，N 层之后就消失了。这就是梯度消失——深层网络的经典问题。

梯度消失不是"训练变慢"，而是"底层几乎不再学习"。前面几层的权重基本不动，只有最后几层在变化。

权重初始化的改进

一个直接的思路：控制权重初始化的大小，让各层激活值的方差保持稳定。

Kaiming He 等人发现：对于使用 ReLU 的网络，权重应该从 N(0, 2/fan_in) 初始化；对于 tanh/Sigmoid，Xavier/Glorot 初始化建议用 N(0, 1/fan_in)。

为什么是 1/fan_in？考虑一个简单的线性层 y = Wx，其中 x 的均值为 0，方差为 1。W 有 fan_in 个输入。y 的方差大约是 fan_in * Var(W)。要 y 的方差保持为 1，需要 Var(W) = 1/fan_in。

用 Kaiming 初始化后，各层激活值的分布确实更稳定了——tanh 的输入不会一上来就飞到饱和区，梯度也能正常流通。

但 Kaiming 初始化不是银弹。它只是一个静态的修补——当你确定网络结构、深度、激活函数后，算一个合适的初始值。一旦网络深度变化、层类型变化（Linear → CNN → Attention），你得重新算。

有没有更动态、更通用的方案？

Batch Normalization（2015）

Batch Normalization（BN）是 Google 在 2015 年提出的，一篇论文彻底改变了深层网络的训练方式。

BN 的核心思想

每一层之前，显式地把激活值拉回到均值为 0、方差为 1 的标准正态分布，然后再送给下一层。

具体来说，对于一个 batch 的激活值 x（维度是 batch_size × features）：

1
2
3
4


μ_B = mean(x) # batch 均值
σ²_B = var(x) # batch 方差
x̂ = (x - μ_B) / √(σ²_B + ε) # 归一化
y = γ * x̂ + β # 缩放 + 平移（可学习）

关键设计：归一化之后又加了一个可学习的缩放和平移。为什么？

如果不加这一层，强制输出为 N(0,1) 可能限制了网络的表达能力——网络可能想学到一个非标准正态的分布。γ 和 β 给了网络"反悔"的能力：如果网络发现 N(0,1) 不好，可以学回原来的分布。

实际上，γ 初始化为 1，β 初始化为 0，所以 BN 一开始做的是纯归一化，然后网络在训练过程中慢慢调整 γ 和 β。

BN 解决了什么问题？

梯度消失：tanh 的输入被拉到 0 附近，永远在 tanh 的线性区域工作（梯度最大），不会再进入饱和区。这使得我们可以训练更深的网络，而不需要小心翼翼地调初始化。
对初始化不敏感：有了 BN，用什么样的初始化差别不大。BN 会自动修正激活值的分布。
允许更大的学习率：激活值分布稳定 → 梯度分布稳定 → 可以用更大的学习率加速训练。

BN 的正则化效果（副效应）

这是一个"意外收获"：BN 有正则化效果。

原因：每个样本在一个 batch 中的归一化依赖于同一 batch 中的其他样本。具体用哪些样本来算均值/方差，每个 epoch 都不同（因为 shuffle）。这相当于在训练过程中引入了噪声——同一个样本每次经过 BN 时的"语境"不同。

这种噪声让网络不容易过拟合到特定样本的精确特征。类似于 Dropout，但来源不同：

Dropout：显式随机丢弃神经元
BN 的正则化：隐式通过 batch 统计量的随机性引入

这也是为什么很多任务中，去掉 BN 后需要加 Dropout 或其他正则化手段才能维持同样的泛化性能。

BN 的耦合问题

BN 有一个不易察觉的代价：样本耦合。

没有 BN 时，每个样本独立处理，batch 只是效率优化。有了 BN，算 mean/std 依赖整个 batch——样本 A 的输出耦合了样本 B、C、D。同一样本在不同 batch 里输出不同（因为"同桌"不同），梯度也变得耦合。

这就是为什么后来的人更倾向用 Layer Normalization（不做 batch 维度的归一化，只做特征维度的归一化，每个样本独立）。

训练 vs 推理：BN 的两副面孔

训练时，BN 使用当前 batch 的均值/方差。

推理时，没有 batch 的概念（可能一次只来一个样本），不能再用 batch 统计量。所以 BN 在训练过程中维护running mean 和 running variance——对所有 batch 的均值/方差做指数移动平均（EMA）。

推理时直接用 running 统计量，不再依赖 batch 大小。类比：训练时每次考试按这班同学的成绩来评分，推理时用过去一学期的平均分标准评分。

训练过程的健康检查

Karpathy 在代码中做了大量的可视化——这是理解网络是否在健康训练的核心手段：

前向传播的激活值直方图：

对每一层，在 forward 之后画出激活值的分布
健康的分布（钟形）：接近 N(0,1)，没有大片饱和区域
不健康的分布：集中在 ±1 附近（tanh 饱和），或者方差发散

反向传播的梯度直方图：

各层梯度应该在相似的尺度上
如果第一层的梯度比最后一层小 1000 倍，梯度消失了
如果第一层的梯度比最后一层大 1000 倍，梯度爆炸了

调整 - 直方图变化 - 诊断的链条：

发现 W 太大 → 所有层激活值直方图两头高中间空（饱和）→ 梯度≈0
把 W 乘 0.1 → 激活值缩回中间 → 钟形恢复 → 梯度开始流通
加 BN → 所有层自动稳定 → 不需要手动试
看梯度直方图 → 检查各层梯度是否同数量级

手动调 W → 看直方图 → 再调 → 再看… 这个试错循环就是 BN 和 Kaiming 初始化要替代的。

一个令人困惑的发现

在 MLP 中，最后一层（输出层）的梯度往往比前面的隐藏层大几个数量级。

原因：输出层直接连接着 softmax + 交叉熵损失。损失函数对输出层 logits 的梯度就是 (softmax - target)，这是一个直接的误差信号。而前面层的梯度需要经过多层 tanh 的链式法则，每一层放大或缩小梯度，最终传到前面的梯度被大幅衰减。

这说明：即使有了 BN，输出层和隐藏层之间的梯度尺度仍然不匹配。需要对最后一层用更小的学习率，或者给不同的层设置不同的学习率。

从 BN 到更多归一化层

BN 工作得很好，但它有一个局限：依赖 batch 维度。当 batch size 很小（比如 2 或 4）时，batch 统计量不稳定；当 batch size = 1 时（在线学习），BN 完全无法工作。

这引出了一系列后续工作：

Layer Normalization（LN）：对每个样本的所有特征做归一化，不依赖 batch。Transformer 用的就是 LN
Instance Normalization（IN）：对每个样本的每个通道做归一化。风格迁移常用
Group Normalization（GN）：介于 LN 和 IN 之间，把特征分成几组做归一化。适用于 batch size 小的场景

一个有趣的历史事实：LN 比 BN 早几个月被提出，但 BN 的影响力远大于 LN，因为 BN 的论文把故事讲得更好——它抓住了"internal covariate shift"这个痛点。直到 Transformer 出现，LN 才重新被重视。

小结

Part 3 的核心教训是：不要假设你的网络在健康地训练。

三个层层递进的方案：

方案	思路	局限
手动调初始化	缩小 W 的 std，让 tanh 落在线性区	深度/层类型变了得重新试
Kaiming/Xavier 初始化	根据 fan_in 算合适的 std	静态的，不动态适应
Batch Normalization	每层动态归一化 + 可学习缩放平移	依赖 batch，耦合样本

本质： 激活值和梯度的统计特性决定网络能不能正常训练。调初始化、做 BN、做 ResNet，归根结底都在做同一件事——让激活值分布稳定，让梯度顺畅流通。

Batch Normalization 是 makemore 系列的一个重要转折点——解决了"训练深不深得下去"的问题，为后面 Part 4（Backprop Ninja）和 Part 5（WaveNet）的复杂网络铺平了道路。

思考与延伸

理解激活函数的关键：tanh 把直线掰弯，让神经元从"音量旋钮"变成"软开关"。没有激活函数，叠多少层都等价于一层。

梯度消失的直觉：不是"训练变慢"，是"前面层在空转"。梯度传不到的地方，参数不更新，深层网络的有效深度比层数浅得多。

BN 的"反悔权"设计很巧妙：先强制归一化到 N(0,1)，再用 γ 和 β 允许网络学回去。初始化=1 和 0，所以一开始做纯归一化，需要时再偏离。

BN 的耦合是它最不直观的代价：样本 A 的输出取决于 batch 里的 B、C、D——“同桌"不同，输出不同。这让调试变得复杂，也是后来 LN 被重用的原因。

直方图可视化是核心调试手段：一层层看激活值和梯度的分布，而不是只看最终 loss。各层梯度在同一数量级 → 健康；越靠近输入层越小 → 梯度消失。