02. 优化器

假设你被蒙上眼睛，扔进一座连绵起伏的大山里。你的任务是：找到这座山的最低点（全局最低谷）。你手里没有地图，没有GPS，只能靠两只脚来探索。

每走一步，你就用脚踩一踩地面：哪边的坡度最陡？然后朝那个方向迈一步。这就是最朴素的 梯度下降——摸着坡度走，总能走到谷底。

神经网络训练 = 找山谷最低点。这个山谷不是什么地理山脉，而是 损失函数（Loss Function） 的地形。山的每个位置代表一组权重参数 W，山的高度代表损失 L(W)。我们要找 损失最小的那组权重。

优化器（Optimizer）就是决定：

• 往哪个方向走？——负梯度方向（下山最快的方向）
• 每一步走多大？——学习率（步长）
• 怎么越走越聪明？——用历史经验加速收敛

一个完整的训练循环：

1. 前向传播：输入数据经过网络，算出一个预测结果和对应的损失 L
2. 反向传播：用链式法则，算出每个参数 w 对损失 L 的偏导数 ∂L/∂w（梯度）
3. 更新参数：W_new = W_old - α × 梯度（朝负梯度的方向迈一步）
4. 回到步骤1，直到损失不再下降

类比总结：

先从最简单的情况开始：假设我们只有一个参数 w，损失函数是 f(w) = w²。这个函数在 w=0 时取最小值 0。我们来看怎么用梯度下降找到 w=0。

什么是导数？

导数 f’(w) 表示函数在 w 点的 瞬时变化率。f’(w) > 0 表示函数在 w 处上升，f’(w) < 0 表示下降。f’(w) = 0 表示可能是最低点或最高点。

对 f(w)=w² 求导：f’(w) = 2w。

• 当 w=3，f’(3)=6 > 0 → 上升方向 → 要向左走（减小w）才能下降
• 当 w=-2，f’(-2)=-4 < 0 → 下降方向 → 要向右走（增大w）才能下降

梯度下降的核心公式：

w_{new} = w_{old} - α × f’(w_{old})

为什么是减号？因为导数指向函数 上升 最快的方向，我们要下降，所以取 负方向。

参数说明表：

数值例子——手算梯度下降：

设 w_0 = 3，α = 0.1，f(w)=w²，f’(w)=2w

第1步：w_0=3, f’(3)=6, 更新量=-0.1×6=-0.6, w_1=3-0.6=2.4, f(w_1)=5.76
第2步：w_1=2.4, f’(2.4)=4.8, 更新量=-0.1×4.8=-0.48, w_2=2.4-0.48=1.92, f(w_2)=3.69
第3步：w_2=1.92, f’(1.92)=3.84, 更新量=-0.384, w_3=1.536, f(w_3)=2.36
第4步：w_3=1.536, f’(1.536)=3.072, 更新量=-0.307, w_4=1.229, f(w_4)=1.51
第5步：w_4=1.229, f’(1.229)=2.458, 更新量=-0.246, w_5=0.983, f(w_5)=0.97
... 经过约20步，w ≈ 0.06，损失 ≈ 0.004
经过约30步，w ≈ 0.006，损失 ≈ 0.00004 —— 已接近全局最低点 w=0

注意到一个重要现象：越接近谷底，梯度越小（f’(w) → 0），参数的更新量越小，收敛变得平滑而缓慢。这是梯度下降的特点：前期快，后期慢。

实际神经网络有 数百万到数十亿个参数，每个参数都有自己的梯度。优化器的任务就是协调好这庞大的更新过程。

学习率 α 是优化器最重要的超参数。它决定了每一步参数更新的幅度。设得不对，训练直接失败。

三种常见情况：

• α 过小（比如 0.0000001）：每一步像蚂蚁爬，需要极多步才能到谷底。训练时间从几小时变成几周，而且可能困在很小的局部洼地里出不来。
• α 过大（比如 0.5）：一步跨太大，直接从谷底这头跳到了对面山坡上，甚至震荡发散，损失越优化越大。
• α 刚好（比如 0.1）：每一步稳健下降，n步后到达谷底。

用 f(w)=w² 演示不同学习率的效果：

日常类比——做饭加盐：

• 学习率 = 每次加盐的勺子大小
• 损失 = 汤的咸度偏差（太淡或太咸都不好）
• α 太小：每次加一粒盐，尝了100次还是淡的
• α 太大：一勺下去直接咸死人，只能在“太咸”和“太淡”之间反复横跳
• α 刚好：两三勺就调到完美咸度

实际训练中的学习率策略：通常从 α=0.001（1e-3）开始调整。随着训练进行，学习率通常会 衰减——开始时大步探索，后期小步精细调整。

假设你有 N=1000 条训练数据。BGD 的做法是：用全部1000条数据计算梯度，然后更新一次参数。

公式：

W_{new} = W - α × (1/N) ∑_{i=1}^{N} ∇L_i(W)

其中 ∇L_i(W) 是第 i 条数据对当前参数 W 的梯度。1/N 的作用是取平均，让梯度大小不受数据量影响。

参数说明表：

数值例子：

假设只有 3 条数据，损失函数 L(W)=W²（简化版，实际每个样本损失不同）

数据1的梯度：∇L₁=2 × 5 = 10  (对应W=5的位置)
数据2的梯度：∇L₂=2 × 3 = 6   (W=3)
数据3的梯度：∇L₃=2 × 1 = 2   (W=1)
平均梯度 = (10+6+2)/3 = 18/3 = 6
α=0.1 → 更新量 = -0.1×6 = -0.6
新的 W = (5+3+1)/3 - 0.6 = 3 - 0.6 = 2.4
（这里假设我们用一个W代表所有参数的简化情况）

类比——全班旅游投票：

全班 N 个同学投票决定去哪里玩。BGD = 先问每一个人，统计全部意见后，取一个平均方向，然后出发。方向很精准，但问完所有人要很久很久。

BGD 的优缺点：

• ✅ 梯度方向准确，因为用了全部数据
• ✅ 每一步损失一定下降（或持平），不会震荡
• ❌ 计算极慢——每更新一步得算 N 条数据的梯度
• ❌ 如果 N=100万，一次更新就要算100万次前向和反向传播，几个小时才能更新一次
• ❌ 不能在线学习（新数据来了不能即时更新）

实际使用：BGD 几乎没有人在大模型训练中使用了，太慢了。

SGD 和 BGD 只有一个区别：每次只用一个随机样本计算梯度。

公式：

W_{new} = W - α × ∇L_i(W)   （i 是随机选的一个样本）

数值例子——SGD 与 BGD 对比：

还是上面3条数据，W=3，α=0.1：

BGD: 平均梯度=(10+6+2)/3=6, 更新=-0.6, 新W=2.4（每次都一样）

SGD（假设随机顺序：数据2→数据3→数据1→数据2...）:
第1步：抽到数据2, ∇L=6, 更新=-0.6, W=3-0.6=2.4
第2步：抽到数据3, ∇L=4, 更新=-0.4, W=2.4-0.4=2.0
第3步：抽到数据1, ∇L=10, 更新=-1.0, W=2.0-1.0=1.0
第4步：抽到数据2, ∇L=2, 更新=-0.2, W=1.0-0.2=0.8
...

可以看到 SGD 每一步的方向有 噪声（波动），但整体仍然在往正确的方向走。

类比——拍脑袋决策 vs 全面调研：

SGD 就像领导 随机拦下一个员工问意见，不等别人就直接调头走了。有时候问到的人给出离谱的建议，你就走了弯路（噪声大）。但更多时候，这个随机问路的方式让你 动作超快——别人还在收集意见时你已经走出十步了。

SGD 的优缺点：

• ✅ 计算极快——每步只用1条数据
• ✅ 可以流式/在线学习——新数据来了立刻更新
• ✅ 噪声有好处——可能跳过局部最小值（像热力学扰动让人摆脱困境）
• ❌ 梯度噪声大——更新方向不一定准确
• ❌ 不会严格收敛——会在最小值附近来回震荡
• ❌ 不能利用 GPU 的大规模并行计算优势（一次只算一条数据太浪费 GPU）

BGD 太慢，SGD 太颠，实战中没人用这两种极端。大家用的是 Mini-batch SGD。

做法：每次随机取一个小批量（mini-batch），比如 32 条或 128 条数据，用这一个批量的数据计算平均梯度，然后更新一次参数。

公式：

W_{new} = W - α × (1/B) ∑_{i=1}^{B} ∇L_i(W)

其中 B 是小批量的大小（batch size，也叫 batch_size）。

参数说明表：

数值例子——完整的一次训练过程：

假设 N=1000 条数据，batch_size=32，α=0.01：

每个iteration：随机取32条 → 计算32个梯度 → 平均 → 更新参数
每个epoch: 1000/32 = 31.25 ≈ 32次iteration（最后一个batch可能不足32）
训练10个epoch: 共 10×32 = 320 次参数更新

三种方法对比表：

为什么 batch_size 通常取 32 或 128？

• 2 的幂次（32, 64, 128, 256）对 GPU 内存对齐友好
• 太小（<16）：梯度噪声大，GPU并行能力没充分利用
• 太大（>512）：梯度更精确，但 GPU 显存可能不够，而且太大的 batch 会降低泛化能力（收敛到“尖锐”的极小值）
• 经验法则：起步用 32，内存够就 128，再大收益递减

SGD/Mini-batch 的核心直觉：不要试图完美计算梯度再更新，而是 边走边修正。方向有一点偏差没关系，因为你会不断用新的信息调整方向。走得快比走得准更重要。

SGD 有什么问题？

想象一个窄而长的山谷：沿着山谷的方向（长轴）坡度很缓，需要慢慢走；垂直于山谷的方向（短轴）坡度很陡，左右震荡。SGD 在这种地形上会表现为：在山谷两侧反复摩擦、左右摇摆，但就是不怎么前进。

Momentum 的解决方案——加入惯性：

就像从山顶推下一个球。球不会每步都重新“看坡度决定方向”，而是 保持之前的速度，加上当前坡度带来的加速度。即使某个时刻坡度水平方向为0，球也会因为惯性继续前进。

公式：

v_t = β × v_{t-1} + ∇L(W_t)
W_{t+1} = W_t - α × v_t

参数说明表：

数值例子——一步步手算 Momentum：

假设在某方向上的梯度序列为：g=[3, 2, 1, 0.5, 0.1, -0.2, -0.1, 0]，β=0.9，α=0.1

初始化：v=0

第1步：梯度g=3
  v = 0.9×0 + 3 = 3
  ΔW = -0.1×3 = -0.3
  新W = W - 0.3

第2步：梯度g=2
  v = 0.9×3 + 2 = 2.7 + 2 = 4.7
  ΔW = -0.1×4.7 = -0.47
  新W = W - 0.47

第3步：梯度g=1
  v = 0.9×4.7 + 1 = 4.23 + 1 = 5.23
  ΔW = -0.1×5.23 = -0.523
  新W = W - 0.523

第4步：梯度g=0.5
  v = 0.9×5.23 + 0.5 = 4.707 + 0.5 = 5.207
  ΔW = -0.521

第5步：梯度g=0.1
  v = 0.9×5.207 + 0.1 = 4.686 + 0.1 = 4.786
  ΔW = -0.479

第6步：梯度g=-0.2（注意梯度方向反转了！）
  v = 0.9×4.786 + (-0.2) = 4.307 - 0.2 = 4.107
  ΔW = -0.411
  （虽然反转了，但惯性很大，只减速了一点，仍然前进）

第7步：梯度g=-0.1
  v = 0.9×4.107 + (-0.1) = 3.696 - 0.1 = 3.596
  ΔW = -0.360

第8步：梯度g=0
  v = 0.9×3.596 + 0 = 3.236
  ΔW = -0.324
  （即使梯度为0，惯性仍让参数继续前进！）

与不加 Momentum 的 SGD 对比：

不加 Momentum：第6步梯度为负→直接往回走；第8步梯度为0→完全不更新。加了 Momentum：即使梯度方向变了或为0，惯性让参数继续朝原方向前进，同时逐渐减速，不会突然转向。

日常类比——开车：

• SGD = 你每走一步都停下来，重新看路牌决定方向
• Momentum = 你开车时带着速度，踩刹车要一段距离才能停下来，踩油门速度是逐渐加上去的
• β = 车的惯性系数（0.9=冰面开车，惯性大；0.1=沙地开车，摩擦力大）
• 梯度 = 油门（正梯度）或刹车（负梯度）

问题场景：一个峡谷，长轴方向（谷底方向）梯度=0.1，短轴方向（震荡方向）梯度=±5。

SGD 的行为：

第1步：向左震荡5 + 前进0.1 = 方向5.01（几乎横向走）
第2步：向右震荡5 + 前进0.1 = 方向-4.99（又横跳回来）
... 每一步都在左右横跳，前进极其缓慢

Momentum 的行为（β=0.9）：

第1步：v = 0.9×0 + [5, 0.1] = [5, 0.1]
第2步：v = 0.9×[5,0.1] + [-5,0.1] = [4.5,-0.09] + [-5,0.1] = [-0.5, 0.01]
第3步：v = 0.9×[-0.5,0.01] + [5,0.1] = [-0.45,0.009] + [5,0.1] = [4.55, 0.109]
第4步：v = 0.9×[4.55,0.109] + [-5,0.1] = [4.095,0.098] + [-5,0.1] = [-0.905, 0.198]
...
关键：震荡方向（短轴）的梯度正负交替，累积后正负抵消；
前进方向（长轴）的梯度同向，累积后叠加加速！

结论：Momentum 天然 抑制震荡、加速前进。震荡方向的梯度一正一负互相抵消，前进方向的梯度不断叠加。就像一个秋千，你只在它荡回来时推一下，它就越荡越高——Momentum 就是在正确的时机“顺势推一把”。

Nesterov Momentum（NAG）——比标准 Momentum 更聪明：

NAG 的想法是：既然我们知道当前速度会带惯性往前走，为什么不先“预见”一下到哪？

标准 Momentum：
  1. 算当前位置的梯度 g
  2. 更新速度：v = βv + g
  3. 更新参数：W = W - αv

Nesterov Momentum：
  1. 先按惯性“跳一步”到预估位置：W_temp = W - βv
  2. 在预估位置计算梯度 g_lookahead
  3. 更新速度：v = βv + g_lookahead
  4. 更新参数：W = W - αv

NAG 的 提前看一步 行为，让它在接近最小值时不会冲过头，收敛更稳定。就像司机快到路口时提前松油门，而不是到路口才急刹车。

一个问题：前面的 BGD、SGD、Momentum 对所有参数都用同一个学习率 α。但实际中，不同参数的梯度数量级差异很大。

例子：神经网络中，靠近输入的层和靠近输出的层，梯度大小可能差1000倍。用一个统一的学习率，要么对 “大梯度参数”震荡，要么对 “小梯度参数”学不动。

AdaGrad 的想法：经常更新的参数降学习率（因为梯度大，已经学了很多），不常更新的参数保持高学习率（因为梯度小，需要多学）。

公式：

G_t = G_{t-1} + (∇L(W_t))²   （每个参数的梯度平方累积）
W_{t+1} = W_t - α / (√(G_t) + ε) × ∇L(W_t)

参数说明表：

数值例子：

有两个参数 w₁ 和 w₂，初始化 α=0.1，ε=1e-8（忽略 ε 简化计算）：

时间步     w₁的梯度    w₂的梯度    G(w₁)    G(w₂)    w₁的学习率    w₂的学习率
t=1       0.5          0.01         0.25       0.0001     0.1/0.5=0.2    0.1/0.01=10
t=2       0.3          0.02         0.34       0.0005     0.1/0.58=0.17  0.1/0.022=4.5
t=3       0.2          0.01         0.38       0.0006     0.1/0.62=0.16  0.1/0.024=4.08
t=10      ...          ...          大约2.0    大约0.002   0.1/1.4=0.07   0.1/0.045=2.2

可以看到：w₁（梯度大）的学习率从0.2快速下降到0.07
w₂（梯度小）的学习率一直保持很大（4-10倍于w₁）
这让w₂这个大梯度能快速追上——解决了学习率不均衡问题！

AdaGrad 的问题——学习率会降为零：

G_t 是 单调递增 的（不断累积正数）。随着训练进行，G_t → ∞，α/√(G_t) → 0。参数最终 完全停止学习。对于需要长期训练的任务（如大模型训练数百亿步），这不可接受。

日常类比——学英语：AdaGrad 像是给每个单词一个“努力计数器”。你每背一次单词，它的“努力”就累积一点，然后后续分配给它的复习时间就减少。缺点：越往后你学任何新东西都越来越慢，最后完全不想学了。

关键改进：不用全部历史的梯度平方累积，而用 指数移动平均（EWMA）——只记住 “最近一段时间的梯度大小”，老梯度的影响逐渐衰减。

公式：

v_t = β₂ × v_{t-1} + (1 - β₂) × (∇L(W_t))²
W_{t+1} = W_t - α / (√(v_t) + ε) × ∇L(W_t)

与 AdaGrad 的区别：

参数说明表：

数值例子——RMSprop vs AdaGrad：

设每步梯度恒为 0.5，对比两种方法的 G_t 或 v_t 变化（β₂=0.9）：

时间      AdaGrad(G)        RMSprop(v)
t=1      0.25              0.1×0 + 0.9×0.25 = 0.225
t=2      0.50              0.9×0.225 + 0.1×0.25 = 0.203+0.025 = 0.228
t=3      0.75              0.9×0.228 + 0.025 = 0.205+0.025 = 0.230
t=10     2.50              0.232
t=100    25.0              0.249
t=1000   250.0             0.250

AdaGrad: G_t 线性增长，学习率 α/√(G_t) 从0.2→0.02→0.006... 一直下降到0
RMSprop: v_t 趋于稳定值 0.25，学习率 α/√(0.25)=0.1/0.5=0.2 保持不变！

日常类比——记笔记：

• AdaGrad = 把所有笔记越堆越高，最后要找一条信息需要翻完整座山
• RMSprop = 用一个笔记本，不断翻新——最新记的放在最上面，旧的内容慢慢被覆盖

RMSprop 完美解决了 AdaGrad 的学习率衰减到零的问题，是 Adam 算法的重要组成部分。

Adam = Adaptive Moment Estimation（自适应矩估计）

这是目前 最常用、最推荐的首选优化器。它将 Momentum（动量）和 RMSprop（自适应学习率）两个思想融合在一起，同时解决了两个问题：

• Momentum 部分：用指数移动平均平滑梯度方向，抑制震荡、加速收敛
• RMSprop 部分：用梯度平方的指数移动平均给每个参数自适应学习率

完整公式（高中数学版本）：

m_t = β₁ × m_{t-1} + (1 - β₁) × g_t          (1)  动量：梯度的移动平均
v_t = β₂ × v_{t-1} + (1 - β₂) × g_t²        (2)  自适应：梯度平方的移动平均

m̂_t = m_t / (1 - β₁^t)                     (3)  偏差校正
v̂_t = v_t / (1 - β₂^t)                     (4)  偏差校正

W_{t+1} = W_t - α / (√(v̂_t) + ε) × m̂_t    (5)  最终更新

参数说明表：

为什么需要 “偏差校正”？

Adam 初始化时 m_0=0, v_0=0。前几步的移动平均值会严重偏向0（因为一开始全是0）。偏差校正 = 把被0拉低的平均值 “拉伸回来”。公式 m̂_t = m_t/(1-β₁^t) 中，分母随 t 增大从接近0逐渐趋近1，正好补偿了初始的“零偏”。

例子：β₁=0.9, 前几步 m_t 和 m̂_t 对比
t=1: m_1=0.0+0.1×g=0.1g, 校正 m̂=0.1g/(1-0.9)=0.1g/0.1=g   (校正后等于真实梯度g！)
t=2: m_2=0.9×0.1g+0.1×g=0.19g, 校正 m̂=0.19g/(1-0.81)=0.19g/0.19=g
t=3: m_3=0.9×0.19g+0.1×g=0.271g, 校正 m̂=0.271g/(1-0.729)=0.271g/0.271=g
实际上校正后 m̂_t 约等于 g 的移动平均值，初始偏差被完全消除！

设 β₁=0.9, β₂=0.999, α=0.01, ε=1e-8（本算例中忽略 ε），梯度序列 g=[0.5, -1.0, 2.0, 0.3, -0.8]

初始: m_0=0, v_0=0

=== t=1, g=0.5 ===
m_1 = 0.9×0 + 0.1×0.5 = 0.05
v_1 = 0.999×0 + 0.001×0.25 = 0.00025
m̂_1 = 0.05 / (1 - 0.9^1) = 0.05/0.1 = 0.5
v̂_1 = 0.00025 / (1 - 0.999^1) = 0.00025/0.001 = 0.25
ΔW = -0.01 × 0.5 / √0.25 = -0.01 × 0.5/0.5 = -0.01

=== t=2, g=-1.0 ===
m_2 = 0.9×0.05 + 0.1×(-1.0) = 0.045 - 0.1 = -0.055
v_2 = 0.999×0.00025 + 0.001×1.0 = 0.00024975 + 0.001 = 0.00124975
m̂_2 = -0.055 / (1 - 0.9^2) = -0.055/(1-0.81) = -0.055/0.19 = -0.2895
v̂_2 = 0.00124975 / (1 - 0.999^2) = 0.00124975/(1-0.998001) = 0.00124975/0.001999 ≈ 0.625
ΔW = -0.01 × (-0.2895) / √0.625 = 0.002895/0.791 = 0.00366

=== t=3, g=2.0 ===
m_3 = 0.9×(-0.055) + 0.1×2.0 = -0.0495 + 0.2 = 0.1505
v_3 = 0.999×0.00124975 + 0.001×4.0 = 0.0012485 + 0.004 = 0.0052485
m̂_3 = 0.1505 / (1 - 0.9^3) = 0.1505/(1-0.729) = 0.1505/0.271 = 0.555
v̂_3 = 0.0052485 / (1 - 0.999^3) = 0.0052485/(1-0.997003) = 0.0052485/0.002997 ≈ 1.751
ΔW = -0.01 × 0.555 / √1.751 = -0.00555/1.323 = -0.00419

=== 总结 ===
t=1: ΔW=-0.01 (原始梯度0.5, 被缩小但方向正确)
t=2: ΔW=+0.00366 (梯度-1.0反向应减W, 但动量方向仍然正向! 惯性拉扯中)
t=3: ΔW=-0.00419 (梯度2.0改变方向, 动量跟上了)
对比纯SGD: t1:-0.005, t2:+0.01, t3:-0.02 （3倍于Adam的更新量）
Adam的更新量更小更平滑, 因为RMSprop感知到梯度大小在变, 自动调节了学习率

Adam 的直觉理解——自动驾驶：

• SGD = 刚拿驾照的新手：每步都重新判断方向，方向盘大幅乱转
• Momentum = 有经验的老司机：有预判，转弯顺滑
• AdaGrad/RMSprop = 自适应的车：根据路况自动调节油门大小
• Adam = 顶级自动驾驶：既有老司机的预判（Momentum），又能根据路况自动调油门（RMSprop）

Adam 有一个隐藏问题——L2正则化（权重衰减）的实现方式不对。

问题：标准 Adam 中，L2正则化项 λ·W 被加在损失函数中参与梯度计算，然后梯度被 Adam 的移动平均值平滑和自适应学习率缩放。这导致 权重的衰减效果不稳定——被自适应学习率改变了衰减量。

AdamW 的修复：把权重衰减 从梯度计算中剥离出来，在 Adam 更新完成后，直接对权重做一次独立的衰减。

标准 Adam 的 L2 正则化（有问题）：
  1. 计算损失梯度时包含 L2 项: g_t = g_loss + λ·W
  2. g_t 被 Adam 的 m/v 机制缩放
  3. 最终更新量 = -α·m̂/√(v̂) —— 权重衰减也被缩放了!

AdamW 的权重衰减（正确）：
  1. 计算损失梯度时不含 L2: g_t = g_loss
  2. g_t 被 Adam 的 m/v 机制正常缩放
  3. 在更新最后额外加一步: W -= α·λ·W（或 W *= 1-α·λ）
  —— 权重衰减不再被自适应学习率干扰！

为什么这对大模型训练重要？

LLM 训练中，权重衰减帮助控制模型复杂度、防止过拟合。AdamW 让权重衰减的效果 可预测且稳定，是 GPT、LLaMA 系列的标准配置。

PyTorch 代码示例：

# Adam（旧方式）
import torch.optim as optim
optimizer = optim.Adam(model.parameters(), lr=0.001, weight_decay=0.01)

# AdamW（推荐方式）
optimizer = optim.AdamW(model.parameters(), lr=0.001, weight_decay=0.01)
# 区别：PyTorch 的 Adam 的 weight_decay 是错的（旧实现），
# AdamW 的 weight_decay 才是正确的权重衰减。

进化路线图：

BGD → SGD → Mini-batch SGD（基础框架）

↓ 　　　　　　　　　　　　　　　　　　　　　　　　　　

Momentum（+惯性）→ Nesterov Momentum（+预见）

AdaGrad（+每个参数自适应）→ RMSprop（+滑动窗口替代无限累积）

Adam = Momentum + RMSprop + 偏差校正

↓

AdamW = Adam + 正确权重衰减

完整对比表：

一句话指南：

“先用 Adam/AdamW 快速跑通，再考虑要不要换。”

详细建议：

调参建议：

• 学习率 α：最重要的超参数。Adam 从 0.001 开始，不收敛就降（0.0003、0.0001），震荡太厉害也降
• batch_size：起步 32，显存够用 128，再大收益递减
• β₁（动量衰减）：不要动！0.9 几乎总是最优
• β₂（自适应衰减）：不要动！0.999/0.9999 几乎总是最优
• ε：不要动！1e-8 足够。如果训练不稳定可以试试 1e-6
• weight_decay（AdamW）：LLM 通常 0.01~0.1，CV 通常 0.0001~0.001

学习率调度（Learning Rate Schedule）——配合优化器使用：

光靠优化器还不够，好的学习率调度能显著提升训练效果：

• Step Decay：每 N 个 epoch 学习率减半（如每30epoch×0.1）
• Cosine Annealing：学习率按余弦曲线从大变小再变大（重启），帮助跳出局部最优
• Warmup：前几步从小学习率逐步升到目标值，防止初始不稳定
• ReduceLROnPlateau：损失不再下降时自动降低学习率

PyTorch 使用示例：

import torch.optim as optim
from torch.optim.lr_scheduler import CosineAnnealingLR

# 定义模型
model = MyNeuralNetwork()

# 选择优化器
optimizer = optim.AdamW(
    model.parameters(),
    lr=0.001,              # 学习率
    betas=(0.9, 0.999),    # β₁, β₂
    eps=1e-8,              # ε
    weight_decay=0.01      # 权重衰减
)

# 学习率调度器
scheduler = CosineAnnealingLR(
    optimizer,
    T_max=100,   # 余弦完成一个周期需要多少步
    eta_min=1e-6 # 最小学习率
)

# 训练循环
for epoch in range(100):
    for batch in dataloader:
        # 前向 + 反向 + 更新
        loss = model(batch)
        loss.backward()
        
        # 梯度裁剪（可选，推荐大模型训练时使用）
        torch.nn.utils.clip_grad_norm_(
            model.parameters(), max_norm=1.0)
        
        optimizer.step()
        optimizer.zero_grad()
    
    # 每 epoch 更新学习率
    scheduler.step()