Lecture 8 · 优化算法：mini-batch、动量、RMSprop、Adam 与学习率调度 · Optimization Algorithms

对应 Maps to：Coursera Deep Learning Specialization C2M2 “Optimization Algorithms” 的全部视频（Mini-batch Gradient Descent、Understanding Mini-batch Gradient Descent、Exponentially Weighted Averages、Understanding Exponentially Weighted Averages、Bias Correction in Exponentially Weighted Averages、Gradient Descent with Momentum、RMSprop、Adam Optimization Algorithm、Learning Rate Decay、The Problem of Local Optima）；编程作业 “Optimization Methods”（月牙数据、三层网络、mini-batch 64，比较 GD / Momentum / Adam；较新的版本加了学习率衰减）。在 Fall 2025 的课表里，C2M2 和 C2M1 排在同一周（那一周的课堂讲座讲对抗样本与生成模型，见第 18 讲）。 依据说明：Coursera 的视频和编程作业要注册才能看，所以本讲不引用其中的原文。内容依据 Andrew Ng 在 C2M2 里广为人知的讲法（伦敦一年的气温、“小球滚下碗”的比喻、Adam 的默认超参数、几个学习率衰减公式、高维空间里的鞍点），以及原始文献：Polyak（1964）的 heavy ball、Hinton 的 Coursera 讲义（RMSprop）、Kingma & Ba（2015，Adam）、Dauphin et al.（2014，鞍点）等（见 §13）。作业里的 sklearn make_moons 换成了第 3 讲 planar_data.py 里用 numpy 重写的等价版本，所以具体的点和数字和作业不同。文中提到的作业细节（默认学习率、epoch 数、作业的结论）凭对这份公开作业的了解写成，不同版本之间可能有出入。 配套代码 Code：code/lecture08/（numpy 从零实现；5 个脚本 + 2 个工具模块；04 约 75 秒（有 --quick），其余 3–12 秒） 预计阅读时间：3 小时（含运行代码）

0. 本讲导航 · How to read this lecture

0.1 学习目标 Learning goals

学完这一讲，你应该能够：

1. 说清楚 batch / mini-batch / stochastic 梯度下降的取舍：每一步的准确度、每个 epoch 走几步、向量化效率。能从”按步数""按样本数""按耗时”三种口径读懂一张收敛曲线，知道 mini-batch 训练的代价曲线为什么会抖。
2. 写出指数加权平均 $v_t = \beta v_{t-1} + (1-\beta)\theta_t$，用 $(1-\varepsilon)^{1/\varepsilon} \approx 1/e$ 解释”约等于最近 $1/(1-\beta)$ 个数的平均”；说出偏差修正为什么需要、怎么做。
3. 用”病态的碗”解释普通梯度下降为什么走之字形、为什么步数和条件数 $\kappa$ 成正比。
4. 写出 Momentum、RMSprop、Adam 的更新公式，说出每一项的作用：momentum 平均掉震荡、允许更大的学习率；RMSprop 按维度缩放步长；Adam 两者结合再加偏差修正。知道 Adam 的默认超参数 $\beta_1 = 0.9$、$\beta_2 = 0.999$、$\varepsilon = 10^{-8}$。
5. 知道这些方法各自的局限：同一学习率下 momentum 不一定更快，它也会冲过谷底；按维度缩放只对”和坐标轴对齐”的病态有效；常数学习率的 RMSprop / Adam 停不稳；Adam 不是”不用调学习率”。
6. 写出几种学习率衰减公式，解释 mini-batch 噪声造成的”噪声球”，知道现代常用的 warmup + cosine。
7. 解释为什么在高维空间里局部最优很少是问题，梯度为 0 的点大多是鞍点，真正拖慢训练的是平台；知道 Adam 为什么会”部分掩盖”梯度消失。

0.2 先修与本讲范围 Prerequisites & scope

第 1 讲的 tiny_nn.py 把”优化”这一块当黑盒：train 每一步取一个 mini-batch，Adam 类的注释写着”第 8 讲详细推导，这里只给直觉”。这一讲就把它拆开。第 4 讲代码 03、04 借用过这个 Adam，第 5 讲的 case_tools.ArrayAdam 也是同一个公式。读完这一讲，这些代码里的每一行你都能自己写出来。

0.3 本讲地图 Map

§1  优化要解决的三个问题：每一步太贵 / 方向不好 / 步长一成不变
§2  Mini-batch 梯度下降：切块、代价曲线为什么抖、三种口径、batch 大小        ← 代码 01
§3  指数加权平均：伦敦的气温（合成）、1/(1−β) 天、偏差修正                   ← 代码 02 演示 1–3
§4  Momentum：病态的碗、平均掉震荡、"小球"的比喻和它的局限                    ← 代码 03 演示 1、2、4
§5  RMSprop：按维度缩放步长                                                  ← 代码 03 演示 2
§6  Adam：两者结合 + 偏差修正；各自最好的学习率；旋转的碗                     ← 代码 02 演示 4、代码 03 演示 3
§7  在网络上比较：复刻 "Optimization Methods" 作业                           ← 代码 04 演示 3–4
§8  学习率衰减：噪声球、常见公式、warmup + cosine                            ← 代码 04 演示 1、2、5
§9  局部最优的问题：鞍点与平台                                               ← 代码 05
§10–14  小结、常见误区、练习、延伸阅读、下一讲预告

工具模块 optimizers.py 里是本讲所有算法的从零实现，函数名和 Coursera 作业一样（random_mini_batches、initialize_velocity、update_parameters_with_momentum、initialize_adam、update_parameters_with_adam、update_lr、schedule_lr_decay、model……），前向和反向直接用第 4 讲的 deep_nn.py。

0.4 记号 Notation（沿用第 1 讲 §0.4，本讲新增）

本讲所有平方、开方、除法作用在梯度上时都是逐元素的：$dW^2$ 是 $dW$ 的每个元素各自平方，不是矩阵乘法。

0.5 关于数字 · About the numbers

讲义里所有实验数字都来自配套代码的实际输出（固定随机种子，同一台机器上重复运行逐字相同；只有代码 01 演示 3 的计时每次不同）。代码 04 完整运行约 75 秒，讲义里的数字来自完整运行，--quick 的数字会不一样。气温、“老师网络”、月牙都是合成数据，二次函数和鞍点是写下来的公式，所以我们知道真相。好几处实验结果和我写代码前的预想不一样：同一学习率下 momentum 并不更快，作业里”Adam 赢”主要是学习率的原因，等等。讲义按实际结果来写，这些情况都列在代码 README 的”关于实验结果”里。

1. 优化要解决的三个问题 · What problems are we solving?

第 2 讲的梯度下降只有一行：$W := W - \alpha\, dW$。它在逻辑回归上工作得很好，为什么还需要一整讲的”优化算法”？

先想想训练一个真实的网络时，时间花在哪里。总时间 ≈ 每一步的代价 × 需要走的步数。这两项各有自己的问题，再加上一个和时间有关的问题：

还有第四个问题，它和地形本身有关：代价函数上有很多梯度为 0 或接近 0 的地方。早年大家最担心”坏的局部最优”，Ng 用这个模块的最后一个视频解释，在高维空间里真正的麻烦是鞍点和平台（§9）。

本讲用五个”试验场”，每个都选得能把一种现象看清楚：

• “老师网络”分类任务（第 1 讲 dl_data.py）：看 batch 大小（§2）和深层 sigmoid 网络的平台（§9.4）；
• 一年的每日气温（合成）：看指数加权平均（§3）；
• 二维二次函数 $f = \tfrac12(x^2 + \kappa y^2)$：看各种优化器的轨迹（§4–6）；
• 月牙数据（第 3 讲 planar_data.py）：复刻 Coursera 作业（§7、§8）；
• 一个二维鞍点和随机对称矩阵：看局部最优的问题（§9）。

2. Mini-batch 梯度下降 · Mini-batch gradient descent

2.1 一步该看多少数据？

第 2–4 讲的梯度下降每一步都用全部 $m$ 个样本算 $J$ 和梯度，这叫 batch gradient descent（全批量梯度下降）。Ng 的例子：$m = 5{,}000{,}000$。向量化之后一次算 500 万个样本也不算太慢，但每走一步都要把 500 万个样本全部过一遍——在看完所有数据之前，参数一点都没动。

想法很自然：把训练集切成很多小块，每看完一块就更新一次参数。 每块 1000 个样本，就是 5000 块：

$X^{\{t\}}$ 的形状是 $(n_x, 1000)$，$Y^{\{t\}}$ 是 $(1, 1000)$。算法是两层循环：

for epoch in range(num_epochs):            # 外层：一个 epoch = 把训练集完整过一遍
    打乱训练集，切成 mini-batch X^{1}, ..., X^{T}
    for t in 1..T:                         # 内层：每个 mini-batch 更新一次
        前向：用 X^{t} 算 A^{[L]}
        cost：J^{t} = (1/B) Σ_{i ∈ 第 t 块} L(ŷ^(i), y^(i))      （+ 正则项，第 6 讲）
        反向：算 dW^{[l]}、db^{[l]}（只用这一块的样本）
        更新：W^{[l]} := W^{[l]} − α dW^{[l]}，b 同理

前向、反向、更新的公式和第 4 讲一模一样，只是把 $X$ 换成了 $X^{\{t\}}$、把 $m$ 换成了 $B$。全批量梯度下降一个 epoch 走 1 步，mini-batch 一个 epoch 走 5000 步（代码 01 演示 1(a)）。在大数据上，mini-batch 几乎总是快得多，这也是第 1 讲 tiny_nn.train 默认用 batch 128 的原因。

2.2 切 mini-batch：打乱、切块、最后一块

optimizers.random_mini_batches 和 Coursera 作业的同名函数一样做两件事：

1. 打乱（shuffle）：用同一个随机排列同时重排 $X$ 和 $Y$ 的列，保证每个输入仍然配着自己的标签（自检里专门检查了这一点）；
2. 切块（partition）：按顺序每 $B$ 列切一块。$m$ 不能被 $B$ 整除时，最后一块是”不满的”。

代码 01 演示 1(b)：月牙数据 $m = 300$、$B = 64$，切出 5 块，大小是 [64, 64, 64, 64, 44]。最后一块怎么办有两种常见做法：

• Coursera 作业（以及 random_mini_batches 的默认值）：保留这个 44 个样本的小块；
• 第 1 讲的 tiny_nn.train：剩下的样本不够一个 batch，就丢掉，直接重新打乱开始下一个 epoch（相当于 drop_last=True）。这个 epoch 有 44 个样本（14.7%）没用上，但下个 epoch 没用上的是另一批，长期看每个样本都会被用到。

两种都对。PyTorch 的 DataLoader 也有 drop_last 这个选项。$m$ 远大于 $B$ 时两者几乎没有区别；保留的坏处是最后一块的梯度噪声更大，丢掉的坏处是每个 epoch 有一小部分数据没看到。

为什么一定要打乱？ 月牙数据是按类别排好的：前 150 个全是类别 0，后 150 个全是类别 1。演示 1(c) 训练 500 个 epoch，看最后一个 epoch 里每块的情况：

不打乱时，每个 epoch 的最后两块全是类别 1，网络被推向”猜 1”；下一个 epoch 一开头就是全是类别 0 的一块，cost 冲到 0.319。代价曲线上会出现一个每个 epoch 重复一次的锯齿。诚实地说，在这个小问题上最终测试准确率差不多（0.962 vs 0.968）。数据按时间、按来源排序时，不打乱的害处会大得多。打乱几乎没有成本，所以默认总是打乱。

2.3 代价曲线为什么会抖

用全批量梯度下降时，学习率合适的话 $J$ 每一步都下降。换成 mini-batch，把每一步的 $J^{\{t\}}$ 画出来，曲线会上下抖，但总体趋势向下。Ng 的解释是：有的 mini-batch 碰巧”容易”，有的碰巧”难”（比如有几个标错的样本），所以 $J^{\{t\}}$ 本身就有起伏。

更根本的原因是：mini-batch 的梯度是真梯度的一个带噪声的估计。设 $g$ 是全部 $m$ 个样本的平均梯度，$g_B$ 是随机抽 $B$ 个样本的平均梯度。$g_B$ 的期望正好是 $g$（无偏），但它有方差：

其中 $\sigma^2$ 是”单个样本的梯度和 $g$ 的平均平方距离”，$\frac{m-B}{m-1}$ 是”不放回抽样”的修正（$B = m$ 时为 0）。误差按 $1/\sqrt{B}$ 缩小：想把噪声减半，batch 要大 4 倍。

代码 01 演示 2 在刚初始化的网络 [10, 32, 32, 1] 上（“老师网络”任务，4096 个样本），对每个 $B$ 随机抽 200 个 mini-batch：

几个值得停下来想的地方：

• 实测和理论值吻合，误差确实按 $1/\sqrt{B}$ 缩小：$B$ 从 1 到 64（64 倍），误差从 2.63 降到 0.34（约 1/8）。
• 单个样本的梯度几乎全是噪声：它和真梯度的平均夹角余弦接近 0，只有 44% 的样本给出”下坡方向”（沿它走一小步，全体 cost 会下降）。也就是说，随便挑一个样本，按它的梯度走一小步，更可能让整体 cost 上升。SGD 照样能工作，因为很多步的随机误差会互相抵消，平均下来朝着下坡走。§3 的指数加权平均是同一个道理。
• $B = 64$ 时 $g_B$ 和 $g$ 的夹角余弦已经是 0.96，方向基本对了。花 64 倍的计算把梯度算到 $B = 4096$ 那么准，换来的方向改进并不多。这就是 mini-batch 划算的原因。
• 最后一列：mini-batch 上算出来的 cost 本身也在抖。所以训练日志里”每一步的 cost”抖动，一部分是参数在变，一部分只是这一块数据碰巧难或碰巧容易。看趋势要看平均（比如每个 epoch 的平均，Coursera 作业就是这样记录的），或者定期在整个训练集 / 验证集上算一次。

2.4 三种极端的取舍：按步数、按样本数、按耗时

Ng 把 batch 大小的两个极端说得很清楚：

• $B = m$：batch gradient descent。每一步方向最准，但每一步太贵。
• $B = 1$：stochastic gradient descent（SGD，随机梯度下降）。每一步只看一个样本，方向很吵，而且完全丢掉了向量化的好处。
• 中间：mini-batch。两头的好处各占一部分。

代码 01 演示 3 把这个取舍量化了：同一个网络、同一组初始参数、普通梯度下降，学习率都是 0.1（SGD 另加一组 0.01），比较全训练集上的 cost。

(a) 按更新步数（走了同样多步之后）：

(b) 按看过的样本数（1 epoch = 4096 个样本）：

(c) 按耗时（下面是我运行的一次，计时数字每次都不一样）：

三张表讲了三个不同的故事：

1. 按步数，全批量最好：每一步的梯度最准。
2. 按样本数，结论反过来：1 个 epoch 里全批量只走了 1 步，$B = 64$ 走了 64 步。30 个 epoch 后全批量才到 0.484，$B = 64$ 已经 0.262，$B = 8$ 到了 0.164。很多步”吵但便宜”的小步，加起来比少数几步”准但贵”的大步走得远。 学习率合适的 SGD（lr 0.01）按样本数也很省数据（0.166）。lr 0.1 的 SGD 噪声太大，cost 一直来回跳。
3. 按耗时，mini-batch 最快：SGD 处理一个样本的时间是全批量的约 170 倍（这一次运行的数字；我运行了几次，都在 170–190 倍之间）。一次只算一个样本，Python 的函数调用、numpy 的调度开销完全摊不薄。在 GPU 上这个差距更悬殊，因为 GPU 需要足够大的矩阵才能把成千上万个计算核心填满。

所以实践中几乎总是用 mini-batch：既保留了向量化（每个样本便宜），又每个 epoch 走很多步。

一个说明：这里所有 $B$ 用的是同一个学习率。最合适的学习率本身会随 $B$ 变化（$B$ 越大噪声越小，通常可以用更大的学习率；Goyal et al. 2017 的”linear scaling rule”建议 batch 放大 $k$ 倍时学习率也放大 $k$ 倍，并配合 warmup），所以更严格的比较应该给每个 $B$ 各自调学习率。这个演示只是展示三种口径的差别，不是给出”最好的 $B$”。

2.5 mini-batch 大小怎么选

Ng 的经验法则：

• 训练集小（比如 $m \le 2000$）：直接用全批量梯度下降，mini-batch 带来的好处不大。
• 否则：常用 64、128、256、512。这些都是 2 的幂，Ng 的理由是计算机内存的布局方式让 2 的幂有时跑得更快。这是一个惯例，在现代硬件上差别通常不大，不必拘泥。1024 也有人用，但少一些。
• 确保一个 mini-batch 的数据（连同前向时存下的 cache）能放进 CPU / GPU 的内存。一个 batch 的激活值所占的内存和 $B$ 成正比（第 4 讲 §4.4 讲过 cache 的代价）。放不下的话，要么减小 $B$，要么用”梯度累积”（gradient accumulation：几个小 batch 的梯度加起来再更新一次，效果接近一个大 batch）。

$B$ 本身也是一个超参数，它和学习率是联动的（上面的说明）。一个常被讨论的现象是：很大的 batch 有时泛化得差一些，一种解释是小 batch 的梯度噪声起了某种正则化的作用（Keskar et al. 2017 的”sharp minima”假说；也有研究认为调好学习率和训练时长之后差别可以消除）。这方面没有定论。实用的做法是：在显存允许、训练速度合适的范围里选一个 $B$，然后围绕它调学习率。

3. 指数加权平均 · Exponentially weighted averages

下面三种优化器（momentum、RMSprop、Adam）共用一个”零件”：指数加权平均（exponentially weighted average，统计里也叫 exponentially weighted moving average）。Ng 先用三个视频把这个零件讲透，再拿它去组装优化器。我们也照这个顺序。

3.1 伦敦的气温（合成）

Ng 的例子是伦敦一年里每天的气温：一串很吵的数 $\theta_1, \theta_2, \dots, \theta_{365}$。我们想要一条平滑的曲线，看出季节的变化。

代码 02 用一份合成的数据代替真实的伦敦气温：季节曲线 $12 - 7\cos\big(2\pi(d - 15)/365\big)$ °C（1 月中旬最冷约 5 °C，7 月中旬最热约 19 °C），加上每天独立的高斯噪声（标准差 3 °C）。这一年最低 −1.7 °C，最高 25.4 °C。真实天气的噪声前后几天是相关的，这里用独立噪声，是为了让”噪声被平均掉多少”有一个干净的公式。另外，Ng 在视频里用华氏度，这里换成了摄氏度。

3.2 公式

每来一个新数，就把旧的平均打 $\beta$ 折，再加上新数的 $(1-\beta)$ 份。代码 02 演示 1 用三个 $\beta$：

（季节曲线本身在第 197 天最热。因为平均是线性的，“噪声剩下多少”只对噪声做平均来量，“滞后多少”只对季节曲线做平均来量，两者互不干扰。表中只看第 61 天以后，避开开头的”热身期”，开头的问题在 §3.5 讲。）

这张表就是 Ng 那三条曲线（黄、红、绿）的定量版：

• $\beta$ 越大，曲线越平滑：噪声从每天 3 °C 降到 1.75、0.80、0.29 °C。对独立噪声，理论值是 $3\sqrt{(1-\beta)/(1+\beta)}$（练习 3）。0.9 那一行实测 0.80 和理论 0.69 差得多一点，是因为 $\beta$ 大时相邻几天的平均值高度相关，305 天里的样本标准差本身就有不小的随机误差。
• 代价是滞后：$\beta = 0.98$ 的曲线把最热的一天推迟了 40 天，季节起伏也只剩 84%（夏天不够热、冬天不够冷）。Ng 说绿线”适应得更慢”、“往右移”，就是这个意思。
• 两种误差此消彼长：$\beta = 0.5$ 噪声大，$\beta = 0.98$ 滞后大，总误差在 $\beta = 0.9$ 时最小。$\beta$ 是一个超参数，最好的值取决于信号变化得多快、噪声有多大。

在优化里，“信号”是真正的下坡方向，“噪声”是 mini-batch 的随机性和来回的震荡。Momentum 默认用 $\beta = 0.9$，就是在”平滑”和”反应速度”之间取的一个折中。

3.3 为什么”约等于最近 $1/(1-\beta)$ 天的平均”

把 (3.1) 一层层展开：

$k$ 天以前的数拿到的权重是 $(1-\beta)\beta^k$，按 $\beta$ 的幂指数衰减，“指数加权”的名字就是这么来的。权重衰减到多小可以算”不算了”？Ng 的说法是降到今天的 $1/e$ 左右。令 $\varepsilon = 1 - \beta$，那么 $N = 1/\varepsilon$ 天以前的权重相对于今天是

所以 $v_t$ 大约是最近 $N = 1/(1-\beta)$ 天的平均。代码 02 演示 2：

$\beta^N$ 一列从 0.25 逐渐逼近 $1/e = 0.3679$。这只是一个经验说法，不是精确的窗口：最近 $N$ 天的权重加起来只有约 63%，另外 37% 分给了更早的日子。另一种同样合理的”窗口长度”是平均年龄 $\beta/(1-\beta)$（练习 2），$\beta = 0.98$ 时是 49 天，它正好是一条直线（线性变化的信号）会被拖后的天数。演示 1 的季节曲线是弯的，实测滞后是 9 天（$\beta = 0.9$）和 40 天（$\beta = 0.98$）。

3.4 实现：一行代码，一个数的内存

v = 0
for theta in data:
    v = beta * v + (1 - beta) * theta     # optimizers.ewa 就是这一行

不管平均多少天，只需要记住一个数。如果真的保存最近 50 天的数据再求平均，要 50 倍的内存。对一个有上亿参数的网络，每个参数都要这样一份”平均”，这个差别就很要紧了。这也是为什么 Adam 额外的内存只是参数量的 2 倍（每个参数一份 $v$、一份 $s$）。

3.5 偏差修正 · Bias correction

(3.1) 有一个问题：$v_0 = 0$ 是一个”假的”初始值。第 1 天 $v_1 = (1-\beta)\theta_1$，$\beta = 0.98$ 时只有当天气温的 2%。代码 02 演示 3：

（$\beta = 0.98$；完整的表和 $\beta = 0.9$ 的表见代码输出。）

前几十天的 $v_t$ 都被那个 0 往下拉。前 10 天的平均气温是 6.74 °C，$v_{10}$ 却只有 1.23 °C。原因就在展开式里：$\theta_1, \dots, \theta_t$ 的权重 $(1-\beta)(1 + \beta + \cdots + \beta^{t-1})$ 加起来是 $1 - \beta^t$，不是 1。剩下的 $\beta^t$ 那部分权重给了 $v_0 = 0$。修正的办法就是把权重重新归一化：

修正后 $\hat v_1 = \theta_1$ 恰好成立（表的第一行）。开头几天 $\hat v_t$ 很接近”前 $t$ 天的简单平均”，因为 $t$ 远小于 $1/(1-\beta)$ 时各天的权重几乎一样。$t$ 变大以后 $\beta^t \to 0$，修正自动消失：第 200 天 $1-\beta^t = 0.9824$，修正前后只差 0.28 °C。（第 200 天的 $\hat v_t$ 和”前 200 天的简单平均”差得很远，这不是 bug：指数加权平均本来就更看重最近的日子，春夏在升温。）

什么时候需要修正？ 偏差大约持续 $1/(1-\beta)$ 步。Momentum 用 $\beta = 0.9$，10 步左右偏差就没了，Ng 说实践中很多人不做修正。Adam 的 $\beta_2 = 0.999$，偏差要持续上千步，必须修正（§6.3）。

4. Momentum · Gradient descent with momentum

4.1 病态的碗：梯度下降为什么走之字形

Ng 讲 momentum 时画了一张图：一个被压扁的椭圆碗，梯度下降在窄的方向上来回震荡，在长的方向上慢慢挪。代码 03 把这张图变成可以运行的实验：

$\kappa$ 叫条件数（condition number）：最陡方向的曲率 / 最平方向的曲率。$\kappa$ 越大，碗越扁，问题越病态（ill-conditioned）。梯度下降每走一步，两个方向各自按一个固定倍数收缩：

代码 03 演示 1（$\kappa = 25$；“收敛步数”是 $f$ 降到初始值的 $10^{-6}$ 以下并且一直保持的步数）：

这就是第 2 讲 §4.2”学习率超过 $2/\text{曲率}$ 就会发散”在两个方向上的版本：

• 学习率被陡的方向卡住。$\alpha > 2/25 = 0.08$ 时 $|1 - 25\alpha| > 1$，$y$ 越震越大，发散。$y$ 方向的倍数是负数时，$y$ 每一步变号，这就是图里左上角 GD 的之字形。
• 在平的方向上，$\alpha \le 0.08$ 意味着 $x$ 每步最多缩小 8%，只能慢慢挪。最优学习率 $\alpha^* = 2/(1+\kappa)$ 让两个方向收缩得一样快，每步乘以 $(\kappa-1)/(\kappa+1)$。
• 步数和 $\kappa$ 成正比：最优学习率下，$\kappa = 10 / 25 / 100 / 1000$ 分别要 35 / 87 / 346 / 3454 步。

深度网络的代价函数在不同方向上的曲率可以差好几个数量级。两种对策：改地形，让碗变圆（第 7 讲的输入归一化，第 9 讲的 Batch Norm）；或者改走法，也就是本讲的 momentum、RMSprop、Adam。

4.2 算法

Momentum 的想法：不直接用当前的梯度走，而是用最近若干步梯度的指数加权平均走。 在第 $t$ 次迭代：

$v$ 初始化为 0（initialize_velocity），形状和对应的参数相同。超参数是 $\alpha$ 和 $\beta$，$\beta = 0.9$ 是很常用的默认值（“平均最近约 10 步的梯度”），一般不用调。对照 update_parameters_with_momentum，每个参数就是两行。

4.3 为什么有效，以及一个常被说错的地方

Ng 的直觉解释：在 $y$ 方向（陡的方向），梯度每一步正负交替，平均起来接近 0，震荡被”平均掉”了；在 $x$ 方向（平的方向），梯度一直指向同一边，平均值仍然那么大，前进不受影响。于是轨迹更直接地朝着最低点走。

这个直觉是对的，但要说准确，它带来的到底是什么好处。代码 03 演示 2 在 $\kappa = 25$ 的碗上，让四种方法用相同的学习率：

（“停在 $x$“表示 3000 步时 $f/f_0 = x$，没有收敛。RMSprop 和 Adam 两行在 §5、§6 解释。）

先看前两行，和很多人的直觉不一样：

1. Momentum 的第一个好处是”能用更大的学习率”：$\alpha \ge 0.1$ 时 GD 发散，momentum 从 0.03 到 1 都能收敛，而且步数几乎一样（124–135）。它对学习率的选择宽容得多。演示 4(c) 算出了它能用的学习率上限：$\beta = 0.9$ 时是 GD 的 19 倍（理论值 $2(1+\beta)/\big((1-\beta)\kappa\big)$，和实测 1.520 完全一致，练习 6）。
2. 在 GD 也能用的学习率下，momentum 并不更快：$\alpha = 0.075$ 时 GD 83 步，momentum 128 步。原因在公式 (4.1)：$v$ 是梯度的平均。方向一致时，$v$ 稳定在 $dW$ 本身那么大，步子不会比 GD 大。所以同一个 $\alpha$ 下，平的方向上 momentum 并不加速。
3. Momentum 的速度有一个”地板”：$\alpha$ 从 0.03 到 1，步数都在 130 左右。$\beta = 0.9$ 时，误差每一步最好也只能乘以约 $\sqrt{0.9} \approx 0.95$，不能缩得更快（这是 heavy-ball 方法的一个性质，这里不推导）。于是 $f$ 每步最多只能缩小到原来的约 0.9 倍，降到 $10^{-6}$ 要 $\ln 10^6 / \ln(1/0.9) \approx 131$ 步。要更快，就得调 $\beta$（练习 8）。

那 momentum 什么时候真正占优？碗很扁的时候。代码 03 演示 3 给每种方法各自挑最好的学习率（§6.4 的表）：$\kappa = 1000$ 时 GD 要 2420 步，momentum 144 步，快约 17 倍；但 $\kappa = 10$ 时 momentum（119 步）反而比 GD（39 步）慢。理论上，调好 $\alpha$ 和 $\beta$ 的 momentum 需要的步数大约和 $\sqrt{\kappa}$ 成正比，而 GD 和 $\kappa$ 成正比（Polyak 1964）。真实网络的代价函数通常是很病态的，这正是 momentum 有用的地方。

4.4 “小球滚下碗”的比喻，以及它的局限

Ng 给了一个物理比喻：把代价函数想成一只碗，参数是一个小球。$dW$ 像加速度，$v_{dW}$ 像速度，$\beta$ 像摩擦力（$\beta < 1$ 让速度不会无限增大）。小球有惯性，所以不会每一步都被”最近的碗壁”拉着拐弯。

这个比喻很有用，但要知道它在哪里不准。代码 03 演示 4(b)（$\alpha = 0.06$、前 150 步）：

• 小球会冲过谷底：$f$ 比上一步升高的次数，GD 0 次，momentum 60 次。GD 始终在 $x < 0$ 的一侧，momentum 的 $x$ 最远冲到了 +0.249（最低点在 $x = 0$）。图里右上角那条轨迹（α = 0.075）也冲过了最低点，在它的右侧绕了一圈才回来。所以用 momentum 时，代价不一定单调下降，偶尔上升不一定是学习率太大。
• “速度”不是越滚越快的物理速度：在 Ng 的写法里，方向一致时 $v$ 稳定在梯度本身那么大，不会无限加速（§4.3 第 2 条）。真实的小球在一个长下坡上会越滚越快。
• 惯性对不太扁的碗可能是坏事：$\kappa = 10$ 时，$\beta = 0.9$ 的小球在谷底来回晃，比 GD 慢 3 倍。

4.5 两种写法

很多资料和框架里的 momentum 写成

（没有 $1-\beta$）。这时梯度方向一致时 $v$ 稳定在 $dW/(1-\beta)$，是 Ng 写法的 10 倍，所以 $\alpha' = (1-\beta)\alpha$ 时两种写法完全等价。代码 03 演示 4(a) 验证了 200 步的轨迹最大只差 4.4e−16（浮点舍入）。Ng 更喜欢带 $1-\beta$ 的写法，因为 $v$ 和 $dW$ 是同一个量级，换 $\beta$ 时不用重新调 $\alpha$。PyTorch 的 torch.optim.SGD(momentum=0.9) 用的是不带 $1-\beta$ 的写法，在不同框架之间搬运超参数时要注意。

（还有一个常见的变体 Nesterov momentum：先按惯性走一步，再在那个位置算梯度。Ng 的课里没有讲，感兴趣可以看 Sutskever et al. 2013。）

5. RMSprop · Root mean square prop

5.1 按维度缩放步长

Momentum 解决震荡的办法是”平均掉”。RMSprop 换了一个思路：震荡的方向梯度大，就在那个方向上走小步；平缓的方向梯度小，就走大步。 每个参数各自记住”最近梯度有多大”：

$b$ 同理。$\sqrt{s}$ 近似”最近一段时间梯度的均方根”（root mean square，名字就是这么来的）。用它去除梯度，每个参数的步长就被归一化了：在 Ng 那张图里，竖直方向（他用 $b$ 代表）梯度大，$s_{db}$ 大，除完之后步子小；水平方向（$W$）梯度小，$s_{dW}$ 小，除完之后步子相对大。效果相当于给每个参数配了一个自己的学习率。

几个细节：

• $\varepsilon$（比如 $10^{-8}$）只是为了防止除以 0：某个参数的梯度一直是 0 时 $\sqrt{s} = 0$。它一般不用调。
• 为什么用 $\beta_2$ 这个名字？ 为了和 momentum 的 $\beta$ 区分，Adam 里两个都要用。
• $\beta_2$ 取多少？ RMSprop 最早出现在 Hinton 在 Coursera 上的神经网络课程里（不是一篇论文，Ng 在视频里特意提到这一点），那份讲义用的是 0.9。PyTorch 的 RMSprop 默认 0.99，Keras 默认 0.9。本讲的代码用 0.9，原因见下一条。
• RMSprop 没有偏差修正：$s$ 从 0 开始，第 1 步 $s = (1-\beta_2)\,dW^2$，步长变成 $\alpha/\sqrt{1-\beta_2}$ 乘以梯度的符号。$\beta_2 = 0.9$ 时这是 $3.16\alpha$，$\beta_2 = 0.999$ 时是 $31.6\alpha$（练习 7）。所以不带偏差修正的 RMSprop 不宜配太大的 $\beta_2$。

5.2 RMSprop 在碗里：快到附近，却停不下来

回到 §4.3 那张表的 RMSprop 一行：每一格都”停在”一个和 $\alpha$ 有关的水平上，从 $\alpha = 0.01$ 时的 $2 \times 10^{-5}$ 到 $\alpha = 1$ 时的 0.2。图里左下角的轨迹几乎是直奔最低点去的，但到了附近就停不下来。

原因是：$\beta_2 = 0.9$ 时分母 $\sqrt{s}$ 只记得最近约 10 步。梯度变小时分母跟着变小，两者相除，步长始终约等于 $\alpha$，和离最低点还有多远无关。于是它在最低点附近以 $\alpha$ 的幅度来回跳。要精确收敛，就得让 $\alpha$ 随时间变小，也就是 §8 的学习率衰减。演示 3 里 RMSprop 只有在很小的 $\alpha$（约 0.001–0.003）下才精确收敛，要两三千步。

这其实是”按梯度大小归一化”的两面：好处是步长不依赖梯度的尺度，坐标轴方向上曲率差 1000 倍也不怕；坏处是梯度变小时它不会自动放慢。

6. Adam · Adaptive moment estimation

6.1 两者结合，再加偏差修正

Ng 说，深度学习的历史上，很多人提出过各种优化算法，后来发现它们往往只在少数问题上好用，大家就对新的优化算法有点怀疑。Momentum、RMSprop，以及把两者合起来的 Adam，是少数被证明在很多种网络上都好用的。Adam（Kingma & Ba 2015）的名字来自 Adaptive moment estimation。

初始化 $v_{dW} = 0$、$s_{dW} = 0$（initialize_adam）。第 $t$ 次迭代（$t$ 从 1 数起）：

$b$ 同理。分子是”平均下来往哪边走”（平均掉震荡），分母是”这个参数的梯度通常有多大”（按维度缩放）。两者相除之后，每个参数一步大约走 $\alpha$ 那么远；梯度方向稳定时恰好是 $\alpha$（练习 7）。这一点很重要：Adam 的步长和梯度本身的尺度无关，§7 和 §9.4 会看到它带来的好处和坏处。

6.2 超参数

Ng 的原话大意是：实践中大家用 $\beta_1, \beta_2, \varepsilon$ 的默认值，只调 $\alpha$。

6.3 偏差修正为什么必须做

§3.5 说 momentum 可以不做偏差修正。Adam 为什么不行？代码 02 演示 4(a) 设想梯度一直等于同一个数 $g$。做了修正时，Adam 每一步恰好走 $\alpha \cdot \text{sign}(g)$；不做修正时步长变成 $\alpha (1-\beta_1^t)/\sqrt{1-\beta_2^t}$。下表是”不修正的步长 / 应有的步长”：

• Adam 不修正时，分子 $v_1 = 0.1g$ 被压小了 10 倍，分母 $\sqrt{s_1} = \sqrt{0.001}\,|g| \approx 0.032|g|$ 被压小了约 32 倍。分母偏得更厉害，于是步长反而偏大。分子的偏差 10 步左右就消失了，分母的偏差要上千步，所以放大倍数先升后降：第 12 步最大（6.57 倍），到第 1,751 步才回到 1.1 倍以内。不做偏差修正的 Adam，前几百步的实际学习率是你设定值的好几倍。
• Momentum 不修正时正好相反：开头步子偏小，只是”热身慢一点”，不危险。这就是 Ng 说”momentum 一般不做修正”、而 Adam 论文专门强调要修正的原因。

演示 4(b) 在月牙数据上验证（[2, 5, 2, 1]、mini-batch 64、1000 个 epoch，5 个种子的测试准确率）：

$\alpha = 0.01$ 时修不修正都一样。$\alpha = 0.07$ 时，不修正的 5 次里有 1 次准确率停在 0.5。代码检查了这一次：第 5 步之后，第 2 个隐藏层的 2 个 ReLU 单元已经全部”死掉”（对所有样本都输出 0），而修正后的版本还有 1 个活着。头几步被放大 3–6 倍的步子把 ReLU 推死了，和第 4 讲代码 05”学习率太大，ReLU 全部死掉”是同一种失败。偏差修正几乎不花计算，却让 Adam 在稍大的学习率下也更安全。

6.4 各自用最好的学习率：扁的碗和斜的碗

§4.3 的”同一个 $\alpha$“对 Adam 不太公平：GD 的一步是 $\alpha \times$ 梯度，Adam 的一步约等于 $\alpha$，两者的 $\alpha$ 单位不一样。所以 Adam 在 $\alpha = 0.01$ 时最慢（1153 步），因为它每步只走约 0.01。

代码 03 演示 3 让每种方法在 41 个学习率（0.001 到 10，对数均匀）里各挑最好的那个。为了看清”按维度缩放”到底在做什么，同一个碗还旋转了 45°：碗的形状完全不变，只是扁的方向不再和坐标轴对齐。

（格子里是收敛步数；每种方法最好的学习率见代码输出。）

• GD 和 Momentum 对旋转完全不敏感（每对两行一模一样）：它们的更新规则不在乎坐标轴朝哪边。
• Adam 在碗和坐标轴对齐时，不管 $\kappa$ 多大都只要 119–124 步：它给每个坐标配了自己的步长，相当于把扁碗按坐标轴拉圆了。
• 碗转了 45° 以后，扁的方向是 $x$ 和 $y$ 的混合，按坐标缩放就帮不上忙了：$\kappa = 1000$ 时 Adam 从 123 步变成 733 步，比 momentum 还慢。
• RMSprop（$\beta_2 = 0.9$，没有动量）只有很小的 $\alpha$ 才能精确收敛（§5.2），所以要上千步。

对深度网络意味着什么？ 网络里不同参数的梯度尺度确实常常差很多（§9.4 有一个例子：同一个网络里，第 1 层和输出层的梯度差 3000 多倍）。这部分病态和坐标轴是对齐的，Adam 能修正。不和坐标轴对齐的那部分，它和 momentum 一样只能靠惯性。这是 Adam 成为很好的默认选择的原因，也是它不会在所有问题上都赢的原因。

最后，代码 03 演示 3 还把 $\kappa = 25$ 的 Adam（$\alpha = 0.2$，这个碗上它最好的学习率）跑了 20000 步：第 1000 步时 $f/f_0$ 已经是 $3 \times 10^{-46}$，但第 3000 步以后又回升，最高到 $10^{-2}$（第 5344 步）。梯度变得极小以后，分母 $\sqrt{\hat s}$ 也慢慢变小，等效学习率越来越大，最后又被”踢”了出来。常数学习率的 Adam 停不稳，这和 RMSprop 停不下来是同一类问题，药方都是学习率衰减（§8）。在 mini-batch 训练里梯度一直带着噪声，不会小到这个程度，所以通常不会这么极端，但道理是一样的。

6.5 和第 1 讲的黑盒对答案；Adam 的后续

直接运行 optimizers.py 会做一次自检：本讲的 update_parameters_with_adam 和第 1 讲 tiny_nn.Adam 在同一串随机梯度上走 200 步，参数的最大差别是 0.0e+00（逐位相同）。第 1 讲的黑盒，第 4 讲代码 03、04 借用的优化器，第 5 讲的 ArrayAdam，全都是公式 (6.1)。

Adam 之后还有很多改进，最值得知道的一个是 AdamW（Loshchilov & Hutter 2019）。第 6 讲的 L2 正则化是把 $\lambda W$ 加进梯度，可是加进梯度的这一项在 Adam 里也会被 $\sqrt{\hat s}$ 除，正则化的强度因此因参数而异。AdamW 把 weight decay 从梯度里拿出来，直接对参数做 $W \leftarrow W - \alpha\lambda W$。今天训练 Transformer 和大语言模型，默认几乎都是 AdamW。另外，理论上 Adam 在某些构造出来的问题上可以不收敛（Reddi et al. 2018），有研究发现调好的 SGD + momentum 在一些图像任务上泛化得比 Adam 好（Wilson et al. 2017）。所以 Adam 是”很好的默认选择”，不是”永远最好”。

7. 在网络上比较：复刻 “Optimization Methods” 作业 · GD vs Momentum vs Adam on a network

7.1 设定

Coursera 的编程作业 “Optimization Methods” 在月牙数据（sklearn.datasets.make_moons，300 个点，噪声 0.2）上训练一个三层网络 [2, 5, 2, 1]（ReLU + sigmoid 输出，He 初始化），mini-batch 64，学习率 0.0007，较新的版本训练 5000 个 epoch（早期版本是 10000），比较 mini-batch GD、Momentum、Adam。作业报告的结果大约是：GD 和 Momentum 在训练集上约 80%，Adam 约 94%（具体数字随版本略有不同）。作业的结论是：momentum 在这么小的学习率和这么简单的数据上作用几乎可以忽略，Adam 明显更好。

代码 04 演示 3 用 optimizers.model()（作业里 model() 的复刻）和第 3 讲的 numpy 版月牙数据重做一遍，加了一个独立生成的 2000 个样本的测试集，每种优化器跑 3 个种子（种子决定初始化和每个 epoch 的打乱顺序）：

和作业的结论一致：Adam 明显好，GD 和 Momentum 几乎一模一样（训练 cost 最大相差 0.0008），而且 cost 还在缓慢下降，远没有训练完。（左图里 Adam 的曲线在第 1000 个 epoch 前后也有一段几乎平的”台阶”，然后又降下去：平台不只出现在 GD 身上，§9 再说。）

GD 和 Momentum 一样，正是 §4.3 的预言：同一个 $\alpha$ 下，Ng 写法的 momentum 并不比 GD 走得快，它的好处是”允许更大的 $\alpha$“，而 0.0007 小到根本没有震荡可以平均。

7.2 换学习率之后

那么，Adam 赢是因为它”更聪明”，还是因为 0.0007 对 GD 来说太小了？代码 04 演示 4 把学习率换成 0.007、0.07、0.7（3 个种子的测试准确率：平均，括号里是最低–最高；“×k”表示有 k 次停在 0.5）：

• 学习率加大 10 倍，GD 和 Momentum 就到了 0.959；再加大 10 倍，三种方法几乎一样（0.963 / 0.965 / 0.965）。作业里 Adam 的优势，主要来自”0.0007 对 GD 来说太小、对 Adam 来说刚好”。
• 为什么同一个 $\alpha$ 对两者意义不同？代码量了一下：这个网络刚初始化时梯度各元素的均方根只有 0.0030–0.0323（3 个种子）。GD 的一步是 $\alpha \times$ 梯度，Adam 的一步约等于 $\alpha$。同样写 $\alpha = 0.0007$，Adam 的实际步子是 GD 的 31–338 倍。
• Adam 也要调学习率：$\alpha = 0.7$ 时 3 次全部停在 0.5（ReLU 全部死掉）。GD 和 Momentum 在 0.7 时也开始出问题（GD 有 1 次停在 0.5；momentum 3 次都没有，但最低只有 0.883，这和”momentum 允许更大的学习率”一致，只是 3 个种子说明不了太多）。

7.3 那到底用哪个？

把 §4–7 合起来，可以给出一个诚实的总结：

• Adam 的最大实际好处是”好调”：步长不太依赖梯度的尺度，默认的 $\beta_1, \beta_2, \varepsilon$ 几乎不用动，$\alpha$ 从 0.001 附近开始试，常常一次就能用。网络里不同参数的梯度尺度差很多时（§9.4），它的优势更明显。这是它成为默认选择的原因。
• 调好学习率之后，三者在这个任务上差不多。Momentum 的价值是让更大的学习率可用、在很病态的问题上快得多；它和 GD 共用同一个 $\alpha$ 时并不更快。
• 哪一个都不是”不用调”。不同的问题上排名可能不同（§6.4 的旋转碗、§6.5 的文献）。

这也是 Ng 在课上的建议：Adam 是一个很好的默认选择，但学习率 $\alpha$ 一定要调。第 9 讲会讲怎样系统地调（在对数尺度上随机搜索）。

8. 学习率衰减 · Learning rate decay

8.1 为什么要衰减：噪声球

用 mini-batch 训练时，每一步的梯度都带着噪声（§2.3）。学习率是常数的话，参数走到最低点附近之后，会在一个”球”里随机游走，停不下来。学习率越大，球越大。Ng 的建议是：开头用大的学习率走得快，后面慢慢减小，让参数在最低点附近一个更小的范围里打转。

代码 04 演示 2 用一个能精确算出最优解的问题来看这件事：线性回归，10 个特征、1000 个样本，mini-batch 大小 10，普通梯度下降。表中是第 $e$ 个 epoch 里各步的 $J(w) - J(w^*)$ 的平均（0 = 到达最低点）：

• 常数 α = 0.1：第 3 个 epoch 就降到 6.2e−03，之后再也下不去了。不是算法坏了，是噪声球。
• 常数 α = 0.01：开头慢得多，但最后停得低（1.4e−04，是 α = 0.1 的 1/47）。
• 衰减：开头和 α = 0.1 一样快，最后比 α = 0.01 还低。前期大步走得快，后期小步停得准，两者兼得。

注意两种”停不下来”的区别：这里是 mini-batch 的噪声造成的，全批量梯度下降在这个凸问题上用常数学习率就能精确收敛；§5.2、§6.4 里 RMSprop 和 Adam 停不稳，是因为它们的步长不随梯度变小。两种情况的药方都是让学习率随时间变小。（理论上，SGD 要收敛到最优点，学习率需要满足 $\sum_t \alpha_t = \infty$、$\sum_t \alpha_t^2 < \infty$，这是 Robbins & Monro 1951 的经典条件。$\alpha_t \propto 1/t$ 满足它，常数学习率不满足。）

8.2 常见的衰减公式

记 1 个 epoch = 把训练集过一遍。Ng 视频里的第一个公式：

他的例子：$\alpha_0 = 0.2$、decay_rate = 1 时，epoch 1、2、3、4 的学习率是 0.1、0.0667、0.05、0.04（代码 04 演示 1）。其他常见的形式：

• 指数衰减：$\alpha = 0.95^{\text{epoch\_num}}\,\alpha_0$；
• $\alpha = \dfrac{k}{\sqrt{\text{epoch\_num}}}\,\alpha_0$，或者用 mini-batch 的步数 $t$ 代替 epoch 数：$\dfrac{k}{\sqrt t}\,\alpha_0$；
• 阶梯衰减（discrete staircase）：每隔一段时间学习率减半，或者除以 10；
• 手动衰减：训练一个模型要好几天时，有人会盯着学习曲线，看到它变平了就手动把学习率调小。

代码 04 演示 1 打出了几种调度在 100 个 epoch 里的样子（$\alpha_0 = 0.1$）：

公式 (8.1) 在开头降得最猛：decay_rate = 1 时第 1 个 epoch 就砍掉一半。衰减的快慢完全由 decay_rate 决定，它本身就是一个要调的超参数。较新版本的 Coursera 作业正是从这一点出发的：先用 (8.1) 每个 epoch 衰减一次，发现 5000 个 epoch 下学习率很快就小到几乎不动；再改成”每隔 time_interval 个 epoch 才衰减一次”（fixed interval scheduling，代码里的 schedule_lr_decay）：

8.3 现代做法：warmup + cosine

今天训练大模型，最常见的调度是 warmup + cosine，代码里的 warmup_cosine：

• warmup（热身）：最开始的一小段（比如几百到几千步）里，学习率从接近 0 线性升到 $\alpha_0$。Goyal et al.（2017）用 batch 8192 训练 ResNet 时用它解决训练初期的不稳定；Transformer 的原论文（Vaswani et al. 2017）也用了 4000 步的 warmup。一个直觉：刚开始时参数是随机的，梯度大而且方向不稳定，Adam 的二阶矩估计 $s$ 也还不准（§6.3 的表说明了开头的 $s$ 有多不可靠），先走小步更安全。
• cosine：之后学习率沿余弦曲线从 $\alpha_0$ 降到 0（或一个很小的值）：$\alpha = \alpha_{\min} + \tfrac12(\alpha_0 - \alpha_{\min})(1 + \cos(\pi p))$，$p$ 是训练进度（0 到 1）。前期降得慢、中间快、最后又慢慢贴近底部。来自 Loshchilov & Hutter（2017，SGDR）。

经典的 ImageNet 图像分类训练则常用阶梯衰减，比如每 30 个 epoch 把学习率除以 10。

8.4 在月牙数据上的效果，以及它排在第几位

代码 04 演示 5 在月牙数据上比较几种调度。起始学习率 $\alpha_0 = 0.07$，选法是写代码时定下的规则：“演示 4 里三种优化器、所有种子都没有停在 0.5 的最大学习率”。每格是 3 个种子平均的”训练集 cost / 测试准确率”：

• 每个 epoch 都按 1/(1 + epoch) 衰减太快了：5000 个 epoch 后学习率只剩 $\alpha_0$ 的 1/5000，绝大部分时间几乎不动，GD 的训练 cost 停在 0.6207。这就是作业里演示的问题。
• 温和的衰减（每 1000 epoch 一次、cosine）比常数学习率的训练 cost 略低一点，测试准确率几乎不变。这个任务只有 300 个样本，mini-batch 噪声不大，网络也很小，学习率衰减能做的事有限。

这和 Ng 的建议一致：学习率衰减在他”要调的东西”清单里排得比较靠后，先把常数学习率 $\alpha$ 调好，衰减是锦上添花（第 9 讲会讲他的超参数重要性排序）。在大数据、训练几十到几百个 epoch 的任务上，衰减的作用要大得多，§8.1 的噪声球就是原因。

9. 局部最优的问题 · The problem of local optima

9.1 低维直觉 vs 高维现实

早年讲神经网络优化时，常见的一张图是一个二维的、坑坑洼洼的曲面，有很多局部最小值。大家担心梯度下降会卡在某个很差的局部最小里出不来。

Ng 说，这种直觉来自低维的图，在高维空间里会误导你。梯度为 0 的点，在每一个方向上可能向上弯，也可能向下弯。要成为局部最小，必须所有方向都向上弯。如果网络有 20,000 个参数，每个方向”独立地抛硬币”决定弯上还是弯下，那么全部向上的概率大约是 $2^{-20000}$。所以高维空间里梯度为 0 的点，绝大多数是鞍点（saddle point）：有的方向向上弯，有的方向向下弯，像马鞍。

9.2 随机对称矩阵：比抛硬币还极端

在一个梯度为 0 的点附近，$J \approx J_0 + \tfrac12\Delta^\top H \Delta$，$H$ 是二阶导数矩阵（Hessian）。$H$ 的特征值全 > 0 是局部最小，全 < 0 是局部最大，有正有负是鞍点。我们不知道真实网络的 $H$ 长什么样，代码 05 演示 1 用最简单的”随机”版本当作漫画：$H = (G + G^\top)/\sqrt2$，$G$ 的元素是独立的标准正态分布（物理学里叫 GOE 随机矩阵）。每个维数生成 400,000 个：

维数每加 1，局部最小的比例掉得比抛硬币还快得多。6 维时 40 万个里只有 1 个。为什么？抛硬币的论证假设每个方向独立，可随机矩阵的特征值之间互相”排斥”。要所有特征值同时为正，是一个代价极高的集体事件。可以证明这个概率在 $n$ 很大时大约按 $e^{-c n^2}$ 衰减，$c = \ln 3/4 \approx 0.27$（Dean & Majumdar 2006），比 $2^{-n}$ 快得多。（$n = 2$ 的 0.146 可以手算出来，见练习 10。）

维数更高时，看特征值里负数占多少：$n = 10$、100、1000 时平均都是一半左右（0.499、0.499、0.500）。$n = 1000$ 的 10 个矩阵里最少 0.499、最多 0.502，离”局部最小要求的 0”差得很远。

要小心这个漫画的局限。 真实网络的 Hessian 不是随机矩阵。Dauphin et al.（2014）等人的研究（建立在 Bray & Dean 2007 的随机场理论之上）发现，临界点的”负方向个数”和它的 cost 高低有关：cost 高的临界点大多是有很多下降方向的鞍点，cost 越接近最低，负方向越少。在低 cost 的区域里确实有很多局部最小，只是它们的 cost 大多和全局最小差不多（Choromanska et al. 2015 在一个简化模型里得到类似的结论）。所以准确的说法是：对大网络，“卡在一个很差的局部最小里”很少是真正的问题。

9.3 鞍点：逃出来要多久

既然到处是鞍点，梯度下降会不会卡在鞍点上？代码 05 演示 2 用一个最简单的鞍点：

$(0, 0)$ 是鞍点（$x$ 方向向上弯，$y$ 方向向下弯，$f = 0$），$(0, \pm1)$ 是两个最小值（$f = -\tfrac14$）。从 $(1, \delta)$ 出发：$x$ 方向很快滑到 0，点被”吸”到鞍点旁边；能不能离开，全看 $y$ 方向那一点点 $\delta$。每格是”第一次 $|y| > 0.5$ 的步数 / 在鞍点附近（$|f| < 10^{-3}$）停留的步数”：

（”—“表示 5000 步内没有离开。）

• GD：鞍点附近 $y$ 每步只放大 $(1+\alpha) = 1.1$ 倍，从 $\delta$ 长到 0.5 要 $\log(0.5/\delta)/\log 1.1$ 步。$\delta$ 每小 1000 倍，就多花约 70 步（67 → 139 → 212）。这段时间里 $f$ 几乎不变，训练曲线上就是一段平台。 鞍点本身不会把 GD 永远困住，但会让它停很久。
• Momentum（Ng 的写法，同一个 α）比 GD 还慢（326 vs 212 步）：$v$ 是梯度的平均，一个持续变大的梯度被平均之后总是”慢半拍”。换成它允许的更大学习率，它会快起来。
• RMSprop / Adam 几乎不在乎 δ：$\delta$ 从 $10^{-1}$ 到 $10^{-9}$，Adam（α = 0.01）都是 37–45 步。$y$ 方向的梯度再小，除以它自己的均方根之后也是 1 的量级，于是 $y$ 方向一开始就以约 $\alpha$ 的速度往外走。这就是 Ng 说”momentum、RMSprop、Adam 能帮你更快地离开平台”时，最直接的一个机制。（这里鞍点的方向和坐标轴对齐；斜的时候效果会打折扣，和 §6.4 同样的道理。）
• 正好在鞍点上（δ = 0）：梯度恰好是 0，四种方法全都一步不动。鞍点是”不稳定的平衡”，但没有任何扰动就永远不会离开。

最后一条引出 mini-batch 噪声的一个好处。演示 2 让点正好从 $y = 0$ 出发，但给每一步的梯度加一点点噪声（模拟 mini-batch），各跑 200 次：噪声标准差 $10^{-6}$ 时 GD 逃出来的中位数是 159 步，$10^{-3}$ 时 87 步，200 次全部逃了出来。第 1 讲 tiny_nn.train 的注释说”梯度里的随机性有时还有好处”，指的就是这一类情形。

9.4 平台：真正的麻烦，以及 Adam 怎样”部分掩盖”梯度消失

Ng 的结论是：真正拖慢训练的不是局部最优，而是平台（plateau）：一大片梯度接近 0 的区域，参数要在上面挪很久才能走出去。§9.3 的鞍点附近就是一种平台。另一种我们已经见过：第 1 讲代码 04 演示 3 里，5 个 sigmoid 隐藏层的网络用普通 SGD 训练，4000 步都停在 50% 的准确率上。

代码 05 演示 3 重做这个实验（同一个”老师网络”任务、同样的网络结构、mini-batch 128、4000 步），换几种优化器：

用默认学习率的 Adam 200 步就离开了平台。为什么？看前 100 步里每一层权重的梯度和实际更新量的均方根：

• SGD 的更新量 = $\alpha \times$ 梯度。梯度从输出层往输入层一层层变小（梯度消失，第 1 讲 §4.4），第 1 层的更新量只有输出层的 $3 \times 10^{-4}$ 倍，靠近输入的几层几乎不动。
• Adam 把每个参数的梯度除以它自己的均方根，各层的更新量都变成了约 $\alpha$ 的量级（第 1 层 / 输出层 = 3.0）。梯度本身仍然差了几千倍，但步子差不多大了。这正是 §6.4 说的”和坐标轴对齐的病态”：每一层自己的梯度尺度不同，Adam 按参数修正了它。

这就是第 1 讲 tiny_nn.py 里那句注释”Adam 的自适应步长会部分掩盖梯度消失”的意思。为什么说部分？

1. 梯度消失本身并没有被修好：第 1 层的梯度仍然很小，里面的”信号”相对噪声可能也更弱。如果梯度小到和 $\varepsilon = 10^{-8}$ 一个量级，除法就失效了，Adam 也救不回来（练习 9 把 $\varepsilon$ 改大来模拟这种情况）。
2. 从根上解决梯度消失的办法是 ReLU（第 1、3 讲）、好的初始化（第 7 讲）、Batch Norm（第 9 讲）、残差连接（第 13 讲）。
3. 反过来，正因为 Adam 会掩盖它，用 Adam 训练得不错，并不说明网络里没有梯度消失。要诊断，就像这里一样直接看每一层的梯度。这也是第 1 讲代码 04 比较 sigmoid 和 ReLU 时特意用普通 SGD 的原因。

10. 小结 · Summary

• Mini-batch：每一步只用 $B$ 个样本。按步数全批量最准，按样本数小 batch 更省，按耗时 mini-batch 最快（代码 01：$B = 64$ 在 0.050 s 降到 cost ≤ 0.3，全批量 0.666 s，SGD 每个样本慢约 170 倍）。mini-batch 梯度的误差按 $1/\sqrt{B}$ 缩小（2.63 → 0.34 → 0.11），所以代价曲线会抖。每个 epoch 打乱；最后一块可留可丢；常用 64–512，确保放得进内存。
• 指数加权平均 $v_t = \beta v_{t-1} + (1-\beta)\theta_t$ ≈ 最近 $1/(1-\beta)$ 个数的平均，理由是 $(1-\varepsilon)^{1/\varepsilon} \approx 1/e$。$\beta$ 越大越平滑也越滞后（$\beta = 0.98$ 滞后 40 天）。偏差修正 $\hat v_t = v_t/(1-\beta^t)$ 修正 $v_0 = 0$ 造成的开头偏低。
• 病态的碗：GD 的学习率被陡的方向卡住，平的方向走得慢，步数 ∝ $\kappa$（35 / 87 / 346 / 3454）。
• Momentum 用梯度的平均走：平均掉震荡，允许更大的学习率（$\beta = 0.9$ 时上限是 GD 的 19 倍），在很扁的碗上快得多（$\kappa = 1000$：144 vs 2420 步）。但同一学习率下它不比 GD 快，会冲过谷底，$\beta = 0.9$ 对不太扁的碗惯性太大。
• RMSprop 用梯度均方根按维度缩放步长；步长约等于 $\alpha$，常数学习率下停不下来。
• Adam = momentum + RMSprop + 偏差修正，默认 $\beta_1 = 0.9$、$\beta_2 = 0.999$、$\varepsilon = 10^{-8}$，只调 $\alpha$。偏差修正必须做（不修正时前几百步步长被放大到最多 6.57 倍）。按维度缩放只对和坐标轴对齐的病态有效（旋转后 123 → 733 步）。
• 作业的复刻：$\alpha = 0.0007$ 时 Adam 0.967、GD / Momentum 0.860；$\alpha = 0.07$ 时三者都在 0.963–0.965。Adam 的主要优势是”好调”，不是”终点更好”；它也会在大学习率下失败。
• 学习率衰减：mini-batch 噪声让常数学习率停在一个”噪声球”里（线性回归：常数 0.1 停在 6.4e−03，cosine 到 1.9e−06）。公式 $\alpha_0/(1 + \text{decay\_rate}\cdot\text{epoch})$、指数、阶梯、手动；现代常用 warmup + cosine。衰减太快会让训练停住。在 Ng 的清单里它排得比较靠后。
• 局部最优：高维空间里梯度为 0 的点几乎都是鞍点（随机矩阵：6 维时 40 万个里只有 1 个局部最小）；真正的麻烦是平台。GD 离开鞍点的时间 ∝ $\log(1/\delta)$，Adam 几乎不受影响，梯度噪声能帮忙离开”正好的”鞍点。Adam 让各层的更新量变得一样大，从而部分掩盖梯度消失。

11. 常见误区 · Common pitfalls

1. “mini-batch 训练的 cost 在抖，说明学习率太大了。” 不一定。mini-batch 的梯度和 cost 本身就有噪声（代码 01 演示 2）。要看的是趋势：用每个 epoch 的平均，或者定期在整个训练集 / 验证集上评估。持续上升或者变成 nan 才是学习率太大。
2. “SGD 就是 batch = 1 的梯度下降。” 原课里的 stochastic gradient descent 指 $B = 1$；但今天很多人（包括 PyTorch 的 torch.optim.SGD）把 mini-batch 梯度下降也叫 SGD。读论文和代码时，看清楚他们的 batch 是多大。
3. “Momentum 让小球越滚越快，所以同一个学习率下比 GD 快。” Ng 写法里方向一致时 $v$ 稳定在梯度本身那么大，同一个 $\alpha$ 下并不更快（代码 03 演示 2：83 vs 128 步；代码 04：GD 和 Momentum 结果几乎相同）。它的好处是允许更大的学习率、在很病态的问题上快得多。
4. “用了 momentum，cost 就应该单调下降。” 小球会冲过谷底，cost 偶尔上升是正常的（代码 03 演示 4：150 步里 60 步在上升）。
5. “Adam 不用调学习率。” $\beta_1, \beta_2, \varepsilon$ 几乎不用调，$\alpha$ 一定要调。月牙数据上 $\alpha = 0.7$ 时 Adam 3 次全部失败（代码 04 演示 4）。
6. “偏差修正可有可无。” 对 momentum 基本如此；对 Adam 不是：不修正时前几百步的实际学习率是设定值的 3 到 6.6 倍，学习率稍大就可能把网络训坏（代码 02 演示 4）。
7. “Adam 训练得好，所以网络里没有梯度消失。” Adam 会把各层的更新量拉到同一个量级，掩盖梯度消失（代码 05 演示 3）。诊断要直接看各层的梯度。
8. “学习率衰减越快越好 / 一定能提升结果。” 衰减太快会让训练提前停住（代码 04 演示 5：1/(1 + epoch) 衰减 5000 个 epoch，GD 的 cost 停在 0.62）。先调好常数学习率，衰减是锦上添花。
9. “训练卡住了，一定是掉进了局部最小。” 在大网络里更可能是平台或鞍点附近（梯度很小但不为 0）。可以试试换优化器（Adam）、调大学习率、检查是不是梯度消失（各层梯度的大小），而不是换随机种子重来。

12. 练习 · Exercises

练习 1（手算指数加权平均）。三天的气温是 $\theta = (10, 12, 8)$，$\beta = 0.9$，$v_0 = 0$。(a) 算出 $v_1, v_2, v_3$。(b) 算出偏差修正后的 $\hat v_1, \hat v_2, \hat v_3$。(c) 为什么 $\hat v_1$ 恰好等于 $\theta_1$？

(a) $v_1 = 0.1 \times 10 = 1.0$；$v_2 = 0.9 \times 1.0 + 0.1 \times 12 = 2.1$；$v_3 = 0.9 \times 2.1 + 0.1 \times 8 = 2.69$。三个数都远小于真实气温，这就是 $v_0 = 0$ 造成的偏差。

(b) $\hat v_1 = 1.0/0.1 = 10$；$\hat v_2 = 2.1/(1-0.81) = 2.1/0.19 \approx 11.05$；$\hat v_3 = 2.69/(1-0.729) = 2.69/0.271 \approx 9.93$。

(c) $v_1 = (1-\beta)\theta_1$，修正项 $1 - \beta^1 = 1-\beta$，两者一除就是 $\theta_1$。一般地，如果 $\theta$ 一直等于常数 $c$，$v_t = c(1-\beta^t)$，修正后 $\hat v_t = c$ 对所有 $t$ 都成立。这就是偏差修正”把权重归一化成 1”的意思。（可以用 optimizers.ewa([10, 12, 8], 0.9, bias_correction=True) 验证。）

练习 2（权重之和与平均年龄）。(a) 证明 $v_t$ 展开后 $\theta_1, \dots, \theta_t$ 的权重之和是 $1 - \beta^t$。(b) 当 $t \to \infty$ 时，”$k$ 天前”的权重是 $(1-\beta)\beta^k$。证明平均年龄 $\sum_k k(1-\beta)\beta^k = \beta/(1-\beta)$。(c) $\beta = 0.98$ 时这是多少天？和代码 02 演示 1 实测的滞后（40 天）比较，为什么不一样？

(a) 权重之和 $(1-\beta)(1 + \beta + \cdots + \beta^{t-1}) = (1-\beta)\cdot\frac{1-\beta^t}{1-\beta} = 1-\beta^t$（等比数列求和）。

(b) 利用 $\sum_{k\ge0} k\beta^k = \beta/(1-\beta)^2$（对 $\sum \beta^k = 1/(1-\beta)$ 两边关于 $\beta$ 求导再乘 $\beta$），所以 $\sum_k k(1-\beta)\beta^k = (1-\beta)\cdot\beta/(1-\beta)^2 = \beta/(1-\beta)$。

(c) 49 天。对一条直线 $\theta_t = a + bt$，指数加权平均（$t$ 很大时）恰好等于 $a + b(t - 49)$，也就是”拖后 49 天”。季节曲线是弯的：在最热的那几天，曲线已经开始往下拐，平均里混进的”更早的日子”反而没那么热，所以峰值的滞后小一些（40 天），同时峰值也被压低（起伏只剩 84%）。

练习 3（噪声被平均掉多少）。设 $\theta_t$ 是独立的噪声，方差 $\sigma^2$。证明 $t$ 很大时 $\text{Var}(v_t) = \sigma^2\,\frac{1-\beta}{1+\beta}$。$\sigma = 3$、$\beta = 0.9$ 时，$v_t$ 的标准差是多少？和代码 02 演示 1 的”理论值”一列对照。

$v_t = \sum_k (1-\beta)\beta^k\theta_{t-k}$，各项独立，所以 $\text{Var}(v_t) = (1-\beta)^2\sigma^2\sum_k \beta^{2k} = (1-\beta)^2\sigma^2 \cdot \frac{1}{1-\beta^2} = \sigma^2\,\frac{1-\beta}{1+\beta}$（用了 $1-\beta^2 = (1-\beta)(1+\beta)$）。

$\sigma = 3$、$\beta = 0.9$：$3\sqrt{0.1/1.9} \approx 0.69$ °C，就是表里的理论值。对比”平均最近 $N = 10$ 天”的简单平均，标准差是 $3/\sqrt{10} \approx 0.95$。指数加权平均的”有效样本数”是 $(1+\beta)/(1-\beta) = 19$，比 $N$ 大，因为它的权重拖得更长。

练习 4（数 mini-batch）。$m = 1{,}000{,}000$，$B = 512$。(a) 用 random_mini_batches 的默认做法，每个 epoch 有多少个 mini-batch？最后一块有多少个样本？(b) 训练 20 个 epoch 一共更新多少次参数？(c) 换成 drop_last=True，每个 epoch 有多少样本没用上？

(a) $\lfloor 1{,}000{,}000/512 \rfloor = 1953$ 个满的块，$1953 \times 512 = 999{,}936$，剩下 64 个样本组成第 1954 块。所以每个 epoch 1954 个 mini-batch。

(b) $20 \times 1954 = 39{,}080$ 次。（全批量梯度下降 20 个 epoch 只更新 20 次。）

(c) 64 个（0.0064%），完全可以忽略。这就是”$m$ 远大于 $B$ 时两种做法几乎没有区别”。

练习 5（先预测再看表：GD 在更扁的碗里）。$f = \tfrac12(x^2 + 100y^2)$。(a) GD 不发散的最大学习率是多少？(b) 最优学习率 $\alpha^*$ 是多少？每一步误差乘以多少？(c) 粗略估计 $f$ 降到初始值的 $10^{-6}$ 需要多少步（提示：$f$ 每步大约乘以倍数的平方）。然后对照代码 03 演示 1 的表。