---
tags: [AI, 深度学习, 反向传播, 自动微分]
阶段: 04-深度学习核心
难度: ★★★
created: 2026-10-18
related: "[[神经网络与前向传播]], [[微积分与梯度]], [[损失函数]], [[PyTorch实战入门]]"
---

# 反向传播详解

## 定义

**反向传播**（backpropagation）是在由可微运算构成的计算图上，从标量损失出发、按与数据流相反的方向逐节点应用链式法则，累积损失对每个参数的偏导数的算法。

逐项定义其中符号：

- $L$：标量损失。
- $\bar{v}=\partial L/\partial v$：损失对节点 $v$ 的偏导，称为该节点的梯度或伴随（adjoint）；$\bar{v}$ 与 $v$ 同形状。
- $\partial v/\partial u$：运算节点 $v=f(u)$ 的局部雅可比，形状为 $\dim(v)\times\dim(u)$。
- $\mathbf{x}\in\mathbb{R}^{d}$：单个样本的输入向量；$d$ 为输入维数。
- $\mathbf{y}\in\mathbb{R}^{K}$：one-hot 标签向量；$\mathbf{p}\in\mathbb{R}^{K}$：softmax 输出，即预测概率。
- $m$：隐藏层宽度；$K$：类别数。
- $\mathbf{W}_1\in\mathbb{R}^{m\times d}$，$\mathbf{b}_1\in\mathbb{R}^{m}$，$\mathbf{W}_2\in\mathbb{R}^{K\times m}$，$\mathbf{b}_2\in\mathbb{R}^{K}$：两层网络参数。
- $\mathbf{z}_1,\mathbf{z}_2$：激活前值；$\mathbf{h}=\mathrm{ReLU}(\mathbf{z}_1)$：隐藏层激活值。
- $\boldsymbol{\delta}_l=\partial L/\partial\mathbf{z}_l$：第 $l$ 层激活前值的梯度。
- $B$：批大小；加粗大写字母表示按样本堆叠的批矩阵。
- $\mathbf{1}_B\in\mathbb{R}^{B}$：全 1 向量；$\mathbf{1}[\cdot]$：指示函数，条件成立取 1，否则取 0。
- $\odot$：逐元素乘积，要求两侧同形。
- 符号约定：两层网络的具体参数用下标（$\mathbf{W}_1$）表示，任意深度的第 $l$ 层用上标（$\mathbf{W}^{(l)}$）表示。

术语：

- 计算图（computational graph）：以变量与运算为节点、以数据依赖为有向边的有向无环图。
- 自动微分（automatic differentiation）：由程序中的基本运算及其局部导数机械地组合出导数的技术，区别于符号微分与数值差分。
- 前向模式（forward mode）与反向模式（reverse mode）：沿图正向传播雅可比—向量积、或反向传播向量—雅可比积的两种遍历方式。
- 向量—雅可比积（VJP，vector-Jacobian product）：给定行向量 $\mathbf{u}^{\top}$，计算 $\mathbf{u}^{\top}\mathbf{J}$，无需显式构造 $\mathbf{J}$。
- 梯度检验（gradient check）：用数值差分独立估计梯度，与解析梯度比较以定位实现错误。

## 为什么重要

- 参数规模决定可行性。现代网络参数从 $10^{6}$ 到 $10^{12}$。中心差分的每次梯度估计需要 $2P$ 次前向计算，$P=10^{6}$ 时即 $2\times10^{6}$ 次前向，训练不可行。反向传播用一次前向加一次反向得到全部梯度，代价约为前向的三倍，且不随 $P$ 增长。
- 没有它，网络只能依靠无梯度方法或有限差分训练，深度带来的表达能力无法转化为可用模型。
- 它是所有深度学习框架的核心抽象：PyTorch 的 `autograd`、TensorFlow 的 `GradientTape`、JAX 的 `grad` 实现同一算法。只有理解反向传播，才能解释梯度消失与爆炸、梯度裁剪、参数共享层的梯度累积，以及自定义算子为何必须保存中间量。
- 在全书中的位置：前置为 [[神经网络与前向传播]]（本篇消费其缓存）与 [[微积分与梯度]]（链式法则）；后续为 [[损失函数]]（本篇以交叉熵为例）、[[优化器与学习率]]（消费本篇产出的梯度）、[[卷积神经网络CNN]] 与 [[循环神经网络RNN]]（参数共享与时间展开下的梯度累积）。
- 对应能力目标：懂原理对应「两层网络全手推」；能复现对应「NumPy 反向与 PyTorch autograd 数值一致」；会评估对应「用梯度检验定位实现错误、识别消失与爆炸」。

## 原理与推导

### 1. 计算图与局部梯度

把前向传播写成基本运算的复合，就得到计算图。图 $G=(V,E)$ 中每个节点是一个变量或一次基本运算，边 $(u,v)$ 表示 $v$ 的计算直接使用 $u$。每个运算节点只需记录两件事：前向输出，以及输出对各输入的局部偏导。

反向传播按拓扑逆序处理节点。设节点 $v$ 已收到上游梯度 $\bar{v}$，对它的每个输入 $u$ 执行

$$\bar{u}\ \leftarrow\ \bar{u}+\bar{v}\cdot\frac{\partial v}{\partial u}$$

箭头表示累加赋值而非覆盖：若 $u$ 被多个下游节点使用，各条路径的贡献必须相加，见第 2 小节。矩阵形式下局部雅可比左乘上游梯度，即向量—雅可比积（VJP）。

六个基本节点的规则：

| 节点 | 前向 | 反向 |
|---|---|---|
| 加法 $\mathbf{V}=\mathbf{U}_1+\mathbf{U}_2$ | $\mathbf{V}$ | $\bar{\mathbf{U}}_1\leftarrow\bar{\mathbf{U}}_1+\bar{\mathbf{V}}$，$\bar{\mathbf{U}}_2$ 同 |
| 乘法 $\mathbf{V}=\mathbf{U}_1\odot\mathbf{U}_2$ | $\mathbf{V}$ | $\bar{\mathbf{U}}_1\leftarrow\bar{\mathbf{U}}_1+\bar{\mathbf{V}}\odot\mathbf{U}_2$，$\bar{\mathbf{U}}_2$ 同 |
| 矩阵乘 $\mathbf{V}=\mathbf{U}_1\mathbf{U}_2$ | $\mathbf{V}$ | $\bar{\mathbf{U}}_1\leftarrow\bar{\mathbf{U}}_1+\bar{\mathbf{V}}\mathbf{U}_2^{\top}$，$\bar{\mathbf{U}}_2\leftarrow\bar{\mathbf{U}}_2+\mathbf{U}_1^{\top}\bar{\mathbf{V}}$ |
| 广播加 $\mathbf{V}=\mathbf{U}+\mathbf{b}$ | 沿批维复制 | $\bar{\mathbf{U}}\leftarrow\bar{\mathbf{U}}+\bar{\mathbf{V}}$，$\bar{\mathbf{b}}\leftarrow\bar{\mathbf{b}}+\sum_{\text{批维}}\bar{\mathbf{V}}$ |
| ReLU $\mathbf{V}=\max(\mathbf{U},0)$ | 负半轴置零 | $\bar{\mathbf{U}}\leftarrow\bar{\mathbf{U}}+\bar{\mathbf{V}}\odot\mathbf{1}[\mathbf{U}>0]$ |
| 最大值 $\mathbf{V}=\max_i\mathbf{U}_i$ | 取最大元素 | $\bar{\mathbf{U}}_i\leftarrow\bar{\mathbf{U}}_i+\bar{\mathbf{V}}\cdot\mathbf{1}[i=\arg\max]$ |

矩阵乘规则可由逐元素链式法则推出。记 $V_{ik}=\sum_j U^{(1)}_{ij}U^{(2)}_{jk}$，则 $\partial V_{ik}/\partial U^{(1)}_{ij}=U^{(2)}_{jk}$，对输出下标 $k$ 求和并用上游梯度加权：

$$\bar{U}^{(1)}_{ij}=\sum_k\bar{V}_{ik}U^{(2)}_{jk}=\big(\bar{\mathbf{V}}\mathbf{U}_2^{\top}\big)_{ij}$$

第二条同理得到 $\bar{\mathbf{U}}_2=\mathbf{U}_1^{\top}\bar{\mathbf{V}}$。两条规则中出现的转置不是约定，而是求和指标位置的直接结果：$\bar{\mathbf{V}}$ 的行指标对应 $\mathbf{V}$ 的行指标，必须与 $\mathbf{U}_2$ 的行指标（即 $j$）收缩。

广播规则的反向是求和：前向把 $\mathbf{b}$ 复制 $B$ 份，反向必须把这 $B$ 份的梯度加回一个 $\mathbf{b}$。若忘记求和，$\bar{\mathbf{b}}$ 的形状与 $\mathbf{b}$ 不符；若用覆盖而非累加，只有最后一份样本的贡献被保留。

### 2. 从标量链式法则到多元链式法则

一元情形：$y=f(u)$，$u=g(x)$，则

$$\frac{dy}{dx}=f'(g(x))\,g'(x)$$

多元情形：设 $y=f(u_1,\dots,u_n)$，各 $u_i=g_i(x_1,\dots,x_m)$。固定其余变量，对 $x_j$ 求偏导，所有经由不同 $u_i$ 的路径各贡献一项：

$$\frac{\partial y}{\partial x_j}=\sum_{i=1}^{n}\frac{\partial y}{\partial u_i}\frac{\partial u_i}{\partial x_j}$$

写成矩阵形式。记 $\partial\mathbf{u}/\partial\mathbf{x}\in\mathbb{R}^{n\times m}$ 为雅可比矩阵，其 $(i,j)$ 元为 $\partial u_i/\partial x_j$，则

$$\frac{\partial y}{\partial\mathbf{x}}=\Big(\frac{\partial\mathbf{u}}{\partial\mathbf{x}}\Big)^{\top}\frac{\partial y}{\partial\mathbf{u}}$$

即雅可比的转置左乘上游梯度，这正是第 1 小节 VJP 的一般形式。

变量被多次使用的情形。若同一变量沿多条路径影响输出，总导数等于各路径贡献之和，不能只取其中一条。最小例子：

$$y=x\cdot x$$

把两个因子视为不同变量 $u_1=x$、$u_2=x$，则

$$\frac{dy}{dx}=\frac{\partial y}{\partial u_1}\frac{\partial u_1}{\partial x}+\frac{\partial y}{\partial u_2}\frac{\partial u_2}{\partial x}=x\cdot1+x\cdot1=2x$$

只保留一条路径会得到 $x$，与正确答案相差因子 2。反向传播中累加赋值的实现方式就是该求和的机械化：梯度在节点处累加，而不是覆盖。这一点直接解释了 [[循环神经网络RNN]] 中同一权重矩阵在多个时间步复用时的梯度形式。

路径数爆炸与动态规划。展开后的路径数可能随图规模指数增长。反向传播不枚举路径，而是按拓扑逆序为每个节点只计算一次 $\bar{v}$，把后续路径的贡献在节点处合并；总计算量为 $O(\lvert V\rvert+\lvert E\rvert)$，与路径数无关。

### 3. 反向模式自动微分的复杂度

设 $\mathbf{f}:\mathbb{R}^{n}\to\mathbb{R}^{m}$ 由计算图表示，雅可比 $\mathbf{J}\in\mathbb{R}^{m\times n}$，计算 $\mathbf{f}$ 一次前向的代价记为 $c_f$。

- 前向模式：给定种子向量 $\mathbf{v}\in\mathbb{R}^{n}$，一次正向遍历同时算出 $\mathbf{J}\mathbf{v}\in\mathbb{R}^{m}$，代价 $O(c_f)$。要得到完整 $\mathbf{J}$，需对 $n$ 个基向量各做一次，总代价 $O(n\,c_f)$。
- 反向模式：给定种子向量 $\mathbf{u}\in\mathbb{R}^{m}$，一次反向遍历算出 $\mathbf{u}^{\top}\mathbf{J}\in\mathbb{R}^{n}$，代价 $O(c_f)$。要得到完整 $\mathbf{J}$，需 $m$ 次，总代价 $O(m\,c_f)$。

深度学习的情形是 $m=1$：损失是标量。因此反向模式只需一次遍历就得到对全部 $n=P$ 个参数的梯度，代价为前向的常数倍，实践中约为 2 倍。该结论与参数数量无关，是反向传播可行的根本原因。

| 方法 | 得到全部梯度的代价 | 精度 | 额外内存 |
|---|---|---|---|
| 数值差分（中心） | $2P$ 次前向 | $O(\epsilon^{2})$ 截断误差 | $O(1)$ |
| 前向模式 | $P$ 次前向 | 机器精度 | $O(1)$ |
| 反向模式 | $1$ 次反向遍历，约 $2c_f$；另需 $1$ 次前向 | 机器精度 | $O(\lvert V\rvert)$ |

反向模式的代价是内存：为计算局部梯度，必须保存前向的中间激活，内存随层数与批大小线性增长。激活检查点（activation checkpointing）以重算换内存：只保存若干段的输入，反向时重算段内前向，内存降至 $O(\sqrt{L})$，计算量增加约三分之一。

数值差分不仅代价高，精度也受限于 $\epsilon$ 的选择：$\epsilon$ 过大时截断误差主导，过小时两个相近浮点数相减产生抵消误差。它只用于检验，不用于训练。

### 4. 两层网络的手推

问题设定：单样本 $\mathbf{x}\in\mathbb{R}^{d}$，one-hot 标签 $\mathbf{y}\in\mathbb{R}^{K}$，隐藏宽度 $m$。

前向：

$$\mathbf{z}_1=\mathbf{W}_1\mathbf{x}+\mathbf{b}_1,\qquad \mathbf{h}=\mathrm{ReLU}(\mathbf{z}_1)=\max(\mathbf{z}_1,\mathbf{0})$$

$$\mathbf{z}_2=\mathbf{W}_2\mathbf{h}+\mathbf{b}_2,\qquad \mathbf{p}=\mathrm{softmax}(\mathbf{z}_2),\qquad L=-\sum_{k=1}^{K}y_k\log p_k$$

记 $\boldsymbol{\delta}_2=\partial L/\partial\mathbf{z}_2$。

步骤 1：$\partial L/\partial\mathbf{z}_2=\mathbf{p}-\mathbf{y}$。推导见第 5 小节，此处先使用结论。$\boldsymbol{\delta}_2\in\mathbb{R}^{K}$。

步骤 2：$\partial L/\partial\mathbf{W}_2$。由 $\mathbf{z}_2=\mathbf{W}_2\mathbf{h}+\mathbf{b}_2$ 得 $\partial z_{2,k}/\partial W_{2,kj}=h_j$，当 $i\ne k$ 时 $\partial z_{2,i}/\partial W_{2,kj}=0$。故

$$\frac{\partial L}{\partial W_{2,kj}}=\sum_{i=1}^{K}\frac{\partial L}{\partial z_{2,i}}\frac{\partial z_{2,i}}{\partial W_{2,kj}}=\delta_{2,k}h_j$$

矩阵形式：

$$\frac{\partial L}{\partial\mathbf{W}_2}=\boldsymbol{\delta}_2\mathbf{h}^{\top}\in\mathbb{R}^{K\times m}$$

维度：$(K,1)(1,m)\to(K,m)$，与 $\mathbf{W}_2$ 一致。

步骤 3：$\partial L/\partial\mathbf{b}_2=\boldsymbol{\delta}_2$。由 $\partial z_{2,k}/\partial b_{2,j}=\mathbf{1}[k=j]$ 得

$$\frac{\partial L}{\partial b_{2,j}}=\sum_{k=1}^{K}\delta_{2,k}\mathbf{1}[k=j]=\delta_{2,j}$$

步骤 4：$\partial L/\partial\mathbf{h}=\mathbf{W}_2^{\top}\boldsymbol{\delta}_2$。由 $\partial z_{2,k}/\partial h_j=W_{2,kj}$ 得

$$\frac{\partial L}{\partial h_j}=\sum_{k=1}^{K}\delta_{2,k}W_{2,kj}\quad\Longrightarrow\quad\frac{\partial L}{\partial\mathbf{h}}=\mathbf{W}_2^{\top}\boldsymbol{\delta}_2\in\mathbb{R}^{m}$$

$\mathbf{h}$ 只通过 $\mathbf{z}_2$ 影响损失，故该步是单一的 VJP。

步骤 5：$\partial L/\partial\mathbf{z}_1$。$\mathbf{h}=\mathrm{ReLU}(\mathbf{z}_1)$ 是逐元素运算，$\partial h_j/\partial z_{1,j}=\mathbf{1}[z_{1,j}>0]$，跨元素偏导为零。于是

$$\frac{\partial L}{\partial z_{1,j}}=\frac{\partial L}{\partial h_j}\frac{\partial h_j}{\partial z_{1,j}}=\big(\mathbf{W}_2^{\top}\boldsymbol{\delta}_2\big)_j\mathbf{1}[z_{1,j}>0]$$

$$\boldsymbol{\delta}_1=\frac{\partial L}{\partial\mathbf{z}_1}=\big(\mathbf{W}_2^{\top}\boldsymbol{\delta}_2\big)\odot\mathbf{1}[\mathbf{z}_1>\mathbf{0}]\in\mathbb{R}^{m}$$

逐元素乘积不可写成矩阵乘法：掩码与梯度同形，只有对应位置相乘才是该运算雅可比的作用。

步骤 6：$\partial L/\partial\mathbf{W}_1$。与步骤 2 同构，$\partial z_{1,j}/\partial W_{1,ji}=x_i$：

$$\frac{\partial L}{\partial W_{1,ji}}=\delta_{1,j}x_i\quad\Longrightarrow\quad\frac{\partial L}{\partial\mathbf{W}_1}=\boldsymbol{\delta}_1\mathbf{x}^{\top}\in\mathbb{R}^{m\times d}$$

步骤 7：$\partial L/\partial\mathbf{b}_1=\boldsymbol{\delta}_1$。

汇总与维度校验：

| 量 | 形状 | 校验依据 |
|---|---|---|
| $\mathbf{x}$ | $(d)$ | 输入 |
| $\mathbf{W}_1$ | $(m,d)$ | 参数 |
| $\mathbf{z}_1,\mathbf{h},\boldsymbol{\delta}_1$ | $(m)$ | 同形 |
| $\partial L/\partial\mathbf{W}_1=\boldsymbol{\delta}_1\mathbf{x}^{\top}$ | $(m,d)$ | 与 $\mathbf{W}_1$ 同形 |
| $\partial L/\partial\mathbf{b}_1=\boldsymbol{\delta}_1$ | $(m)$ | 与 $\mathbf{b}_1$ 同形 |
| $\mathbf{W}_2$ | $(K,m)$ | 参数 |
| $\mathbf{z}_2,\mathbf{p},\mathbf{y},\boldsymbol{\delta}_2$ | $(K)$ | 同形 |
| $\partial L/\partial\mathbf{W}_2=\boldsymbol{\delta}_2\mathbf{h}^{\top}$ | $(K,m)$ | 与 $\mathbf{W}_2$ 同形 |
| $\partial L/\partial\mathbf{b}_2=\boldsymbol{\delta}_2$ | $(K)$ | 与 $\mathbf{b}_2$ 同形 |

内层维度也自洽：$\mathbf{W}_2^{\top}\boldsymbol{\delta}_2$ 为 $(m,K)(K)\to(m)$，与 $\mathbf{h}$ 同形；$\boldsymbol{\delta}_1\mathbf{x}^{\top}$ 为 $(m)(1,d)\to(m,d)$。任何一处转置写错，形状校验都会失败，除 $m=d$ 或 $m=K$ 的退化情形。

级联到更多层。对第 $l$ 层，若已知 $\boldsymbol{\delta}_l$，则

$$\frac{\partial L}{\partial\mathbf{W}^{(l)}}=\boldsymbol{\delta}_l\big(\mathbf{a}^{(l-1)}\big)^{\top},\qquad \frac{\partial L}{\partial\mathbf{b}^{(l)}}=\boldsymbol{\delta}_l,\qquad \boldsymbol{\delta}_{l-1}=\big(\big(\mathbf{W}^{(l)}\big)^{\top}\boldsymbol{\delta}_l\big)\odot\varphi'\big(\mathbf{z}^{(l-1)}\big)$$

反向传播即从 $\boldsymbol{\delta}_L$ 出发反复应用该式。三层以上的网络不需要新的推导，只是该递推的重复。

### 5. softmax 与交叉熵的组合梯度

设 $\mathbf{z}\in\mathbb{R}^{K}$ 为 logits，$S=\sum_{j=1}^{K}e^{z_j}$，$p_k=e^{z_k}/S$，$L=-\sum_k y_k\log p_k$。

先化简 $\log p_k$：

$$\log p_k=\log e^{z_k}-\log S=z_k-\log S$$

对 $z_m$ 求偏导。第一项 $\partial z_k/\partial z_m=\mathbf{1}[k=m]$。第二项中 $\log S$ 依赖全部 $z_j$，用链式法则：

$$\frac{\partial\log S}{\partial z_m}=\frac{1}{S}\frac{\partial S}{\partial z_m}=\frac{1}{S}e^{z_m}=\frac{e^{z_m}}{S}=p_m$$

因此

$$\frac{\partial\log p_k}{\partial z_m}=\mathbf{1}[k=m]-p_m$$

代入损失：

$$\frac{\partial L}{\partial z_m}=-\sum_{k=1}^{K}y_k\big(\mathbf{1}[k=m]-p_m\big)=-y_m+p_m\sum_{k=1}^{K}y_k$$

对 one-hot 标签或满足 $\sum_k y_k=1$ 的软标签，得

$$\boxed{\frac{\partial L}{\partial\mathbf{z}}=\mathbf{p}-\mathbf{y}}$$

三个性质。

第一，梯度不需要 $K\times K$ 的 softmax 雅可比。softmax 的雅可比为 $\operatorname{diag}(\mathbf{p})-\mathbf{p}\mathbf{p}^{\top}$，显式构造与相乘的代价为 $O(K^{2})$；组合后只需一次减法，代价 $O(K)$。这是框架把 softmax 与交叉熵融合为一个算子的原因。

第二，梯度有界。$\mathbf{p}$ 与 $\mathbf{y}$ 都在概率单纯形内，故 $\lVert\mathbf{p}-\mathbf{y}\rVert_2\le\sqrt{2}$，不存在随 $K$ 增长的放大。

第三，数值稳定。若先算 $\mathbf{p}$ 再取 $\log$，当某个 $p_k$ 下溢为 0 时 $\log 0=-\infty$，损失与梯度变为非数。实现应直接使用 log-softmax：

$$\log p_k=z_k-\max_j z_j-\log\sum_{j=1}^{K}e^{z_j-\max_j z_j}$$

减去最大值不改变结果，因为 softmax 对 logits 的整体平移不变：$p_k(\mathbf{z}+c\mathbf{1})=p_k(\mathbf{z})$。PyTorch 的 `nn.CrossEntropyLoss` 与 `F.cross_entropy` 内部即采用该形式。

### 6. ReLU 的导数与不可导点

$$\mathrm{ReLU}(z)=\max(z,0),\qquad \mathrm{ReLU}'(z)=\begin{cases}1,&z>0\\0,&z<0\\ \text{未定义},&z=0\end{cases}$$

在 $z=0$ 处左导数为 0、右导数为 1，导数不存在。工程上取次梯度 $\mathrm{ReLU}'(0)=0$，PyTorch 的 `torch.relu` 与 `F.relu` 采用该约定。

三点说明：

1. 单个点上导数未定义不影响训练。输入是连续分布时 $z=0$ 是零测集，取任一单侧导数得到的梯度几乎处处与真实梯度一致；反向传播只需保证在可导点正确。
2. 该点不影响前向。前向在 $z=0$ 处有定义且连续，只有反向需要选择约定。
3. 梯度检验需避开折点。中心差分在 $z=0$ 处给出 $(\mathrm{ReLU}(\epsilon)-\mathrm{ReLU}(-\epsilon))/(2\epsilon)=1/2$，与约定的 0 或 1 都不符。若随机初始化使某个 $z$ 恰好接近 0，梯度检验会出现局部大误差。检验时应使用双精度、固定随机种子，并对误差量级而非单个元素作判断。

ReLU 的另一个性质是硬零：$z<0$ 时梯度恒为 0。若某单元的输入长期为负，其梯度恒为零，参数不再更新，该单元永久失效。这是 [[激活函数]] 中讨论死区与带负斜率变体的出发点。

### 7. 参数共享与批处理向量化

参数共享。同一个参数在计算图中出现多次时，累加规则自动给出总梯度：

$$\frac{\partial L}{\partial\theta}=\sum_{u:\ \theta\ \text{参与计算}\ u}\frac{\partial L}{\partial u}\frac{\partial u}{\partial\theta}$$

循环网络是最直接的情形。设 $\mathbf{z}_t=\mathbf{W}_{hh}\mathbf{h}_{t-1}+\mathbf{W}_{xh}\mathbf{x}_t+\mathbf{b}$，$\mathbf{h}_t=\varphi(\mathbf{z}_t)$，则 $\mathbf{W}_{hh}$ 在每个时间步被复用，其梯度为各时间步贡献之和：

$$\frac{\partial L}{\partial\mathbf{W}_{hh}}=\sum_{t=1}^{T}\boldsymbol{\delta}_t\mathbf{h}_{t-1}^{\top},\qquad \boldsymbol{\delta}_t=\frac{\partial L}{\partial\mathbf{z}_t}$$

时间步数 $T$ 越大，求和项越多；同时梯度传递包含连乘项 $\prod_{t}\mathbf{W}_{hh}^{\top}\operatorname{diag}(\varphi')$，带来消失与爆炸问题，见第 8 小节与 [[循环神经网络RNN]]、[[LSTM与GRU]]。

卷积网络同理。卷积核在全部空间位置共享，梯度为各位置贡献之和，形式上是输入与上游梯度的互相关，见 [[卷积神经网络CNN]]。实现上无需特殊处理：只要前向真的复用了同一个张量，autograd 的累加就会给出正确结果；错误来自手工实现时用赋值而非累加。

批处理向量化。批大小 $B$ 下，损失取逐样本平均：

$$L=\frac{1}{B}\sum_{i=1}^{B}\ell_i,\qquad \frac{\partial L}{\partial\theta}=\frac{1}{B}\sum_{i=1}^{B}\frac{\partial\ell_i}{\partial\theta}$$

矩阵形式把该求和吸收进矩阵乘法。设 $\mathbf{X}\in\mathbb{R}^{B\times d}$：

$$\mathbf{Z}_1=\mathbf{X}\mathbf{W}_1^{\top}+\mathbf{b}_1,\qquad \mathbf{H}=\mathrm{ReLU}(\mathbf{Z}_1),\qquad \mathbf{Z}_2=\mathbf{H}\mathbf{W}_2^{\top}+\mathbf{b}_2,\qquad \mathbf{P}=\mathrm{softmax}(\mathbf{Z}_2)$$

$$\boldsymbol{\Delta}_2=\frac{\mathbf{P}-\mathbf{Y}}{B}\in\mathbb{R}^{B\times K}$$

$$\frac{\partial L}{\partial\mathbf{W}_2}=\boldsymbol{\Delta}_2^{\top}\mathbf{H}\in\mathbb{R}^{K\times m},\qquad \frac{\partial L}{\partial\mathbf{b}_2}=\boldsymbol{\Delta}_2^{\top}\mathbf{1}_B\in\mathbb{R}^{K}$$

$$\boldsymbol{\Delta}_1=\big(\boldsymbol{\Delta}_2\mathbf{W}_2\big)\odot\mathbf{1}[\mathbf{Z}_1>\mathbf{0}]\in\mathbb{R}^{B\times m}$$

$$\frac{\partial L}{\partial\mathbf{W}_1}=\boldsymbol{\Delta}_1^{\top}\mathbf{X}\in\mathbb{R}^{m\times d},\qquad \frac{\partial L}{\partial\mathbf{b}_1}=\boldsymbol{\Delta}_1^{\top}\mathbf{1}_B\in\mathbb{R}^{m}$$

维度校验：$\boldsymbol{\Delta}_2^{\top}\mathbf{H}$ 为 $(K,B)(B,m)\to(K,m)$，与 $\mathbf{W}_2$ 同形；$\boldsymbol{\Delta}_2\mathbf{W}_2$ 为 $(B,K)(K,m)\to(B,m)$，与 $\mathbf{Z}_1$ 同形；$\boldsymbol{\Delta}_1^{\top}\mathbf{X}$ 为 $(m,B)(B,d)\to(m,d)$，与 $\mathbf{W}_1$ 同形。偏置梯度是沿批维求和，与第 1 小节的广播规则一致。

除以 $B$ 的位置只有一处：$\boldsymbol{\Delta}_2$ 的定义中。若损失用求和而非平均，则不应除 $B$；两者相差常数因子，效果等价于把学习率乘以 $B$。混用（损失平均而梯度未除）会使有效学习率随批大小线性变化，是最常见的实现错误之一。

向量化的收益是计算密度：同样的乘加次数，矩阵乘法比逐样本循环快一到两个数量级，因为内存访问与并行度都更好。数值上二者等价，仅在浮点求和顺序上有 $10^{-16}$ 量级的差异。

### 8. 梯度消失与爆炸的矩阵乘积解释

对 $L$ 层前馈网络，$\mathbf{a}^{(l)}=\varphi(\mathbf{z}^{(l)})$，$\mathbf{z}^{(l)}=\mathbf{W}^{(l)}\mathbf{a}^{(l-1)}+\mathbf{b}^{(l)}$。反复应用第 4 小节的级联式：

$$\frac{\partial L}{\partial\mathbf{a}^{(0)}}=\big(\mathbf{W}^{(1)}\big)^{\top}\mathbf{D}^{(1)}\big(\mathbf{W}^{(2)}\big)^{\top}\mathbf{D}^{(2)}\cdots\big(\mathbf{W}^{(L)}\big)^{\top}\mathbf{D}^{(L)}\frac{\partial L}{\partial\mathbf{a}^{(L)}}$$

其中 $\mathbf{D}^{(l)}=\operatorname{diag}\big(\varphi'(\mathbf{z}^{(l)})\big)$。

取谱范数，由 $\lVert\mathbf{A}\mathbf{B}\rVert_2\le\lVert\mathbf{A}\rVert_2\lVert\mathbf{B}\rVert_2$：

$$\Big\lVert\frac{\partial L}{\partial\mathbf{a}^{(0)}}\Big\rVert_2\le\Big(\prod_{l=1}^{L}\big\lVert\mathbf{W}^{(l)}\big\rVert_2\Big)\Big(\prod_{l=1}^{L}\big\lVert\mathbf{D}^{(l)}\big\rVert_2\Big)\Big\lVert\frac{\partial L}{\partial\mathbf{a}^{(L)}}\Big\rVert_2$$

且 $\lVert\mathbf{D}^{(l)}\rVert_2=\max_j\lvert\varphi'(z_j^{(l)})\rvert$。对 ReLU 该值不超过 1，对 sigmoid 不超过 $1/4$，对 tanh 不超过 1。

由此得到两条结论：

1. 若每层的 $\lVert\mathbf{W}^{(l)}\rVert_2\max\lvert\varphi'\rvert<1$，梯度上界随 $L$ 指数衰减。以 sigmoid 为例，即使 $\lVert\mathbf{W}\rVert_2=1$，每层因子也不超过 $1/4$，$L=10$ 时上界为 $4^{-10}\approx9.5\times10^{-7}$，$L=20$ 时为 $4^{-20}\approx9.1\times10^{-13}$。
2. 若该因子大于 1，梯度上界随 $L$ 指数增长，出现溢出与参数发散。

乘积呈指数是矩阵连乘的一般性质，与激活函数的具体形式无关；激活函数只决定每层因子的大小。Xavier 与 He 初始化的目标正是让每层的前向与反向方差因子等于 1，使乘积的期望量级不随 $L$ 变化，推导见 [[神经网络与前向传播]]。

缓解手段各自作用于乘积中的不同因子：

| 手段 | 作用位置 | 机制 |
|---|---|---|
| He 或 Xavier 初始化 | $\lVert\mathbf{W}^{(l)}\rVert_2$ | 使每层方差因子为 1 |
| 残差连接 | 乘积结构 | 引入恒等路径，连乘变为含恒等项的展开 |
| 归一化层 | 激活尺度 | 固定每层输入尺度，间接限制权重范数 |
| 梯度裁剪 | 更新步长 | 按全局范数缩放，防止单步爆炸 |
| 门控结构 | $\mathbf{D}^{(l)}$ | 遗忘门使连乘项可接近 1 |

残差连接的作用值得单独说明。设 $\mathbf{a}^{(l)}=\mathbf{a}^{(l-1)}+F(\mathbf{a}^{(l-1)})$，则

$$\frac{\partial\mathbf{a}^{(l)}}{\partial\mathbf{a}^{(l-1)}}=\mathbf{I}+\frac{\partial F}{\partial\mathbf{a}^{(l-1)}}$$

连乘变为 $\prod_l(\mathbf{I}+\mathbf{J}_l)$，展开后包含全部阶的项，其中恒等项的乘积不衰减。这是 [[卷积神经网络CNN]] 中深层网络可训练的结构性原因。梯度裁剪的公式与阈值选择见 [[优化器与学习率]]。

### 9. 梯度检验

解析梯度实现错误时，训练仍会进行，只是收敛变慢或停在较差的点。梯度检验用数值差分独立估计梯度并与之比较，是定位反向传播错误的标准手段。

中心差分。对参数 $\theta_i$，取扰动 $\epsilon>0$：

$$\frac{\partial L}{\partial\theta_i}\approx\frac{L(\theta+\epsilon\mathbf{e}_i)-L(\theta-\epsilon\mathbf{e}_i)}{2\epsilon}$$

误差阶由泰勒展开确定。设 $f(\theta)=L(\theta)$ 在 $\theta_i$ 处三阶可导：

$$f(\theta_i+\epsilon)=f+\epsilon f'+\frac{\epsilon^{2}}{2}f''+\frac{\epsilon^{3}}{6}f'''+O(\epsilon^{4})$$

$$f(\theta_i-\epsilon)=f-\epsilon f'+\frac{\epsilon^{2}}{2}f''-\frac{\epsilon^{3}}{6}f'''+O(\epsilon^{4})$$

两式相减，偶数阶项抵消：

$$f(\theta_i+\epsilon)-f(\theta_i-\epsilon)=2\epsilon f'+\frac{\epsilon^{3}}{3}f'''+O(\epsilon^{5})$$

$$\frac{f(\theta_i+\epsilon)-f(\theta_i-\epsilon)}{2\epsilon}=f'+\frac{\epsilon^{2}}{6}f'''+O(\epsilon^{4})$$

截断误差为 $O(\epsilon^{2})$。单侧差分 $(f(\theta+\epsilon)-f(\theta))/\epsilon$ 的误差为 $O(\epsilon)$，精度低一个量级，因此检验用中心差分。

$\epsilon$ 的选取存在权衡：截断误差随 $\epsilon^{2}$ 下降，舍入误差随 $1/\epsilon$ 上升，因为 $f(\theta+\epsilon)$ 与 $f(\theta-\epsilon)$ 的差约为 $2\epsilon f'$，当 $\epsilon$ 过小时该差值落入浮点有效位的噪声中。float64 下 $\epsilon\in[10^{-6},10^{-5}]$ 通常合适；float32 的有效十进制位约 7 位，检验不可靠，应转为双精度。

相对误差。绝对误差随梯度量级变化，不具可比性，因此用

$$\text{rel\_err}=\frac{\lvert g_{\text{analytic}}-g_{\text{numeric}}\rvert}{\max\big(\lvert g_{\text{analytic}}\rvert+\lvert g_{\text{numeric}}\rvert,\ 10^{-8}\big)}$$

分母中的 $10^{-8}$ 防止二者同时接近零时除零。判定阈值：

| 相对误差 | 判定 |
|---|---|
| $<10^{-7}$ | 正确，float64 下的正常水平 |
| $10^{-7}$ 至 $10^{-4}$ | 可疑，检查是否存在折点或精度不足 |
| $>10^{-2}$ | 错误，反向实现有问题 |

大模型的检验。逐参数差分的代价为 $2P$ 次前向，$P$ 很大时不可行。改用方向导数：取随机单位向量 $\mathbf{v}$，

$$\frac{L(\theta+\epsilon\mathbf{v})-L(\theta-\epsilon\mathbf{v})}{2\epsilon}\approx\mathbf{v}^{\top}\mathbf{g}_{\text{analytic}}$$

只需两次前向，与 $P$ 无关。若解析梯度在任一方向有误，随机 $\mathbf{v}$ 以高概率暴露该错误；多取几个 $\mathbf{v}$ 可提高检出率。

检验协议。以下五条缺一不可：

1. 转为双精度。float32 的舍入误差会淹没 $O(\epsilon^{2})$ 的截断误差。
2. 关闭随机性。Dropout 置为推理模式，BatchNorm 使用固定统计量，数据固定，否则两次前向的损失差异来自随机性而非参数扰动。
3. 避开折点。ReLU 在 $z\approx0$ 处不可导，检验前可把激活换为平滑版本，例如 softplus，或确认没有 $z$ 落在 $\pm\epsilon$ 内。
4. 逐个参数张量检验，先看相对误差最大的元素，再看整体分布；单个大误差通常指向某处转置或掩码错误。
5. 检验与训练使用同一份损失定义，包括是否除以 $B$。若检验用平均损失而训练用求和，梯度相差 $B$ 倍，相对误差接近 1。

## 关键直觉

> [!tip] 机制性直觉
> 反向传播是在计算图上按拓扑逆序做一次梯度累积：每个节点把收到的上游梯度左乘自己的局部雅可比，再累加给它的输入。因为损失是标量，反向模式只需一次遍历即可得到对全部参数的梯度，代价与参数个数无关，只与图的规模成正比。与定义的关系是：定义中的 $\bar{v}=\partial L/\partial v$ 就是这里所说的上游梯度，累加赋值保证同一变量被多次使用时各路径贡献相加。

## 例子与代码

### 手算例：两层网络的完整反向

沿用 [[神经网络与前向传播]] 的手算例：$d=2$，$m=2$，$K=2$，

$$\mathbf{W}_1=\begin{bmatrix}1&2\\-1&0.5\end{bmatrix},\quad \mathbf{b}_1=\begin{bmatrix}1\\1\end{bmatrix},\quad \mathbf{W}_2=\begin{bmatrix}1&-1\\0.5&2\end{bmatrix},\quad \mathbf{b}_2=\begin{bmatrix}0\\1\end{bmatrix},\quad \mathbf{x}=\begin{bmatrix}1\\2\end{bmatrix}$$

标签 $\mathbf{y}=[0,1]^{\top}$，即正确类别为第 2 类。

前向结果：$\mathbf{z}_1=[6,1]^{\top}$，$\mathbf{h}=[6,1]^{\top}$（ReLU 未截断），$\mathbf{z}_2=[5,6]^{\top}$，$\mathbf{p}=[0.2689,0.7311]^{\top}$，$L=-\log0.7311=0.3133$。

反向：

$$\boldsymbol{\delta}_2=\mathbf{p}-\mathbf{y}=\begin{bmatrix}0.2689\\-0.2689\end{bmatrix}$$

$$\frac{\partial L}{\partial\mathbf{W}_2}=\boldsymbol{\delta}_2\mathbf{h}^{\top}=\begin{bmatrix}0.2689\\-0.2689\end{bmatrix}\begin{bmatrix}6&1\end{bmatrix}=\begin{bmatrix}1.6136&0.2689\\-1.6136&-0.2689\end{bmatrix}$$

$$\frac{\partial L}{\partial\mathbf{b}_2}=\boldsymbol{\delta}_2=\begin{bmatrix}0.2689\\-0.2689\end{bmatrix}$$

$$\frac{\partial L}{\partial\mathbf{h}}=\mathbf{W}_2^{\top}\boldsymbol{\delta}_2=\begin{bmatrix}1&0.5\\-1&2\end{bmatrix}\begin{bmatrix}0.2689\\-0.2689\end{bmatrix}=\begin{bmatrix}0.2689-0.1345\\-0.2689-0.5379\end{bmatrix}=\begin{bmatrix}0.1345\\-0.8068\end{bmatrix}$$

$\mathbf{z}_1=[6,1]^{\top}$ 两个分量都大于零，掩码为 $[1,1]^{\top}$，故

$$\boldsymbol{\delta}_1=\begin{bmatrix}0.1345\\-0.8068\end{bmatrix}$$

$$\frac{\partial L}{\partial\mathbf{W}_1}=\boldsymbol{\delta}_1\mathbf{x}^{\top}=\begin{bmatrix}0.1345\\-0.8068\end{bmatrix}\begin{bmatrix}1&2\end{bmatrix}=\begin{bmatrix}0.1345&0.2689\\-0.8068&-1.6136\end{bmatrix},\qquad \frac{\partial L}{\partial\mathbf{b}_1}=\boldsymbol{\delta}_1$$

核对一处符号：$\partial L/\partial W_{1,21}=-0.8068<0$。$W_{1,21}$ 是 $\mathbf{z}_1$ 第二个分量对第一个输入特征的系数，其正值会增大 $z_{1,2}$，进而增大 $z_{2,2}$ 与 $p_2$，降低损失；因此沿负梯度方向增大该权重可降低损失，符号一致。

$\mathbf{W}_2$ 的两行梯度符号相反：第 1 行全正，第 2 行全负。原因是 $p_1$ 偏大需要减小 $z_{2,1}$，而 $p_2$ 偏小需要增大 $z_{2,2}$，两个 logit 的调整方向相反。

### NumPy 手写前向与反向

运行环境：Python 3.10 以上，NumPy 1.24 以上。

```python
import numpy as np

rng = np.random.default_rng(42)
D, M, K, B = 4, 8, 3, 16          # 输入维、隐藏维、类别数、批大小

X = rng.normal(size=(B, D))                                  # (B, D)
Y = np.eye(K)[rng.integers(0, K, size=B)]                    # one-hot 标签 (B, K)

params = {
    "W1": rng.normal(0.0, np.sqrt(2.0 / D), size=(M, D)),    # He 正态
    "b1": np.zeros(M),
    "W2": rng.normal(0.0, np.sqrt(2.0 / M), size=(K, M)),
    "b2": np.zeros(K),
}

def softmax(z):
    z = z - z.max(axis=1, keepdims=True)      # 数值稳定：减去行最大值
    e = np.exp(z)
    return e / e.sum(axis=1, keepdims=True)

def forward(X, p):
    # 返回概率与反向所需缓存
    Z1 = X @ p["W1"].T + p["b1"]              # (B, M)
    A1 = np.maximum(Z1, 0.0)                  # ReLU
    Z2 = A1 @ p["W2"].T + p["b2"]             # (B, K)
    P = softmax(Z2)                           # (B, K)
    return P, (X, Z1, A1, P)

def loss_fn(P, Y, eps=1e-12):
    # 批平均交叉熵；eps 防止 log 0
    return -np.mean(np.sum(Y * np.log(P + eps), axis=1))

def backward(P, Y, cache, p):
    X, Z1, A1, _ = cache
    B = X.shape[0]
    dZ2 = (P - Y) / B                         # (B, K) 归一化在此处
    dW2 = dZ2.T @ A1                          # (K, M)
    db2 = dZ2.sum(axis=0)                     # (K,)
    dA1 = dZ2 @ p["W2"]                       # (B, M)
    dZ1 = dA1 * (Z1 > 0)                      # (B, M) 乘掩码，不是矩阵乘
    dW1 = dZ1.T @ X                           # (M, D)
    db1 = dZ1.sum(axis=0)                     # (M,)
    return {"W1": dW1, "b1": db1, "W2": dW2, "b2": db2}

P, cache = forward(X, params)
grads = backward(P, Y, cache, params)
print(f"初始损失: {loss_fn(P, Y):.6f}")      # 1.222377
for k, v in grads.items():
    print(k, v.shape, np.round(v.ravel()[:3], 6))
```

预期输出：

```text
初始损失: 1.222377
W1 (8, 4) [ 0.014214  0.005998 -0.010447]
b1 (8,) [-0.00784   0.108639  0.071145]
W2 (3, 8) [-0.080005 -0.027665 -0.024068]
b2 (3,) [-0.173042 -0.021353  0.194395]
```

关键行说明：

- `dZ2 = (P - Y) / B`：组合梯度 $\mathbf{p}-\mathbf{y}$ 与批平均的 $1/B$ 在此一次完成。若损失改为求和，此处的 `/ B` 必须去掉，否则梯度整体缩小 $B$ 倍。
- `dW2 = dZ2.T @ A1`：对应 $\boldsymbol{\Delta}_2^{\top}\mathbf{H}$。写成 `dZ2 @ A1.T` 时，内层维度为 $K$ 与 $m$，在 $K\ne m$ 时直接报形状错误，在 $K=m$ 时得到 $(B,B)$ 并与参数形状不符；两种情形都无法通过形状检查。
- `dA1 = dZ2 @ p["W2"]`：对应 $\boldsymbol{\Delta}_2\mathbf{W}_2$，不需要转置，因为 $\mathbf{W}_2$ 的形状是 $(K,M)$，右乘后由 $(B,K)$ 变为 $(B,M)$。
- `dZ1 = dA1 * (Z1 > 0)`：布尔掩码参与逐元素乘法，Python 自动把 `True` 与 `False` 转为 1 与 0。此处若写成 `dA1 @ (Z1 > 0)` 则是矩阵乘法，形状与语义都错。
- `db2 = dZ2.sum(axis=0)`：偏置在批维上广播，反向必须对批维求和，否则形状为 $(B,K)$。

### 梯度检验

```python
def numeric_grad(f, p, name, eps=1e-5):
    # 中心差分逐元素估计梯度
    g = np.zeros_like(p[name])
    for idx in np.ndindex(p[name].shape):
        orig = p[name][idx]
        p[name][idx] = orig + eps
        f_plus = f()
        p[name][idx] = orig - eps
        f_minus = f()
        p[name][idx] = orig                 # 复原，避免污染后续计算
        g[idx] = (f_plus - f_minus) / (2.0 * eps)
    return g

def rel_err(a, b):
    # 相对误差：分母加 1e-8 防止除零
    return np.max(np.abs(a - b) / np.maximum(1e-8, np.abs(a) + np.abs(b)))

closure = lambda: loss_fn(forward(X, params)[0], Y)

for name in ["W1", "b1", "W2", "b2"]:
    num = numeric_grad(closure, params, name)
    print(f"{name}: 相对误差 {rel_err(num, grads[name]):.3e}")
```

预期输出：

```text
W1: 相对误差 1.126e-09
b1: 相对误差 6.023e-10
W2: 相对误差 2.747e-09
b2: 相对误差 1.305e-10
```

四个相对误差均在 $3\times10^{-9}$ 以下，远低于 $10^{-7}$ 阈值，说明反向实现正确。

### 与 PyTorch autograd 对照

运行环境：PyTorch 2.0 以上。

```python
import torch

Xt = torch.from_numpy(X)                    # float64，与 NumPy 一致
Yt = torch.from_numpy(Y)

# 每个参数张量都是叶子节点，requires_grad 打开后反向时累积梯度
pt = {k: torch.tensor(v, requires_grad=True) for k, v in params.items()}

Z1 = Xt @ pt["W1"].T + pt["b1"]             # 前向必须用张量运算，不能转回 NumPy
A1 = torch.relu(Z1)
Z2 = A1 @ pt["W2"].T + pt["b2"]
logP = torch.log_softmax(Z2, dim=1)         # 直接算 log 概率，避免先 softmax 再 log
loss = -(Yt * logP).sum(dim=1).mean()       # 与 NumPy 的批平均交叉熵相同
loss.backward()                             # 反向：填充各叶子节点的 .grad

print(f"损失: {loss.item():.6f}")           # 1.222377
for name in params:
    err = np.abs(pt[name].grad.numpy() - grads[name]).max()
    print(f"{name}: 最大绝对误差 {err:.3e}")
```

预期结果：损失打印为 `1.222377`；四个参数梯度的最大绝对误差均在 $10^{-16}$ 至 $10^{-17}$ 量级，即双精度舍入极限，相对误差约 $10^{-16}$，远小于 $10^{-6}$ 的验收阈值。若把 `dZ2` 中的 `/ B` 漏掉，此处误差会跳到 $10^{-1}$ 量级。

需要说明的三点：

1. `pt` 中的张量是叶子节点。只有叶子节点的 `.grad` 会被填充；中间结果 `Z1`、`A1` 的梯度默认不保留，除非显式调用 `retain_grad()`。
2. `loss.backward()` 累积而非覆盖梯度。循环训练中每次反向之前必须调用 `optimizer.zero_grad()` 或手动置零，否则梯度跨步累加。
3. 前向必须使用张量运算。若中途把张量转成 NumPy 再转回，计算图断开，`loss.backward()` 会报错或给出零梯度。

### 完整训练循环

```python
def make_blobs(n_per_class=64, seed=0):
    # 三个高斯簇构成的三分类数据，中心分别为 e1、-e1、e2
    r = np.random.default_rng(seed)
    centers = np.array([[2.0, 0.0, 0.0, 0.0],
                        [-2.0, 0.0, 0.0, 0.0],
                        [0.0, 2.0, 0.0, 0.0]])
    Xs, ys = [], []
    for k, c in enumerate(centers):
        Xs.append(c + 0.6 * r.normal(size=(n_per_class, 4)))
        ys.append(np.full(n_per_class, k))
    Xa = np.concatenate(Xs)
    ya = np.concatenate(ys)
    order = r.permutation(len(ya))
    return Xa[order], np.eye(3)[ya[order]]

Xtr, Ytr = make_blobs()

p = {
    "W1": rng.normal(0.0, np.sqrt(2.0 / 4), size=(8, 4)),
    "b1": np.zeros(8),
    "W2": rng.normal(0.0, np.sqrt(2.0 / 8), size=(3, 8)),
    "b2": np.zeros(3),
}

lr = 0.5
for epoch in range(201):
    Pt, cache_t = forward(Xtr, p)           # 前向：概率与缓存
    loss_t = loss_fn(Pt, Ytr)               # 损失：批平均交叉熵
    g = backward(Pt, Ytr, cache_t, p)       # 反向：与手推逐项对应
    for k in p:                             # 朴素 SGD：沿负梯度方向更新
        p[k] -= lr * g[k]
    if epoch % 20 == 0:
        acc = (Pt.argmax(axis=1) == Ytr.argmax(axis=1)).mean()
        print(f"epoch {epoch:3d}  loss {loss_t:.4f}  acc {acc:.3f}")
```

预期输出：

```text
epoch   0  loss 2.5597  acc 0.260
epoch  20  loss 0.0792  acc 0.984
epoch  40  loss 0.0408  acc 0.995
epoch  60  loss 0.0281  acc 1.000
epoch  80  loss 0.0219  acc 1.000
epoch 100  loss 0.0184  acc 1.000
epoch 120  loss 0.0159  acc 1.000
epoch 140  loss 0.0141  acc 1.000
epoch 160  loss 0.0126  acc 1.000
epoch 180  loss 0.0114  acc 1.000
epoch 200  loss 0.0105  acc 1.000
```

三点说明：

- 初始损失 2.5597 高于 $\log3\approx1.0986$，因为初始 $\mathbf{W}_2$ 的标准差为 $\sqrt{2/8}=0.5$，使 logits 量级偏大、初始预测过度自信。这是初始化尺度影响初始损失的直接体现，机制见 [[神经网络与前向传播]]。
- 损失单调下降且准确率在 60 步达到 1.000，说明梯度方向正确。若把 `dZ2` 的转置写错，形状检查会失败；若把 `/ B` 漏掉，等效学习率为 1.0，曲线形状改变但方向仍正确。
- 该循环使用全批量梯度下降，未打乱数据。批大小为 192，每步一次前向一次反向，与第 3 小节的代价分析一致。

### 计算图

```mermaid
flowchart LR
    X["x"] --> Z1["z1 = W1 x + b1"]
    W1["W1"] --> Z1
    b1["b1"] --> Z1
    Z1 --> H["h = ReLU z1"]
    H --> Z2["z2 = W2 h + b2"]
    W2["W2"] --> Z2
    b2["b2"] --> Z2
    Z2 --> PP["p = softmax z2"]
    PP --> LL["L = -sum y log p"]
    y["y"] --> LL
    LL -.->|dz2| Z2
    Z2 -.->|dW2| W2
    Z2 -.->|db2| b2
    Z2 -.->|dh| H
    H -.->|dz1| Z1
    Z1 -.->|dW1| W1
    Z1 -.->|db1| b1
```

实线为前向，虚线为反向。反向每条边携带的量即第 4 小节各步骤的结果：$\mathrm{dz}_2=\mathbf{p}-\mathbf{y}$，$\mathrm{dW}_2=\boldsymbol{\delta}_2\mathbf{h}^{\top}$，$\mathrm{dh}=\mathbf{W}_2^{\top}\boldsymbol{\delta}_2$，$\mathrm{dz}_1=\mathrm{dh}\odot\mathbf{1}[\mathbf{z}_1>0]$，$\mathrm{dW}_1=\boldsymbol{\delta}_1\mathbf{x}^{\top}$。节点出度为 1 时梯度只被复制，出度大于 1 时梯度被累加，这就是第 2 小节求和规则的图形化表述。

## 易错点

> [!warning] 常见错误
> - 忘记除以批大小。损失用均值而反向写成 `P - Y`，梯度整体放大 $B$ 倍，效果等价于学习率乘以 $B$；批大小改变时训练行为随之改变，单步更新可能直接发散。
> - 转置错误。单样本下 $\partial L/\partial\mathbf{W}_2=\boldsymbol{\delta}_2\mathbf{h}^{\top}$，批量下为 $\boldsymbol{\Delta}_2^{\top}\mathbf{H}$；后者写成 $\boldsymbol{\Delta}_2\mathbf{H}^{\top}$ 时，内层维度为 $K$ 与 $m$，$K\ne m$ 直接报错，$K=m$ 得到 $(B,B)$，只有 $B=K=m$ 时才与参数形状相同而静默算错。
> - 原地操作破坏计算图。反向需要前向保存的张量，若在反向之前用 `+=`、`relu_`、切片赋值修改了这些张量，PyTorch 会报「one of the variables needed for gradient computation has been modified by an inplace operation」。需要修改时用 `.clone()` 或非原地版本。
> - softmax 与 log 的数值不稳定。先 `softmax` 再 `log`，在概率下溢为 0 时得到 $-\infty$；应先减去最大值或直接使用 `log_softmax`。在 `CrossEntropyLoss` 之前再加 `softmax` 会重复归一化，梯度被额外压缩。
> - 掩码用错变量。ReLU 的反向应由激活前值 $\mathbf{Z}_1$ 判断 $\mathbf{Z}_1>0$，而不是激活后 $\mathbf{H}>0$；对纯 ReLU 两者等价，但对带负斜率的变体不等价。另需确认掩码参与逐元素乘法而非矩阵乘法。
> - 梯度检验时未固定随机性或跨过折点。Dropout 未关闭时两次前向的损失差来自随机性，相对误差随机波动；参数恰好落在折点附近时中心差分给出 0.5 而解析约定为 0，产生局部大误差，容易被误判为实现错误。

## 关联笔记

- 前置：[[神经网络与前向传播]] —— 本篇的每个反向公式都以该篇的前向定义、缓存内容与形状约定为输入。
- 前置：[[微积分与梯度]] —— 链式法则与雅可比矩阵是反向传播的唯一数学工具，多元链式法则的求和形式直接对应梯度累加。
- 后续：[[损失函数]] —— 本篇以交叉熵为例完成 softmax 组合梯度，其他损失的梯度结构由该篇统一处理。
- 后续：[[优化器与学习率]] —— 优化器消费本篇产出的梯度，动量与自适应学习率都建立在梯度估计之上。
- 对照：[[PyTorch实战入门]] —— 框架把本篇的手工步骤封装为 `backward()`，对照可检查自定义算子是否满足 autograd 的要求。

## 达标检测

- [ ] 写出两层网络四个参数梯度的矩阵形式，标注每一步的形状，并说明 $\mathbf{W}_2^{\top}\boldsymbol{\delta}_2$ 中的转置为何不能省略。
- [ ] 从 $\log p_k=z_k-\log S$ 出发完整推导 $\partial L/\partial\mathbf{z}=\mathbf{p}-\mathbf{y}$，指出 $\sum_k y_k=1$ 在何处被使用。
- [ ] 解释反向模式为何对标量损失只需一次遍历，并给出它与前向模式在得到完整雅可比时的代价比 $m:n$。
- [ ] 在 $L=10$ 的 sigmoid 网络上估算梯度上界的衰减量级，并说明 Xavier 初始化改变了乘积中的哪个因子。
- [ ] 运行 NumPy 反向代码，故意去掉 `dZ2` 中的 `/ B`，用梯度检验的相对误差说明该错误为何能被检出，并预测误差的近似倍数。
- [ ] 用中心差分公式推导 $O(\epsilon^{2})$ 的截断误差阶，并说明 $\epsilon$ 过大与过小分别由哪种误差主导。
- [ ] 指出「先 softmax 再 log 再交叉熵」的实现在何种输入下产生非数，并写出等价的稳定实现。

## 参考来源

- Goodfellow, Bengio, Courville, *Deep Learning*, 2016, 第 6.5 节 —— 对应本篇计算图、反向传播算法、参数共享下的梯度累积与梯度消失的矩阵分析。
- d2l.ai《动手学深度学习》，第 5 章「深度学习计算」中的反向传播与自动求导小节 —— 对应两层网络手推流程与计算图的实现视角。
- Stanford CS231n 课程笔记，Backpropagation, Intuitions —— 对应局部梯度、链式法则的逐节点计算与梯度检验的相对误差判据。
- Matrix Calculus 讲义 —— 对应向量与矩阵求导的维度约定、雅可比形式与 VJP 的矩阵写法。
- PyTorch 官方文档，`torch.autograd`、`torch.autograd.gradcheck` 与 `torch.nn.CrossEntropyLoss` —— 对应自动微分机制、数值梯度检验 API 与 log-softmax 的融合实现。
