优化算法

        泛化误差
            ↑
            |        ● 过拟合模型（训练误差低，但泛化差）
            |
            |
            |   ● 理想模型（泛化最好）
            |
            |
            |● 欠拟合模型
            +--------------------→ 训练误差（经验风险）

- 投影法：每一步梯度更新后都“投影回约束线”，所以可行性最好， |g(x)| 基本立刻很小。
- 拉格朗日法：通过乘子 λ 动态调节“目标下降”和“满足约束”的平衡，轨迹通常靠近约束并逐步收敛。
- 惩罚法：把约束违反写进目标函数，早期可能偏离约束，随着罚系数 ρ 增大才更强地逼近可行域。
- 右图对数曲线 |x+y-1| 用来直观看“谁更快满足约束”。

我不知道前面地形
→ 先试一步
→ 再试一步

我看脚下这块地：
- 斜率是多少？
- 弯曲程度是多少？

👉 假设这附近是个“碗”

👉 直接算出碗底在哪

🟥 左图（没预处理）

你会看到：

等高线是“细长椭圆”
路径来回折（zigzag）

👉 本质：

x方向快，y方向慢 → 震荡

🟩 右图（预处理后）

你会看到：

等高线变“圆”
路径更直

👉 本质：

各方向尺度统一了

🟥 普通 GD

走一步 → 看情况 → 再调整

🟦 线搜索 GD

每一步：
在这条方向上“试很多步”
找到最优点再走

GD (Gradient Descent)：梯度下降

形象比喻： 稳扎稳打的“完美主义者”。

在下山之前，你必须站在原地，仔细测量四周每一个方向的坡度，计算出最精确的“下山最快路径”，然后迈出一小步。

操作方式： 每次更新模型，都要把全部数据看一遍。

优点： 走得很稳，方向非常准确，几乎总是朝着山谷前进。

缺点： 极慢。如果你有 1 亿条数据，每走一小步都要算 1 亿次，电脑会累瘫。

########################################

SGD (Stochastic Gradient Descent)：随机梯度下降

形象比喻： 追求效率的“急性子”。

你不再测量所有方向，而是随手抓起一条数据（或者一小波数据），瞄一眼大致方向，立马就迈步。

操作方式： 每次更新模型，只看一条（或一小部分）数据。

优点： 极快。模型更新频率高，能够迅速开始“下山”。

缺点： 走得歪歪扭扭。因为只看局部数据，有时会走错路，甚至往山上跑，但大体趋势还是向下的。

每隔一段时间，学习率乘一个系数（比如 0.1）

👉 举例：

epoch 0–30：0.1
epoch 30–60：0.01
epoch 60–90：0.001

✔ 优点：简单稳定
❌ 缺点：不够平滑

👉 特点：

每一步都在变
比 step 更平滑

非常流行（Transformer / CV 常用）：

👉 形状像：

LR
│\
│ \
│  \__
│     \__
│        \____
└────────────── t

✔ 优点：

平滑下降
后期更稳定
常配合 warm restart

Transformer / 大模型几乎必用：

👉 一开始学习率从很小慢慢升高

LR
│     /\
│    /  \
│   /    \____
│  /
└────────────── t

👉 原因：

防止一开始梯度不稳定（特别是深网络）
避免训练直接崩

实际训练中最常见：

🔥 先 warmup → 再 cosine 衰减

流程：

阶段1：线性升高（warmup）
阶段2：平滑下降（cosine）

👉 这就是很多大模型的默认策略（如 Transformer）

不是“手动调度”，而是优化器自动调整：

代表算法：
Adam
RMSProp
Adagrad

👉 核心思想：

不同参数 → 用不同学习率

1️⃣ Batch Gradient Descent（全量）
每次用全部数据
一次只更新一次参数（每个 epoch）

✔ 优点：方向最准
❌ 缺点：

非常慢
不利用 GPU 并行

👉 实验现象：

收敛很慢，甚至“几步后就停滞”


2️⃣ SGD（单样本）
每次只用一个样本
更新非常频繁

✔ 优点：更新快
❌ 缺点：

计算效率低（无法向量化）
噪声大

👉 实验现象：

每个 epoch 时间更长（反而慢）

1️⃣ 向量化（Vectorization）

关键结论：

👉 矩阵运算比逐元素运算快几个数量级

实验里：

单元素：极慢
按列：一般
整体矩阵：极快

👉 因为：

GPU / CPU 擅长并行计算
一次处理越多数据 → 越高效


2️⃣ 缓存（Cache）和带宽

核心问题：

CPU/GPU 算力很强
但内存带宽跟不上

👉 解决方法：

👉 一次多处理数据（mini-batch），减少内存访问

3️⃣ 并行计算（多 GPU）

现实情况：

8 GPU × 16 机器
每个 GPU 至少要有数据

👉 batch size 不能太小

┌───────────────────────────────┐
│        数据集 Dataset          │
│  (x₁,y₁), (x₂,y₂)...(xN,yN)   │
└───────────────┬───────────────┘
                │
                ▼
        [1] 数据打乱（Shuffle）
        👉 防止模型记住顺序，增强泛化
                │
                ▼
        [2] 划分 Mini-batch
        👉 batch size = B（如 32 / 64）
                │
                ▼
    ┌─────────────────────────┐
    │   对每个 mini-batch 循环 │
    └─────────────┬───────────┘
                  │
                  ▼
        ┌──────────────────────┐
        │ [3] 前向传播 Forward  │
        │ y_pred = model(x)    │
        │ 👉 神经网络逐层计算   │
        └─────────┬────────────┘
                  │
                  ▼
        ┌──────────────────────┐
        │ [4] 计算损失 Loss     │
        │ L = loss(y_pred, y)  │
        │ 👉 衡量预测误差       │
        └─────────┬────────────┘
                  │
                  ▼
        ┌────────────────────────────┐
        │ [5] 反向传播 Backward       │
        │ 计算 ∂L/∂θ（梯度）          │
        │ 👉 链式法则逐层回传          │
        └─────────┬──────────────────┘
                  │
                  ▼
        ┌────────────────────────────┐
        │ [6] 参数更新 Update         │
        │ θ = θ - η · g              │
        │ 👉 SGD / Adam / Momentum   │
        └─────────┬──────────────────┘
                  │
                  ▼
        ┌────────────────────────────┐
        │ [7] 清空梯度（重要！）       │
        │ grad = 0                   │
        │ 👉 防止梯度累积污染         │
        └─────────┬──────────────────┘
                  │
                  ▼
        （继续下一个 batch）

核心一句话：

👉 SGD 每个参数用同一个学习率，不合理

问题来源：

❗1. 不同参数“重要性不同”
有些参数梯度大（变化快）
有些参数梯度小（变化慢）

👉 但 SGD：一视同仁

❗2. 稀疏特征问题（重点）

比如 NLP：

“the” → 经常出现
“preconditioning” → 很少出现

👉 SGD 会：

高频词更新太多
低频词几乎学不到

👉 每个参数用自己的学习率，并且自动衰减

👉 历史梯度平方累积 → 自动缩小学习率

✔ 1. 自动调学习率

不用手动 decay

✔ 2. 适合稀疏数据

NLP / 推荐系统特别好

✔ 3. 稳定

不用调太多超参

四个面板

A — 等高线路径（最直观）
看路径形状：

SGD（黑）：在 y 方向来回弹跳，x 方向缓慢推进，呈典型"锯齿"形
Momentum（蓝）：速度积累让 x 方向更快，但 y 方向的惯性使震荡幅度更大
AdaGrad（绿）：y 方向梯度大 → 累积平方和大 → 步长迅速缩小 → 震荡快速消失，但后期路径几乎停滞（步长趋近 0）
RMSProp（橙）：与 AdaGrad 类似但不停滞，路径更平滑、收敛更稳
Adam（红）：路径最直、最快到达原点，同时兼顾速度和稳定性
B — 3D 曲面路径

同样的轨迹叠在曲面上，可以感受下降的高度——Adam/RMSProp 一开始就急速下降，SGD 则在高处来回抖动。

C — Loss 曲线（对数坐标）
看收敛速度：

SGD/Momentum 前期 loss 震荡，下降缓慢
AdaGrad 初期快，后期曲线变平（停滞）
RMSProp/Adam loss 曲线最陡，最终值最小
对数坐标让后期微小差异也清晰可见。

D — 步长 ‖Δw‖
看自适应效果：

SGD/Momentum 步长基本恒定（固定 lr）
AdaGrad 步长单调递减，最终接近 0——这就是它停滞的原因
RMSProp/Adam 步长在初期大、后期自动收缩但不归零，自动适应梯度规模

🔵 结论 1：Constant 不稳定

本质：

学习率不变 → 无法适配训练阶段变化

表现：

前期慢
后期震荡

🔵 结论 2：Step / MultiFactor 最实用

本质：

“等模型稳定后再降低学习率”

特点：

工业最常用
不依赖连续函数假设

🔵 结论 3：Warmup + Cosine 最优

本质：

👉 “前期避免梯度爆炸 + 后期平滑收敛”

这是 Transformer 标配