NYU-DLSP20 优化工具(一):从梯度下降、随机梯度下降到动量法

原创2026-10-11 14:55:301,418 阅读
文章标签:示例工程

NYU-DLSP20 优化工具(一):从梯度下降、随机梯度下降到动量法

本文基于 NYU Deep Learning Spring 2020 课程第 5 周第 1 讲(docs/zh/week05/05-1.md)整理扩充,系统讲解深度学习中三种最基础也最核心的优化方法:梯度下降(Gradient Descent)、随机梯度下降(Stochastic Gradient Descent, SGD)以及动量法(Momentum)。你将理解每种方法的数学迭代式、优缺点、步长(学习率)与阻尼系数 β\beta 的调参直觉,并能在 PyTorch 中通过 torch.optim.SGD 与自定义 Optimizer 子类把它们落地到真实模型训练中。

引言:为什么需要学习"最基础、最差"的梯度下降

在神经网络训练中,我们最终要解决的是一个无约束优化问题:

min⁡wf(w)\min_w f(w)

其中 ww 是模型的全部参数,f(w)f(w) 是损失函数。课程的这一讲从"所有方法中最基本、也最差(原因后文叙述)"的梯度下降法讲起——它是一切高级优化器的起点,理解了它的局限,才能理解 SGD 的噪声与动量法的平滑为什么是必要的。

本文涉及的核心内容均可以在当前仓库中找到对应的可视化与可运行示例:

梯度下降:沿负梯度方向"走一小步"

迭代式与符号约定

假设函数 ff 是连续且可导的,梯度下降的迭代式为:

wk+1=wk−γk∇f(wk)w_{k+1} = w_k - \gamma_k \nabla f(w_k)

其中各符号含义如下:

符号 含义
wk+1w_{k+1} 第 kk 次迭代后的更新值
wkw_k 第 kk 次迭代前的初始值
γk\gamma_k 第 kk 步的步长(学习率)
∇f(wk)\nabla f(w_k) 损失函数 ff 在 wkw_k 处的梯度

我们的目标是找到优化方程的最低点(谷底),但到达最低谷的全局路径是未知的。我们只能看到局部信息——梯度的负方向是当前已知的最佳信息:向那个方向移动一小步,就向最小值靠近一步。每移动一小步,重新计算梯度,再向相反方向移动一小步,直到抵达最低谷。因此本质上来讲,梯度下降所做的就是"沿着下降最急剧的方向(负梯度)前进"。

步长(学习率)的选择

迭代式中的 γ\gamma 叫做步长(step size)。我们通常不知道最佳的步长值,必须尝试不同的值。标准的做法是:尝试一串呈对数比例的值,然后使用最好的那个。

下图描绘了一元二次函数情况下不同步长的效果:

一元二次函数的步长对收敛的影响(图片来源:docs/images/week05/05-1/step-size.png)

实践中可能出现的情况:

  • 学习率太小:稳定地向最小值前进,但可能比理想状态更费时,收敛过慢;
  • 步长恰好合适:直接一步到最小值几乎是不可能的;
  • 稍大于理想步长:实际中收敛最快,这是值得追求的目标;
  • 学习率过大:迭代会越过最小值并越走越远,导致不收敛(发散)。

结论:在实际训练中,我们想使用"稍小于不收敛"的学习率,即在收敛速度与稳定性之间取一个安全边际。

从源码看梯度下降的实现骨架

仓库中的 extra/utils/optim.py 提供了一个继承 torch.optim.Optimizer 的自定义优化器骨架,清晰地展示了 PyTorch 优化器的标准实现结构:

from torch.optim import Optimizer
import torch

class Optim(Optimizer):
    def __init__(self, params, defaults):
        super(Optim, self).__init__(params, defaults)

    def step(self, closure=None):
        """Performs a single optimization step."""
        loss = None
        if closure is not None:
            loss = closure()
        for group in self.param_groups:
            for p in group['params']:
                if p.grad is None:
                    continue
                self.my_step(p, self.state[p], group)
        return loss

    def my_step(self, p, state, group):
        raise NotImplementedError

这段代码体现了梯度下降在框架层的三个关键事实:

  1. step() 是每次迭代的入口:遍历所有参数组(param_groups)中的参数,只更新那些 p.grad 不为 None 的参数(即本次前向中参与计算且被 backward() 填充了梯度的参数);
  2. my_step(p, state, group) 是留待子类实现的更新逻辑:标准的梯度下降更新 p←p−γ∇f(p)p \leftarrow p - \gamma \nabla f(p) 就写在这里;
  3. state 字典用于保存动量等历史状态——这正是后文动量法需要"额外维护一条迭代序列 pp"的地方。

同一文件还提供了二次目标函数等高线可视化的辅助逻辑(objective、output),可以在二维参数空间上直接观察每一步迭代的落点轨迹,是理解下文"步长过大导致振荡/发散"的最直观实验。

随机梯度下降(SGD):用噪声换速度与泛化

从全量损失到单样本梯度

在随机梯度下降中,我们用梯度向量的随机估计替换实际的全量梯度向量。专门针对神经网络,随机估计指单个数据点(单个实例)的损失梯度。

令 fif_i 表示第 ii 个实例的网络损失:

fi=l(xi,yi,w)f_i = l(x_i, y_i, w)

最终我们想最小化的函数是 ff,表示所有实例的总损失:

f=1n∑infif = \frac{1}{n}\sum_i^n f_i

在 SGD 中,我们根据 fif_i 上的梯度(而不是总损失 ff 上的梯度)更新权重:

wk+1=wk−γk∇fi(wk)(i 随机选择,服从均匀分布)w_{k+1} = w_k - \gamma_k \nabla f_i(w_k) \qquad (i\text{ 随机选择,服从均匀分布})

无偏性与期望一致性

如果 ii 是随机选择的,那么 ∇fi(wk)\nabla f_i(w_k) 是 ∇f(wk)\nabla f(w_k) 的一个有噪声但无偏的估计量:

E[∇fi(wk)]=∇f(wk)\mathbb{E}[\nabla f_i(w_k)] = \nabla f(w_k)

因此 SGD 的期望第 kk 步与完整梯度下降的第 kk 步完全相同:

E[wk+1]=wk−γkE[∇fi(wk)]=wk−γk∇f(wk)\mathbb{E}[w_{k+1}] = w_k - \gamma_k \mathbb{E}[\nabla f_i(w_k)] = w_k - \gamma_k \nabla f(w_k)

也就是说,任何 SGD 更新在期望意义上都与批次更新相同。但 SGD 的价值远不止"带噪声的更快梯度下降"——它还能比全批次梯度下降取得更好的结果,因为 SGD 更新中的噪声可以帮助我们避免浅的局部最小值,找到更好的(更深的)最小值。这种现象称为退火(annealing):

SGD 的退火效应:噪声帮助跳出浅局部极小(图片来源:docs/images/week05/05-1/annealing.png)

SGD 的优点总结

原讲义总结 SGD 的优势如下:

  1. 跨实例存在大量冗余信息,SGD 可以避免大量此类冗余计算;
  2. 在训练初期,与梯度中的信息量相比,噪声相对较小,因此 SGD 的一步与 GD 的一步"实际上一样好";
  3. 退火——SGD 更新中的噪声可阻止收敛到坏的(浅的)局部最小值;
  4. 随机梯度下降的计算成本大大降低(因为无需遍历所有数据点即可完成一次更新)。

小批次处理(Mini-batching)

在小批次处理中,我们考虑多个随机选择的实例上的损失,而不是仅计算一个实例上的损失,这可以减小每次步进更新中的噪声:

wk+1=wk−γk1∣Bi∣∑j∈Bi∇fj(wk)w_{k+1} = w_k - \gamma_k \frac{1}{|B_i|} \sum_{j \in B_i}\nabla f_j(w_k)

其中 BiB_i 是第 ii 个小批次,∣Bi∣|B_i| 是其样本数量。小批次处理的好处在于更好地利用硬件:单实例训练时 GPU 使用率很低,而小批次可以填满 GPU 的并行计算单元。分布式网络训练技术正是将大型小批次在集群的机器之间分割,再汇总生成的梯度(课程讲授时提到 Facebook 曾用分布式训练在一个小时内完成 ImageNet 上的网络训练)。

一个重要警告:梯度下降(全量 GD)绝不能用于全尺寸批次。如果你确实想以完整的批次大小训练,请使用一种称为 LBFGS 的优化技术——PyTorch 与 SciPy 都提供了该技术的实现(PyTorch 中对应 torch.optim.LBFGS)。

在 PyTorch 中实践 SGD

仓库中的多个实战 notebook 展示了 SGD 的标准用法,例如 04-spiral_classification.ipynb 与 05-regression.ipynb 中完全相同的优化器构造方式:

optimizer = torch.optim.SGD(model.parameters(), lr=learning_rate, weight_decay=lambda_l2)  # built-in L2

配合的训练循环骨架为(伪代码):

for t in range(1000):
    y_pred = model(X)
    loss = criterion(y_pred, y)
    optimizer.zero_grad()   # 清零梯度,避免跨步累积
    loss.backward()         # 反向传播,填充 p.grad
    optimizer.step()        # 执行 my_step 中的参数更新

对照上文源码,这三个调用分别对应:清零旧梯度 → 计算当前梯度 → 触发 step() 完成参数更新。这正是梯度下降/SGD 在框架中的真实调用链。

动量法(Momentum):给梯度"接上惯性"

双迭代式

在动量法中,我们有两个迭代序列(pp 和 ww),而不是只有一个。更新式如下:

pk+1=βk^pk+∇fi(wk)wk+1=wk−γkpk+1\begin{aligned} p_{k+1} &= \hat{\beta_k}p_k + \nabla f_i(w_k) \\ w_{k+1} &= w_k - \gamma_k p_{k+1} \end{aligned}

pp 称为 SGD 动量(SGD momentum)。在每个更新步骤中,我们将动量的旧值乘以系数 β\beta(0 到 1 之间的值),再加上新的梯度,然后沿着新动量 pp 的方向移动 ww。可以将 pp 视为梯度的指数滑动平均(moving average)。

替代形式:随机重球法(heavy ball method):

wk+1=wk−γk∇fi(wk)+βk(wk−wk−1),0≤β<1w_{k+1} = w_k - \gamma_k\nabla f_i(w_k) + \beta_k(w_k - w_{k-1}), \qquad 0 \leq \beta < 1

该形式在数学上与前述形式等价。在这里,下一步是上一步的方向(wk−wk−1w_k - w_{k-1})与新的负梯度的组合。

直观理解:滚下山坡的重球

SGD 动量类似于物理学中的动量概念。优化过程就像一个沉重的球滚下山坡:动量使球保持与已移动方向相同的方向,而梯度可以理解为沿其他方向推动球的力。

动量的影响:缓解仅使用 SGD 时常见的振荡(图片来源:docs/images/week05/05-1/momentum.png)

动量并没有使行进方向发生巨大变化,而是产生适度的修正。动量可减轻仅使用 SGD 时常见的振荡——这正是它最重要的实战价值。

β\beta 参数称为阻尼因子(damping factor):

  • β\beta 必须大于 0:如果等于 0,退化为纯梯度下降;
  • β\beta 必须小于 1:否则系统发散,一切崩溃;
  • 较小的 β\beta:方向更改更快,对当前梯度更敏感;
  • 较大的 β\beta:转向需要更长的时间,惯性更强。

下图展示了 β\beta 取值对收敛轨迹的影响:

Beta 取值对收敛的影响(图片来源:docs/images/week05/05-1/momentum-beta.png)

实用指南

原讲义的调参经验总结为两条:

  1. 动量必须总是与随机梯度下降一起使用(全量 GD 通常不需要);
  2. β=0.9\beta = 0.9 或 0.990.99 基本效果就很好;
  3. 增大动量参数时,通常需要减小步长参数以保持收敛:如果 β\beta 从 0.9 变为 0.99,学习率必须降低 10 倍(一个数量级)。

这条"β\beta 涨、γ\gamma 跌"的对应关系是训练中最重要的实操经验之一。

为什么动量有用?

加速(Acceleration)

讲义还给出了**涅斯捷罗夫动量(Nesterov momentum)**的更新规则:

pk+1=βk^pk+∇fi(wk)wk+1=wk−γk(∇fi(wk)+βk^pk+1)\begin{aligned} p_{k+1} &= \hat{\beta_k}p_k + \nabla f_i(w_k) \\ w_{k+1} &= w_k - \gamma_k(\nabla f_i(w_k) +\hat{\beta_k}p_{k+1}) \end{aligned}

使用涅斯捷罗夫动量,如果非常仔细地选择常数,可以加快收敛速度。但这仅适用于凸问题,不适用于神经网络(神经网络损失非凸)。关于"普通动量也是加速方法"的说法:它实际上仅对二次函数有加速效果;此外,由于 SGD 自带噪声,加速效果对 SGD 不适用。因此尽管 Momentum SGD 有一些加速作用,但仅凭加速并不能很好地解释该技术的高性能。

噪声平滑(Noise Smoothing)

更实际、更可能的动量有效的原因,是噪声平滑:

  • 动量在平均梯度——每一步使用的实际上是梯度的滑动平均值;
  • 从理论上讲,为了使 SGD 正常工作,应该对所有步骤求平均:

wˉk=1K∑k=1Kwk\bar w_k = \frac{1}{K} \sum_{k=1}^K w_k

  • SGD 具有动量的优点在于:不再需要显式地做平均。动量给优化过程增加了平滑度,使每次更新都很好地接近解,而不必攒一堆更新再朝平均方向走一步。

下图直观对比了纯 SGD 与动量 SGD 的轨迹差异:

SGD 与 Momentum 的轨迹对比:纯 SGD 在谷底反弹,动量平滑收敛(图片来源:docs/images/week05/05-1/sgd-vs-momentum.png)

使用纯 SGD 时,最初在接近解方面进展良好,但到达函数最低区域(谷底)后会在那里反弹;即使调小学习率,反弹只是变慢。有了动量,步伐变得平稳,不再有反弹发生。加速与噪声平滑共同构成了动量法性能的来源。

在 PyTorch 中启用动量

PyTorch 的 torch.optim.SGD 通过 momentum 参数直接支持动量法。课程仓库中虽然默认未开启,但只需在优化器构造时传入即可:

optimizer = torch.optim.SGD(
    model.parameters(),
    lr=learning_rate,        # 步长 γ,增大 momentum 时通常需要按 10 倍量级调小
    momentum=0.9,            # 阻尼因子 β,常用 0.9 或 0.99
    weight_decay=lambda_l2,  # 内置 L2 正则(课程第 12 周主题,此处仅提及)
    nesterov=False           # 设为 True 即切换为涅斯捷罗夫动量
)

对照 extra/utils/optim.py 中的 state[p] 设计可以看出,PyTorch 正是用 state 字典为每个参数保存动量缓冲(即 pkp_k),在每次 step() 时按公式 pk+1=βpk+∇fi(wk)p_{k+1} = \beta p_k + \nabla f_i(w_k) 更新后,再以 wk+1=wk−γpk+1w_{k+1} = w_k - \gamma p_{k+1} 更新参数。

总结:三种方法的选择脉络

方法 迭代式 核心特点 适用注意
梯度下降 GD wk+1=wk−γk∇f(wk)w_{k+1} = w_k - \gamma_k \nabla f(w_k) 稳定但昂贵,需遍历全量数据 实际训练中应避免全尺寸批次,除非使用 LBFGS
随机梯度下降 SGD wk+1=wk−γk∇fi(wk)w_{k+1} = w_k - \gamma_k \nabla f_i(w_k) 无偏、有噪声、便宜;噪声带来退火效应,可能找到更深的极小值 小批次可以降噪并充分利用 GPU
动量法 Momentum SGD pk+1=βpk+∇fi(wk)p_{k+1} = \beta p_k + \nabla f_i(w_k);wk+1=wk−γpk+1w_{k+1} = w_k - \gamma p_{k+1} 平滑梯度平均、减轻振荡、加速(二次情形) 必须配合 SGD;β\beta 取 0.9/0.99;增大 β\beta 需按比例降低学习率

理解这条从"最基础、最差"的梯度下降到"必配动量"的演进脉络,是后续学习 Adam 等自适应学习率方法的前提。读者可以通过 extra/utils/optim.py 中的二次函数等高线实验,动手对比三种方法在同一目标函数上的收敛轨迹,从而形成最直观的调参手感。

登录后查看全文
NYU-DLSP20