第一次认真调学习率的人,往往会撞上两种相反的失败。把学习率设成 0.1,loss 从 3.20 开始,几步之内变成 4.1、11.6,然后直接 NaN;把学习率调到 1e-5,跑完一千步,loss 从 3.20 变成 3.19,几乎等于没动。旁边还有人遇到第三种:loss 不炸也不停,就是在某个值附近来回锯,像一条锯齿。

这几种现象看起来是不同的问题,其实是同一件事的不同侧面:每一步走多远,和脚下这块地面的弯曲程度是否匹配。梯度只告诉你哪个方向是上坡,没告诉你坡有多陡、走多远会跨过谷底。步长偏大,一步跨过谷底落到对面更高的位置,下一步跨得更远;步长偏小,方向再对也只能一小步一小步地挪。

这篇把梯度下降拆开:先看更新规则为什么成立,再用一个能算到底的二次函数求出学习率的合法区间,然后解释为什么同一个学习率会在某些方向上爆炸、在另一些方向上几乎不动,最后说清随机梯度、动量、自适应方法各自在补哪个洞,以及这套方法从原理上就管不了什么。

更新规则:为什么沿负梯度走

梯度(gradient)是一个向量,第 i 个分量是函数对第 i 个变量的偏导。它指向函数上升最快的方向,长度是那个方向上的变化率。所以要走下坡,最直接的做法是取它的反方向。

x_next = x − α∇f(x)

其中 α 是学习率,也就是步长;∇f(x) 是当前位置的梯度。只看这个式子,会觉得 α 越大下降越快。用一阶泰勒展开检查一下,令 g = ∇f(x):

f(x − αg) ≈ f(x) − α∇f(x)·g
          = f(x) − α‖g‖²

因为 ‖g‖² 非负,只要 α 是一个正的小量,右边一定小于 f(x),函数值下降。这就是「沿负梯度走一定下降」的由来,也是它唯一无条件保证的东西。注意这里说的是方向选对了,不是说走得远。

举个具体例子。f(x,y)=x²+3y² 在点 (1,1) 的梯度是 (2,6),两个分量大小不同,说明 y 方向陡得多,同样走一步,在 y 上带来的变化是 x 的三倍。负梯度方向 (−2,−6) 垂直于等高线,指向函数值下降最快的方向。这个「最快」只在当前位置的邻域里成立,走远之后等高线形状变了,方向也就过时了。

但这个结论只在 α 足够小时成立。泰勒展开丢掉的二阶项大约是 ½α²gᵀHg,H 是二阶导数矩阵,描述曲面在各个方向上的弯曲程度。α 一大,这一项就盖过一阶项:本以为是下坡,实际跨到了对面更高的位置。α 该多小,取决于 H 的最大特征值,也就是这片区域最陡的曲率。下一节用一个最干净的例子把这条界线精确算出来。

一维二次函数:学习率的合法区间

取 f(x)=½ax²,其中 a 是正数。它的梯度是 ax,最小值在 x=0。把更新规则代进去,得到

x_{k+1} = x_k − α·a·x_k = (1 − αa)x_k

每一步都乘同一个系数,所以走十步之后,结果就是初值乘以 (1−αa) 的十次方。要收敛到 0,必须 |1−αa| < 1。解这个不等式:−1 < 1−αa < 1,左边给出 αa < 2,右边给出 αa > 0。合起来就是 0 < α < 2/a。这是二次函数上学习率的完整合法区间,没有别的附加条件。

取 a=1,也就是 f(x)=½x²,从 x=1 出发迭代十步,把五组 α 的输出打出来:

def run(alpha, x=1.0, steps=10):
    xs = [x]
    for _ in range(steps):
        x = x - alpha * x
        xs.append(x)
    return xs

for alpha in (0.1, 1.0, 1.9, 2.0, 2.1):
    print("alpha =", alpha, " 1-alpha =", 1 - alpha)
    print("   ", "  ".join("%.6g" % v for v in run(alpha)))

在本机 Python 3.15 上跑,输出是:

alpha = 0.1  1-alpha = 0.9
    1  0.9  0.81  0.729  0.6561  0.59049  0.531441  0.478297  0.430467  0.38742  0.348678
alpha = 1.0  1-alpha = 0.0
    1  0  0  0  0  0  0  0  0  0  0
alpha = 1.9  1-alpha = -0.8999999999999999
    1  -0.9  0.81  -0.729  0.6561  -0.59049  0.531441  -0.478297  0.430467  -0.38742  0.348678
alpha = 2.0  1-alpha = -1.0
    1  -1  1  -1  1  -1  1  -1  1  -1  1
alpha = 2.1  1-alpha = -1.1
    1  -1.1  1.21  -1.331  1.4641  -1.61051  1.77156  -1.94872  2.14359  -2.35795  2.59374

五组结果对应五种命运。α=0.1 是单调收敛,每步乘 0.9,十步后剩 0.35 左右。α=1.0 一步到位,因为系数正好是 0,一步就落在最优点上;这是 a=1 这个特殊例子的运气,换个曲率就不成立。α=1.9 的绝对值序列和 α=0.1 一模一样,只是每步换号,在 0 两侧来回跳,振幅每次缩到 0.9 倍,属于振荡收敛。

α=2.0 时系数是 −1,每一步都跳到对面同样远的位置,永远不收敛。这是临界点,公式给的是开区间,2 本身不算合法。α=2.1 只比临界值大 0.1,系数变成 −1.1,振幅每步涨一成,十步就从 1 涨到 2.59,继续跑会指数发散。所以「稍微大一点应该没事」在二次函数上是可以精确算出来的错觉。

把 a 换回一般值,结论就是 0 < α < 2/a。a 越大,允许的 α 越小。这句话是后面所有问题的种子:一个模型里不同方向的 a 并不相同,而学习率通常只有一个。

把 a 看成这个方向的曲率。对一般的二次型,a 对应 Hessian 的最大特征值 L,条件变成 α < 2/L;对非二次函数,这个 L 只能在一个局部邻域里估,所以合法区间也是局部的。这就是为什么同一个学习率在前几步没问题,跑到后面突然炸:不是学习率变了,是脚下的 L 变大了。

条件数:同一个步长,一个方向炸一个方向不动

看 f(x,y)=½(100x²+y²)。它在 x 方向的曲率是 100,在 y 方向是 1,等高线是被拉得很长的椭圆。梯度是 (100x, y),两个方向各自按自己的系数迭代:x 每步乘 1−100α,y 每步乘 1−α。

用 α=0.1 跑六步,再从同一点用 α=0.02 跑八步:

def run(alpha, steps, x=1.0, y=1.0):
    for k in range(steps):
        print("step %d  x=%10.4g  y=%10.4g  f=%10.4g" %
              (k, x, y, 0.5 * (100 * x * x + y * y)))
        x, y = x - alpha * 100 * x, y - alpha * y
    print("step %d  x=%10.4g  y=%10.4g  f=%10.4g" %
          (steps, x, y, 0.5 * (100 * x * x + y * y)))

print("alpha = 0.1")
run(0.1, 6)
print("alpha = 0.02")
run(0.02, 8)
alpha = 0.1
step 0  x=         1  y=         1  f=      50.5
step 1  x=        -9  y=       0.9  f=      4050
step 2  x=        81  y=      0.81  f= 3.281e+05
step 3  x=      -729  y=     0.729  f= 2.657e+07
step 4  x=      6561  y=    0.6561  f= 2.152e+09
step 5  x=-5.905e+04  y=    0.5905  f= 1.743e+11
step 6  x= 5.314e+05  y=    0.5314  f= 1.412e+13
alpha = 0.02
step 0  x=         1  y=         1  f=      50.5
step 1  x=        -1  y=      0.98  f=     50.48
step 2  x=         1  y=    0.9604  f=     50.46
step 3  x=        -1  y=    0.9412  f=     50.44
step 4  x=         1  y=    0.9224  f=     50.43
step 5  x=        -1  y=    0.9039  f=     50.41
step 6  x=         1  y=    0.8858  f=     50.39
step 7  x=        -1  y=    0.8681  f=     50.38
step 8  x=         1  y=    0.8508  f=     50.36

α=0.1 对 x 方向的系数是 1−10=−9,每步放大九倍,六步就冲到十万量级;同一时刻 y 方向的系数是 0.9,老老实实收敛。loss 由 x 主导,所以整条曲线看起来是爆炸的,但 y 其实一直在变好。只看总 loss,很容易误判成「整个模型都坏了」。

把 α 压到 0.02,x 方向的系数正好是 −1,在正负一之间原地跳;y 方向系数 0.98,八步只从 1 降到 0.85。这已经是 x 能承受的极限,y 却慢得让人失去耐心。想同时照顾两边,做不到:x 要求 α 小于 0.02,y 希望 α 接近 1。

两个曲率之比叫条件数 κ,这里是 100。梯度下降在二次函数上的收敛速度由 (κ−1)/(κ+1) 决定,κ=100 时约为 0.98,意味着误差每步只缩 2%,要缩到千分之一需要几百步。这就是数据标准化为什么有用:把所有特征缩放到相近的尺度,各方向的曲率接近,κ 接近 1,一个学习率就能同时照顾所有方向。它没有让模型变聪明,只是把问题的形状从细长椭圆掰回接近圆。

用数字验证一下:令 x 变为 10x,原来的 f 变成 ½(x²+y²)。此时两个方向曲率都是 1,κ=1,取 α=1,两个方向各自一步归零。同一次缩放,把「一个方向要 α 小于 0.02、另一个要 α 接近 1」的矛盾直接消掉了。深度学习里的批归一化、输入标准化,做的是同一件事,只是对象是每一层的激活值。

随机梯度:噪声是成本也是工具

真实训练集有几百万条,每步都算全部样本的梯度不现实。随机梯度下降(SGD)每次只取一小批样本,用这批的平均梯度代替全量梯度。这一小批叫 mini-batch,大小为 b。

这个替代有偏吗?没有。只要样本是随机抽的,每批梯度的期望就等于全量梯度。但它是带噪声的:单批结果会围着真值上下跳。若单个样本梯度的方差是 σ²,b 个独立样本求平均后方差是 σ²/b,标准差是 σ/√b。下面用「每个样本给出一个带噪声的梯度估计」模拟这个关系:

import random, math, statistics
rng = random.Random(7)
ts = [rng.gauss(5, 2) for _ in range(200000)]
sigma = statistics.pstdev(ts)
for b in (1, 8, 64, 256):
    est = [sum(rng.choice(ts) for _ in range(b)) / b for _ in range(3000)]
    print("b=%3d  std=%.4f  sigma/sqrt(b)=%.4f" %
          (b, statistics.pstdev(est), sigma / math.sqrt(b)))
b=  1  std=1.9958  sigma/sqrt(b)=1.9989
b=  8  std=0.7021  sigma/sqrt(b)=0.7067
b= 64  std=0.2485  sigma/sqrt(b)=0.2499
b=256  std=0.1235  sigma/sqrt(b)=0.1249

batch 从 1 加到 64,噪声降到八分之一。注意这是 1/√b,不是 1/b:想让噪声减半,batch 要翻四倍;想减到十分之一,batch 要一百倍。所以「加大 batch」的收益递减得很快,而每一步的计算成本却是线性增加的。

噪声有两面。坏的一面是每步方向不准,loss 曲线抖,收敛后期在最优点附近晃。好的一面是它让参数不会死守一条下降路径:遇到尖锐的极小值,噪声更容易把参数推出去;遇到梯度为零的鞍点,噪声也能提供离开的扰动。全量梯度在鞍点会停住,小 batch 反而可能走掉。很多「小 batch 泛化更好」的经验说法,背后就有这一层。

动量和自适应方法,各补一个洞

动量(momentum)补的是「方向摇摆」。它不再每步只看当前梯度,而是维护一个梯度的指数移动平均:v = βv + (1−β)g,β 通常取 0.9,然后用 v 代替 g 去更新。直觉是给下降加了一点惯性:连续几步都指向同一侧的分量被累加,来回变号的分量被抵消。在细长椭圆上,这正是抑制横向锯齿的办法。

动量

对历史梯度做指数移动平均,β 越接近 1 惯性越强。它改变的是「走的方向」,让同一方向的分量积累,减少横向摆动。代价是多存一份和参数同样大的状态。

Adam

除了对梯度做移动平均,还对梯度平方做移动平均,更新时除以它的平方根。效果是每个参数按自己的历史梯度尺度缩放步长,梯度大的参数步子被压小,梯度小的参数步子被放大。

一句话概括:动量解决方向不稳,Adam 解决不同参数尺度差异。两者都没有改变「沿负梯度走」这件事,也没有取消学习率,只是把步长变成随方向和参数变化的量。学习率仍然要调,太大照样发散,只是发散的样子可能被自适应分母掩盖一阵子,然后突然爆掉。

还有两个容易被忽略的实现细节。Adam 在最初几步会对一阶和二阶的移动平均做偏差修正,因为这两个量都从零开始,前几步会明显偏小;不修正的话,起步会异常慢。另外,分母通常要加一个很小的数防止除零。这些细节不影响理解,但漏掉会让「同样的超参数换个框架结果不一样」变成玄学。

局部极小、鞍点、平台

梯度为零只是「站住了」,不等于「到谷底」。梯度为零的点有三种:局部极小、局部极大、鞍点。鞍点在一个方向上是谷底,在另一个方向上是山顶。

看 f(x,y)=x²−y²。它在原点的梯度是 (2x, −2y)=(0,0),但原点既不是极小也不是极大。沿 x 方向走,函数值变大;沿 y 方向走,函数值变小。把原点附近几个点代进去:

def f(p):
    x, y = p
    return x*x - y*y

for p in [(0,0), (0.1,0), (-0.1,0), (0,0.1), (0,-0.1), (0.1,0.1)]:
    print("point", p, "  f =", round(f(p), 4))
point (0, 0)   f = 0.0
point (0.1, 0)   f = 0.01
point (-0.1, 0)   f = 0.01
point (0, 0.1)   f = -0.01
point (0, -0.1)   f = -0.01
point (0.1, 0.1)   f = 0.0

原点比左右两侧都低,比上下两侧都高,所以它连局部极小都不是。梯度下降从原点出发,梯度为零,一步也走不了;但只要有一点点扰动,就会沿 y 方向滑下去。这也解释了为什么初始化不能全设成零:对称的参数会让梯度对称地抵消,模型停在鞍点上。

高维里这件事更重要。一个 n 维的临界点,Hessian 有 n 个特征值,要成为局部极小,所有特征值都得为正;只要有一个负的,它就是鞍点。随机落在临界点附近时,鞍点的概率远高于局部极小,维度越高越明显。所以在深网络里,「卡在局部极小」通常不是主要矛盾,「在鞍点附近变慢」和「在平台上走不动」更常见。

平台(plateau)是另一类麻烦:一大片区域梯度都接近零,但不是极小值。典型来源是饱和的激活函数,比如 sigmoid 在输入很大或很小时导数接近零。参数在这片区域里移动,loss 几乎不变,梯度也几乎为零,看起来像收敛了,其实还没到。此时降低学习率只会更慢,换激活函数或做归一化往往更有效。

还要区分鞍点和平台。鞍点附近梯度小,但沿着负特征值方向有明确的下降方向;平台则是四周都平,梯度小且方向信息很弱。前者靠噪声或二阶信息能走出去,后者往往要靠换激活函数、加归一化或调整初始化,单纯调学习率帮不上忙。

一张现象对照表

下面这些现象在训练日志里很常见,原因不一定在模型结构上。表格的第三列是排查的第一步,不是全部。

现象真实原因第一步查什么
loss 几步内变成 NaN学习率相对曲率过大,更新跨出定义域或数值溢出打印前几步 loss 和梯度范数,把 α 缩小十倍重跑
loss 长时间几乎不动α 太小,或梯度消失,或各方向尺度差太大看梯度范数与参数更新量的比值
loss 锯齿状来回抖α 超过 2/L,反复跨过谷底估最大曲率,减小 α 或改用线搜索
训练后期开始震荡接近极小值后局部曲率变大,固定 α 偏大加学习率衰减,或按梯度范数裁剪
换随机种子结果差很多batch 太小、初始化差异,噪声主导固定种子重复多次,比较结果方差
验证集 early stop 太早验证 loss 的噪声大于真实提升平滑验证曲线,给 patience 留余量
训练 loss 降验证 loss 升过拟合,不是优化失败查数据分布、正则和数据量

边界与代价

第一,它只保证局部。梯度是局部信息,每一步只对当前位置附近成立。非凸目标上,它不保证到全局最优,甚至不保证到局部极小,鞍点和平台都能让它停住或变慢。

第二,它对参数尺度敏感。同一个 α 在不同曲率方向上效果完全不同,条件数大时收敛极慢。标准化、归一化、换参数化都能改变条件数,但改变的是问题本身,不是算法。

第三,它要求可导。梯度不存在的地方用不了,比如阶跃、取整、离散选择。实际做法是换可导的替代,或者改用无梯度的搜索,后者代价通常更高。

第四,它不处理约束。参数必须为正、必须在球内、必须满足某个等式,这些约束梯度下降本身不知道。要么把约束编码进参数化,要么在每步之后做投影,投影的代价和约束的复杂度有关。

第五,每步都要算梯度。全量梯度是 O(n),小批是 O(b),但都要前向加反向。batch 小省算力但噪声大,batch 大噪声小但每步更贵,这个取舍没有免费的一边。此外还有内存:动量和 Adam 都要为每个参数额外存一到两份状态。

第六,调参成本不低。学习率、batch、动量系数、初始化都影响结果,而每次试错都要完整训练一遍。它不给出「已经到最优」的证书,只能靠验证集和早停判断。这也是训练流程里最耗人力的一部分,算法本身并没有把这件事变简单。

当天可以验证的练习

  1. 把二次函数的例子改成 a=4,从 x=1 出发,分别用 α=0.1、0.4、0.5、0.6 跑十步,验证合法区间是 0 < α < 0.5,并解释 0.5 为什么是临界。
  2. 用 f(x,y)=½(100x²+y²),固定 α=0.02,记录 x 和 y 各自缩小到 0.01 需要多少步,再对 x 做标准化(令 x 变为 10x)重跑,比较步数。
  3. 把 batch 从 1 改到 64,重复采样一千次,统计梯度估计的标准差,和 σ/√b 对照,验证 1/√b 的量级。
  4. 构造 f(x,y)=x²−y²,在原点加一个 0.001 的扰动,跑梯度下降,观察它沿哪个方向离开,并打印每步梯度。
  5. 对一组尺度差很大的特征做标准化前后各跑一次线性回归,固定学习率,比较 loss 曲线的收敛速度。

从一步到累积

把这篇压成三句:梯度给方向,学习率给步长,曲率决定步长能有多大;条件数把「一个步长服务所有方向」这件事变成不可能,所以要么改数据尺度,要么让步长自适应;梯度为零只说明站住了,鞍点和平台在高维里比局部极小更常见。

但这些说的都是「一步」。真正训练时,loss 不是某一个样本的误差,而是整个训练集上误差的平均。平均是一个累积量:把许多样本的贡献加起来,再除以个数。理解「平均」为什么能代表整体、batch 大小为什么改变它的波动,需要另一套工具:积分。

下一篇从面积讲起,把累积、概率密度和期望连起来,也顺带解释训练日志里那个一直在降的 loss 到底是什么。