09 · 优化器与学习率

   全批量 (Batch GD)：用全部数据算一次梯度，走一步
      ✅ 方向准   ❌ 慢、内存装不下

   随机 (SGD)：一个样本算一次梯度
      ✅ 快       ❌ 抖得厉害

   小批量 (Mini-batch) ⭐ 实际都用这个
      每次用 32~512 个样本
      ✅ 兼顾速度和稳定，且能吃满 GPU 并行

   小 batch 的梯度是【带噪声的】真实梯度
   → 更新方向随机抖动
   → 抖得出尖锐的局部极小值，抖不出平坦的
   → 最终停在【平坦极小值】里

   ⭐ 而平坦极小值泛化更好（参数微小扰动不改变结果）

   → 这就是"SGD 的隐式正则化"

 ① SGD：  w ← w − lr·g
    最朴素。在峡谷地形里会来回震荡

 ② Momentum（动量）：v ← βv + g;  w ← w − lr·v
    💡 像小球滚下山，累积惯性
    ✅ 穿过震荡、冲过小坑

 ③ Adagrad/RMSProp：每个参数有自己的学习率
    💡 梯度一直很大的参数，学习率自动调小
    ✅ 稀疏特征友好

 ④ Adam = Momentum + RMSProp  ⭐ 默认选它
    同时用一阶动量（方向）和二阶动量（自适应步长）
    ✅ 几乎不用调就能work

   lr 太大                  lr 合适                lr 太小
   loss ▲                   loss ▲                 loss ▲
        │╲    ╱╲                 │╲                     │╲___
        │ ╲  ╱  ╲   震荡/NaN     │ ╲___                 │    ╲___ 慢
        │  ╲╱    ╲               │     ╲__              │        ╲__
        └────────►               └────────►             └────────►

   固定 lr        →  后期在最优点附近震荡，下不去
   逐渐衰减 lr    →  前期跑得快，后期精细收敛 ✅

   常用三种：
   ├─ Step：每 N 轮 × 0.1
   ├─ Cosine ⭐：余弦曲线平滑衰减到 0，现在最主流
   └─ ReduceLROnPlateau：验证集不降了就自动砍学习率

   lr ▲
      │   ╱╲___
      │  ╱     ╲___
      │ ╱          ╲___
      └────────────────►
       ↑warmup   ↑cosine衰减

   前几百步 lr 从 0 线性升到目标值

# 让 lr 从 1e-7 指数增长到 1，记录每步的 loss
lrs, losses = [], []
lr = 1e-7
for batch in loader:
    for g in optimizer.param_groups: g["lr"] = lr
    loss = train_one_step(batch)
    lrs.append(lr); losses.append(loss)
    lr *= 1.1
    if loss > 4 * min(losses): break     # loss 炸了就停

# 画 loss vs log(lr)，选【loss 下降最陡】的那个 lr
# 保守起见取那个点的 1/3 ~ 1/10

   loss ▲
        │────╲
        │     ╲          ← 这段最陡，选这里的 lr
        │      ╲___
        │          ╲╱╲  ← 开始发散
        └──────────────► log(lr)

import torch

optimizer = torch.optim.AdamW(model.parameters(), lr=1e-3, weight_decay=0.01)
scheduler = torch.optim.lr_scheduler.CosineAnnealingLR(optimizer, T_max=epochs)

for epoch in range(epochs):
    for xb, yb in train_loader:
        optimizer.zero_grad()             # ⭐ 必须！梯度默认累加
        loss = criterion(model(xb), yb)
        loss.backward()
        torch.nn.utils.clip_grad_norm_(model.parameters(), 1.0)   # 防梯度爆炸
        optimizer.step()
    scheduler.step()

# 梯度累积：注意 loss 要除以 accum_steps ⭐
accum = 4
for i, (xb, yb) in enumerate(loader):
    loss = criterion(model(xb), yb) / accum      # ⭐ 别忘了这个除法
    loss.backward()
    if (i + 1) % accum == 0:
        optimizer.step()
        optimizer.zero_grad()