优化器

loss.backward() 算出了每个参数的梯度。梯度告诉你"往哪个方向改损失会降"。

优化器就是决定"这一步迈多大、怎么迈"的那个东西。

这一课把常用的几种拆开看:它们各自解决了什么问题,公式长什么样。 看懂之后你就知道为什么默认用 AdamW,以及什么时候该换回 SGD。

最朴素的更新,以及它的问题

所有优化器的祖宗是这一行:

w ← w - lr × grad

叫 SGD(随机梯度下降)。写出来就是:

for p in model.parameters(): p.data -= lr * p.grad # 等价于 opt = torch.optim.SGD(model.parameters(), lr=0.01) opt.step()

它能用,但有两个毛病:

问题

现象

山谷形损失

一个方向陡、一个方向平。梯度总指向陡的方向,于是在窄谷里左右横跳,走不快

所有参数同一个 lr

出现频繁的参数梯度大、罕见的参数梯度小,但学习率是一样的

后面所有优化器,都是在修这两个毛病。

动量:让它有惯性

第一种修法针对第一个毛病。思路是把"上一个方向"也带上:

v ← β·v + grad ← 速度是历史梯度的累积 w ← w - lr·v

β 通常取 0.9。展开看,v 里装着最近几步梯度的加权和:

v = grad_t + 0.9·grad_{t-1} + 0.81·grad_{t-2} + ...

方向

会发生什么

一直朝同一个方向

越积越大,加速

来回震荡

正负抵消,被压住

所以动量做的事是:放大一致的方向,抵消摇摆的方向。 原来在窄谷里横跳的那部分,正好被抵消掉了。

torch.optim.SGD(model.parameters(), lr=0.01, momentum=0.9)

Nesterov:先看一眼再决定

普通动量用当前梯度更新速度;Nesterov 用"如果按当前速度再走一步,那里的梯度"。

理论上收敛更好,实际差别不大。nesterov=True 一个参数就开了。

自适应学习率:每个参数自己的步子

第二个毛病——所有参数共用一个 lr——是这四个优化器在修的事。

AdaGrad:梯度的历史越大,步子越小

h ← h + grad² ← 累积梯度平方 w ← w - lr · grad / (√h + ε)

某个参数一直有大梯度,h 就大,除以它就变小——自动减速。 罕见参数 h 小,步子相对大。

问题:h 只增不减,训练久了所有参数的步子都会趋近于 0,提前停住。

RMSProp:只看最近一段

h ← β·h + (1-β)·grad² ← 滑动平均,旧的会被忘掉 w ← w - lr · grad / (√h + ε)

把累积改成滑动平均,解决了"越走越慢"。β 通常 0.9。

Adam:动量 + RMSProp

把上面两个思路合起来,再加一步修正:

m ← β₁·m + (1-β₁)·grad ← 一阶矩(动量) v ← β₂·v + (1-β₂)·grad² ← 二阶矩(自适应) m̂ = m / (1 - β₁ᵗ) ← 偏差修正 v̂ = v / (1 - β₂ᵗ) w ← w - lr · m̂ / (√v̂ + ε)

部件

作用

m

动量,管方向

v

自适应,管每个参数的步长

偏差修正

训练初期 m 和 v 都从 0 开始,会偏小;除以 (1-βᵗ) 补回来

默认 β₁=0.9、β₂=0.999、ε=1e-8,基本不用改。

torch.optim.Adam(model.parameters(), lr=1e-3)

AdamW:修 Adam 的一个错误

Adam 想加权重衰减时,标准做法是把 weight_decay × w 直接加进梯度里。

但 Adam 接下来会把这个梯度除以 √v——自适应缩放把衰减也一起缩放了。

结果:衰减的力度取决于梯度大小,不是你要的那个数。

AdamW 把衰减单独拿出来做,不经过自适应:

w ← w - lr·(m̂/√v̂) - lr·wd·w ↑ ↑ 梯度那部分 衰减那部分,独立
torch.optim.AdamW(model.parameters(), lr=1e-3, weight_decay=1e-2)

别用 Adam(weight_decay=...)

那个参数实现的还是老做法,衰减被自适应学习率抵消掉一部分。

要用衰减就用 AdamW。

四个优化器放一起对比

优化器

每个参数额外存

显存

典型 lr

SGD

无

1×

0.1

SGD(momentum)

速度 v

2×

0.01

RMSProp

h

2×

1e-3

Adam / AdamW

m 和 v

3×

1e-3

参数本身占 1 份。一亿参数的模型用 Adam,光优化器状态就要 800 MB 显存。

这也是为什么大模型训练时会用 8-bit Adam 之类的省内存版本。

什么时候用哪个

场景

选

为什么

不知道用什么

AdamW

开箱可用,极少调参就能收敛

追求最终精度(CV)

SGD + momentum

论文里微调后的 SGD 常比 Adam 高零点几

NLP / Transformer

AdamW

几乎所有论文都用它

显存紧张

SGD 或 8-bit Adam

状态少占两份

数据流式到达

SGD

支持 partial_fit 式的增量更新

学习率调度器

优化器管"怎么改",调度器管"lr 什么时候变"。固定 lr 通常不是最优的。

常见做法是先大后小:开始大步找方向,后来小步精调。

调度器

形状

什么时候用

StepLR

阶梯:每 N 轮乘 0.1

老办法,简单可控

MultiStepLR

在指定轮次降

知道大概在哪儿该降

CosineAnnealingLR

余弦曲线平滑降到 0

现在最常用

OneCycleLR

先升到峰值再降

轮数少、想快速训完

ReduceLROnPlateau

指标不降就降

不知道该降多少轮时,让它自己判断

LambdaLR

自定义函数

论文复现、warmup

用起来都长一个样

sched = torch.optim.lr_scheduler.CosineAnnealingLR(opt, T_max=epochs) for epoch in range(epochs): train_one_epoch() opt.step() # 先更新参数 sched.step() # 再更新 lr

只有 ReduceLROnPlateau 要传参数

别的调度器 step() 不带参数,它带:

sched.step(val_loss)

因为它要根据指标决定降不降。

各种形状具体什么效果

调度器

第 1 轮

中途

最后一轮

StepLR(step=30, gamma=0.1)

1e-3

第 30 轮变 1e-4,第 60 轮变 1e-5

1e-5

CosineAnnealingLR(T_max=100)

1e-3

第 50 轮约 5e-4

约 0

OneCycleLR(max_lr=1e-3)

约 0

第 30 轮左右到 1e-3

约 0

差别主要在后期:Cosine 平滑,Step 突变,OneCycle 是"热身 + 退火"合成一段。

warmup:先小后大再小

训练最开始几步梯度可能很大,一上来就用大学习率容易直接崩。 所以先跑几百步很小的 lr 热个身。

# 前 5% 的步数里,lr 从 0 线性升到目标值 # 常用 LambdaLR 或 OneCycleLR 实现

Transformer 训练几乎必用。小模型可以不加。

训练循环里这三行的顺序

优化器和调度器都出现了,把顺序钉死:

for x, y in loader: loss = loss_fn(model(x), y) opt.zero_grad() # 1. 清空上一轮的梯度 loss.backward() # 2. 算这一轮的梯度 opt.step() # 3. 按梯度改参数 # 一轮结束后 sched.step() # 4. 调学习率(不是每个 batch)

顺序错了会怎样

后果

zero_grad() 放在 backward() 后

梯度累加,越训越离谱,而且不报错

step() 放在 backward() 前

用上一轮的梯度更新,等于慢一拍

sched.step() 放进 batch 循环

一个 epoch 里 lr 衰减了几百次,直接掉到 0

下一课

网络、损失、优化器都有了。下一课把它们装进训练循环,跑通 MNIST。