第 9 章 · 学习是怎么发生的

让它真的训得动

前向、损失、反向、梯度下降——“学习”的原理已经讲完了。但把原理变成 真能训练成功的模型,中间还隔着一整套工程技巧。 这一章我们把现代训练栈拼齐:从初始化起步, 接上第 8 章选好的优化器, 再配学习率调度和梯度裁剪,最后看清它们在一个 minibatch 里怎么串起来。

1. 起点很重要:参数初始化

训练前,所有权重得有个初始值。你可能想:全设成 0 不是最干净吗? 恰恰是最糟的。如果一层里每个神经元的权重都一样,它们收到的输入一样、 算出的输出一样、反传回来的梯度也一样,于是永远保持相同—— 这一层等于只有一个神经元在工作。这叫对称性问题,必须用随机初始化打破。

但随机也有讲究:初始值太大,信号逐层放大直到“爆炸”;太小,信号逐层衰减直到“消失”。 诀窍是让每层输出的“波动幅度”大致稳定。仓库里两种常用方案:

double limit = std::sqrt(6.0 / (double)fan_in);                 1
std::uniform_real_distribution<double> dis(-limit, limit);      2

for (auto &w : weight[i])
  for (auto &w_ : w)
    w_ = dis(gen);                                              3

2. 训练栈里挂上优化器

“梯度算出来之后参数该怎么挪”——这是优化器的活。 第 8 章已经把 SGD → Momentum → RMSProp → Adam → AdamW 的演进、公式和仓库里的统一接口 (BeforeStep + CalcChangeValue)讲透了;这里不再复述,只关心在训练栈里通常怎么选、怎么配。

实务上的默认答案大多是 AdamW:Adam 那套“方向 + 自适应步长 + 偏差校正”省心又稳, 再把 weight decay(权重衰减,第 10 章详讲)从梯度里解耦出来, 正则力度更可控,训 Transformer、训大模型几乎都是它。 不确定用啥时先 AdamW;想看 SGD / Momentum / Adam 在同任务上谁收敛更快,跑 optimizer_bench demo(第 8 章)。

net.set_optimizer_function(OPTIMIZER_ADAMW);       1
net.optimizer_function()->set_weight_decay(1e-4); 2

if (weight_pos != -1 && weight_decay_ != 0.0)
  adaptive += learning_rate * weight_decay_ * param_value;

3. 梯度消失与梯度爆炸

这是深层网络最有名的两个“训不动”故障。它俩其实同根同源——都出自反向传播那一长串乘法,只是一个越乘越小、一个越乘越大。 先把根源讲透,后面为什么要初始化、裁剪、热身就全顺理成章了。

根源:反传其实是「一长串数」在连乘

回忆第 6 章的 δ 递推:误差每往回穿过一层,就要乘一次 “这一层的权重 × 这一层激活函数的导数”。所以当它传到很前面的某个权重时,那个梯度长这样:

一串数连乘,结果几乎只由“每个因子的平均大小 r”决定,而且是指数级的:穿过 L 层就约等于 r^L。 于是只有三种命运:

• 因子平均 r < 1 → r^L 迅速趋近 0 → 梯度消失
• 因子平均 r > 1 → r^L 迅速冲上天 → 梯度爆炸
• 因子平均 r ≈ 1 → 梯度能稳稳传过几十层(这正是好初始化、残差、归一化拼命想维持的状态)

一个数字例子:深度一上来,差距有多离谱

假设每层因子 r 大致稳定,看梯度乘到第 5 / 10 / 30 层还剩多少倍:

套到具体元凶上:谁把 r 推离了 1

有了“因子连乘”这个根,常见诱因就都能归成一句话——它们要么把 r 压到小于 1,要么把 r 顶到大于 1:

• 梯度消失(r < 1,越传越小)
  • 激活函数饱和:Sigmoid 的导数最大也只有 0.25,两端更趋近 0;Tanh 类似。于是每层先天带一个 ≤0.25 的乘数,层一多必然归零。(第 7 章:斜率≈0 就断流)
  • 权重初始化太小:w 本身就小于 1,再和小小的 f′ 相乘,因子雪上加霜。
  • 网络太深:哪怕每层因子有 0.9,30 层后也只剩约 4%——深度本身就是放大器。
  • 怎么救:好初始化(把因子拉回 ≈1,见本章 §1 的 Xavier/He)、换 ReLU/GELU(正区间导数=1,不衰减)、残差连接(给梯度留一条 +1 的直通车道,第 18 章)。
• 梯度爆炸(r > 1,越传越大)
  • 权重过大 / 初始化不当:w 偏大让因子 >1,连乘就指数级放大。
  • 学习率过大:就算梯度本身正常,一步 w ← w − η·g 迈得太猛,会把参数推进激活的极端区,下一轮梯度更大——形成正反馈,几步就发散成 NaN。
  • 输入没归一化:x 尺度过大,第一层的 net 就偏离正常范围,整条链的数值跟着一起失控。(第 11 章)
  • RNN 尤其危险:它沿时间步反复乘同一个权重矩阵 T 次,相当于一张超深网络,两头都比普通网络更容易失控。(第 14 章)
  • 怎么救:梯度裁剪(直接给梯度封顶,下一节)、warmup 热身(前期用小学习率)、把输入缩放到合理尺度。

4. 防止训练“踩空”:梯度裁剪

上一节说的梯度爆炸,实战里最常见的急救手段是梯度裁剪: 给梯度设一个上限,防止某一步把参数推飞。本仓库支持两种模式,可以单独开,也可以先按值、再按范数连着用:

double norm = std::sqrt(sq_sum);                 1
if (norm > grad_clip_norm_ && norm > 0.0) {
  double scale = grad_clip_norm_ / norm;        2
  // 所有梯度 *= scale, 整体缩回阈值以内
}

5. 学习率不必一成不变:调度器

第 5 章我们用固定学习率,但更聪明的做法是让它随训练进程变化。 仓库里 lr_scheduler/ 提供一整族调度器,都和 Train 配合:每步开头调 GetLR(step) 更新当前学习率。

下面展开本仓库和 MNIST demo 最常用的 warmup + cosine。它把整个训练分成前后两段, 分界点就是一个你自己设的步数 warmup_steps:

• ① 热身(warmup),第 0 → warmup_steps 步:学习率从接近 0 线性升到峰值 base_lr。 为什么不一上来就用大步子?因为刚开始参数还是随机的、梯度很乱,一步迈太大容易直接把训练搞崩(loss 飞到 NaN)。先小步“热热身”,等方向稳了再加速。
• ② 退火(cosine),warmup_steps → t_max 步:学习率从峰值 base_lr 沿余弦曲线平滑降到 min_lr。 越接近终点步子越小,像快到谷底时收油门,免得在最低点附近反复横跳、稳稳落进谷里。

所以“什么时候开始退火”答案很干脆:第 warmup_steps 步。在这一步之前是热身(升),到达这一步时学习率正好冲到峰值 base_lr,从这一步往后就一路余弦下降,直到第 t_max 步落到 min_lr。

两段各用一个公式,其实就是把上图翻译成算式(base_lr=峰值学习率,min_lr=最低学习率,t_max=总步数):

• 热身段(step < warmup_steps):lr = base_lr × (step+1) / warmup_steps。就是一条直线,step 越大 lr 越大,到 warmup_steps 时正好等于 base_lr。
• 退火段(step ≥ warmup_steps):先算“退火走了几成” progress =(step − warmup_steps) /(t_max − warmup_steps)(从 0 走到 1),再 lr = min_lr + ½ ×(base_lr − min_lr)×(1 + cos(π × progress))。

余弦这段之所以是“两头慢、中间快”:progress=0 时 cos0=1,lr 还等于 base_lr(刚过峰值,先缓降、多学一会); progress=0.5 时 cos(π/2)=0,lr 正好落在 base_lr 与 min_lr 的正中间(下降最快); progress=1 时 cos(π)=−1,lr 降到 min_lr 并停住(小步精修、稳稳落底)。

这四个参数怎么定? 它们不是拍脑袋的魔法数,每个都有来路——下面给出经验法则,并标上本仓库两个 demo 的真实取值:

• base_lr — 峰值,其实就是主学习率:就是你平时给优化器设的那个 lr,也是这四个里唯一真正要“调”的旋钮。拿不准先用优化器的典型值(Adam ≈ 1e-3、SGD ≈ 0.1),或做一次 LR range test,挑“最大但还没发散”的那个。
  仓库里:MNIST 用 1e-3(续训微调降到 1e-4);transformer 用命令行 --learning-rate。
• warmup_steps — 用多少步爬到峰值:取总步数的一小截,常见 3%~10%,或干脆“1 个 epoch”。
  仓库里:MNIST = steps_per_epoch(1 个 epoch = 938 步);transformer = epoch_num / 20(≈5%)。
• t_max — 退火铺满多少步(退火终点):一般 = 整个训练的总步数,让 lr 正好在训练结束时降到底,不多不少。
  仓库里:MNIST = epochs × steps_per_epoch = 5 × 938 = 4690;transformer = epoch_num。
• min_lr — 退火终点的最低学习率:取 base_lr 的一个小比例,常见 ×0.1 或 ×0.01(也有人直接设 0)。
  仓库里:MNIST = base_lr × 0.01 = 1e-5;transformer = base_lr × 0.1。

为了让算术清爽,下面换一组整数示例走一遍(规律和上面的真实取值完全一样,只是把数字凑圆好心算):base_lr=0.1、warmup_steps=100(总步数的 10%)、t_max=1000、min_lr=0.01(= base_lr × 0.1):

if (step < warmup_steps_)
  return base_lr_ * (step + 1) / warmup_steps_;          1

double progress = (double)(step - warmup_steps_) / rest; 2
double cos_val = std::cos(kPi * progress);
return min_lr_ + 0.5 * (base_lr_ - min_lr_) * (1.0 + cos_val);  3

6. 一个 minibatch 里发生什么

第 5 章看过 Train 的骨架;加上本章零件后,每一步其实是下面这一圈。 初始化只在建网时做一次;其余都在循环里转:

if (lr_scheduler_ != nullptr)
  learning_rate_ = lr_scheduler_->GetLR(i);           1

ForwardPropagationBatch(batch_data);                 2
ResetGradients();
BackPropagationBatch(batch_target);                    3

if (grad_clip_norm_ > 0.0 || grad_clip_value_ > 0.0)
  ClipGradients(B);                                    4
ApplyGradient(B);                                      5

7. 把它们拼成一个“现代训练循环”

零件齐了,配置一个网络大概长这样(概念上和 PyTorch / JAX 训练脚本一一对应):

net.set_random_seed(42);                  // 可复现
net.set_param_init_function(PARAM_INIT_HE);     // 好的初始化
net.set_activate_function(ACTIVATE_GELU);       // 平滑激活
net.set_optimizer_function(OPTIMIZER_ADAMW);    // 自适应 + 解耦正则
net.optimizer_function()->set_weight_decay(1e-4);
net.set_gradient_clip_norm(1.0);                // 防爆炸
net.set_lr_scheduler(
    std::make_shared<WarmupCosineLR>(1e-3, 500, 10000));  // 热身+退火
net.Train(data, target, callback, 10000, 64);

8. 训练不稳?先拧本章这几个旋钮

真上手训练十有八九会“不对劲”。完整排查见第 11 章清单; 下面这张迷你表只列本章能直接动的开关,按顺序试往往就够:

动手与思考

训练能跑稳了,但“训练集上表现很好、没见过的数据上却拉垮”怎么办? 下一章我们讲正则化与泛化:过拟合到底是什么,以及 weight decay、Dropout、early stopping 这些防过拟合的常用招。