BP神经网络反向传播详解：从链式法则到梯度消失与调试实战

我先说个真实感受：很多朋友刚接触神经网络时，第一反应就是“我只要会调用框架就行，数学原理不重要”。但等你真正开始调参、模型不收敛、loss 掉不下去、梯度爆炸或者消失的时候，你才会发现，那些藏在封装后面的一堆参数，每一层都在跟“链式法则”打交道。BP神经网络，也就是反向传播，是整个深度学习的基石，无论后面是卷积还是 Transformer，它的核心更新逻辑仍然沿用了BP里“前向算输出、反向传误差”的思想。这篇文章就是一份我自己复习时写下的笔记，目标是做到基础、易懂，并且把数学推导完整走一遍，顺带聊几个简单变体，帮你从“会用”过渡到“会调”。

这篇内容适合两类人：一类是刚学完神经网络基础但还没来得及做推导的初学者，另一类是以前学过、但现在印象模糊、想快速把脉络拣回来的复习者。我不打算用复杂的测度论和矩阵分析吓你，只用到导数和链式法则。只要你会算一元函数的导数，能看懂复合函数求导，就能跟着推完整个BP流程。推导完之后，我还会放一个完整的数值算例，以及几个我在实际调试中踩过的坑。

1. 为什么还要手推一遍BP：从“会用”到“会调”

1.1 框架封装得再好，也绕不开梯度

现在的深度学习框架已经把反向传播封装成了几十行代码。你调用一句.backward()，梯度就自动算完，参数更新轻松完成。可正因为太轻松，很多人遇到问题的时候反而没有排查的思路。比如损失不降，你以为是学习率的问题，改小之后发现训练慢到怀疑人生；你以为是网络太深，减少层数之后准确率又开始下降。这种时候，如果你脑子里没有一张“梯度是怎么在网络里流动”的图，你就只能在各种组合拳里反复试。

我自己的经历是这样的：某次做一个图像分类的小项目，结果交叉熵损失在某个 epoch 后突然变成NaN。网上一搜，有人说学习率太大，有人说标签写错，也有人说数值稳定性没处理。但我心里清楚，问题几乎肯定出在某一个中间层的梯度计算上，或者出现在损失函数求导的某一步。我顺着前向、反向公式逐个检查，最后发现是我在写自定义损失时，对输出层的误差项少乘了一个激活函数导数。那一刻我才意识到，手推一遍BP不是学术仪式，而是调试时的保命技能。

还有一个更实际的原因：当你想给模型加一点自定义结构时，比如手动实现一个“加权输出”、“梯度裁剪”、“动量更新”或者某些小众的正则项，框架未必直接支持。这时你必须在底层实现里搞清楚哪些地方要改。如果没有亲手推过BP，你连“误差项”和“梯度”之间的关系都说不清楚，根本不知道从哪里改起。

1.2 推导前的符号约定

为了不让后面的公式绕晕，我们先统一符号。这里用一个最简单的全连接网络作为样例：输入层有 2 个特征，隐藏层有 2 个神经元，输出层有 1 个神经元。当然，推到一般情况也不难，但先从小网络开始，更容易看穿每个下标是怎么回事。

我约定：

• 输入向量：$x = (x_1, x_2)$
• 隐藏层神经元：$h_1, h_2$，它们的激活函数均为 $f$
• 输出层神经元：$\hat{y}$，激活函数同样用 $f$
• 隐藏层权重：$v_{ji}$，表示输入层第 $i$ 个节点连接到隐藏层第 $j$ 个神经元的权重
• 隐藏层偏置：$b_{hj}$
• 输出层权重：$w_j$，表示隐藏层第 $j$ 个神经元连接到输出节点的权重
• 输出层偏置：$b_o$
• 学习率：$\eta$
• 真实标签：$y$
• 损失函数：$L$，均方误差形式 $L = \frac{1}{2}(y - \hat{y})^2$

为什么在均方误差前面放一个 $\frac{1}{2}$？纯粹是为了求导方便。因为 $\frac{1}{2}$ 倍的平方求导之后刚好消掉系数，变成 $(y - \hat{y})$。这个细节虽然不影响最终收敛方向，但在手推的时候会让你少跟分数打交道。

激活函数默认选择 Sigmoid：$f(z) = \frac{1}{1 + e^{-z}}$。它的导数有个漂亮的性质：$f'(z) = f(z)(1 - f(z))$。这个性质在推导中会反复使用，建议你背下来。

2. 前向传播：把信号送到输出端

2.1 单样本前向传播的数学表达

前向传播就是输入数据从输入层，经过加权求和、偏置、激活函数，一层一层往后传，最后得到预测值。你完全可以把它理解成一条流水线：每个神经元先收齐上一层的所有输出，每个输出乘上对应的权重，再加一个偏置，得到“加权输入”，然后通过激活函数完成非线性变换，把结果作为自己的输出，传给下一层。

对于隐藏层第一个神经元 $h_1$，它的加权输入为：

$$ \text{net}{h_1} = b{h_1} + x_1 v_{11} + x_2 v_{12} $$

激活后得到输出：

$$ h_1 = f(\text{net}_{h_1}) $$

同样，隐藏层第二个神经元 $h_2$ 有：

$$ \text{net}{h_2} = b{h_2} + x_1 v_{21} + x_2 v_{22}, \quad h_2 = f(\text{net}_{h_2}) $$

然后输出层节点接收两个隐藏神经元的输出：

$$ \text{net}_o = b_o + h_1 w_1 + h_2 w_2 $$

$$ \hat{y} = f(\text{net}_o) $$

用矩阵可以把上面这一串写成：

$$ h = f(x V + b_h) $$

注意这里的 $V$ 是一个形状为“输入维度 × 隐藏维度”的矩阵，而 $xV$ 的每一项正好就是每个隐藏神经元的加权输入。矩阵写法在工程实现里很有用，但如果你现在看不太习惯，那就先以单一神经元的公式为准，矩阵只是一个压缩写法。

2.2 损失函数：怎么定义“错得有多离谱”

前向传播做完，我们需要一个数值来量化预测值和真实标签之间的差距，这就是损失函数。

对于回归问题或者二分类这种输出为连续值的场景，最常用的就是均方误差：

$$ L = \frac{1}{2}(y - \hat{y})^2 $$

如果你手里的任务是分类任务，而且输出层用的是 Softmax，那么更常用的是交叉熵损失。但为了推导BP时简单直观，我们先用均方误差。均方误差的好处是连续可导，且导数和误差成正比：预测越离谱，梯度越大，参数的更新步子也就越大。这在直觉上是合理的。

需要提醒的是：损失函数的选择直接影响到反向传播时输出层的误差项。如果你后来换成交叉熵，输出层的“误差项”形式也会随之变化。很多初学者在看别人推导BP时，只背了一个输出层 $\delta = \hat{y} - y$ 就到处套用，结果换成别的损失就错了。这就是因为没理解$\delta$是从 $L$ 对 $\text{net}_o$ 的导数来的，而不是凭空出来的。

3. 反向传播：从误差倒推更新量（核心推导）

3.1 链式法则：反向传播的发动机

反向传播的核心，就是高数里的链式法则。如果一个变量 $z$ 依赖 $y$，而 $y$ 依赖 $x$，那么：

$$ \frac{dz}{dx} = \frac{dz}{dy} \cdot \frac{dy}{dx} $$

神经网络就是一堆嵌套的复合函数：预测值 $\hat{y}$ 由输出层加权输入 $\text{net}_o$ 激活而来，而 $\text{net}_o$ 又由隐藏层输出和权重计算而来，隐藏层输出又由更前一层输入计算而来。我们要更新参数，就是要求损失 $L$ 对每个参数的偏导数，而这条路必然是一条复合链。

你可以把“误差”想象成一股逆流而上的水，从最终损失出发，先爬过输出层激活函数，再爬过输出加权求和，再到隐藏层激活函数，最后回到输入权重。每走一段，都要乘上这一段对上一层输出的导数。这就是“反向传播”这个名称的由来。

3.2 输出层权重更新推导

现在我们开始求导。目标参数是输出层权重 $w_1$ 和 $w_2$。

根据链式法则，损失 $L$ 对 $w_1$ 的偏导可以分为三段：

$$ \frac{\partial L}{\partial w_1} = \frac{\partial L}{\partial \hat{y}} \cdot \frac{\partial \hat{y}}{\partial \text{net}_o} \cdot \frac{\partial \text{net}_o}{\partial w_1} $$

逐项算：

第一段：

$$ \frac{\partial L}{\partial \hat{y}} = \frac{\partial}{\partial \hat{y}} \left[\frac{1}{2}(y - \hat{y})^2\right] = \hat{y} - y $$

第二段：

$$ \frac{\partial \hat{y}}{\partial \text{net}_o} = f'(\text{net}_o) = f(\text{net}_o)\left(1 - f(\text{net}_o)\right) $$

第三段：

$$ \frac{\partial \text{net}_o}{\partial w_1} = h_1 $$

因此：

$$ \frac{\partial L}{\partial w_1} = (\hat{y} - y) \cdot f'(\text{net}_o) \cdot h_1 $$

通常把前半部分定义为输出层误差项：

$$ \delta_o = (\hat{y} - y) \cdot f'(\text{net}_o) $$

那么权重的梯度就简洁地写成：

$$ \frac{\partial L}{\partial w_1} = \delta_o \cdot h_1 $$

同理：

$$ \frac{\partial L}{\partial w_2} = \delta_o \cdot h_2 $$

输出层偏置的导数更简单，因为 $\frac{\partial \text{net}_o}{\partial b_o} = 1$，所以：

$$ \frac{\partial L}{\partial b_o} = \delta_o $$

看到没有，所谓“BP”，本质上就是把输出端的误差 $\hat{y} - y$ 通过激活函数导数和中间输出，一步步倒推回每个权重上。

3.3 隐藏层权重更新推导

隐藏层权重的推导稍微绕一点，因为隐藏神经元的输出 $h_1$ 会通过 $w_1$ 影响输出层的加权输入，从而影响最终损失。这就意味着，当我们想更新 $v_{11}$ 时，要从最终的损失出发，先走到 $h_1$，再走到 $\text{net}{h_1}$，最后才到 $v{11}$。

链式法则展开：

$$ \frac{\partial L}{\partial v_{11}} = \frac{\partial L}{\partial h_1} \cdot \frac{\partial h_1}{\partial \text{net}{h_1}} \cdot \frac{\partial \text{net}{h_1}}{\partial v_{11}} $$

先看前两项的乘积。$\frac{\partial L}{\partial h_1}$ 是损失对隐藏层输出的敏感度，它需要通过输出层传导回来：

$$ \frac{\partial L}{\partial h_1} = \frac{\partial L}{\partial \hat{y}} \cdot \frac{\partial \hat{y}}{\partial \text{net}_o} \cdot \frac{\partial \text{net}_o}{\partial h_1} $$

其中已经有：

$$ \frac{\partial L}{\partial \hat{y}} = \hat{y} - y, \quad \frac{\partial \hat{y}}{\partial \text{net}_o} = f'(\text{net}_o), \quad \frac{\partial \text{net}_o}{\partial h_1} = w_1 $$

所以：

$$ \frac{\partial L}{\partial h_1} = (\hat{y} - y) \cdot f'(\text{net}_o) \cdot w_1 = \delta_o \cdot w_1 $$

而：

$$ \frac{\partial h_1}{\partial \text{net}{h_1}} = f'(\text{net}{h_1}) $$

$$ \frac{\partial \text{net}{h_1}}{\partial v{11}} = x_1 $$

于是：

$$ \frac{\partial L}{\partial v_{11}} = \delta_o \cdot w_1 \cdot f'(\text{net}_{h_1}) \cdot x_1 $$

这个式子里出现了多个权重相乘的因子：$\delta_o \cdot w_1$。这也就是梯度消失的隐患来源。如果这些值一直小于 1，尤其是 Sigmoid 的导数最大也只有 0.25，那么多层之后梯度就会迅速缩小到几乎为 0，前面层的权重基本无法更新。

为了方便，我们同样给隐藏层定义误差项：

$$ \delta_{h_1} = \delta_o \cdot w_1 \cdot f'(\text{net}_{h_1}) $$

于是：

$$ \frac{\partial L}{\partial v_{11}} = \delta_{h_1} \cdot x_1 $$

更一般地，对于任意隐藏层神经元 $j$ 和输入节点 $i$：

$$ \frac{\partial L}{\partial v_{ji}} = \delta_{h_j} \cdot x_i $$

隐藏层偏置的导数为：

$$ \frac{\partial L}{\partial b_{h_j}} = \delta_{h_j} $$

到这里，你可能会发现一个规律：不管哪一层的权重，其梯度都可以写作“来自后面的误差项 × 来自前面的输入”。这个模式在后来的深度学习框架中也没有变过，只是换成了更复杂的张量版本。

3.4 用具体数值走一遍全流程

理论推导看多了容易晕，我拿一组具体数字手算子一遍。假设网络结构为 2-2-1，也就是两个输入、两个隐藏神经元、一个输出。

初始化参数如下：

• $x_1 = 0.5, x_2 = 0.2, y = 1$
• $v_{11}=0.1, v_{12}=-0.2, v_{21}=0.3, v_{22}=0.4$
• $b_{h1}=0.05, b_{h2}=-0.1$
• $w_1=0.2, w_2=-0.3, b_o=0.1$
• 学习率 $\eta = 0.5$

第一步：前向传播。

隐藏层第一个神经元：

$$ \text{net}_{h_1} = 0.05 + 0.1 \times 0.5 + (-0.2) \times 0.2 = 0.06 $$

$$ h_1 = \frac{1}{1 + e^{-0.06}} \approx 0.5150 $$

隐藏层第二个神经元：

$$ \text{net}_{h_2} = -0.1 + 0.3 \times 0.5 + 0.4 \times 0.2 = 0.13 $$

$$ h_2 \approx 0.5325 $$

输出层：

$$ \text{net}_o = 0.1 + 0.2 \times 0.5150 + (-0.3) \times 0.5325 = 0.04325 $$

$$ \hat{y} \approx 0.5108 $$

损失：

$$ L = \frac{1}{2}(1 - 0.5108)^2 \approx 0.1197 $$

第二步：反向传播。

输出层误差项：

$$ \delta_o = (\hat{y} - y) \cdot \hat{y}(1 - \hat{y}) \approx (-0.4892) \times 0.2499 \approx -0.1223 $$

$w_1$ 的梯度：

$$ \frac{\partial L}{\partial w_1} = \delta_o \cdot h_1 \approx -0.1223 \times 0.5150 \approx -0.0630 $$

更新 $w_1$：

$$ w_1 \leftarrow 0.2 - 0.5 \times (-0.0630) \approx 0.2315 $$

注意因为是梯度下降，所以参数更新要沿着梯度的反方向走，减去学习率乘以梯度。

$w_2$ 的梯度：

$$ \frac{\partial L}{\partial w_2} = \delta_o \cdot h_2 \approx -0.0651 $$

$$

w_2 \leftarrow -0.3 - 0.5 \times (-0.0651) \approx -0.2675 $$

偏置 $b_o$：

$$ b_o \leftarrow 0.1 - 0.5 \times (-0.1223) \approx 0.1612 $$

再看隐藏层权重。先计算隐藏层误差项：

$$ \delta_{h_1} = \delta_o \cdot w_1 \cdot h_1(1 - h_1) $$

注意这里使用旧权重 $w_1=0.2$，也就是在更新之前的值：

$$ \delta_{h_1} \approx -0.1223 \times 0.2 \times 0.2499 \approx -0.0061 $$

同理：

$$ \delta_{h_2} = \delta_o \cdot w_2 \cdot h_2(1 - h_2) \approx -0.1223 \times (-0.3) \times 0.2488 \approx 0.0091 $$

于是：

$$ \frac{\partial L}{\partial v_{11}} = \delta_{h_1} \cdot x_1 \approx -0.0061 \times 0.5 \approx -0.0031 $$

$$ v_{11} \leftarrow 0.1 - 0.5 \times (-0.0031) \approx 0.1015 $$

$$

\frac{\partial L}{\partial v_{12}} = \delta_{h_1} \cdot x_2 \approx -0.0061 \times 0.2 \approx -0.0012 $$

$$ v_{12} \leftarrow -0.2 - 0.5 \times (-0.0012) \approx -0.1994 $$

$$

\frac{\partial L}{\partial v_{21}} = \delta_{h_2} \cdot x_1 \approx 0.0091 \times 0.5 \approx 0.0046 $$

$$ v_{21} \leftarrow 0.3 - 0.5 \times 0.0046 \approx 0.2977 $$

$$

\frac{\partial L}{\partial v_{22}} = \delta_{h_2} \cdot x_2 \approx 0.0091 \times 0.2 \approx 0.0018 $$

$$ v_{22} \leftarrow 0.4 - 0.5 \times 0.0018 \approx 0.3991 $$

隐藏层偏置的更新也不难：

$$ b_{h_1} \leftarrow 0.05 - 0.5 \times (-0.0061) \approx 0.0531 $$

$$ b_{h_2} \leftarrow -0.1 - 0.5 \times 0.0091 \approx -0.1046 $$

如果你把这轮更新后的参数重新做一次前向传播，你会得到一个新的预测值，新的损失会比 0.1197 稍微小一点。当然，单次迭代下降不明显，这是很正常的。真正的训练需要成百上千次迭代，才会逐步逼近最小值。

这里有一个特别容易踩坑的细节：在计算隐藏层误差项时，应该使用更新前的权重 $w_1, w_2$，而不是已经更新过的权重。有些人在实现时先把输出层权重更新了，再拿更新后的权重去算隐藏层梯度，这会导致梯度算得不对，整个训练过程变得极其不稳定。正确做法是：先统一算出所有梯度，再统一更新所有参数。这也是“反向传播”名称的另一个提醒——先传播，再更新。

4. 从标准BP到简单变体：那些让训练更稳的改动

4.1 学习率与动量：别让梯度像个无头苍蝇

标准BP最大的问题之一，是它对参数更新路径没有任何“惯性”，每一次都直接按照当前梯度走。而真实的目标函数往往是一个高低不平的山谷，梯度方向在谷底附近来回振荡，导致训练很慢，甚至卡在局部极小值附近。

我在之前的项目中就遇到过一个典型情况：训练损失在前 50 轮下降得很快，之后就以一种非常规律的“震荡”形态来回摆动，怎么都压不下去。后来我加了动量项，问题立刻缓解。动量项的本质，是把上一次更新的方向也考虑进来。写成公式就是：

$$ \Delta w^{(t)} = \beta \Delta w^{(t-1)} + (1 - \beta) \frac{\partial L}{\partial w} $$

$$ w^{(t)} = w^{(t-1)} - \eta \Delta w^{(t)} $$

这里的 $\beta$ 通常取 0.9。它就像给小球一个速度，方向一致的梯度会越滚越快，而方向反复变化的梯度会被平均掉一部分，从而减少振荡。你可以把它理解成跑步时的惯性：当你想转身往回跑时，惯性会拉住你一下，这样你的步伐就不会忽左忽右那么剧烈。

动量项的原理还可以和“EMA，指数移动平均”挂钩，本质上是对梯度做了一个平滑滤波。在神经网络训练中，这个变体几乎已经成为标配，很多高级优化器里都能看到它的影子。

4.2 激活函数的选择：Sigmoid的饱和区和ReLU的修正

标准BP诞生时，最常用的激活函数是 Sigmoid。但它有两个明显缺点：输出不以零为中心，以及梯度饱和。什么叫梯度饱和？当输入加权和特别大或者特别小时，Sigmoid 的曲线变得非常平缓，导数趋近于 0。这意味着权重的梯度会变得非常小，网络几乎学不动。

我见过一些初学者用 Sigmoid 搭建深度网络，训练到中间层时，发现靠近输入层的权重更新量比输出层小了至少几个数量级，整个网络几乎变成了一层线性模型。这就是梯度消失的典型症状。为了解决这个问题，后来的变体大量采用 ReLU：

$$ \text{ReLU}(z) = \max(0, z) $$

ReLU 在正半轴的导数为 1，在负半轴导数为 0。它有两个好处：正区间梯度恒定，不容易消失；计算简单，不需要算指数函数和除法。但 ReLU 也有自己的坑：当一个神经元的加权输入长期为负，这个神经元的梯度永远是 0，相当于“死”掉了。这种情况称为 Dead ReLU Problem。为了缓解，就有了 Leaky ReLU 或者 Parametric ReLU：

$$ \text{LeakyReLU}(z) = \max(\alpha z, z) $$

其中 $\alpha$ 是一个很小的常数，比如 0.01。这样即使在负区间，也保留一丝梯度，神经元就有机会“复活”。

在实际实现中，我个人更习惯在隐藏层用 ReLU 或 Leaky ReLU，在输出层根据任务选择：回归问题用线性输出，二分类用 Sigmoid，多分类用 Softmax。这句经验看似简单，但它背后就是对激活函数导数行为的直接考量。

4.3 权重初始化与小批量：训练稳定性的底线

还有一个容易被忽略的变体，是权重初始化方法。

如果你把所有权重初始化为 0，那么同一层所有神经元的前向输出相同，反向传播的梯度也相同，所有神经元会像一个神经元一样被更新，网络就失去了“宽度”的意义。如果你把权重初始化得过大，经过多层激活函数之后，输出会迅速进入饱和区，梯度直接湮灭；如果你把权重初始化得过小，信号传到后面逐渐变弱，网络也学不动。

这里最常用的方案是 Xavier 初始化。假设某个神经元有 $n_{in}$ 个输入，那么权重从一个均值为 0、方差为 $\frac{2}{n_{in} + n_{out}}$ 的高斯分布中采样。这个方案的目标，是让信号在网络中传播时，每一层的输出方差尽量保持稳定。放到 ReLU 一类的激活函数下，也有 He 初始化：方差取 $\frac{2}{n_{in}}$。

初始化只是第一步，另一项对训练稳定性影响巨大的变体是小批量训练。标准BP一次处理一个样本，梯度噪声很大；全量数据集训练一次，梯度方向稳定但计算代价太高。折中方案是每次随机抽取一小批样本，比如 32 个或 128 个，算出这批样本的平均梯度再做更新。这样既平滑了噪声，又能利用矩阵运算加速。你可以在自己写BP练习时试一下，同样的网络结构，小批量训练要比单样本训练收敛稳定得多。

4.4 一个真实变体应用：手写数字识别简化版

理论讲完，我来说一个我复现过的简化版变体应用：用手写BP做手写数字识别。

我没有用任何深度学习框架，只用了 Python 和 NumPy。网络结构是 784-64-10，输入是 28×28 的灰度图像展平后的像素值，隐藏层 64 个神经元，输出层 10 个神经元，分别代表 0 到 9。损失函数我用了均方误差，输出层激活函数用 Sigmoid，隐藏层也先用 Sigmoid。训练前，我把像素值除以 255 缩放到 0 到 1 之间，权重用类似 Xavier 的方式初始化。

核心代码骨架大概是这样的：

import numpy as np def sigmoid(x): return 1 / (1 + np.exp(-x)) def sigmoid_deriv(x): s = sigmoid(x) return s * (1 - s) class SimpleBP: def __init__(self, input_size, hidden_size, output_size, lr=0.5, momentum=0.9): self.lr = lr self.momentum = momentum self.v = np.random.randn(input_size, hidden_size) * np.sqrt(2 / input_size) self.b_h = np.zeros(hidden_size) self.w = np.random.randn(hidden_size, output_size) * np.sqrt(2 / hidden_size) self.b_o = np.zeros(output_size) self.vel_v = np.zeros_like(self.v) self.vel_b_h = np.zeros_like(self.b_h) self.vel_w = np.zeros_like(self.w) self.vel_b_o = np.zeros_like(self.b_o) def forward(self, x): self.x = x self.net_h = x @ self.v + self.b_h self.h = sigmoid(self.net_h) self.net_o = self.h @ self.w + self.b_o self.y_pred = sigmoid(self.net_o) return self.y_pred def backward(self, y_true): m = y_true.shape[0] delta_o = (self.y_pred - y_true) * sigmoid_deriv(self.net_o) / m self.vel_w = self.momentum * self.vel_w - self.lr * (self.h.T @ delta_o) self.vel_b_o = self.momentum * self.vel_b_o - self.lr * delta_o.sum(axis=0) delta_h = (delta_o @ self.w.T) * sigmoid_deriv(self.net_h) self.vel_v = self.momentum * self.vel_v - self.lr * (self.x.T @ delta_h) self.vel_b_h = self.momentum * self.vel_b_h - self.lr * delta_h.sum(axis=0) def update(self): self.w += self.vel_w self.b_o += self.vel_b_o self.v += self.vel_v self.b_h += self.vel_b_h

这段代码把前向、反向和动量更新都压缩到了核心逻辑里。需要注意，我的代码里先对所有参数累积了vel_*，然后再统一更新，强调的是“先算梯度、再更新”的顺序。你在自己写的时候也可以把梯度和动量分开处理，但顺序一定不能乱。

这个 Demo 跑下来的结果，验证准确率大概在 90% 左右，和现代框架动辄 99% 当然没法比，但作为理解BP原理的练习，我觉得已经足够了。更重要的是，中途我还尝试了不加动量的版本，训练到最后损失会周期性震荡，而且验证集准确率始终不如带动量版本。后来我又把 Sigmoid 换成 ReLU，并用 He 初始化重新调整，收敛速度立刻上去一截，这让我实打实感受到了变体的价值。

5. 调试BP网络时最常见的坑：参数与排错实录

5.1 损失不收敛的五个排查方向

我复盘了过往调试中的十几个案例，发现“损失不收敛”的原因其实高度集中在几个固定方向。下面表格是常见原因和对应的处理思路。

还有一种是大家最容易忽略的：数据标签写错了。如果训练标签和预测目标本身有噪声，BP再怎么努力，损失也会维持在一个奇怪的高位。遇到损失不对劲，我建议先打印几个样本的标签，肉眼确认一下，再开始调参。

5.2 梯度检查：用数值差分验证写法

这一条是直接受益于手推BP的实操技巧。当我自己实现反向传播时，为了确认手写代码里的梯度公式没有写错，我会用数值差分来验证。

数值差分的原理很简单，直接用导数定义近似：

$$ \frac{\partial L}{\partial w} \approx \frac{L(w + \epsilon) - L(w - \epsilon)}{2\epsilon} $$

其中 $\epsilon$ 取一个很小的数，比如 $10^{-7}$。然后我分别用数值差分算出来的梯度和反向传播算出来的梯度做对比，如果每一项的相对误差都在 $10^{-4}$ 量级以下，基本说明反向传播实现是正常的。

具体操作时，我会把所有参数拉平成一个大向量，对每个位置做两次前向传播来计算该位置的数值梯度，再跟偏导代码返回的梯度比较。虽然这样效率很低，但作为验证脚本跑一次，能极大减少后期调参的痛苦。

这里有个小细节：数值差分对很多参数位置可能会产生不稳定性，尤其是 Sigmoid 的饱和区。如果你发现某个参数的数值梯度和解析梯度差异较大，先看看这个位置的加权输入是不是已经到达了饱和区，再用更小的 $\epsilon$ 或者改初始化重新测试。

5.3 从损失曲线判断网络状态

看损失曲线的形态，其实比看具体数值更有诊断价值。我自己看曲线时，通常会分三种情况。

第一种是曲线平稳下降，最后趋于平缓。这种状态最让人放心，说明学习率合适，网络结构也没有明显问题。这时你可以继续训练，或者稍微调大一点学习率，看看能不能加速。

第二种是曲线下降后震荡，震荡幅度较大。这通常是学习率太高、梯度方向不一致造成的。处理方法是先把学习率缩小 10 倍，看看震荡是否减弱；如果减弱了，再配合动量项一起使用。

第三种是曲线一开始就卡住，或者下降到一定程度后明显偏离预期。这种情况往往和初始化、激活函数、数据预处理有关，而不是学习率的问题。我曾经遇到一个例子，归一化时不小心把像素值除以了 2550，结果所有输入都集中在很小的范围，模型学了很久都没有实质性进展。后来检查数据分布才发现问题。

训练过程中还有一个经验：如果你同时打印训练集损失和验证集损失，发现训练集继续下降、验证集开始反弹，这就是过拟合的信号。此时可以停止训练，或者加入更多训练数据和正则项。千万不要等到验证损失涨了一大截才停下。

5.4 两个最容易被忽略的BP实现细节

最后分享两个我实际踩过、而且不太容易在教材里看到的细节。

第一个是关于偏置项的更新。很多人记住了权重梯度公式，却忘了偏置也有梯度。偏置的梯度等于对应神经元的误差项 $\delta$，如果不更新偏置，模型的拟合能力会明显下降。这个错误很容易犯，尤其是使用矩阵形式实现时，偏置的sum维度一错，梯度计算就会出现微妙偏差。

第二个是关于“全部数据都喂给同一个网络”还是“每个样本单独更新”。标准BP在理论上可以逐样本更新，但如果你在代码里循环遍历每个样本并实时更新参数，那么同一个 epoch 内的前后样本会影响彼此的梯度路径，导致收敛不稳定。相比之下，我建议在小批量代码中始终保持一个模式：先在该批内前向传播并平均梯度，再反向传播，再更新参数。这个模式更接近“批梯度下降”的思路，稳定性和可复现性都好很多。

我在早期实现里，就是因为在update()里不小心把参数更新放在backward()前面，导致每一步梯度都用了旧参数，但损失却下降得很“顺利”，最后验证集效果却很差。后来使用梯度检查脚本才发现问题所在。从那以后，我把“先算梯度、再更新参数”当成一条铁律。

这篇文章的推导过程里，我反复提到了同一句话：反向传播的本质，就是复合函数求导的链式法则。你能把每一层的误差项算清楚，你就掌握了大多数神经网络优化技巧的基础。现在很多高级优化器、卷积网络、循环网络，虽然形式复杂，但底层仍然在遵循“前向传播算输出、反向传播传梯度、用梯度更新参数”这个循环。

如果你是自己动手写过BP的人，相信你已经体会到，亲手推一遍公式，远比看十遍理论更有收获。我也是在一次又一次的梯度检查、损失曲线观察和参数调优中，才真正把“梯度”这两个字从抽象的数学符号变成了脑海里一种有方向、有大小、可以感知的量。在你下次调模型调不出来时，不妨回到这篇笔记，沿着链式法则重新走一遍，说不定问题就迎刃而解了。