深度学习---反向传播算法

装载原文：https://www.cnblogs.com/yeluzi/p/7418291.html

一. 一种基于矩阵运算快速计算神经网络输出的方法

在介绍反向传播之前，先介绍怎么利用矩阵运算快速的计算神经网络输出。其实在上一章对这一块也提到过，不过不够详细。这里再介绍一下，帮助大家逐渐适应基于矩阵运算的表示方式。

我们先引入一个能够明确表示连接神经网络中某两层之间的某两个神经元的权重的符号：wljk

，它表示第l−1层的第k个神经元和第l层的第j个神经元连接的权重。例如下图中的w324

表示第二层的第4个神经元到第三层的第2个神经元的权重：

这个符号初看起来可能有点复杂冗长而且需要一点功夫去适应这样的定义。而且大多数人应该有跟我一样的疑惑就是为什么不用j表示输入，k表示输出，而是这样反其道而行之。在下文中作者将解释这样定义的原因。

同样的我们可以用类似的符号定义神经元的bias和受到激活后的输出。我们用blj

表示第l层第j个神经元的bias，用alj表示第l层第j

个神经元的输出。类似下图：

有了这些概念，我们可以把alj

也就是第l层第j

个神经元的输出同上一层神经元的输出联系起来。

 

alj=σ(∑kwljkal−1k+blj)(23)

 

这个式子中的求和部分就是对上一层的神经元输出进行加权求和的过程。

为了用矩阵的形式重写这个式子，我们定义一个权重矩阵wl

表示与第l层所有神经元链接的权重，这个矩阵的第j行，第k列的值wljk表示第l−1层第k个神经元与第l层第j个神经元链接的权重。同样的定义一个bias向量bl表示第l层神经元的bias，然后al表示第l

层神经元的输出。

借助于函数向量化的思想，就是将一个函数作用于一个向量上等价于将一个函数分别作用于该向量上每一个分量。例如对于函数f(x)=x2

,有：

 

f([23])=[f(2)f(3)]=[49](24)

 

有了这些概念就可以将公式(23)改写为：

 

al=σ(wlal−1+bl)(25)

 

去掉了那些表示神经元的序号j

和k，这个式子帮助我们更宏观的理解上一层神经元的输出是怎么影响下一次神经元的。我们将权重矩阵乘以上一层神经元输出，再加上这一层神经元自身的bias，再经过σ

函数得到的就是这一层神经元的输出。

这也是作者定义wljk

时用k表示l−1层的神经元序列而不是用j表示的原因。试想一下，当我们需要计算第l层第一个神经元输出的时候，需要将矩阵wl的第一行所有值wl1k表示的向量和向量al−1相乘，也就是加权求和，所以说这样定义更符合我们矩阵运算的规则，否则的话在进行计算的时候还需要将权重矩阵wl

转置带来不必要的麻烦。

相较于纠结神经元间的联系，用矩阵表示的话更容易理解和感受层级间的联系。而且矩阵表示还有个好处就是在实际工程中，有很多快速矩阵运算的实现。

在计算公式(25)的时候，我们可以定义一个l

层的加权输入的概念：zl=wlal−1+bl，就是在经过σ函数输出之前的部分。公式(25)于是可以表示成al=σ(zl)。zl当然也是一个向量，其中每个分量zlj表示第l层第j

个神经元的加权输入。

二. 关于损失函数的两个假设

反向传播算法是为了计算损失函数的偏导数∂C∂w

和∂C∂b

，为了使算法可行，我们需要对损失函数的形式作两个假设。在介绍这些假设之前，我们先来看一个最常见的二次损失函数：

 

C=12n∑x||y(x)−aL(x)||2(26)

 

其中n

是训练样本总数，对所有训练样本损失求平均，y(x)是输入为x时对应的真实的输出，而L表示神经网络的层数，也就是说aL(x)表示的是输入为x

时，神经网络最后一层输出层的输出，也就是神经网络的输出。

第一个假设是所有训练样本总的损失函数可以被表示成单个样本损失函数和的平均值，即：C=1n∑xCx

. 我们很容易可以验证这个假设对于二次损失函数成立，Cx=12||y−aL||2

。这个假设其实大部分时候都是成立，除了对于少数比较另类的损失函数，不过本文并不涉及。

我们需要这个假设的原因是因为方向传播算法实际是对于单个样本计算偏导数∂Cx∂w

和∂Cx∂b,随后再通过对这些单样本的偏导数求平均作为∂C∂w和∂C∂b。事实上，在对w和b求偏导的时候，我们将输入x当作是固定值，所以方便起见，暂时将Cx写作C

,后面再写回来。

第二个假设是损失函数可以表示成神经网络输出的函数，即C=C(aL)

 

 例如，二次损失函数就满足这样的假设，因为对于一个训练样本x

来说，有：

 

C=12||y−aL||2=12∑j(yj−aLj)2(27)

 

这样就表示成了输出的函数，因为对于一个输入x

来说，它实际正确的输出y是个固定值，并不是我们可以修改的变量。我们可以改变的只能是通过改变weights和biases来改变神经网络的输出aL

从而影响到损失函数的值。

三. Hadamard积 - s⊙t

 

反向传播算法基于一些常见的线性代数操作：向量的相加，向量与矩阵的积等等。其中有一种操作不是很常见，这里简单介绍一下。假设s

和t是两个相同维度的向量，我们使用s⊙t定义两个向量中对应分量相乘的操作，即(s⊙t)j=sjtj

,例如：

 

[12]⊙[34]=[1∗32∗4]=[38](28)

 

这样的乘法操作被称为Hadamard积或Schur积。

四. 反向传播算法背后的四个基本方程

反向传播算法是关于理解改变weights和biases是如何改变损失函数C，也就是计算∂C∂wljk

和∂C∂blj。在介绍如何计算这些偏导数之前，先引入一个中间变量，δlj，称其为第l层第j

个神经元的误差error，反向传播算法会先计算这个中间变量，随后再将其与需要的偏导数关联起来。

为了明白这个error的定义，想象在我们的神经网络中有一个小恶魔：

 

 这个小恶魔位于第l

层第j个神经元处，它会在该神经元接收到输入的时候使坏，在上一层的加权输入和传到这个神经元的时候添加一个改变量Δzlj，导致该神经元的输出就不再是σ(zlj)而变成了σ(zlj+Δzlj)。这个改变就会一直传到下去直到最后一个输出层，使得总的损失函数改变了∂C∂zljΔzlj

。

现在假设这个恶魔是个好恶魔，它会通过找到合适的Δzlj

来帮我们减小损失函数的值。假设∂C∂zlj是一个绝对值大的数(可以是正数或者负数)，那我们可以取一个和其正负相反的一个数Δzlj来减小损失函数。但是如果∂C∂zlj是一个接近0的数，这个恶魔通过影响zlj来减小损失函数的方式就显得力不从心了。此时，这个恶魔就会说，这个神经元已经接近最优状态了（当然这是在Δzlj

是相对小的值的情况下的，我们会约束这个恶魔的能力，使其只能进行这些比较小的干扰）。这就有点类似于说损失函数在这个神经元上已经达到极值，没有继续优化的空间了。

这就给我们一种直觉说∂C∂zlj

可以作为该神经元error的一种评价方式。基于此，我们定义第l层第j

个神经元的error为：

 

δlj=∂C∂zlj(29)

 

 反向传播算法将会对每一层l

计算δl然后再得到对应的∂C∂wljk和∂C∂blj

。

也许我们会有疑问为什么这个恶魔影响的是输入zlj

而不是直接去影响输出alj，那样我们就可以用∂C∂alj作为我们在神经元上error的衡量。实际上这样做并不会对结果产生影响，只是会使得反向传播算法的计算公式更复杂一点而已，所以我们继续使用δlj=∂C∂zlj

作为error的衡量。

接下来就要介绍反向传播算法基于的四个方程了。作者在这强调，这些方程是有难度的，一开始不理解也不要灰心。在这章中，我们会多次学习它们，作者还给出了这些方程的简单证明和伪代码实现，并且还一步步将伪代码实现成了python代码。通过本章的学习，不光是知道这些公式方程，作者还将会使我们对反向传播方程有直觉上的理解，还有就是人们是怎么发现这些方程的。在这期间，我们会不断的提及这四个方程，使我们最终将会对它有更深入的理解。

 方程一：输出层的errorδL

 

 

δLj=∂C∂aLjσ′(zLj)(BP1)

 

根据定义我们可以验证δLj=∂C∂zLj=∂C∂aLj∂aLj∂zLj=∂C∂aLjσ′(zLj)

 

注意到这个式子的每个部分都不难计算的到，zLj

和σ′(zLj)

在计算神经网络输出的时候可以得到，左边的部分在确定了损失函数的形式之后也可以计算得到。

公式(BP1)是针对输出层上某一个神经元而言的，为了方便反向传播计算，我们将其改写为矩阵形式：

 

δL=▽aC⊙σ′(zL)(BP1a)

 

对于这里的二次损失函数，有▽aC=▽a(12∑j(yj−aLj)2)=aL−y

, 注意这里求导的过程只是针对当前分量j

求导，其余的分量就为0.于是有：

 

δL=(aL−y)⊙σ′(zL)(30)

 

方程二：用当前层error表示下一层error

 

δl=((wl+1)Tδl+1)⊙σ′(zl)(BP2)

 

这个方程虽然看上去比较复杂，但是每个部分都有很明确的解释。假设我们知道l+1

层的error：δl+1，当同这一层的权重矩阵相乘的时候就类似于将这个error传到上一层，最后再利用Hadamard积得到l

层的error。详细的推导证明在下一小节中。

有了公式(BP1)和公式(BP2)我们就可以通过先计算输出层的error进而计算每一层的error。

方程三：error等价于损失函数C

对bias的变化率

 

∂C∂blj=δlj(BP3)

 

这说明error δlj

等价于∂C∂blj

。于是可以很容易将其写成：

 

∂C∂b=δ(31)

 

方程四：损失函数C

对weights的变化率

 

∂C∂wljk=al−1kδlj(BP4)

 

这个方程说明，当我们要计算某两个神经元链接的权重对损失函数影响的时候，可以先计算上一层的al−1k

和下一层的δlj

。而这两个值我们根据先前的知识已经知道怎么计算了。这个方程也可以被写为：

 

∂C∂w=ainδout(32)

 

更直观的如下图所示：

从公式(32)中可以看出来，当ain

很小ain≈0的时候，∂C/∂w

也会很小，那样这个权重的学习就会很慢，意味着在梯度下降的学习过程中，这个权重不会发生大的变化。换句话说就是，输出小的神经元的权重学习也慢。

 

介绍完了这四个方程，我们再来聊聊一些关于这四个方程的理解。对于输出层，考虑公式(BP1)中的σ′(zLj)

，我们在第一章学习过σ函数的图像，知道它在σ(zLj)接近0或1的时候是趋于平的，也就是导数是趋于0的。所以我们就能得出结论，如果对于输出层的神经元，如果其输出非常大（≈1）或非常小（≈0

），在这种情况下，其参数的更新是非常缓慢的。我们称这种状态的输出神经元为saturated的状态，这种状态下，参数停止更新（或更新很慢）。

根据公式（BP2）我们对其他层可以得出同样的结论，对任一处于saturated状态的神经元来说，其δlj

趋向于很小的值，然后就会导致它的参数的学习会很慢。（当然要是wl+1δl+1

足够大，即使乘上一个很小的数也能保证积足够大的话就不是这种情形了，不过作者这里说明的只是普遍的情况）

总之，就是一个神经元在低激活或者高激活状态，或者说在saturated状态时，它的参数的更新就会很慢。

上面的一些理解并不难从观察方程得到，但是它仍然能够帮助我们更进一步在脑海中构建神经网络模型。而且我们随后会发现，证明上述方程不需要用到任何σ

函数的性质，所以我们可以将激活函数换成任何函数。甚至我们可以根据学习的需要设计自己的激活函数。例如，我们使用一个函数f，有f′>0

恒成立，并且不会接近于0，这样就可以使神经元避免saturated的状态，就不会减慢参数的学习。在本书的后续章节，我们的确会看到很多使用自己定义的激活函数的例子，现在先让我们牢记(BP1)-(BP4)这四个方程，只有这样到时候才能明白为什么要那样修改激活函数，这样修改会造成什么样的影响。

五. 四个方程的证明(选学)

现在要开始上述四个方程的证明了，这些证明主要用到了多元函数微分的链式法则，如果对这块很熟悉的话，完全可以自己自行证明。

先来公式(BP1)的证明，这个其实在我上面介绍的时候已经证明过了，这里在介绍一下作者是怎么证明的。

公式BP1:

δLj=∂C∂zLj(36)

 

根据链式法则有δLj=∑k∂C∂aLk∂aLk∂zLj(37)

，但是我们知道对于第k个神经元的输出aLk只决定于第k个神经元的输入aLk，所以对于k≠j

的情况，导数为0，所以可以去掉求和符号（其他项都为0）最后有：

 

δLj=∂C∂aLj∂aLj∂zLj(38)

 

由于aLj=σ(zLj)

，所以上式又可以被写为：

 

δLj=∂C∂aLjσ′(zLj)(39)

 

公式BP1就得到了证明。

 

现在证明BP2.根据链式法则可以得到：

 

δlj=∂C∂zlj(40)

 

 

δlj=∑k∂C∂zl+1k∂zl+1k∂zlj(41)

 

 

δlj=∑k∂zl+1k∂zljδl+1k(42)

 

又根据神经网络模型知道：

 

zl+1k=∑jwl+1kjalj+bl+1k=∑jwl+1kjσ(zlj)+bl+1k(43)

 

然后将其对zlj

求导得到：

 

∂zl+1k∂zlj=wl+1kjσ′(zlj)(44)

 

将其带入公式(42)得到：

 

δlj=∑kwl+1kjδl+1kσ′(zlj)(45)

 

这样就完成了BP2的证明。

BP3和BP4的证明留做练习题。

练习：

问题：

证明方程BP3和BP4 

答案：

BP3的证明：

根据链式法则展开为∂C∂blj=∑k∂C∂zlk∂zlk∂blj=∑kδlk∂(∑jwlkjal−1j+blk)∂blj=δlj∗1=δlj

 

因为只有在k=j

的时候右边部分才为1，其余均为0，方程BP3就得到了证明。

 

BP4的证明：

跟BP3几乎一模一样，为了避免误解，这里的下标稍微改一下，∂C∂wljk=∑a∂C∂zla∂zla∂wljk=∑aδla∂(∑bwlabal−1b+bla)∂wljk

 

很显然，∂blawljk=0

,然后另一部分只有在a=j,b=k

时才不为0，此时就可以去掉求和符号得到：

 

∂C∂wljk=al−1kδlj

 

方程BP4证明完毕。

六. 反向传播算法 

有了这些方程，我们再看看反向传播算法是如何进行梯度计算的。

1. 设置输入层的输出a1

为原始输入x

 

2. 前向依次计算l=2,3,...,L

层的加权输入和输出:zl=wlal−1+bl和al=σ(zl)

 

3. 输出层的error δL

: δL=▽aC⊙σ′(zL)

 

4. 反向传播依次计算l=L−1,L−2,...,2

层的error：δl=((wl+1)Tδl+1)⊙σ′(zl)

 

5. 根据上面的结果计算各个梯度：∂C∂wljk=al−1kδlj

和∂C∂blj=δlj

 

 从算法的流程也可以明白为什么它被称为反向传播算法，因为我们是从最后一层的δL

开始反向计算前面的δl

的。因为损失函数是关于神经网络输出的函数，所以为了得到损失函数关于前面层的参数的梯度就需要不断的应用求导链式法则，一层层向前推导得到我们需要的关系的表达式。

练习：

问题一：

假设我们对神经网络中的一个神经元进行替换，使其激活函数不再是sigmoid函数，而是f(∑jwjxj+b)

, 这种情况下反向传播算法应该如何调整？

答案：

只需要修改用到激活函数的部分，首先是该神经元的输出alj

用函数f求，其次就是上面在求σ′(zl)的时候，现在改为函数f′(zlj)

（只影响其中一个分量，因为只替换了一个神经元）

问题二：

将神经网络中所有的sigmoid激活函数替换为线性激活函数σ(z)=z

，写出该情形下的反向传播算法。

答案：

使用这个激活函数的话，一个显著特征就是a=z

和σ′(zL)=1⃗ ，然后就可以去掉⊙

操作，因为右边的向量各分量都为1。其实算法没什么变化，只是这些特殊情况的激活函数会简化算法中某些式子。

 

之前已经提到过，反向传播算法是基于每一个样本计算梯度的即C=Cx

。实际中，经常会涉及到将多个梯度的情况，例如在随机梯度下降算法中使用反向传播。例如给定mini-batch大小为m

，那么算法的做法是：

1. 先针对mini-batch中每一个训练样本进行上述反向传播的计算，计算各个参数（这样就会出现m组参数）

2. 在梯度下降更新参数的时候对m组梯度取平均后再应用到更新参数的公式中：

 

wl→wl−ηm∑xδx,l(ax,l−1)T

 

 

bl→bl−ηm∑xδx,l

 

 

七. 反向传播算法的代码实现 

理解了反向传播算法后，我们再来看前一章相关代码就更容易理解了。

1 class Network(object):
 2 ...
 3     def update_mini_batch(self, mini_batch, eta):
 4         """Update the network's weights and biases by applying
 5         gradient descent using backpropagation to a single mini batch.
 6         The "mini_batch" is a list of tuples "(x, y)", and "eta"
 7         is the learning rate."""
 8         nabla_b = [np.zeros(b.shape) for b in self.biases]
 9         nabla_w = [np.zeros(w.shape) for w in self.weights]
10         for x, y in mini_batch:
11             delta_nabla_b, delta_nabla_w = self.backprop(x, y)
12             nabla_b = [nb+dnb for nb, dnb in zip(nabla_b, delta_nabla_b)]
13             nabla_w = [nw+dnw for nw, dnw in zip(nabla_w, delta_nabla_w)]
14         self.weights = [w-(eta/len(mini_batch))*nw 
15                         for w, nw in zip(self.weights, nabla_w)]
16         self.biases = [b-(eta/len(mini_batch))*nb 
17                        for b, nb in zip(self.biases, nabla_

之前已经说过，主要的计算部分在第11行的backprop函数，它返回的其实就是在当前样本下的∂Cx∂blj

和∂CX∂wljk

，然后nabla_b和nabla_w是讲对应位置的结果叠加，以供在第14行和第16行更新参数时用到平均梯度时使用。下面是backprop函数的代码：

class Network(object):
 2 ...
 3    def backprop(self, x, y):
 4         """Return a tuple "(nabla_b, nabla_w)" representing the
 5         gradient for the cost function C_x.  "nabla_b" and
 6         "nabla_w" are layer-by-layer lists of numpy arrays, similar
 7         to "self.biases" and "self.weights"."""
 8         nabla_b = [np.zeros(b.shape) for b in self.biases]
 9         nabla_w = [np.zeros(w.shape) for w in self.weights]
10         # feedforward
11         activation = x
12         activations = [x] # list to store all the activations, layer by layer
13         zs = [] # list to store all the z vectors, layer by layer
14         for b, w in zip(self.biases, self.weights):
15             z = np.dot(w, activation)+b
16             zs.append(z)
17             activation = sigmoid(z)
18             activations.append(activation)
19         # backward pass
20         delta = self.cost_derivative(activations[-1], y) * \
21             sigmoid_prime(zs[-1])
22         nabla_b[-1] = delta
23         nabla_w[-1] = np.dot(delta, activations[-2].transpose())
24         # Note that the variable l in the loop below is used a little
25         # differently to the notation in Chapter 2 of the book.  Here,
26         # l = 1 means the last layer of neurons, l = 2 is the
27         # second-last layer, and so on.  It's a renumbering of the
28         # scheme in the book, used here to take advantage of the fact
29         # that Python can use negative indices in lists.
30         for l in xrange(2, self.num_layers):
31             z = zs[-l]
32             sp = sigmoid_prime(z)
33             delta = np.dot(self.weights[-l+1].transpose(), delta) * sp
34             nabla_b[-l] = delta
35             nabla_w[-l] = np.dot(delta, activations[-l-1].transpose())
36         return (nabla_b, nabla_w)
37 
38 ...
39 
40     def cost_derivative(self, output_activations, y):
41         """Return the vector of partial derivatives \partial C_x /
42         \partial a for the output activations."""
43         return (output_activations-y) 
44 
45 def sigmoid(z):
46     """The sigmoid function."""
47     return 1.0/(1.0+np.exp(-z))
48 
49 def sigmoid_prime(z):
50     """Derivative of the sigmoid function."""
51     return sigmoid(z)*(1-sigmoid(z))

 

现在稍微解释一下这段代码：

 

8，9行是初始化一下需要计算的梯度值。

14-18行的for循环是计算所有的zlj

和alj

 

20行是计算最后一层的error：δL

，cost_derivate函数计算∂C∂aLj，在损失函数为二次函数的情况下为aLj−yj

, sigmoid_prime函数就是计算sigmoid函数的导数。

22行和23行就是损失函数对输出层的参数的导数。

30行开始的for循环就是根据那四个方程进行反向传播的过程。

可见只要了解了那四个方程，反向传播算法的代码并不难理解。

作者最后强调他实现的代码并没有完全实现矩阵化，因为在mini-batch阶段，作者是使用for循环遍历其中的每个样本的。实际上这一步是可以依靠矩阵运算实现的，矩阵运算比遍历for循环要快。实际上，大部分的库中反向传播的实现都是依靠矩阵运算而不是循环遍历的。

八. 反向传播为什么被认为是快速的算法？

我们之前提到反向传播是一种快速计算梯度的算法，那么为什么称它快速呢，这是跟什么比才说它快呢？

为了回答这个问题，我们先看另一种计算梯度的方法。考虑损失函数为C=C(w)

（先不考虑bias），根据导数的概念我们有：

 

Cwj≈C(w+ϵej)−C(w)ϵ(46)

 

其中ϵ>0

是一个很小的正数，ej是j方向上的一个单位向量。这样的话通过计算分子上的损失函数C的两个值，就可以得到我们需要的梯度∂C∂wj，同样的方法我们可以计算∂C∂b

。

这个方法看起来很完美，而且代码实现更加容易，似乎比我们的反向传播算法更好。但是事实是，当我们尝试实现使用这种方法的时候，就会发现它的运行效率非常低下。假设我们的神经网络中有一百万个权重，那样的话为了计算梯度肯定就需要计算这一百万个C(w+ϵej)

。但是每次计算这个损失函数的值都必须从输入层开始一层层计算直到输出层（每个样本都需要经过这样的计算）。除此之外当然还需要计算一百万个C(w)

，不过这个只需要计算一次神经网络的输出即可得到。

反向传播算法的聪明之处在于我们只需要一次正向遍历神经网络和一次反向遍历神经网络，就可以计算出所有的∂C∂wj

。正向遍历计算alj和zlj，反向遍历计算各个δlj

，然后经过简单计算就得到了需要的梯度值。所以说虽然从形式上可能会觉得反向传播算法更复杂，但其实它的计算量更少，算法更高效。

自从反向传播算法被发现，它就解决了许多神经网络上的问题。但是反向传播算法也不是万能的，尤其是在用来训练拥有非常多隐藏层的深度神经网络的时候。我们会在本书的后面章节介绍现代计算机和一些前人聪明的想法是怎么使这样的深度神经网络的学习变得可能的。

九. 反向传播概貌

到目前为止，反向传播还给我们留下了两个疑团。首先，这个算法本质上做了些什么，我们已经知道了error从输出层反向传播这个关键步骤。那我们能否了解的更深入一点，能否建立起一种直觉明白在这些矩阵向量运算背后究竟发生了什么？其次，读懂反向传播算法及其证明并不困难，但是读懂并不意味着你能凭空发现这个算法，是否存在合理的直觉或方法可以引导我们去发现这个算法呢？这一节将会围绕这两个疑团进行讨论。

为了让我们更直观的感受算法的行为，我们想象对神经网络的参数wljk

进行了微调Δwljk

，如下图：

 

 当然这个变化会引起相关联的神经元的输出：

这个神经元的输出的变化又会引起和它相连接的所有的神经元的变化。就这样一层层的影响，最后就到输出层了对损失函数直接造成影响：

其中ΔC

与权重改变的关系为：

 

ΔC≈∂C∂wljkΔwljk(47)

 

这就给我们带来一种计算∂C∂wljk

的方法：通过给wljk引入细微的变化，然后再仔细的追踪这个变化最终对C的影响。我们按照这种思路，从权重改变处一层层往输出层推导，最后应该就可以计算出∂C∂wjjk

。

假设Δwljk

会引起第l层j个神经元的输出改变Δalj

：

 

Δalj≈∂alj∂wljkΔwljk(48)

 

这个输出的变化量Δalj

又将会影响到下一层所有的神经元的输出。假设我们现在只关心下一层的一个神经元q

：

该神经元输出al+1q

的改变为：

 

Δal+1q≈∂al+1q∂aljΔalj(49)

 

将其代入公式(48)得到：

 

Δal+1q≈∂al+1q∂alj∂alj∂wljkΔwljk(50)

 

然后当然Δal+1q

又会影响下一层的神经元的输出，这样一层层直到输出层。我们考虑其中的一条路径，假设经过的神经元输出为alj,al+1q,...,aL−1n,aLm，那么它对C

的影响为：

 

ΔC≈∂C∂aLm∂aLm∂aL−1n∂aL−1n∂aL−2p...∂al+1q∂alj∂alj∂wljkΔwljk(51)

 

当然这只是所有影响C

路径中的一条，为了计算总的变化，我们对所有可能路径的影响进行求和：

 

ΔC≈∑mnp...q∂C∂aLm∂aLm∂aL−1n∂aL−1n∂aL−2p...∂al+1q∂alj∂alj∂wljkΔwljk(52)

 

然后同公式（47）对比就能得到：

 

∂C∂wljk=∑mnp...q∂C∂aLm∂aLm∂aL−1n∂aL−1n∂aL−2p...∂al+1q∂alj∂alj∂wljk(53)

 

方程(53)看上去挺复杂，但是它有一个非常好的直观解释。这个方程告诉我们，当我们在计算C

对于权重的变化率时，任意两个神经元之间的连接都相当于引入了一个变化率，这个变化率就是两个被连接的神经元的输出之间的导数即∂al+1q∂alj

, 然后每一条路径带来的变化就是这些值的积，总的变化就是所有路径带来变化的和，如下图：

 上面给大家提供一种思考，就是当你影响神经网络一个参数的时候，这期间会发生什么并进而影响最后的损失函数。让我们简述一下有这些知识你还可以做哪些更进一步的讨论。首先，我们可以获得方程(53)中所有单个偏导数的明确计算式，这只需要一些积分即可。然后就可以将这个求和的运算改成矩阵相乘的形式。你就会渐渐发现我们现在做的就是反向传播所做的事情，所以说反向传播算法可以被认为是计算所有路径上偏导数积的和的一种方法。或者说，反向传播提供了一种追踪权重变化对神经网络输出影响的途径。