如果你去问一个刚学完神经网络的人，反向传播到底是什么，大概率会得到一个含糊的回答：把误差传回去，用链式法则算梯度。这个回答没错，但太笼统了。真正让我对反向传播产生敬畏的，是有一天把它拆成两个词来看——链式法则回答“梯度往哪个方向传播”，动态规划回答“怎样让这个传播不重复计算”。一个负责数学正确性，一个负责计算效率，两个看似无关的思想，在神经网络里恰好嵌合成同一个算法。这篇文章就沿着这条线索，从最朴素的“求梯度”问题讲起，把反向传播从原理到手算，再到工程实现里的坑，完整捋一遍。无论你是刚开始学深度学习的新手，还是正想手写训练循环的工程师，这篇都能给你一些可落地的参考。
1. 梯度到底该怎么算：先把这个问题的代价朴素化
1.1 训练神经网络，本质上是在做“找梯度”
神经网络训练的表面动作是更新参数，但真正决定更新方向的，是对每个参数算出来的导数，也就是梯度。神经网络参数少则几千，多则几百万。梯度下降每一步都要问同一件事：损失函数对每个参数的变化率是多少。如果梯度算得准，参数就往下降的方向走；如果算错，训练就会原地打转甚至发散。所以，“求梯度”是整个训练流程里最基础也最容易被低估的步骤。
很多学过机器学习的人都知道，模型训练就是最小化损失函数。但神经网络特殊在损失函数不是一个简单的凸函数，而是一大堆复合运算叠出来的高维非凸函数。函数表达式看上去不长，实际展开之后会产生成千上万个嵌套项。对这样一个函数求梯度，理论上就是多元微积分里把所有偏导数列出来。可难点在于：怎么在有限时间内把全部偏导数算出来？反向传播就是在这个环节登场的。
一个经常被忽视的点：反向传播并不是优化算法，它不决定怎么走，也不决定走多远。它只负责回答“当前参数下，各个参数的梯度是多少”。后续的梯度下降、动量、自适应优化之类，都是在拿这个梯度做文章。因此，反传的正确性直接影响所有上层优化器。我见过不少刚学深度学习的人，以为“反向传播就是优化”，其实这是两件事，分不清楚的话，后面排查问题时很容易把锅甩给优化器，而真正错的反传逻辑还在原地。
1.2 朴素梯度方案为何不可行
如果不考虑效率，直接求梯度最朴素的方式是对每个参数做扰动。把某个参数 (w) 加一个极小的 (\varepsilon)，重新计算一次前向传播得到 (L(w+\varepsilon))，再算 (L(w-\varepsilon))，两者之差除以 (2\varepsilon)，就得到 (w) 的近似导数。这就是有限差分。理论上一段时间有效，但实际操作中完全不可行——因为每算一个参数的导数，就需要重新跑一遍完整的前向传播。
可以算一笔账。假设一个图像分类模型有 300 万个参数，一次前向传播在普通设备上需要 50 毫秒。如果每个参数都用中心差分（每个参数两次前向），一个梯度步就要 2 × 3,000,000 次前向，折合约 83 小时。这样的训练连一个迭代都跑不完，更不用说几百个迭代。而反向传播只需要 1 次前向加 1 次反向，前向成本和反向成本大约在同一个量级，总耗时可能不到 200 毫秒。这个对比是数量级的差异，不是“快一点”。
为什么反向传播能做到这一点？因为它不是独立求每个参数的导数，而是把所有参数放在同一张计算图里，通过一次反向遍历让不同参数的梯度共用中间结果。这里已经能隐约看到动态规划的味道。值得一提的是，有限差分并不是完全没用，它几乎不依赖手推导数公式，所以非常适合在开发阶段做“梯度检查”，用来验证你写的反向传播到底对不对。这一点后面专门展开。
2. 链式法则：链式结构恰好在哪一步发挥作用
2.1 从单变量复合函数说起
微积分里，如果 (y = f(u))，(u = g(x))，那么：
[ \frac{dy}{dx} = \frac{dy}{du} \cdot \frac{du}{dx} ]
这是个看似简单的等式，却蕴含着神经网络求梯度的全部秘密。神经网络的每一层都可以看作一个函数：上一层输出是下一层输入。数据从左往右流动，依次经过线性加权、偏置相加、非线性激活，最后一层输出再接一个损失函数。把这条链路看成一个超长的复合函数，链式法则就是求梯度时绕不开的数学工具。
举个例子，一个只有三层的链路：(x \to h \to a \to L)。损失 (L) 关于参数 (W) 的导数，可以一步步拆成：
[ \frac{dL}{dW} = \frac{dL}{da} \cdot \frac{da}{dh} \cdot \frac{dh}{dW} ]
这个过程不需要知道整个网络长什么样，只需要知道每个局部环节的导数。这种“局部化”是链式法则最漂亮的地方，也是反向传播能落到代码实现的根本原因：每一层只需要关心自己局部的导数，上游信号传下来，乘上局部导数，再传给下游，计算永不解体。
2.2 局部梯度与误差信号
反向传播的每个步骤，可以概括成一句话：拿上游传下来的梯度，乘上当前位置的局部导数，得到再上游的梯度。所谓“上游梯度”，就是损失函数对当前节点输出的导数；所谓“局部导数”，就是当前节点输出对输入或参数的导数。
举个最简单节点：加法节点 (y = x_1 + x_2)，它的局部梯度分别是：
[ \frac{dy}{dx_1} = 1, \quad \frac{dy}{dx_2} = 1 ]
如果上游梯度是 (g)，那么 (x_1)、(x_2) 收到的梯度都是 (g)。再比如乘法节点 (y = x_1 \cdot x_2)，局部梯度分别是 (x_2) 和 (x_1)。这些局部梯度计算极其简单，但正是通过一层一层相乘，最终把损失信号送到了最底层参数。
这里有一个新手特别容易混的地方：局部梯度在反向传播时是“常数”吗？不是。局部导数本身可能依赖前向阶段的输入值，比如乘法节点上，(dy/dx_1 = x_2)，而 (x_2) 是需要在前向时缓存下来的一个具体数值。所以反向传播必须记住前向计算中间结果，不是只靠反向推导就能完成。这也是为什么工程实现里一定要有缓存机制——常见做法是把每一层的输入、加权求和结果、激活输出都保存下来，反向时直接取用。
2.3 多变量版本：雅可比矩阵视角
如果输入输出是向量，链式法则就不再是普通导数相乘，而是雅可比矩阵相乘。假设一个线性层 (y = Wx + b)，那么 (y) 对 (x) 的雅可比矩阵就是 (W)。误差信号从后向前传播，本质上是雅可比矩阵的转置作用在某个向量上：
[ g_x = W^T g_y ]
实际工程中，几乎不会有人显式构造并存储完整的雅可比矩阵，因为参数规模太大。更常见的做法是直接推导每一层输出对输入的梯度公式，然后用矩阵乘法实现。但理解这个视角才能解释一个常见疑问：为什么反向传播的公式里到处都是权重矩阵的转置？因为雅可比矩阵转置。这一小段算是为第五章的矩阵化实现做理论铺垫。
3. 动态规划：反向传播效率的来源不是聪明而是“复用”
3.1 从路径数爆炸说起
我们先忘掉神经网络，单独看一个计算图。输入 (x) 经过若干个门（线性变换、激活、损失等）到达输出 (L)。从 (L) 到 (x) 可能有许多不同路径。比如中间有 (n) 个二分支节点，路径总数就是 (2^n)。如果一条一条枚举每条路径，再把所有路径贡献加起来，计算量随 (n) 指数增长。这显然无法用于大规模参数计算。
但换个角度看，大量路径会经过同一个中间节点。对于任何一个中间变量 (v)，真正重要的是“损失对 (v) 的梯度”。这个值一旦算出来，所有经过 (v) 的上游变量都能直接拿它作为起点，继续往上游传播。这就是典型的重叠子问题：同一个子问题被重复依赖，那就只计算一次，把结果存下来复用。
反向传播做的事情，正是从输出端开始，一个节点一个节点地计算“损失对该节点输出的梯度”，并把这个梯度存起来，作为再上一层的上游梯度。每个节点只被访问一次，复杂度从路径数量的指数级降到了计算图边数的线性级。
3.2 用动态规划的思想来类比
学算法的时候，很多经典问题都主张用动态规划替代递归暴力搜索。背包问题是经典的例子：把子问题的解存起来，避免重复计算。反向传播也一样，只不过它的“状态”是每个中间变量的梯度。第 (l) 层输出的梯度，会被多条更上游的路径重用。正因为这些子问题高度重叠，反向传播采用自底向上的方式，把神经网络里“会爆炸的重复计算”压缩成线性复杂度。
有人可能会问：那为什么不叫它“后向动态规划”？因为名字已经先被反向传播占了。但从算法分类上讲，反向传播完全够得上一个动态规划算法：重叠子问题、最优子结构、自底向上求解。把它当作动态规划来看，不仅有助于理解算法本身，也有助于做内存优化时保持清醒——哪些中间结果必须缓存，哪些可以重新计算，这是典型的动态规划状态取舍问题。
3.3 为什么是“反向”而不是“正向”
自动微分有两种经典模式，前向模式和反向模式。前向模式沿着计算图从输入往输出推，每到一个节点就维护“某个输入的变化会导致这个节点变化多少”。如果输入维度很高，每个输入都要单独推一遍，代价就很大。反向模式刚好相反，从输出往回推，维护“输出变化对某个中间节点输出的依赖”，特别适合最终只有一个标量损失的情况，复杂度几乎与输出维度成正比。
神经网络的损失通常是一个标量，输出的“维度”是 1，所以反向模式非常高效。这也是为什么主流自动微分框架都着重实现反向模式的核心原因。“反向传播”这个名词里的“反向”，本质上就是选择了一条从损失标量往参数方向走的路线。路线一旦选对，效率就完全不一样。
3.4 复杂度对比表
| 方案 | 需要前向次数 | 总复杂度 | 适用场景 |
|---|---|---|---|
| 逐参数有限差分 | 约 (2P) 次 | (O(P \cdot E)) | 小规模验证，不适合训练 |
| 枚举路径求梯度 | 路径数 | 指数级 | 无法使用 |
| 反向传播 | 1 次前向 + 1 次反向 | (O(E)) | 大规模训练的标准选择 |
这里的 (E) 指计算图的边数，也就是所有运算连接。神经网络中 (E) 与参数量正相关。这个表可以给新手一个直观感受：反向传播不是简单优化，而是把“不可能”变成“可行”。
4. 一个两层小网的手算全过程（含数值验证）
4.1 网络结构与符号约定
纸上得来终觉浅，我们手动算一个最小的网络。输入是一个标量 (x=1)，隐藏层有两个神经元，输出层有一个神经元。激活函数用 sigmoid，损失用均方误差。为了计算方便，我特意把参数设计成让隐藏层加权输入落在 0 附近，这样 sigmoid 导数是精确的 0.25。
网络参数如下：
| 参数 | 含义 | 值 |
|---|---|---|
| (w_{11}, b_{11}) | 第一个隐藏神经元的权重和偏置 | -1, 1 |
| (w_{21}, b_{21}) | 第二个隐藏神经元的权重和偏置 | -1, 1 |
| (w_{31}, w_{32}, b_3) | 输出神经元的权重和偏置 | 1, 1, 0 |
前向链路是：(x \to z \to a \to z_3 \to a_3 \to L)，其中 (a = \sigma(z))，(L = 0.5(a_3 - 1)^2)。这个例子虽然只有 5 个参数，但已经包含了线性加权、偏置、非线性激活、损失、多分支结构等几乎所有关键要素。
4.2 前向传播手算表格
先算前向，每个中间变量都必须算清楚，之后反向传播会用到它们：
| 变量 | 计算过程 | 数值 |
|---|---|---|
| (z_1) | (-1 \times 1 + 1) | 0 |
| (a_1) | (\sigma(0)) | 0.5 |
| (z_2) | (-1 \times 1 + 1) | 0 |
| (a_2) | (\sigma(0)) | 0.5 |
| (z_3) | (1 \times 0.5 + 1 \times 0.5 + 0) | 1.0 |
| (a_3) | (\sigma(1)) | ≈ 0.7310585786 |
| (L) | (0.5 \times (a_3 - 1)^2) | ≈ 0.0361696559 |
这里的 (\sigma(1) \approx 0.7310585786)，损失不为 0，说明模型还有改进空间。实际代码里，表格中所有 (z)、(a) 的值都要被缓存下来，反向传播会一个不落地复用。
4.3 反向传播逐级计算
从输出端开始往回推。先算损失对 (a_3) 的导数：
[ \frac{dL}{da_3} = a_3 - 1 \approx -0.2689414214 ]
然后利用 sigmoid 导数性质：
[ \sigma'(z) = \sigma(z)(1-\sigma(z)) ]
得到：
[ \sigma'(z_3) = a_3(1-a_3) \approx 0.1966119332 ]
于是输出层的误差信号：
[ \delta_3 = \frac{dL}{dz_3} = \frac{dL}{da_3} \cdot \sigma'(z_3) \approx -0.0528761558 ]
有了 (\delta_3)，输出层的所有参数梯度都很容易算：
| 梯度 | 计算过程 | 数值 |
|---|---|---|
| (dL/dw_{31}) | (\delta_3 \times a_1) | ≈ -0.0264380779 |
| (dL/dw_{32}) | (\delta_3 \times a_2) | ≈ -0.0264380779 |
| (dL/db_3) | (\delta_3) | ≈ -0.0528761558 |
继续往隐藏层传播。先算损失对 (a_1) 的梯度：
[ \frac{dL}{da_1} = \delta_3 \times w_{31} \approx -0.0528761558 ]
再穿过第一个隐藏神经元的 sigmoid：
[ \delta_1 = \frac{dL}{dz_1} = \frac{dL}{da_1} \cdot \sigma'(z_1) \approx -0.0528761558 \times 0.25 \approx -0.0132190390 ]
于是第一个隐藏神经元的参数梯度：
[ \frac{dL}{dw_{11}} = \delta_1 \times x \approx -0.0132190390 ]
[ \frac{dL}{db_{11}} = \delta_1 \approx -0.0132190390 ]
第二个隐藏神经元完全对称，(\delta_2 \approx -0.0132190390)，(dL/dw_{21} \approx -0.0132190390)，(dL/db_{21} \approx -0.0132190390)。
做完之后，所有参数都有了一个具体的梯度，下一步就可以拿这些梯度去做梯度下降更新了。注意一下三组梯度的大小差异：输出层权重梯度绝对值大约是隐藏层权重梯度的两倍。这并不代表输出层参数更重要，只是损失对两个位置敏感度的真实反映。
4.4 用中心差分验证梯度
手算结果对不对？最可靠的验证方法是中心差分。对任意参数 (w)，数值梯度近似为：
[ \frac{dL}{dw} \approx \frac{L(w+\varepsilon) - L(w-\varepsilon)}{2\varepsilon} ]
以 (w_{31}) 为例，把前向过程写成一个函数，代入 (w_{31}=1+\varepsilon) 和 (1-\varepsilon)，再比较数值差分结果与上面的解析梯度。取 (\varepsilon = 10^{-5}) 时，数值结果和解析梯度在小数点后第五位才出现轻微差异，主要来自截断与浮点误差。
我自己的习惯是：只要新写一个网络结构，就先跑一遍中心差分，把所有参数梯度都对比一次。判断标准看相对误差，不是看绝对误差。相对误差在 (10^{-7}) 附近基本可以认为实现正确；如果只有 (10^{-4})，大概率有某个细节写错了，比如忘记除以 batch size，或者激活函数导数写成了另一个函数的导数。这个检查成本不高，却能省下大量调试时间。
4.5 一个容易漏掉的规则：多路径汇聚时梯度相加
细心的人会注意到，这个例子里的两个隐藏神经元都连接到同一个输入 (x)，但 (x) 是数据而不是可学习变量，所以没有真的去算 (dL/dx)。如果 (x) 也是一个需要更新的变量，它上面的梯度应该是两个隐藏层分支贡献相加：
[ \frac{dL}{dx} = \delta_1 \times w_{11} + \delta_2 \times w_{21} ]
这不是因为反向传播有两种版本，而是因为求导时 (x) 出现在两条不同的加法链路上。只要计算图里有两条路径同时经过一个变量，反向传播就必须把两条路径传过来的梯度加起来。这个规则在矩阵实现里会自动满足，不怎么需要人工干预，但是手算推公式时最容易漏掉，所以单独拿出来强调一遍。
5. 矩阵化实现与维度自检：从单样本到批量训练
5.1 每列一个样本的约定
实际训练不可能一个样本一个样本地更新参数，那样太慢，所以要把一批样本打包成矩阵同时算。这里约定：输入矩阵 (X) 的形状是 ((n_0, m))，每一列是一个样本，(m) 是 batch size。第 (l) 层的权重 (W^{(l)}) 形状是 ((n_l, n_{l-1}))，偏置 (b^{(l)}) 形状是 ((n_l, 1))。
前向公式写成：
[ Z^{(l)} = W^{(l)} A^{(l-1)} + b^{(l)} ]
[ A^{(l)} = \sigma(Z^{(l)}) ]
之所以强调每列一个样本，是因为矩阵乘法的形状推导完全依赖这个约定。如果换成了每行一个样本的约定，很多转置位置都得反过来。本身没有对错，但整套推导必须保持一致，否则就是事故现场。
5.2 反向公式与伪代码
批量反向传播的四个核心公式是：
[ dZ^{(l)} = dA^{(l)} \odot \sigma'(Z^{(l)}) ]
[ dW^{(l)} = \frac{1}{m} dZ^{(l)} (A^{(l-1)})^T ]
[ db^{(l)} = \frac{1}{m} \sum_{\text{axis}=1} dZ^{(l)} ]
[ dA^{(l-1)} = (W^{(l)})^T dZ^{(l)} ]
伪代码可以写成这样：
# 缓存里保存每一层的 W、b、Z、A dout = dLoss(A_last, Y) # 形状 (n_last, m) for l in reversed(range(1, L)): dZ = dout * activation_prime(Z[l]) # 逐元素相乘 dW = dZ @ A[l-1].T / m # 得到 (n_l, n_{l-1}) db = dZ.sum(axis=1, keepdims=True) / m dout = W[l].T @ dZ # 得到 (n_{l-1}, m)，传给更上一层这里 (\odot) 表示逐元素相乘，因为激活函数对每个神经元独立作用，所以反传时误差信号直接逐元素乘上局部导数即可。(dW) 中的 (1/m) 来自批量梯度的平均，这是很多初写者最容易漏掉的项。漏掉后梯度会放大 (m) 倍，训练直接发散，而且非常具有迷惑性。
5.3 用形状自检推断公式
矩阵反传公式容易记混，我最常用的办法不是背公式，而是看形状。假如一时忘记 (dA^{(l-1)}) 到底是 ((W^{(l)})^T dZ^{(l)}) 还是 (dZ^{(l)} (W^{(l)})^T)，那就先列出已知形状：(W^{(l)}) 是 ((n_l, n_{l-1}))，(dZ^{(l)}) 是 ((n_l, m))。想要的 (dA^{(l-1)}) 形状应该和 (A^{(l-1)}) 一致，也就是 ((n_{l-1}, m))。
((W^{(l)})^T dZ^{(l)}) 的形状是 ((n_{l-1}, n_l) \times (n_l, m) = (n_{l-1}, m))，完全吻合。反过来 (dZ^{(l)} (W^{(l)})^T) 的形状是 ((n_l, m) \times (n_{l-1}, n_l))，除非 (m = n_{l-1})，否则根本对不上。这种维度自检法能挡住绝大多数低级的转置错误。我每次写完反向传播，都会在关键变量旁边写上预期形状，算之前先对一遍。
5.4 缓存管理：反向传播的内存代价
反向传播必须复用前向的中间值，所以训练时的内存占用比单纯推理要高不少。在深网络里，每一层激活都要存下来，显存很容易被撑爆。如果遇到这种问题，常见思路是牺牲一部分时间换空间：只缓存少量关键层，反向传播需要用某一层激活时重新执行前向计算。这本质上是动态规划里的状态取舍——是保存还是重算，取决于内存稀缺程度和重算成本。
我的建议是：第一版手写训练代码务必先把正确性做出来，缓存怎么简单怎么来，全部缓存即可。等跑通之后再考虑用“检查点优化”这类方案省显存。一开始就做复杂缓存优化，只会让代码里的 bug 更难找。
6. 那些让反向传播“不好用”的边界情况与经验补救
6.1 sigmoid 饱和和梯度杀死
sigmoid 的导数是 (\sigma(x)(1-\sigma(x)))，当输入很大或很小时，导数趋近于 0。如果中间隐藏层使用了 sigmoid，并且初始化参数让加权输入落到饱和区，反向传播往上游传的就是一个接近 0 的数，后面所有参数梯度都会被“抹平”。这不是数学算错，而是链式相乘的自然结果。
经验上，不要在深层隐藏层里频繁使用 sigmoid 或 tanh，更多用整流类激活函数。如果一定要用，要对输入做归一化或严格控制初始化范围，尽量让加权输入落在导数较大的区域。这属于“算出来的梯度本身是 0，上游参数彻底失去更新信号”，和动态规划的效率无关，但实际训练中它比公式错误更常见。
6.2 输出层 softmax 加交叉熵的梯度化简
很多人在输出层使用 softmax 加交叉熵损失时，喜欢从定义出发做矩阵求导，结果写出一长串包含 softmax 雅可比矩阵的公式。其实如果损失是交叉熵且标签是 one-hot 向量，最终可以化简成一句很简单的话：
[ \frac{dL}{dZ} = A - Y ]
其中 (A) 是 softmax 输出的概率向量，(Y) 是真实标签的 one-hot 向量。也就是说，输出层误差信号直接就是“预测概率向量减真实标签向量”。这个公式背后是大量求导项相互抵消的结果，中间过程又长又容易写错，所以老手基本都会直接用化简后的形式。
不过要注意：这个式子只在标准分类配合 one-hot 标签时成立。如果标签做了平滑，或者输出层后面还接了别的操作，需要重新推导一遍。把它背下来能省时间，但要知道它的适用边界。
6.3 梯度消失与爆炸：链式乘积的本质
深层网络的梯度是一串局部导数的乘积。如果多个局部导数的绝对值都小于 1，乘积会连续缩小；反过来大于 1，乘积会指数膨胀。结果就是浅层参数要么几乎不更新，要么更新完直接溢出。这类问题本质上不是反向传播算错，而是链式结构的固有属性。
常见的缓解思路有：把激活函数换成整流类，减少导数饱和；初始化时按每层输入和输出神经元数量控制方差，避免一开始就把乘积带到极端值；构造残差路径，让梯度可以短距离穿越；对极端大梯度做裁剪。这些方法不是银弹，但它们是实际训练中最常用的组合拳。
注意：梯度消失和梯度爆炸并不代表反向传播是错误的，而是说明数值范围在跨层传递时出了问题。调试时要先分清“梯度算错”和“梯度不太好用”的区别，否则很容易白折腾。
6.4 调试顺序：先证反传正确，再谈调参
很多同学遇到损失不降就急着改模型结构、调整学习率，这是顺序反了。正确的做法是先证明梯度本身是对的。最实用的手段是梯度检查：对部分参数用中心差分算数值梯度，和反向传播算出的解析梯度对比。如果两者相对误差超过 (10^{-2})，大概率是实现有 bug；如果误差小于 (10^{-7})，基本可以放心继续调参。
这个检查的成本并不高，写几行代码就能跑。我自己的习惯是把它固化在开发流程里：每写一层新网络结构都先跑一次梯度检查，确认无误再开始训练。如果把“优化”和“实现”混在一起排查，出问题时会多花费几倍时间。建议刚开始手写训练代码的同学，先用一个玩具网络验证梯度，再逐渐放大模型和数据规模。
最后再分享一个我常用的习惯：每次调试反向传播，我都会在纸上把最后一个输出层的 (dL/dZ) 写出来，然后顺着权重矩阵的转置一路推回输入，全程只做形状检查，不看具体数值。形状对不上，一定是公式记错；形状对了，再用梯度检查看数值。这两层过滤能挡住绝大多数可以实现中的低级错误，也是我这么多年写训练代码最依赖的排障路径。
