反向传播

反向传播

现在我们来到了如何让多层神经网络学习的问题上。之前我们了解了如何用梯度下降来更新权重。反向传播算法是它的一个延伸，用链式法则来找到误差与输入层到输入层链接的权重（两层神经网络）。

要更新输入到隐藏层的权重，你需要知道隐藏层节点的误差对最终输出的影响是多大。输出是由两层之间的权重决定的，这个误差是输入跟权重在网络中正向传播的结果。既然我们知道输出误差，我们可以用权重来反向传播到隐藏层。

例如，输出层的话，在每一个输出节点 $k$ 的误差是 δ​k​o​​ 。隐藏节点 $j$ 的误差来自输出层和隐藏层之间的权重（以及梯度）。

梯度下降跟之前一样，只是用新的误差：

w​ij​​ 是输入和隐藏层之间的权重， x​i​​ 是输入值。这个形式可以表示任意层数。权重更新步长等与步长乘以层输出误差再乘以这层的输入值。

这里，你有了输出误差，δ​output​​，从高层反向传播这些误差。V​in​​ 是对这一层的输入，经过隐藏层激活后到输出节点。

通过一个实际案例学习

让我们一起过一遍计算一个简单的两层网络权重的更新过程。假设有两个输入值，一个隐藏节点，一个输出节点，隐藏层和输出层的激活函数都是 sigmoid 。下图描述了这个网络。（注意：输入在这里显示为图最下方的节点，网络的输出标记为顶端的 ​y​^​​，输入本身不算做层，这也是为什么这个网络结构被称作两层网络。）

假设我们试着输入一些二分类数据，目标是 $y=1$。我们从正向传导开始，首先计算输入到隐藏层

h=∑​i​​w​i​​x​i​​=0.1×0.4−0.2×0.3=−0.02

隐藏层的输出

a=f(h)=sigmoid(−0.02)=0.495.

把它作为输出层的输入，神经网络的输出是：

​y​^​​=f(W⋅a)=sigmoid(0.1×0.495)=0.512.

有了这个输出，我们就可以开始反向传播来计算两层的权重更新了。sigmoid 函数特性 f​′​​(W⋅a)=f(W⋅a)(1−f(W⋅a))，输出误差是：

δ​o​​=(y−​y​^​​)f​′​​(W⋅a)=(1−0.512)×0.512×(1−0.512)=0.122.

现在我们要通过反向传播来计算隐藏层的误差。这里我们吧输出误差与隐藏层到输出层的权重 $W$ 相乘。隐藏层的误差 δ​j​h​​=∑​k​​W​jk​​δ​k​o​​f​′​​(h​j​​)，这里因为只有一个隐藏节点，这就比较简单了

δ​h​​=Wδ​o​​f​′​​(h)=0.1×0.122×0.495×(1−0.495)=0.003

有了误差，就可以计算梯度下降步长了。隐藏层到输出层权重步长是学习率乘以输出误差再乘以隐藏层激活值。

ΔW=ηδ​o​​a=0.5×0.122×0.495=0.0302

从输入到隐藏层的权重 w​i​​，是学习率乘以隐藏节点误差再乘以输入值。

Δw​i​​=ηδ​h​​x​i​​=(0.5×0.003×0.1,0.5×0.003×0.3)=(0.00015,0.00045)

这个例子你可以看出用 sigmoid 做激活函数的效果。sigmoid 函数最大的导数是 0.25，输出层的误差被至少减少了75%，隐藏层的误差被减少了至少93.75%！你可以看出，如果你有很多层，用 sigmoid 激活函数函数会很快把权重降到靠近输入的细小值。这被称作梯度消失问题。后面的课程中你会学到其它的激活函数在这方面表现比它好，也被用于最新的网络架构中。

用 NumPy 来实现

现在你已经有了大部分用 NumPy 来实现反向传导的知识。

但是之前接触的是一个元素的误差项。现在在权重更新时，我们需要考虑隐藏层每个节点的误差：

Δw​ij​​=ηδ​j​​x​i​​

首先，这里会有不同数量的输入和隐藏节点，所以试图把误差与输入当作行向量来乘会报错 

hidden_error*inputs
---------------------------------------------------------------------------
ValueError                                Traceback (most recent call last)
<ipython-input-22-3b59121cb809> in <module>()
----> 1 hidden_error*x

ValueError: operands could not be broadcast together with shapes (3,) (6,)

同时，w​ij​​ 现在是一个矩阵，所以右侧对应也应该有跟左侧同样的维度。幸运的是，NumPy 这些都能搞定。如果你用一个列向量序列和一个行向量序列乘，它会把列向量的第一个元素与行向量的每个元素相乘，然后第一行是一个二维序列。列向量的每一个元素会这门做，所以你会得到一个二维序列，维度是(len(column_vector), len(row_vector))。

hidden_error*inputs[:,None]
array([[ -8.24195994e-04,  -2.71771975e-04,   1.29713395e-03],
       [ -2.87777394e-04,  -9.48922722e-05,   4.52909055e-04],
       [  6.44605731e-04,   2.12553536e-04,  -1.01449168e-03],
       [  0.00000000e+00,   0.00000000e+00,  -0.00000000e+00],
       [  0.00000000e+00,   0.00000000e+00,  -0.00000000e+00],
       [  0.00000000e+00,   0.00000000e+00,  -0.00000000e+00]])

这正好是我们如何计算权重更新的步长。跟以前一样，如果你的输入是一个一行的二维序列，你可以用hidden_error*inputs.T，如果 inputs 是一维序列，就不行了。

反向传播练习

接下来你会用代码来实现一次两个权重的反向传播更新。我们提供了正向传播的代码，你来实现反向传播的代码。

要做的事

• 计算网络输出误差
• 计算输出层误差的梯度
• 用反向传播计算隐藏层误差
• 计算权重更新步长