现代优化器——SGD、动量、Adam 与调度

上一课我们看清了梯度下降的几何：在病态（ill-conditioned）的损失面上——也就是 Hessian \(H\) 的最大、最小特征值相差悬殊、条件数（condition number）很大时——普通梯度下降会在狭长山谷里来回"之字形"震荡，走得又慢又痛苦。这一课我们就来补上工程上真正在用的那套工具：用随机性换便宜、用惯性压震荡、用自适应步长对付病态，再用调度稳住训练。学完这一课，你就能看懂任何一份现代深度学习训练脚本里的优化器配置。

一、为什么不用全部数据算梯度：SGD 的便宜与噪声

先回到最朴素的设定。我们要最小化训练集上的平均损失：

这叫 全批梯度下降（full-batch GD）：每走一步，都要扫一遍全部 \(N\) 个样本求平均梯度。当 \(N\) 是百万、上亿时，光算一步就要把整个数据集过一遍——慢到无法接受。

关键在于这个近似是无偏的（unbiased）。呼应模块2第1课讲的蒙特卡洛与无偏估计：如果随机均匀抽一个样本下标 \(i\sim \mathrm{Uniform}\{1,\dots,N\}\)，那么单样本梯度 \(\nabla\ell_i(\theta)\) 是随机变量，它的期望恰好是真梯度

也就是说，SGD 走的方向平均而言是对的，只是每一步带了随机噪声。抽一小批 \(\mathcal B\)（大小 \(|\mathcal B|=B\)）取平均，估计仍无偏，但方差按 \(\propto 1/B\) 缩小——批量越大越平稳，但每步越贵。这是个权衡（trade-off）。

厘清三个被滥用的词：epoch / batch / iteration

• batch（批）：一次前向+反向用到的那一小撮样本，大小 \(B\)。
• iteration（迭代 / step）：用一个 batch 完成的一次参数更新。
• epoch（轮）：把整个训练集完整过一遍。一个 epoch 包含 \(\lceil N/B\rceil\) 个 iteration。

举例：\(N=50000\)、\(B=100\)，则一个 epoch = 500 个 iteration。训练 10 个 epoch = 5000 次参数更新。注意 full-batch GD 里"一个 epoch = 一步"，而 SGD/mini-batch 里"一个 epoch = 很多步"——这正是后者收敛快的直观原因。

二、动量：给小球加上惯性，压住之字形

回到病态山谷的之字形问题。普通 GD 的麻烦在于：在陡峭方向（大特征值）上步子太大、来回弹跳；在平缓方向（小特征值）上步子太小、推进缓慢。每一步只看当前梯度，没有记忆，于是被陡峭方向的反复横跳主导。

把这个"惯性"写成公式，就是维护梯度的累加作为"速度" \(v\)：

其中 \(\beta\in[0,1)\)（典型 \(0.9\)）是动量系数。从 \(v_0=0\) 展开看，\(v\) 是历史梯度的加权和 \(v_t=\sum_{k=0}^{t-1}\beta^{\,k}\nabla L(\theta_{t-k})\)：越近的梯度权重越大（当前梯度系数恰为 1），越远的按 \(\beta^k\) 几何衰减。\(\beta=0\) 就退化回普通 GD。

为什么能压震荡？在横向（陡峭）方向，相邻梯度正负交替，加权平均后大量抵消，\(v\) 的横向分量很小；在纵向（指向谷底）方向，梯度方向一致，加权累加，\(v\) 的纵向分量越来越大。于是路径更"直"地冲向谷底——这正是我们在代码里会量化看到的：之字形的符号翻转次数大幅下降。

三、自适应学习率：从 AdaGrad 到 RMSProp 到 Adam

动量解决了"方向"问题，但还有个"步长"问题：不同参数该用不同大小的步子。比如 NLP 里高频词的梯度大、低频词的梯度小，用同一个 \(\eta\) 要么对前者太大、要么对后者太小。自适应学习率（adaptive learning rate）的思路是：逐参数地，让历史上梯度大的方向步子小一点、梯度小的方向步子大一点。

AdaGrad：累积梯度平方

给每个参数维护它历史梯度平方的累加 \(G\leftarrow G+g^2\)，更新时除以 \(\sqrt G\)：

梯度一直很大的方向，\(G\) 累积得快，有效步长 \(\eta/\sqrt G\) 被压小；很少更新的方向步长保持较大。（这里的 \(\epsilon\) 是个防除零的极小数，典型 \(10^{-8}\)，下同。）

RMSProp：把累加换成滑动平均

修复办法很自然：别让 \(G\) 无限累加，改成指数滑动平均，只记住"最近"的梯度平方规模：

注意这里带了 \(1-\rho\) 因子（归一化 EMA），\(v\) 是梯度平方的平均而非累加。\(\rho\)（典型 \(0.99\)）一衰减，旧的梯度平方就被遗忘，\(v\) 不再无限增长，学习率不会过早归零。这就是 RMSProp。

Adam = 动量 + RMSProp + 偏差修正

Adam（Adaptive Moment Estimation）把两条线合一：用一阶矩 \(m\)（梯度的 EMA，即动量）定方向，用二阶矩 \(v\)（梯度平方的 EMA，即 RMSProp）定每个参数的步长。注意这里的 \(m\) 用的是带 \(1-\beta_1\) 因子的归一化形式（与上一节无归一化的动量 \(v\) 略有差别，量级回到与单步梯度相当）：

但有个细节：\(m,v\) 都从 \(0\) 初始化，训练最初几步它们被"拉向零"，系统性偏小（有偏估计）。Adam 用偏差修正（bias correction）除掉这个偏：

其中 \(t\) 是步数（从 1 开始）。\(t\) 很小时分母 \(1-\beta_1^t\) 远小于 1，把被低估的 \(m\) 放大回正常规模；\(t\) 变大后 \(\beta_1^t\to0\)，修正因子 \(\to1\)，自动失效。典型超参：\(\beta_1=0.9,\ \beta_2=0.999,\ \epsilon=10^{-8}\)。

四、AdamW：为什么不是"Adam + L2"

训练里常加权重衰减（weight decay）把参数往 0 拉，防过拟合。传统做法是在损失里加 L2 正则项 \(\frac\lambda2\|\theta\|^2\)，它的梯度是 \(\lambda\theta\)，直接并进 \(g\) 里。在最朴素的 SGD（无动量、定学习率）上，"L2 正则"和"权重衰减"完全等价——把 \(\lambda\theta\) 加进梯度，效果就等于每步把 \(\theta\) 按比例往 0 收缩。

AdamW 的修复叫解耦权重衰减（decoupled weight decay）：把权重衰减从梯度里拿出来，不经过任何优化器状态（动量、自适应分母），直接作用在参数上：

这样衰减项 \(\lambda\theta\) 干净地、按统一比例把每个参数往 0 收缩，与自适应步长互不干扰。

五、学习率调度：warmup 与 cosine 衰减

学习率 \(\eta\) 不必是常数，让它随训练过程变化往往更好。两个最常见的部件：

线性 warmup（预热）

训练最开始，参数是随机初始化的，\(\hat v\) 的统计量还没积累准、梯度可能很离谱。这时若直接用大学习率，一步走太远，loss 容易直接变成 NaN（爆掉）。warmup 让 \(\eta\) 从 0（或很小）线性爬升到目标值，给优化器一段"热身"时间稳住统计量。

cosine 衰减

热身结束后，让 \(\eta\) 按余弦曲线平滑地从峰值降到接近 0。前期大步快速探索，后期小步精细收敛（在极小值附近别再乱跳）。设 warmup 步数 \(T_w\)、总步数 \(T\)、峰值 \(\eta_{\max}\)：

import numpy as np
a, b = 1.0, 50.0                      # 条件数 = 50（病态）
def grad(p): return np.array([a*p[0], b*p[1]])
def loss(p): return 0.5*(a*p[0]**2 + b*p[1]**2)

def gd(eta, steps):
    p = np.array([5.0, 5.0])
    for _ in range(steps): p = p - eta*grad(p)
    return loss(p)

def momentum(eta, beta, steps):
    p = np.array([5.0, 5.0]); v = np.zeros(2)
    for _ in range(steps):
        v = beta*v + grad(p); p = p - eta*v
    return loss(p)

def adam(eta, steps):
    p = np.array([5.0, 5.0]); m = np.zeros(2); v = np.zeros(2)
    b1, b2, eps = 0.9, 0.999, 1e-8
    for t in range(1, steps+1):
        g = grad(p)
        m = b1*m + (1-b1)*g
        v = b2*v + (1-b2)*g*g
        mh = m/(1-b1**t); vh = v/(1-b2**t)
        p = p - eta*mh/(np.sqrt(vh)+eps)
    return loss(p)

print("GD      :", gd(0.035, 200))         # ~8e-6
print("Momentum:", momentum(0.01, 0.9, 200))  # ~2e-7
print("Adam    :", adam(0.2, 200))         # ~4e-8

import numpy as np
a, b = 1.0, 50.0
def grad(p): return np.array([a*p[0], b*p[1]])
def flips(ys):
    s = np.sign(ys)
    return int(np.sum(s[1:]*s[:-1] < 0))   # 相邻符号相反 = 一次翻转

p = np.array([5.0,5.0]); ys=[]
for _ in range(60): p = p - 0.035*grad(p); ys.append(p[1])
print("GD   翻转次数:", flips(ys))          # ~59

p = np.array([5.0,5.0]); v=np.zeros(2); ys=[]
for _ in range(60): v=0.9*v+grad(p); p=p-0.01*v; ys.append(p[1])
print("动量 翻转次数:", flips(ys))          # ~14

import numpy as np
rng = np.random.default_rng(0)
N, d = 200, 5
X = rng.normal(size=(N,d)); w_true = rng.normal(size=d)
y = X @ w_true + 0.1*rng.normal(size=N)
def full_loss(w): r = X@w - y; return 0.5*np.mean(r**2)

w = np.zeros(d)                       # full-batch
for t in range(30):
    g = X.T@(X@w - y)/N; w = w - 0.1*g
    if t%6==0: print("full ", round(full_loss(w),3))

w = np.zeros(d)                       # SGD, batch=1
for t in range(30):
    i = rng.integers(N); xi = X[i]
    g = xi*(xi@w - y[i]); w = w - 0.1*g
    if t%6==0: print("sgd  ", round(full_loss(w),3))

# 无偏性：逐样本梯度的平均 == 全梯度
w = rng.normal(size=d)
full_g = X.T@(X@w - y)/N
samp   = np.mean([X[i]*(X[i]@w - y[i]) for i in range(N)], axis=0)
print("无偏（两者相等）:", np.allclose(full_g, samp))   # True