第一次认真调学习率的人,往往会撞上两种相反的失败。把学习率设成 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、动量系数、初始化都影响结果,而每次试错都要完整训练一遍。它不给出「已经到最优」的证书,只能靠验证集和早停判断。这也是训练流程里最耗人力的一部分,算法本身并没有把这件事变简单。
当天可以验证的练习
- 把二次函数的例子改成 a=4,从 x=1 出发,分别用 α=0.1、0.4、0.5、0.6 跑十步,验证合法区间是 0 < α < 0.5,并解释 0.5 为什么是临界。
- 用 f(x,y)=½(100x²+y²),固定 α=0.02,记录 x 和 y 各自缩小到 0.01 需要多少步,再对 x 做标准化(令 x 变为 10x)重跑,比较步数。
- 把 batch 从 1 改到 64,重复采样一千次,统计梯度估计的标准差,和 σ/√b 对照,验证 1/√b 的量级。
- 构造 f(x,y)=x²−y²,在原点加一个 0.001 的扰动,跑梯度下降,观察它沿哪个方向离开,并打印每步梯度。
- 对一组尺度差很大的特征做标准化前后各跑一次线性回归,固定学习率,比较 loss 曲线的收敛速度。
从一步到累积
把这篇压成三句:梯度给方向,学习率给步长,曲率决定步长能有多大;条件数把「一个步长服务所有方向」这件事变成不可能,所以要么改数据尺度,要么让步长自适应;梯度为零只说明站住了,鞍点和平台在高维里比局部极小更常见。
但这些说的都是「一步」。真正训练时,loss 不是某一个样本的误差,而是整个训练集上误差的平均。平均是一个累积量:把许多样本的贡献加起来,再除以个数。理解「平均」为什么能代表整体、batch 大小为什么改变它的波动,需要另一套工具:积分。
下一篇从面积讲起,把累积、概率密度和期望连起来,也顺带解释训练日志里那个一直在降的 loss 到底是什么。