很多人第一次看训练代码,会被这段循环卡住:

for epoch in range(epochs):
    loss = forward(x, y)
    loss.backward()
    optimizer.step()
    optimizer.zero_grad()

四个调用,每行都认识,但连起来不知道发生了什么。为什么先算 loss,再 backward,再 step?zero_grad 又是在清什么?如果只是照抄,模型能跑起来;一旦 loss 不降或变成 NaN,就完全不知道从哪里查。

这篇用一个最小的例子把训练循环拆开:四个点、一条直线、两个参数,手写梯度,不用任何框架。你会看到一个完整的训练循环其实只做四件事:用当前参数算预测,算预测和答案差多少,算参数往哪个方向调能让差距变小,然后挪一小步。剩下的框架代码,都是这四步的工程封装。

用一条直线拟合四个点

假设有四个样本,输入是 x,答案是 y:(1, 3)、(2, 5)、(3, 7)、(4, 9)。肉眼一看就知道答案在直线 y = 2x + 1 上。现在假装不知道这条线,从 w = 0、b = 0 开始,让程序自己把 w 和 b 调过去。

这里的 w 和 b 就是参数,也叫权重和偏置。模型对每个输入的计算是 prediction = w * x + b。训练的目标,是找到一组 w 和 b,让四个预测值尽量接近四个答案。

一开始 w = 0、b = 0,预测全是 0,和答案差得很远。接下来要回答两个问题:怎么衡量「差得远」,以及怎么知道该把 w 往大调还是往小调。前者是损失函数,后者是梯度。

损失函数:把错误变成一个数

损失函数把「预测和答案的差距」压缩成一个标量。回归任务最常用均方误差:每个样本的误差取平方,再对所有样本求平均。平方的作用有两个:让正负误差都变成正数,并且放大较大的误差。

用公式写就是:loss = 平均((w * x + b - y) 的平方)。在初始参数下,四个预测都是 0,误差分别是 -3、-5、-7、-9,平方后是 9、25、49、81,平均是 41。这个 41 就是起点。训练要做的就是让这个数变小。

分类任务用的通常不是均方误差,而是交叉熵。它衡量的是「模型给正确答案分配的概率有多低」:正确答案的概率越接近 1,损失越接近 0;越接近 0,损失越大。均方误差适合预测连续值,交叉熵适合预测类别概率,两者不能随便互换。

损失函数的选择会改变模型的行为。均方误差更在意大误差,一个错得很离谱的样本会主导梯度;平均绝对误差对异常值更稳,但在零点附近不可导;交叉熵配合 softmax 时梯度形式很干净,是分类的默认选择。选损失不是选一个「更高级」的函数,而是选「你更在意哪种错误」。

用均方误差训分类问题也能跑,但通常收敛更慢,而且当模型已经很自信却判错时,梯度会变得很小,纠正不过来。交叉熵在同样的情况下会给一个很大的梯度,逼模型把正确答案的概率拉上来。这不是数学上的对错,而是损失函数和输出层的搭配问题。分类任务默认用交叉熵,除非有明确理由,不要随便换回均方误差。

损失值本身没有绝对意义。41 是大还是小,取决于标签的尺度和样本量。能比较的是同一个损失函数在不同参数下的值,或者训练集和验证集上的同一种损失。拿均方误差的 0.01 去和交叉熵的 0.3 比「谁更好」,是没有意义的。

梯度:参数该往哪个方向调

梯度是损失对每个参数的偏导数。偏导数的含义很直白:把某个参数稍微增大一点,损失会变大还是变小、变化多快。如果增大 w 会让损失变小,梯度就是负的,更新时应该增大 w;反过来就减小。

以均方误差为例,对 w 的偏导是「平均(2 * 误差 * x)」,对 b 的偏导是「平均(2 * 误差)」。误差是预测减答案。初始时预测为 0,误差全为负,所以两个梯度都是负的。更新规则是「参数减去学习率乘以梯度」,负负得正,w 和 b 都会增大,预测开始往上走。

这就是「沿负梯度方向更新」的来历。梯度指向损失上升最快的方向,反着走就是下降最快的方向。它不是保证全局最优,只保证在当前点附近,这一步是往低处走的。步长多大,由学习率决定。

高维情况下,每个参数都有自己的偏导,合起来是一个向量。更新时每个参数各走各的,互不干扰。反向传播做的事情,就是高效地算出所有这些偏导,而不是逐个参数做数值扰动。它的数学基础是链式法则,后面深度学习部分会专门讲。

手写梯度时,可以用数值方法做一次校验:把某个参数增大一个极小的量,重新算损失,看损失变化除以这个极小量,是否接近手算的偏导。这个方法叫有限差分,慢但可靠,适合在小模型上验证公式有没有写错。深度学习的框架会自动求导,但理解这个校验思路,在调试自定义层时仍然有用。

梯度还有一个容易被忽略的性质:它只告诉你当前点的局部方向,不告诉你走多远之后方向会变。损失曲面弯曲得厉害时,沿着当前梯度走一大步,可能走到一个梯度完全不同的地方,甚至往上走。这就是学习率必须小的原因,也是自适应优化器要解决的问题。

学习率:一步走多大

学习率决定每次更新挪多远。太小,损失下降很慢,训练半天还在原地;太大,可能一步跨过最低点,甚至让损失越来越大。下面这段把完整循环跑三十轮,学习率取 0.02:

xs = [1, 2, 3, 4]
ys = [3, 5, 7, 9]
w, b = 0.0, 0.0
lr = 0.02

for epoch in range(1, 31):
    # 前向:用当前参数算预测,再算均方误差
    loss = sum((w * x + b - y) ** 2 for x, y in zip(xs, ys)) / len(xs)

    # 反向:手写均方误差对 w 和 b 的偏导
    gw = 2 * sum((w * x + b - y) * x for x, y in zip(xs, ys)) / len(xs)
    gb = 2 * sum((w * x + b - y) for x, y in zip(xs, ys)) / len(xs)

    # 更新:沿负梯度方向挪一步
    w -= lr * gw
    b -= lr * gb

    if epoch in (1, 5, 10, 20, 30):
        print("epoch", epoch, "loss", round(loss, 4),
              "w", round(w, 3), "b", round(b, 3))

print("最终 w,b:", round(w, 3), round(b, 3))
print("预测 x=5:", round(w * 5 + b, 3))

本机实际输出:

epoch 1 loss 41.0 w 0.7 b 0.24
epoch 5 loss 1.5993 w 1.82 b 0.628
epoch 10 loss 0.0395 w 2.056 b 0.718
epoch 20 loss 0.0109 w 2.086 b 0.746
epoch 30 loss 0.0097 w 2.081 b 0.761
最终 w,b: 2.081 0.761
预测 x=5: 11.168

损失从 41 降到 0.0097,w 从 0 走到 2.08,b 从 0 走到 0.76,已经接近真实的 2 和 1。注意 w 在第 20 轮是 2.086,第 30 轮反而回落到 2.081,说明它越过了最优点又往回走了一点。这是固定学习率在最低点附近来回微调的正常现象,不是代码写错了。

如果把学习率调到 0.3,同样的数据,前几步就会剧烈震荡,损失可能先降后升。学习率不是越大越好,它和数据的尺度、损失函数的曲率都有关系。一个经验做法是先用小学习率确认损失能稳定下降,再逐步放大,找到不发散的上限。

学习率太小的表现不是报错,而是「看起来在学,但慢得没有意义」。跑一百轮损失只从 41 降到 38,曲线几乎是平的。这时候继续加轮数是在浪费算力,正确做法是先调学习率,而不是盲目增加 epoch。反过来,学习率太大时,损失会在几个值之间来回跳,甚至隔轮变成 NaN。

很多框架的默认学习率在千分之一到百分之一之间,这不是万能值,只是在这个量级上不容易立刻发散。换了数据尺度、换了模型结构,同一个学习率可能完全不适用。把它当成需要实验的超参数,而不是一个抄来的常数。

为什么不用解析方法直接求出最优的 w 和 b?对这条直线和均方误差,确实可以解方程一步得到答案。但真实模型有几十万甚至几十亿个参数,损失函数也不是简单的二次型,没有闭式解。梯度下降是用「反复小步走」换「不需要解复杂方程」,它牺牲了精确性,换来了可扩展性。

一个完整的训练循环长什么样

把上面的步骤抽象出来,一个训练循环就是四件事反复执行:

训练循环的四步
前向计算用当前参数算出预测值
算损失比较预测和答案,得到一个标量
算梯度求损失对每个参数的偏导
更新参数沿负梯度方向挪一小步,清零旧梯度

这里有几个容易混淆的时间单位。一次参数更新叫一步,也叫 iteration;把所有训练样本完整过一遍叫一个 epoch;一次前向和反向用多少样本叫 batch size。样本一万条、batch size 一百,那么一个 epoch 有十步。这三个词经常被混用,排查问题时说清楚是哪一个,能省很多沟通成本。

框架里的 zero_grad 是在清上一步累积的梯度。如果忘了清,梯度会把历史值加进来,更新方向就错了。它不会报错,只会让训练悄悄变差,是新手最常见的坑之一。手写代码时没有这个问题,因为每次都是重新计算;框架为了效率会累积,所以才需要显式清零。

还有一个小细节:损失通常是在更新之前算的,所以打印出来的 loss 对应的是「这一步更新前」的参数。看到第一步 loss 很大不要慌,那正是起点。想看更新后的效果,得在下一步或者每轮结束时再算一次。

样本顺序也会影响训练。如果数据按类别排好序,前几百步全是一个类别,梯度方向会严重偏斜,模型先学会「全判这一类」,再慢慢纠正。每个 epoch 开始前打乱顺序,能让每个 batch 的分布更接近整体,梯度估计更稳。这个步骤便宜,但漏掉时表现为前期 loss 剧烈震荡,很容易被误判成学习率问题。

batch 大小不只是速度参数。小 batch 的梯度噪声大,有时反而能帮模型跳出尖锐的低谷;大 batch 的梯度更准,但容易停在平坦区域,泛化未必更好。显存允许时,大 batch 配合更大的学习率是常见组合;显存不够时,可以用梯度累积模拟大 batch,不必为了 batch 大小牺牲太多。

loss 不对劲,按这张表查

训练循环的问题几乎都会体现在 loss 上,但同一条曲线可能对应好几种原因。下面按现象倒查,比盲目调参快:

现象真实原因第一步查什么
loss 变成 NaN 或无穷大学习率过大、除零、对数里出现零先把学习率缩小十倍,再检查损失函数里的除法和 log
loss 完全不降梯度为零、参数没被更新、标签与输入无关打印梯度范数,确认参数确实在变;再确认输入和标签是否对齐
loss 先降后升学习率过大,越过了最低点把学习率减半或改成衰减策略,观察曲线是否变平滑
loss 下降很慢学习率太小,或特征尺度差异大先做特征标准化,再尝试更大的学习率
训练 loss 降,验证 loss 升过拟合,模型在背训练样本看训练样本量和模型复杂度,加入正则或提前停止
loss 很快降到接近零标签泄漏,或任务过于简单检查是否有结果字段混进特征,确认标签在预测时是否可得
每步 loss 波动很大batch 太小,或学习率相对 batch 偏大增大 batch 或降低学习率,观察波动幅度是否收窄

边界与代价

梯度下降不保证找到全局最优。它只保证在当前点沿负梯度走一步,损失会下降(在学习率足够小的情况下)。损失曲面如果有多个低谷,从不同初始点出发可能落到不同的谷里。深度学习的损失曲面更复杂,但实践中更常见的问题不是「落到局部最优」,而是「学习率不对」或「数据有问题」。

特征尺度会严重影响收敛。一个特征取值范围是 0 到 1,另一个是 0 到 10000,梯度会被大尺度特征主导,小尺度特征几乎不动。标准化之后,各方向的曲率接近,同一个学习率才能同时照顾到所有参数。这也是为什么几乎所有训练流程都会先做标准化。

固定学习率是一种简化。实际训练常用衰减、预热或自适应方法,让前期步子大、后期步子小。这些方法不是魔法,它们只是根据梯度的历史调整每个参数的实际步长。后面讲优化器时会展开。

最后是计算成本。每一步都要对所有样本算一次前向和反向,样本多时很贵。mini-batch 用一小批样本估计梯度,换来更快的迭代速度,代价是梯度有噪声。batch 越小,噪声越大,曲线越抖;batch 越大,单步越稳,但内存占用和每步耗时也越高。这是一个工程取舍,不是纯算法问题。

训练循环还需要一个停止条件。常见做法是固定轮数,但这需要事先猜一个合适的数。更稳的是早停:每轮在验证集上算一次损失,连续若干轮不再下降就停下来,并回滚到验证损失最低的那组参数。早停不改变模型结构,只是用验证集决定什么时候收手,是抑制过拟合最便宜的手段之一。

参数初始化也会影响循环能否顺利开始。全部初始化为零时,同一层里的多个神经元会得到完全相同的梯度,永远保持相同,等于只学了一个神经元。随机初始化打破这种对称,让不同神经元走到不同方向。初始值太大或太小又会造成梯度爆炸或消失,后面讲深度学习时会具体展开。

训练过程至少要留下三样记录:训练损失、验证损失、以及梯度范数。只看训练损失,无法判断模型是在学规律还是在背样本;只看最终指标,无法判断哪一轮开始变坏。梯度范数突然变成零或无穷大,往往比损失更早暴露问题。把这些记录按轮保存下来,复盘时比回忆「当时好像还行」有用得多。

当天能自验的五个练习

  1. 把学习率改成 0.001、0.02、0.3,各跑三十轮,记录最终 loss 和参数,画出三条 loss 曲线的形状差异。
  2. 把初始值改成 w = 5、b = -3,重跑,观察它是否还能收敛到接近 2 和 1,以及需要多少轮。
  3. 把损失函数换成平均绝对误差,手写对应的梯度,重跑,比较收敛速度和最终参数。
  4. 把 x 整体放大一百倍,其他不变,观察学习率 0.02 下是否还会发散。解释特征尺度为什么影响训练。
  5. 在循环里打印梯度范数,观察它随训练如何变小。想一想梯度接近零时继续训练还有没有意义。

小结

一次参数更新只做四件事:用当前参数算预测,算预测和答案的损失,求损失对参数的梯度,沿负梯度方向挪一步。学习率决定步长,特征尺度决定各方向是否同步,损失函数决定模型更在意哪种错误。

但训练 loss 降下来,不代表模型真的学会了。下一篇讲训练集、验证集、测试集怎么切,以及为什么训练集 99% 的模型上线就崩。你会看到,评估方式本身就能决定一个模型是「看起来好」还是「真的好」。