反向传播算法非常简单。

为了计算某个标量$z$对图中它的一个祖先$\mathbf{x}$的梯度，我们首先观察到对$z$的梯度由$\frac{\partial z}{\partial z}=1$给出。我们然后可以计算对图中$z$的操作的$\text{Jacobi}$矩阵。我们继续乘以$\text{Jacobi}$矩阵，以这种方式向后穿过图，直到我们到达$\mathbf{x}$。对于从$z$触发可以经过两个或更多路径向后行进而到达的任意节点，我们简单的对该节点来自不同路径上的梯度进行求和。

更正式地，图$\mathcal{G}$中的每个节点对应着一个变量。为了实现最大的一般化，我们将这个变量描述为一个张量$\mathbf{V}$。张量通常可以具有任意维度，并且包含标量、向量和矩阵。

我们假设每个变量$\mathbf{V}$与下列子程序相关联：

• get_operation($\mathbf{V}$)：
  • 它返回用于计算$\mathbf{V}$的操作，代表了在计算图中流入$\mathbf{V}$的边。
  • 例如，可能有一个Python或者C++的类表示矩阵乘法操作，以及get_operation函数。
  • 假设我们的一个变量是由矩阵乘法产生的，$C=AB$。
  • 那么，get_operation($\mathbf{V}$)返回一个指向相应C++类的实力的指针。
• get_consumers($\mathbf{V},\mathcal{G}$)：
  • 它返回一组变量，是计算图$\mathcal{G}$中$\mathbf{V}$的孩子节点。
• get_inputs($\mathbf{V},\mathcal{G}$)：
  • 它返回一组变量，是计算图$\mathcal{G}$中$\mathbf{V}$的父节点。

重要：每个操作op也与bprop操作相关联。该bprop操作可以计算如公式：${\nabla }_{\mathbf{X}}z=\sum _j({\nabla }_{\mathbf{X}}{\mathbf{Y}}_j)\frac{\partial z}{\partial {\mathbf{Y}}_j}$描述的$\text{Jacobi}$向量积。这是反向传播算法能够实现很大通用性的原因。

每个操作负责了解如何通过它参与的图中的边来反向传播。例如，我们可以使用矩阵乘法操作来产生变量$C=AB$。

• 假设标量$z$关于$C$的梯度是$G$。
• 矩阵乘法操作负责定义两个反向传播规则，每个规则对应于一个输入变量。
• 如果我们调用bprop方法来请求$A$ 的梯度，在给定输出的梯度为$G$的情况下，那么矩阵乘法操作的bprop方法必须说明对$A$的梯度是$G{B}^{\top }$。
• 类似的，如果我们调用bprop方法来请求$B$的梯度，那么矩阵操作负责实现bprop方法并指定期望的梯度是$A^{\top }G$。
• 反向传播算法本身并不需知道任何微分法则。它只需要使用正确的参数调用每个操作的bprop 方法即可。正式地， op.bprop(inputs,$\mathbf{X},G$)必须返回：$\sum _i({\nabla }_{\mathbf{X}}\text{op}.f(\text{inputs}{)}_i)G_i$
• 这只是如公式：${\nabla }_{\mathbf{X}}z=\sum _j({\nabla }_{\mathbf{X}}{\mathbf{Y}}_j)\frac{\partial z}{\partial {\mathbf{Y}}_j}$所表达的链式法则的实现。
  • 说明：
    • inputs是提供给操作的一组输入
    • op.f是操作实现的数学函数
    • $\mathbf{X}$是输入，我们想要计算关于它的梯度
    • $G$是操作对输出的梯度
• op.bprop方法应该总是假装它的所有输入彼此不同，即使它们不是。
  • 例如，如果mul操作传递两个$x$来计算$x^2$，op.bprop方法应该仍然返回$x$作为对于两个输入的导数。
  • 反向传播算法后面会将这些变量加起来获得$2x$，这是$x$上总的正确导数。

反向传播算法的软件实现通常提供操作和其bprop 两种方法，所以深度学习软件库的用户能够对使用诸如矩阵乘法、指数运算、对数运算等等常用操作构建的图进行反向传播。构建反向传播新实现的软件工程师或者需要向现有库添加自己的操作的高级用户通常必须手动为新操作推导op.bprop方法。

反向传播算法的正式描述参见算法5

算法5

反向传播算法最外围的骨架。这部分做简单的设置和清理工作。大多数重要的工作在发生在算法6的子程序build_grad中。

伪代码：
$\mathbf{Require}$: $\mathbb{T}$, 计算梯度的变量的目标集
$\mathbf{Require}$: $\mathbb{G}$, 计算图
$\mathbf{Require}$: $z$, 要求导的变量
\quad Let ${\mathcal{G}}^{\prime }$ be $\mathcal{G}$ pruned to contain only nodes that are ancestors of $z$ and descendents of nodes in $\mathbb{T}$.
\quad Initialize grad_table, a data structure associating tensors to their gradients
\quad grad_table[$z$] $\leftarrow$ 1
\quad $\mathbf{for}$ $\mathbf{V}$ in $\mathbb{T}$ $\mathbf{do}$
\quad\quad build_grad($\mathbf{V}$, $\mathcal{G}$, ${\mathcal{G}}^{\prime }$, grad_table)
\quad $\mathbf{end}$ $\mathbf{for}$
\quad Return grad_table restricted to $\mathbb{T}$

算法6

反向传播算法的内循环子程序build_grad($\mathbf{V}$, $\mathcal{G}$, ${\mathcal{G}}^{\prime }$, grad_table)，被在算法5中定义的反向传播算法调用。

伪代码：
$\mathbf{Require}$: $\mathbf{V}$, the variable whose gradient should be added to $\mathcal{G}$ and grad_table.
$\mathbf{Require}$: $\mathcal{G}$, the graph to modify.
$\mathbf{Require}$: ${\mathcal{G}}^{\prime }$, the restriction of $\mathcal{G}$ to nodes that participate in the gradient.
$\mathbf{Require}$: grad_table, a data structure mapping nodes to their gradients
\quad $\mathbf{if}$ $\mathbb{V}$ is in grad_table $\mathbf{then}$
\quad\quad Return grad_table[$\mathbf{V}$]
$\mathbf{end}$ $\mathbf{if}$
$i\leftarrow 1$
\quad $\mathbf{for}$ $\mathbf{C}$ in get_consumers($\mathbf{V}$,${\mathcal{G}}^{\prime }$) $\mathbf{do}$
\quad \quad op get_operation($\mathbf{C}$)
\quad $\mathbf{D}$ build_grad($\mathbf{C}$, $\mathcal{G}$, ${\mathcal{G}}^{\prime }$, grad_table)
\quad \quad ${\mathbf{G}}^{(i)}$ $\leftarrow$ op:bprop(get_inputs($\mathbf{C}$, ${\mathcal{G}}^{\prime }$), $\mathbf{V}$, $\mathbf{D}$)
\quad $i\leftarrow i+1$
\quad $\mathbf{end}$ $\mathbf{for}$
\quad $\mathbf{G}\leftarrow {\sum }_i{\mathbf{G}}^{(i)}$
\quad grad_table[$\mathbf{V}$] = $\mathbf{G}$
\quad Insert $\mathbf{G}$ and the operations creating it into $\mathcal{G}$
\quad Return $\mathbf{G}$

在微积分中的链式法则中，我们使用反向传播作为一种策略来避免多次计算链式法则中的相同子表达式。

由于这些重复子表达式的存在，简单的算法可能具有指数运行时间。现在我们已经详细说明了反向传播算法，我们可以去理解它的计算成本。

如果我们假设每个操作的执行都有大致相同的开销，那么我们可以依据执行操作的数量来分析计算成本。注意这里我们将一个操作记为计算图的基本单位，它实际可能包含许多算术运算（例如，我们可能将矩阵乘法视为单个操作）。

在具有$n$个节点的图中计算梯度，将永远不会执行超过$\mathrm{O}(n^2)$个操作，或者存储超过$\mathrm{O}(n^2)$个操作的输出。这里我们是对计算图中的操作进行计数，而不是由底层硬件执行的单独操作，所以重要的是要记住每个操作的运行时间可能是高度可变的。

例如，两个矩阵相乘可能对应着图中的一个单独的操作，但这两个矩阵可能每个都包含数百万个元素。我们可以看到，计算梯度至多需要$\mathrm{O}(n^2)$的操作，因为在最坏的情况下，前向传播的步骤将执行原始图的全部$n$个节点（取决于我们想要计算的值，我们可能不需要执行整个图）。

反向传播算法在原始图的每条边添加一个$\text{Jacobi}$向量积，可以用$\mathrm{O}(1)$个节点来表达。因为计算图是有向无环图，它至多有$\mathrm{O}(n^2)$条边。对于实践中常用的图的类型，情况会更好。

大多数神经网络的代价函数大致是链式结构的，使得反向传播只有$\mathrm{O}(n)$的成本。这远远胜过简单的方法，简单方法可能需要执行指数级的节点。

这种潜在的指数级代价可以通过非递归地扩展和重写递归链式法则（公式：$\frac{\partial u^{(n)}}{\partial u^{(j)}}=\sum _{i:j\in Pa(u^{(i)})}\frac{\partial u^{(n)}}{\partial u^{(i)}}\frac{\partial u^{(i)}}{\partial u^{(j)}}$）来看出：
$\frac{\partial u^{(n)}}{\partial u^{(j)}}=\sum _{\text{path}(u^{({\pi }_1)},u^{({\pi }_2)},\dots ,u^{({\pi }_t)}),\text{from}{\pi }_i=jto{\pi }_t=n}\prod _{k=2}^t\frac{\partial u^{({\pi }_k)}}{\partial u^{({\pi }_{k-1})}}$

• 由于节点$j$到节点$n$的路径数目可以在这些路径的长度上指数地增长，所以上述求和符号中的项数（这些路径的数目），可能以前向传播图的深度的指数级增长。
• 会产生如此大的成本是因为对于$\frac{\partial u^{(i)}}{\partial u^{(j)}}$，相同的计算会重复进行很多次。
• 为了避免这种重新计算，我们可以将反向传播看作一种表填充算法，利用存储的中间结果$\frac{\partial u^{(n)}}{\partial u^{(i)}}$来对表进行填充。
• 图中的每个节点对应着表中的一个位置，这个位置存储对该节点的梯度。
• 通过顺序填充这些表的条目，反向传播算法避免了重复计算许多公共子表达式。
• 这种表填充策略有时被称为动态规划（dynamic programming）。

• 具体来说，我们使用训练集上的一组minibatch实例，将其规范化为一个设计矩阵$\mathbf{X}$以及相关联的类标签的向量$\mathbf{y}$。

• 网络计算隐藏特征层： H = max ⁡ { 0 , X W ( 1 ) } \boldsymbol{H}=\max\{0,\boldsymbol{XW^{(1)}}\} H=max{0,XW(1)}。为了简化表示，我们在这个模型中不使用偏置。

• 假设我们的图语言包含relu操作，该操作可以对 max ⁡ { 0 , Z } \max\{0,\boldsymbol{Z}\} max{0,Z}表达式的每个元素分别进行计算。

• 类的非归一化对数概率的预测将随后由$\mathbf{H}{\mathbf{W}}^{(2)}$ 给出。假设我们的图语言包含cross_entropy操作，用以计算目标$\mathbf{y}$和由这些未归一化对数概率定义的概率分布间的交叉熵。所得到的交叉熵定义了代价函数$J_{\text{MLE}}$。

• 最小化这个交叉熵将执行对分类器的最大似然估计。然而，为了使得这个例子更加真实，我们也包含一个正则项。总的代价函数为：
  $J=J_{\text{MLE}}+\lambda \left(\sum _{i,j}(W_{i,j}^{(1)}{)}^2+\sum _{i,j}(W_{i,j}^{(2)}{)}^2\right)$

• 包含了交叉熵和系数为$\lambda$的权重衰减项。它的计算图在下图中给出。

• 例如，用于计算代价函数的计算图，这个代价函数是使用交叉熵损失以及权重衰减训练我们的单层MLP示例所产生的。
  

• 说明：

  • 这个示例的梯度计算图实在太大，以至于绘制或者阅读都将是乏味的。这显示出了反向传播算法的优点之一，即它可以自动生成梯度，而这种计算对于软件工程师来说需要进行直观但冗长的手动推导.
  • 我们可以通过观察图中的正向传播图来粗略地描述反向传播算法的行为。为了训练，我们希望计算${\nabla }_{{\mathbf{W}}^{(1)}}J$和${\nabla }_{{\mathbf{W}}^{(2)}}J$。
  • 有两种不同的路径从$J$后退到权重：
    • 一条通过交叉熵成本
    • 另一条通过权重衰减成本
  • 权重衰减成本相对简单，它总是对${\mathbf{W}}^{(i)}$上的梯度贡献$2\lambda {\mathbf{W}}^{(i)}$。
  • 另一条通过交叉熵成本的路径稍微复杂一些。
    • 令$\mathbf{G}$是cross_entropy操作提供的对未归一化对数概率${\mathbf{U}}^{(2)}$的梯度。
    • 反向传播算法现在需要探索两个不同的分支。
    • 在较短的分支上，它使用对矩阵乘法的第二个变量的反向传播规则，将${\mathbf{H}}^{\top }\mathbf{G}$加到${\mathbf{W}}^{(2)}$的梯度上。
    • 另一条更长些的路径沿着网络逐步下降。
      • 首先，反向传播算法使用对矩阵乘法的第一个变量的反向传播规则，计算${\nabla }_{\mathbf{H}}J=\mathbf{G}{\mathbf{W}}^{(2)\top }$
      • 接下来，relu操作使用期反向传播规则来对关于${\mathbf{U}}^{(1)}$的梯度中小于$0$的部分清零。
  • 记上述结果为${\mathbf{G}}^{\prime }$。反向传播算法的最后一步是使用对matmul操作的第二个变量的反向传播规则，将${\mathbf{X}}^{\top }{\mathbf{G}}^{\prime }$加到${\mathbf{W}}^{(1)}$的梯度上。
  • 在计算了这些梯度以后，梯度下降算法或者其他的优化算法的责任就是使用这些梯度来更新参数。

• 在前向传播阶段，我们乘以每个权重矩阵，得到了$\mathrm{O}(\omega )$数量的乘-加，其中$\omega$是权重的数量。
• 在反向传播阶段，我们乘以每个权重矩阵的转置，具有相同的计算成本。
• 算法主要的存储成本是我们需要将输入存储到隐藏层的非线性中去。这些值从被计算时开始存储，直到反向过程回到了同一点。
• 因此存储成本是$\mathrm{O}(m{n}_h)$，其中$m$是minibatch中样例的数目，$n_h$是隐藏单元的数量。

• 其中我们通过指数化、求和与除法运算构建$\text{softmax}$函数，并构造交叉熵损失函数$J=-{\sum }_i{p}_i\log q_i$。
• 人类数学家可以观察到$J$对$z_i$的导数采用了非常简单的形式：$p_i{q}_i-p_i$。
• 反向传播算法不能够以这种方式来简化梯度，而是会通过原始图中的所有对数和指数操作显示地传播梯度。一些软件库如 Theano(Bergstra et al., 2010b;Bastien et al., 2012b) 能够执行某些种类的代数替换来改进由纯反向传播算法提出的图。