误差反向传播法，很多人也叫它 BP 算法，是深度学习里最基础也最容易劝退的一块内容。我第一次学的时候，公式每个字符都认识，连起来就不知道在算什么。后来自己动手做了推导、写了代码、真的跑了几次模型，才把这条链路彻底捋顺。这篇文章打算把 BP 掰开揉碎讲一遍：它在解决什么问题、数学上怎么推、代码里怎么写、实际训练会遇到哪些坑。目标是让看完的人能真正理解“梯度是怎么从损失值一路传回每一层权重”的，而不是只记住一句“通过链式法则反向求导”。
如果你是刚接触深度学习、对反向传播只是听过名字，或者已经会用框架但不太确定底层在干什么，这篇内容应该比较合适。看完之后你会发现，BP 本质上不玄，它只是把“责任分摊”这件事做得特别高效。
1. 误差反向传播法到底在算什么东西
1.1 从一次普通的前向传播说起
先从一个具体例子入手。假设你在训练一个图像分类模型：输入是一张 32x32 的彩色图，经过几层卷积、几层全连接，最后输出一个向量，每个位置对应一个类别的得分。这个过程叫前向传播，因为数据是从输入层往输出层流动的。
前向传播的最后一步通常要算一个损失值，比如交叉熵或者均方误差。这个损失值就好比一次考试的分数：高，说明模型回答得不好；低，说明模型回答得不错。训练模型的目标，就是不断调整网络里的权重，让这个损失值越来越小。
问题来了：权重成千上万，怎么知道该往哪个方向调、调多少？这里就需要梯度。梯度的含义是“损失对某个参数的敏感程度”，或者说“这个参数微调一点点，损失会跟着变化多少”。如果我们能算出每个权重对应的梯度，就能按照“损失下降最快的方向”去更新它们。而反向传播法，就是专门用来高效计算这个梯度的。
1.2 训练的本质：把误差按责任分配出去
用生活里的场景来类比。假设你带了一个小组做项目，最终成果不理想，组长觉得是组员的问题，组员觉得是分工的问题。要真正改进，总得搞清楚：这次失败到底有多少责任在信息传递上，多少责任在执行环节，多少责任在最终整合上。
神经网络也一样。模型最终的损失，是整个网络里所有层共同作用的结果。靠近输出层的权重直接影响预测结果，靠近输入层的权重通过中间层的特征再影响结果，而且这种影响是层层叠加的。如果我们直接同时调整所有权重，很难判断每个权重各自该承担多少“错误责任”。反向传播做的事情，就是顺着网络的结构，把损失这份责任合理拆解，从输出端一层一层地分回输入端。
这其实是一种非常高明的责任分配机制。每一层拿到的不只是一个数字，而是“我这边输出的误差大概有多少，下一层的误差又占了多少”这类信息。只要每一层都知道自己应该负责多少，参数更新就有明确方向了。
1.3 为什么不能完全靠暴力数值微分
可能你会想：既然梯度就是“参数动一点点，损失变多少”，那直接给每个参数加一个很小的扰动，看一下损失变化不就行了吗？这种做法叫数值微分。思路很简单，但实际用起来非常慢。
举个例子：一个参数网络有 100 万个权重，每算一次梯度就需要额外做 100 万次前向传播。一次前向传播在稍微复杂一点的模型上就要几十毫秒，100 万次就意味着几小时甚至几天。而且数值微分还有精度问题，步长取太大，误差大；步长取太小，浮点数计算又会引入舍入误差。
反向传播不一样。它只需要一次前向传播来计算损失和各个中间结果，再配合一次反向遍历，就能把所有权重的梯度全部算出来。之所以能做到这一点，是因为它把整个网络看成了一张计算图，沿着图从输出往输入走，每到一个节点就应用一次链式法则。本质上它是一种动态规划式的梯度计算：前面层重复用到的中间结果只需要算一次，不需要反复重算。
2. 数学原理：链式法则就是全部
2.1 一个最小网络的定义
为了把推导过程看清楚，我建议抛开框架，用一个最简单的网络来定义符号。假设有一个只有一层的隐藏层的全连接网络：
- 输入是
x，维度是2； - 隐藏层有
4个神经元，每个神经元先做线性变换，再过一个激活函数； - 输出层有
1个神经元，也经过线性变换和激活函数； - 损失函数用均方误差
L = 1/2 * (y_pred - y)^2。
具体符号这么约定：隐藏层第j个神经元的线性输出叫net1_j，经过激活函数后的输出叫a_j。输出层神经元的线性输出叫net2，经过激活函数后的预测值叫y_pred。隐藏层权重记为W1，输出层权重记为W2，偏置分别是b1和b2。
网络前向过程可以写成：
a = sigmoid(x @ W1 + b1) y_pred = sigmoid(a @ W2 + b2)这里的@表示矩阵乘法。前向传播就这么简单，但关键的梯度信息都藏在这些等式里。
2.2 输出层的梯度推导
先从最后一层开始。我们需要求L对W2和b2的梯度。按照链式法则，梯度会经过这样一条链路：
L -> y_pred -> net2 -> W2, b2具体来说，对某个权重W2[j]，有：
∂L/∂W2[j] = ∂L/∂y_pred * ∂y_pred/∂net2 * ∂net2/∂W2[j]对均方误差，∂L/∂y_pred = y_pred - y。如果激活函数是 sigmoid，那么∂y_pred/∂net2 = y_pred * (1 - y_pred)。而∂net2/∂W2[j]其实就是隐藏层的输出a[j]。三个部分乘在一起，就得到了这个权重对应的梯度。
实际写代码的时候，我们经常把前两个部分的乘积合并成一个中间变量，叫delta。对输出层来说：
delta_output = (y_pred - y) * y_pred * (1 - y_pred)那输出层权重的梯度就是：
dW2 = a.T @ delta_output偏置的梯度也很自然，就是对delta_output在样本维度上求和。
2.3 隐藏层梯度如何一层层传回去
求完输出层，再往下一层移动，这时候就要回答一个核心问题：隐藏层的误差信息从哪来？答案是，从输出层的误差反向传递过来。
对隐藏层某个神经元j，它的影响路径是先通过a[j]影响输出层的net2，再影响最终损失。所以梯度是这样算的：
∂L/∂W1[j] = ∂L/∂a[j] * ∂a[j]/∂net1[j] * ∂net1[j]/∂W1[j]其中∂L/∂a[j]这个量很有意思。它不是一个独立可以直接算的数，而是需要从下一层的误差“收集”过来：
∂L/∂a[j] = sum_k (∂L/∂net2_k * W2[k, j])这里的k是下一层神经元的编号。换句话说，当前层的误差信号，等于下一层每个神经元传来的误差信号乘以它们之间的连接权重，再全部加起来。这就是“反向传播”这个名字的由来：误差不是从输入往输出走，而是从输出往输入倒着流。
和输出层类似，我们把隐藏层的中间量写成：
delta_hidden = (delta_output @ W2.T) * a * (1 - a)于是隐藏层权重的梯度就是：
dW1 = x.T @ delta_hidden到这里你应该能感觉到，每一层的梯度计算模式其实很一致：当前层的delta，由下一层传来的误差和当前层激活函数的导数相乘得到；而权重梯度，就是上一层输出和当前层delta的外积。
2.4 权重更新与学习率
算出了梯度，参数更新就好办了。最经典的更新方法就是梯度下降：
W = W - learning_rate * dW b = b - learning_rate * db学习率learning_rate代表每次更新迈多大的步子。这一步看似简单，却是整个训练过程里最敏感的地方。学习率太大，参数会在最优值附近来回震荡，甚至直接发散；学习率太小，训练半天损失都降不动。
反向传播本身不决定学习率怎么选，但它决定了我们朝着哪个方向迈。你可以把梯度理解成“当前站在山坡上，哪个方向是下坡”的信息，学习率就是你要迈出的步长。没有靠谱的梯度，后面这些全都白搭；而有了靠谱的梯度，学习率只要不过分夸张，模型多少都会有一点点进步。
3. 用代码把反向传播看个明白
3.1 手工搭建一个两层 BP 网络
理论推导再漂亮，不写代码还是会觉得悬。这里用 NumPy 手写一个极简的两层网络，任务选一个经典的非线性问题：模拟异或逻辑。异或问题很有意思，它不能用一条直线分割，所以单层感知机根本学不会，但用一个带隐藏层的网络就能轻松解决。
网络结构就按前面定义的那样：输入维度 2，隐藏层 4 个神经元，输出 1 个神经元，激活函数用 sigmoid，损失用均方误差。规模虽然小，但前向、反向、更新的完整流程全部具备，非常适合用来验证理解。
3.2 前向与反向的 NumPy 实现
下面是完整代码，我加了关键注释：
import numpy as np def sigmoid(x): return 1 / (1 + np.exp(-x)) def sigmoid_deriv(x): s = sigmoid(x) return s * (1 - s) # 异或数据集 X = np.array([[0, 0], [0, 1], [1, 0], [1, 1]], dtype=float) y = np.array([[0], [1], [1], [0]], dtype=float) np.random.seed(0) n_input, n_hidden, n_output = 2, 4, 1 # 参数初始化：小随机数，避免初始输出饱和 W1 = np.random.randn(n_input, n_hidden) * 0.5 b1 = np.zeros((1, n_hidden)) W2 = np.random.randn(n_hidden, n_output) * 0.5 b2 = np.zeros((1, n_output)) learning_rate = 1.0 for epoch in range(10000): # ---- 前向传播 ---- hidden = sigmoid(X @ W1 + b1) output = sigmoid(hidden @ W2 + b2) loss = np.mean((output - y) ** 2) # ---- 反向传播 ---- # 输出层 delta delta_out = (output - y) * sigmoid_deriv(X @ W1 + b1 if False else hidden @ W2 + b2) # 更清晰一点，分开写： net2 = hidden @ W2 + b2 delta_out = (output - y) * output * (1 - output) # 输出层梯度 dW2 = hidden.T @ delta_out db2 = np.sum(delta_out, axis=0, keepdims=True) # 隐藏层 delta：下一层误差传回 delta_hidden = (delta_out @ W2.T) * hidden * (1 - hidden) # 隐藏层梯度 dW1 = X.T @ delta_hidden db1 = np.sum(delta_hidden, axis=0, keepdims=True) # ---- 参数更新 ---- W2 -= learning_rate * dW2 b2 -= learning_rate * db2 W1 -= learning_rate * dW1 b1 -= learning_rate * db1 if epoch % 1000 == 0: print(f"epoch {epoch}, loss {loss:.6f}") print("训练后预测：") print(output)这段代码里最值得琢磨的是delta_hidden这一行。它先让输出层的误差沿着权重W2传回隐藏层，也就是delta_out @ W2.T，再乘以隐藏层自身的激活函数导数。这一步完整对应了前面推导里“责任分摊”的过程。如果你能自己解释清楚delta_out @ W2.T的形状为什么是(4, 1)然后经过W2.T变成(1, 4)，基本就理解反向传播的维度流动了。
3.3 数值梯度校验：验证实现没写错
手写反向传播最容易犯的错就是维度或者符号搞错，而且错误代码有时候也能跑，只是 loss 怎么降都降不到理想水平。这时候强烈建议用数值梯度来校验。
数值梯度的思路很简单：对于某个参数theta，梯度近似等于：
(f(theta + eps) - f(theta - eps)) / (2 * eps)其中eps通常取1e-6。这个式子叫中心差分，比单向差分更准。我们可以随机挑几个权重，算一下解析梯度和数值梯度，看它们是否接近。如果差很多，说明反向传播代码有问题。
实际用法是写一个函数，每次只挑一个参数，给它手动加一个小的扰动，重新做前向传播算一次 loss。因为整个网络参数不多，所以完全跑得动。只要随机抽几个位置验证精度在1e-7到1e-5之间，基本就能断定反向传播写对了。
这也是我多年来养成的习惯：任何自己写的反向传播实现，上线前都先过一遍梯度校验。不要嫌麻烦，这一步能拦住绝大多数低级错误。
3.4 和现代自动微分框架的关系
现在用 PyTorch 之类的框架，你基本上不会手动写这些delta过程。框架里的自动微分会自动构建计算图，在前向传播时记录每个算子，反向传播时自动把梯度传给每个参数。使用上确实方便很多，但底层的数学原理还是这一套 BP。
区别主要在于两点。第一，框架不会只支持简单的 sigmoid 和全连接，它会把卷积、矩阵乘法、归一化、损失函数等等都拆成算子，每个算子自带“前向函数”和“反向函数”。第二，框架会做很多内存和效率优化，比如复用中间缓冲区、把多个操作融合成一个 kernel。但你要是自己排查梯度问题，理解 BP 依然是最重要的基本功。
4. 实操中的那些坑与调参经验
4.1 梯度消失与梯度爆炸
在深层网络里，反向传播的误差信号要一连穿过很多层。每经过一层，就要乘以一个激活函数导数和一个权重矩阵。激活函数如果是 sigmoid，它的导数最大也只有 0.25。多层乘下来，误差信号会指数级变小，靠近输入层的权重几乎学不到东西，这就是梯度消失。
反过来，如果权重初始值给得太大，误差信号连乘多层的权重值，数值会迅速膨胀，于是出现梯度爆炸。训练的时候会看到 loss 变成 NaN，或者突然跳到非常大的值。
我个人的处理经验是：
- 隐藏层激活函数优先考虑 ReLU 这类“导数要么 0 要么 1”的函数，而不是 sigmoid；
- 权重初始化要用适合当前层数的方案，比如 He 初始化或 Xavier 初始化；
- 结构允许的情况下，尽量把 BN（批量归一化）加上，它能缓解内部协变量偏移；
- 如果网络很深，残差连接几乎是必需品。它让梯度有一条“近路”可以直达前层。
4.2 学习率到底怎么设
学习率大概是调参里最重要、也最容易踩坑的超参数。我说几个自己在训练中常见的情况。
学习率设太大：loss 在一开始可能还会下降，但随后开始震荡，甚至直接升到 Infinity。有时候你还会看到 loss 曲线反复横跳，始终收敛不了。解决办法是把学习率降到原来的十分之一甚至百分之一，重新试。
学习率设太小：loss 确实在下降，但速度慢得让人怀疑模型没在学。这种情况下曲线几乎是一条水平的线，只是非常非常缓慢地往下走。可以先用一个较大的学习率确认梯度方向没大问题，再逐步降低。
我比较常用的做法是先跑一个“学习率扫描”：从1e-4到1e-1取几个值，每个跑几十个 step，观察哪个区间下降最快。再在这个区间里取最终值。此外，训练后期用学习率衰减，例如 cosine 或者 step decay，往往能进一步压低 loss。
4.3 参数初始化真的不是小事
很多人觉得初始化只是随便生成一些随机数，其实它对训练的影响非常大。如果全部初始化为 0，那么同一层所有神经元的输出相同，反向传播时梯度也相同，整个层就退化成“一个神经元”，表达能力直接废掉。
如果初始化范围太大，sigmoid 很容易进入饱和区，梯度趋近于 0，参数干脆不动。如果范围太小，信号可能会层层衰减，深层网络照样学不动。
合理的初始化应该让每一层输出的方差保持在一个可控范围。常见的 Xavier 初始化适合激活函数近似线性的场景，He 初始化适合 ReLU。框架里的kaiming_uniform或xavier_uniform都可以直接用。关键认知是：初始化不是随便 pick 一个随机分布，它是在给反向传播的信号“留一条不宽不窄的通道”。
4.4 训练日志里的三件怪事
我更愿意把常见问题的排查方法整理成表，方便项目里直接对照：
| 现象 | 最可能原因 | 优先检查方向 |
|---|---|---|
| loss 完全不动 | 学习率过小、梯度消失、数据没归一化 | 先看梯度数值量级，再看学习率 |
| loss 变成 NaN | 学习率过大、梯度爆炸、数值不稳定 | 降低学习率，做梯度裁剪，检查输入是否有无穷值 |
| 训练集准确率低但 loss 高 | 模型结构不合适、初始化差、特征没学好 | 先跑一个小规模过拟合测试，确认模型能拟合少量样本 |
| 训练集表现好但验证集差 | 过拟合 | 加正则、加数据增强、用早停 |
我印象很深的一次是在一个图像分类项目里，loss 前几千步降得很漂亮，后面突然变成 NaN。当时第一反应是学习率，把学习率减了十倍，问题还在。后来检查输入数据，发现有少量样本在预处理时产生了inf，模型一来就被污染了。清洗完数据之后，同样参数下训练立马恢复稳定。所以排查顺序最好是：先看数据，再看梯度，最后才动超参数。
反向传播在计算上也有值得注意的地方。数值稳定起见，很多人会把损失函数和激活函数在数学上合并计算，例如用带 logits 的交叉熵，而不是先算 sigmoid 再算交叉熵，这样可以避免中间结果出现log(0)或者0/0。手动实现的时候也要注意浮点精度，不要在小数极小的区域直接做除法。
5. 关于反向传播，我最后想说的话
如果你耐心看到这里，说明你是真的想把反向传播搞懂，而不只是背个公式。我个人最大的感受是：BP 的数学并不难，难的是把维度、链式法则、误差传递这三件事真正串起来。建议你也用 NumPy 手写一个小网络，哪怕只是复现一个异或问题，都比光看教程有用得多。
还有一个拓展方向：当你理解了一层的反向传播，也就很容易理解更高阶的机制，比如梯度裁剪、二阶优化方法、以及现在大模型训练里常用的混合精度策略为什么能提速。反向传播是地基，地基稳了，上面盖什么都安心。
最后分享一个小技巧：在调试自己的 BP 实现时，尽量把网络规模和损失函数都设小一点，比如 2 层、4 个隐藏单元、均方误差，这样数值梯度验证速度非常快。等你确认每个梯度都正确之后，再换成真实数据集和复杂模型。这个步骤看起来不起眼，实际能帮你省掉大量排查问题的时间。
