很多刚接触深度学习的朋友问过我一个挺扎心的问题：反向传播的代码里，为什么每个参数都要乘一个叫 grad 的东西？这些 grad 到底从哪来，又凭什么按顺序传回去？有人选择硬啃矩阵求导公式，啃到一半就开始怀疑人生。我的建议一向是：换个视角，用计算图（Computation Graph）来看误差反向传播。

计算图这个视角最大的优点是，你不需要盯着整个网络的复杂公式，只要搞懂局部节点怎么传梯度，再沿着图从输出一路走到输入，整个反向传播就自然出来了。这篇文章要做的就是把这件事讲透：先讲清楚计算图本身，再讲反向传播在图上运行的几条核心规则，然后带着你手推一个完整例子，用数值梯度做验证，最后把工程里常见的坑和排查方法一并交给你。适合的人群包括：读深度学习源码读到懵的人、刚入门机器学习想真正理解训练细节的人，以及被自动求导黑盒反复坑过的人。

另一个马上能感受到的好处是：一旦你把反向传播理解为“图上的局部规则 + 链式法则”，你会发现自己居然能徒手推任意网络结构的梯度了，不需要背公式，也不需要把某个现成实现当黑盒。尤其是你想给自定义算子写反向函数的时候，计算图视角几乎是唯一不会出错的思考方式。

1. 为什么用计算图看反向传播：把黑盒变成白盒

1.1 计算图到底是一张什么图：节点、边与中间变量

计算图本质上是一张有向无环图。每个节点是一个运算，比如加法、乘法、sigmoid；每条边是一个中间张量或中间值，表示数据流动的方向。节点和边组合起来，就能描述任意复杂的函数关系。

举个例子，一个最简单的损失函数 L = (xw + b - t)^2。这个式子在我们脑子里是一长串代换，但在计算图里就是一条清晰的管道。你可以给每个中间步骤起个名字，比如 z = xw + b，h = z - t，L = h^2。每个中间变量都在图上有自己固定的位置，上下游关系一目了然。

这里要特别强调一点：计算图不只是画给别人看的示意图，它是现代深度学习框架内核的数据结构。我们平时说“构建网络”，本质上就是在组织一张计算图；说“自动求导”，其实是框架在反向遍历这张图。所以学计算图不是学一个比喻，而是直接去理解框架底层的真实运作方式。你看待模型的方式就会从“一坨变量和函数”变成“一张有结构的图”，这种思维转换在排查问题时非常值钱。

1.2 前向传播与反向传播：同一张图上的两条路径

计算图上有两条方向相反的路径。前向传播从输入流向输出：每个节点根据输入计算输出，最终得到预测值和损失。反向传播则从损失这个根节点往回走：每个节点根据上游传来的梯度，算出自己对这个梯度的贡献，继续往输入方向传。

为什么反向传播的全名要叫“误差反向传播法”？关键就在于反向路径上传送的不是原始数据，而是损失函数对各个中间变量的偏导数，也就是误差的梯度。每个中间节点收到上游传来的一个“误差贡献”，经过局部处理再分发给前一层，这个过程不断重复，误差的信号就一路传回了参数所在的节点。

我习惯把前向反向想象成一个收发快递的过程：前向是包裹从发货地一级一级运到目的地，反向是每个站点根据后一个站点发来的“损伤报告”，推断自己这一单该在哪个环节负多大责任。这样想的话，每个节点的任务非常单一，它不需要知道整个网络的全局信息，只需要关心自己怎么把上游梯度换算成下游梯度。

1.3 图比公式好用在哪里：局部求导与梯度复用

用数学公式当然也能算出梯度，但公式会随着网络变深而变得极其难维护。计算图的优雅之处在于，它把复合函数求导拆成了一堆局部动作的组合：每个节点只负责自己的局部导数，全局传导交给图结构自动完成。

一个很典型的场景是共享子表达式。假设某个中间变量 t 同时被两个下游分支使用，比如网络里多个头部共享同一个特征层。在公式里你需要把 t 对两个分支的贡献分别算出来再相加，这种写法非常容易漏项；但在计算图上，这个行为就是一次“分支汇合”，规则很明确：梯度合并相加。图结构直接告诉你哪里需要求和，哪里需要连乘，不需要你凭记忆去补路径。

所以你会发现，能用计算图画清楚的结构，反向传播就一定能一步步推出来；反过来，凡是图画不清楚的地方，比如变量被覆盖、原地操作、参数被 detach，自动求导往往就会出问题。这种一一对应的关系，正是拿计算图当调试工具的底气所在。

2. 反向传播的三条微观规则：梯度怎么在计算图上流动

2.1 规则一：梯度沿边相乘，链式法则的图化表达

计算图上任意一条边 a → z 表示 z 是 a 的函数。反向传播时，从上游传来一个梯度 g_z = ∂L/∂z，那么传给 a 的梯度就是 g_a = g_z × ∂z/∂a。

这就是链式法则的局部形式。我们不需要一次性求“整个网络对 a 的导数”，只需要沿着边一步一步推，每一步只需要做一次乘法和一次局部导数计算。好处是每步运算非常简单，不容易错，也符合人类处理复杂问题时的分治思路。

实操里常见的错误是，想一次性算出最终梯度，于是写了一个很长的复合函数表达式，结果中间某一项求导算错，整个梯度全错。而沿边相乘不会漏项，因为图结构会替你把所有路径都照顾到，只要每一步的局部导数正确，最终结果几乎必然正确。

2.2 规则二：节点局部求导，把梯度分发给每个输入

对于多输入的节点，比如 z = f(x, y)，反向传播时它收到上游梯度 g_z，需要做两件事：

• 计算 f 对 x 的偏导 ∂z/∂x，输出 g_x = g_z × ∂z/∂x；
• 计算 f 对 y 的偏导 ∂z/∂y，输出 g_y = g_z × ∂z/∂y。

节点不需要关心上游是谁，只需要知道自己的本地运算和上游传来的梯度。这也是为什么现代自动求导框架里的每个算子都会带一个 backward 函数，里面写的就是这个局部导数的实现。你自定义一个算子时，本质上就是在定义它的局部导数怎么算。

最初学的时候最容易犯的错，是把“多输入节点的梯度分发”和“分支合并”混在一起。区分方法很简单：多输入是同一个节点内部对不同输入求偏导，而分支合并是同一个变量被多个下游节点引用时，各路梯度要在变量上汇合。前者相当于一个站点同时派几辆车去不同目的地，后者相当于几条路运回来的货物都堆到同一个仓库。

2.3 规则三：分支汇合点梯度相加，等价于求偏导累加

当一个变量被多个下游计算使用时，反向传播到这个变量时，各分支传来的梯度必须相加。这个规则可以从全微分的角度理解：损失 L 对变量 v 的全部影响，等于它在所有使用 v 的路径上的影响之和。图上表现出来，就是多条入射的反向边在同一个变量节点汇合，先把梯度累积起来，再继续往更上游传播。

梯度相加带来的最常见结果，就是共享参数的梯度等于所有使用位置的梯度总和。比如同一个卷积核在输入的不同位置上被重复使用，反向传播时这个核的梯度就是所有位置回传梯度的累加。很多人在自己写神经网络时发现的“梯度怎么有两份”的困惑，其实不是梯度错了，而是没有做分支求和。

另一个容易忽略的细节是，如果有向图中出现了可学习的参数被多处引用，而且你在手动实现时忘了把梯度加起来，训练几乎一定会出问题。所以见到计算图中某个变量引出了多条边，第一反应就应该是：反向时这里要相加。

2.4 常用节点反向规则速查：把节点当成“门”来记

把常见计算节点看成“门”，记忆起来会非常轻松。每种门的前向计算和反向规则都是一一对应的，我把它们整理成一张速查表：

这些门的局部导数不需要死记硬背，但强烈建议在写自定义算子之前把表过一遍。我见过的大部分自定义算子反向出错，最后定位到的原因都非常朴素：局部导数写错了，或者忘了把两个分支的梯度相加。先把这张表刻进脑子里，再去写 backward 函数，会省掉很多调 bug 的时间。

3. 手写一次完整反向传播：从节点算式到梯度验证

3.1 一个最简模型的设计：线性层、sigmoid 与平方损失

我拿一个足够简单又能体现完整推导过程的模拟项目 X 来走一遍。输入是一个标量 x，参数是 w 和 b，中间经过线性变换 z = x*w + b，然后接入 sigmoid 得到预测值 h，最后和真实标签 t 做平方误差 L = (h - t)²。

这个模型相当于一个最迷你的神经网络，但它已经包含了反向传播会遇到的大部分元素：线性层、非线性激活函数、损失函数。把它的计算图完整画出来，只有一排紧凑的节点，非常适合做手推演示。

具体数值我取 x = 0.5，w = 1.2，b = -0.3，t = 0.8。下面所有数字我都会用手算的近似值，建议你拿一张纸跟着算一遍。自己写过一遍每一步的关系之后，再看深度学习框架里那一堆封装函数，会感觉它们没有魔法，就是这套规则的程序化表达。

3.2 前向传播算一算：每一步中间值都要留好

前向路径上依次出现这几个中间量，我把每一步算出来放在这：

• z = x * w + b = 0.5 * 1.2 + (-0.3) = 0.6 - 0.3 = 0.3
• h = σ(0.3) ≈ 0.5744
• L = (0.5744 - 0.8)² ≈ 0.0509

前向传播的过程中，这些中间量都会被缓存下来，因为反向传播马上就要用到它们。真实的深度学习框架也是这样设计的：前向过程中保存的激活值，就是反向传播的“燃料”。这也是训练时显存占用会随着网络深度线性增长的原因之一，参数本身只占小头，各层的中间激活值才是大头。

这里可以顺便记住一个职业习惯：写前向函数的时候，提前想好哪些中间量需要在反向计算里用到。如果你发现某个中间量后面根本不需要，就不要在内存里保留它。类似贝尔曼动态规划里的“只保留当前最必要状态”，这套思维方式在大型模型训练时能实实在在帮你省下不少显存。

3.3 反向传播推一推：从损失一路回传到参数

现在从损失 L 开始，沿着反向路径逐步推到每个参数。

第一步，先求损失对 h 的梯度：

∂L/∂h = 2 * (h - t) = 2 * (0.5744 - 0.8) ≈ -0.4511

第二步，求 sigmoid 节点的局部导数，并把梯度传过 sigmoid：

∂h/∂z = h * (1 - h) ≈ 0.5744 * 0.4256 ≈ 0.2445

∂L/∂z = ∂L/∂h * ∂h/∂z ≈ -0.4511 * 0.2445 ≈ -0.1103

第三步，z = x*w + b 这个节点有两个注意点：它对 w、x、b 的局部导数各不相同，分别是 x、w、1。逐个计算：

∂z/∂w = x = 0.5

∂z/∂x = w = 1.2

∂z/∂b = 1

最后把上面的梯度组合起来：

∂L/∂w = -0.1103 * 0.5 ≈ -0.0551

∂L/∂x = -0.1103 * 1.2 ≈ -0.1324

∂L/∂b = -0.1103 * 1 ≈ -0.1103

这些数字本身看起来不大，但正好告诉我们调参方向：w 增大一点会让损失下降（因为梯度为负），b 同理。整个推导过程中，我们并没有求解任何复杂的复合函数，只是沿着图做了三次乘法和几次局部求导。

这里还有一个很容易被忽略但非常实用的细节：反向传播计算损失对中间变量的梯度，依赖的是前向缓存下来的 z 和 h，而不是再次前向计算。所以一次训练迭代的经济学结构就是“一次前向 + 一次反向”，这也是反向传播能比朴素数值微分高效这么多年的根本原因。

3.4 用数值梯度验证推导：中心差分与计算图求导的对照

手工推导容易担心算错，最稳妥的验证办法是数值梯度：用中心差分估计导数，再和解析梯度做对比。

中心差分的公式很简单：f'(x) ≈ (f(x+ε) - f(x-ε)) / (2ε)。让 x 左右轻微抖动，看输出变化了多少，这个变化率就是导数的一阶近似。ε 一般取 1e-5，太大则差分近似误差明显，太小则浮点精度不足。

下面这段 Python 代码可以直接运行，把解析梯度和数值梯度对比出来：

import numpy as np def forward(x, w, b, t): z = x * w + b h = 1.0 / (1.0 + np.exp(-z)) return (h - t) ** 2 def analytic_grad(x, w, b, t): z = x * w + b h = 1.0 / (1.0 + np.exp(-z)) dL_dh = 2.0 * (h - t) dh_dz = h * (1.0 - h) dL_dz = dL_dh * dh_dz return {"x": dL_dz * w, "w": dL_dz * x, "b": dL_dz * 1.0} def numeric_grad(name, x, w, b, t, eps=1e-5): base = {"x": x, "w": w, "b": b} plus = dict(base) minus = dict(base) plus[name] += eps minus[name] -= eps plus_loss = forward(plus["x"], plus["w"], plus["b"], t) minus_loss = forward(minus["x"], minus["w"], minus["b"], t) return (plus_loss - minus_loss) / (2 * eps) x, w, b, t = 0.5, 1.2, -0.3, 0.8 for name in ["x", "w", "b"]: ag = analytic_grad(x, w, b, t)[name] ng = numeric_grad(name, x, w, b, t) rel_err = abs(ag - ng) / (abs(ag) + abs(ng) + 1e-12) print(f"{name}: analytic={ag:.6f}, numeric={ng:.6f}, rel_err={rel_err:.2e}")

运行结果里，解析梯度和数值梯度的相对误差通常能到 1e-9 到 1e-7 这个量级，基本可以确认推导正确。

数值梯度有一个天然的应用边界：计算速度慢，每个参数都需要额外做两次前向传播，所以它只适合小规模验证。实际训练时我们依赖的永远是解析梯度，也就是自动微分算出来的结果，数值梯度只是当“单元测试”来用。比如你写了一个自定义算子，不确定反向逻辑对不对，最直接的办法就是用数值梯度去验它。

顺带说一个自动微分的核心结论：深度学习框架采用的正是反向模式自动微分，运行一次反向传播的代价通常是前向传播的 2 倍左右，而且无论需要计算多少个参数的梯度，都只需要这一次反向遍历。这是计算图视角最直观的工程红利。

4. 工程实战：反向传播调试与常见坑位排查

4.1 显存去哪儿了：中间激活缓存与内存优化思路

很多人一开始以为训练模型占用的显存主要是参数本身，但参数在总占用里只占一小部分，真正的大头是前向传播缓存的中间激活值。每个节点的输出几乎都要存下来，供反向传播计算局部导数时使用，网络越深，这个开销越大。

理解计算图之后，常见的省显存手段看起来就非常自然。重计算（激活检查点）的思路是：前向时故意丢弃一部分中间值，反向需要的时候再重新算一遍，用时间换显存。算子融合的思路是把多个相邻节点合并成一个节点，减少中间结果的保存数量。结构设计上的思路则是有意识地减少图上的分支和共享，避免不必要的中间张量。

我在实际训练里遇到过几次显存不够，其中最有效的短期解法往往不是调小 batch size，而是找到计算图里那些根本没参与下游计算的中间量并释放掉。计算图的价值在于，它逼着你正视每个中间张量的生命周期，而不是把所有张量都留在内存里。

4.2 梯度检查的正确姿势：epsilon、相对误差与随机性处理

梯度检查是自定义算子开发里最常用的定位手段，但很多人做过之后得到“不一致”的结论，其实是检查方法出了问题。

epsilon 的取值是关键。太大会让差分近似误差变大，太小又会触发浮点精度问题，1e-5 附近比较稳。比较标准一定要用相对误差，(解析梯度 - 数值梯度) 的绝对值除以 (解析梯度绝对值 + 数值梯度绝对值)，小于 1e-7 基本就可以认为正确。

另一个高频坑是随机性。如果网络里有 dropout、随机数据增强这类每次前向结果都不同的操作，做梯度检查时必须把它们关掉或者固定随机种子，否则两次前向的随机状态不一致，数值梯度计算出来就是错的。batch normalization 这种在训练和推理时行为不同的层，也要保证在做梯度检查时处于同一种模式。

我自己的检查习惯是：先把整体梯度检查跑一遍，确认没有明显问题；再单独对新增的自定义算子做一次专项检查，只随机抽几个有代表性的参数位置，而不是全参数检查。这样既快又能精准定位问题，不至于在几百个参数里大海捞针。

4.3 数值不稳定和梯度异常的定位思路

训练中出现 NaN 或者 loss 怎么都不降，大概率是某些节点在数值上出了问题。常见场景包括：log 节点对 0 或负数求对数，比如交叉熵里预测概率被 clip 到极小数后取对数，梯度会变得异常大甚至直接反推成 NaN；除法节点遇到接近零的除数，梯度瞬间膨胀好几个数量级；softmax 和交叉熵分开实现，导致大数在 exp 阶段溢出。这类问题的标准解法是把容易炸的复合节点合并成一个实现，比如用 log-softmax 等价形式替代分开的 softmax 加交叉熵。

梯度爆炸则是多层网络里的经典问题：梯度沿边连乘，如果某些局部导数大于 1，梯度过几层就会指数级膨胀。常见对策是梯度裁剪、残差连接、合理的参数初始化。从计算图视角看，这些策略本质是在管理连乘路径上的数值范围。

排查这类问题时，我的固定流程是从输出端往回看：先确认 loss 是不是 NaN，再看最后一层梯度是否异常，然后逐层向前找，第一次出现 NaN 或巨值的地方，十有八九就是问题源头。这个思路比东试一下西试一下高效得多。

4.4 反向传播调试速查表：症状、原因与排查顺序

把平时调试中最常用的检查项整理成一张速查表，可以直接当模板用：

这些坑大部分我在自己的训练过程里都踩过，有的甚至是一个小小的原地操作，让整个训练静默失败到完全看不出问题。所以我的习惯是：每次代码改动后，先小规模跑一次梯度检查，再上正式训练。检查的成本很低，但能拦住大部分灾难性的 bug。

5. 计算图视角的进阶：从算法到框架内核

5.1 动态图与静态图：两种构图哲学和它们的取舍

理解计算图之后，你去看主流深度学习框架的设计，会有一种豁然开朗的感觉。动态图是边执行边构图，你写 Python 循环、if 分支都能直接反映到计算图上，调试非常友好；静态图则是先把完整图构建好，再交给编译器统一执行，图优化空间更大。

动态图的代价是每次迭代都要重新构图，有一定的调度开销；静态图的代价是调试不直观，写起来像在描述抽象语法树。现代框架普遍采用“动态图优先，必要时再编译成静态图”的策略，本质就是对这两种构图哲学的取长补短。

这件事对你个人也有实际意义：它能解释为什么有些代码能用 Python 的 if 语句，有些部署场景却要求把模型导出成固定结构。前者背后是动态图，后者背后本质上是把计算图固定下来做静态优化。理解了这层差异，你就不会被框架间的表现差异搞晕。

5.2 算子融合与图优化：框架内核如何在计算图上加速

你写的每一个自定义模块，在框架内部都会被拆解成更小的算子，最终形成一张细粒度的计算图。框架的图优化器会在这张图上做不少事情。

算子融合会把相邻的乘加运算合并成单一算子，减少内核启动次数和中间张量写回显存的开销。死代码消除会删掉没有下游引用的节点，根本不执行。内存复用则通过分析图中各个张量的生命周期，让不同节点的中间张量共享同一块显存，节省训练过程中的峰值占用。

这些优化的共同前提，都是框架能够从计算图结构里获取足够的信息。当你习惯了用计算图思考模型时，就不只是在理解算法，也在理解框架背后的工程体系。很多看起来神秘的性能优化，放到图视角下都变得非常直白。

5.3 前向模式与反向模式：为什么训练一定要用反向自动微分

自动微分有前向模式和反向模式两种。前向模式从输入向输出传播导数，适合输入少、输出多的情况；反向模式从输出向输入回传，适合输出少、输入多的情况。神经网络训练正好是典型的输出单点、参数海量的场景，反向模式一次前向加一次反向就能拿到所有参数梯度，所以深度学习框架几乎无一例外选择实现反向自动微分。

这也是为什么说“反向传播法”不仅仅是一种教学技法，它本身就是自动微分在神经网络训练中的最优工程形态。计算图视角让你直观地看到，图上多传播一次梯度的成本，远低于把损失函数对每个参数分别跑一次前向。这种数量级上的差距，决定了深度学习能否被真正大规模训练起来。

我个人每次接触一个新的网络结构，都不会先找现成实现，而是先在纸上把计算图画出来，标出每个参数的输入输出，再亲手推一遍梯度，最后用数值梯度验证。这个过程看起来慢，实际非常高效。因为当你把图和局部规则刻进脑子之后，再复杂的网络也只是基础节点的拼接。希望这篇文章能把计算图这个工具真正交到你手上，让误差反向传播从一门玄学，变成一道你随时能拆解的算术题。