神经网络反向传播

反向传播

如何让多层神经网络学习呢？我们已了解了使用梯度下降来更新权重，反向传播算法则是它的一个延伸。以一个两层神经网络为例，可以使用链式法则计算输入层-隐藏层间权重的误差。

要使用梯度下降法更新隐藏层的权重，你需要知道各隐藏层节点的误差对最终输出的影响。每层的输出是由两层间的权重决定的，两层之间产生的误差，按权重缩放后在网络中向前传播。既然我们知道输出误差，便可以用权重来反向传播到隐藏层。

例如，输出层每个输出节点 kk 的误差是 \delta^o_kδko​ ，隐藏节点 jj 的误差即为输出误差乘以输出层-隐藏层间的权重矩阵（以及梯度）。

然后，梯度下降与之前相同，只是用新的误差：

其中 <span class=''mathquill''>w_{ij} 是输入和隐藏层之间的权重， <span class=''mathquill''>x_i 是输入值。这个形式可以表示任意层数。权重更新步长等于步长乘以层输出误差再乘以该层的输入值。

现在，你有了输出误差，<span class=''mathquill''>\delta_{output}，便可以反向传播这些误差了。<span class=''mathquill''>V_{in} 是该层的输入，比如经过隐藏层**函数的输出值。

范例

以一个简单的两层神经网络为例，计算其权重的更新过程。假设该神经网络包含两个输入值，一个隐藏节点和一个输出节点，隐藏层和输出层的**函数都是 sigmoid，如下图所示。（注意：图底部的节点为输入值，图顶部的 \hat yy^​ 为输出值。输入层不计入层数，所以该结构被称为两层神经网络。）

 

从这个例子中你可以看到 sigmoid 做**函数的一个缺点。sigmoid 函数导数的最大值是 0.25，因此输出层的误差被减少了至少 75%，隐藏层的误差被减少了至少 93.75%！如果你的神经网络有很多层，使用 sigmoid **函数会很快把靠近输入层的权重步长降为很小的值，该问题称作梯度消失。后面的课程中你会学到在这方面表现更好，也被广泛用于最新神经网络中的其它**函数。

用 NumPy 来实现

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

但是之前接触的只是单个节点的误差项。现在在更新权重时，我们需要考虑隐藏层 每个节点 的误差 \delta_jδj​：

Δwij​=ηδj​xi​

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

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}wij​ 是一个矩阵，所以右侧对应也应该有跟左侧同样的维度。幸运的是，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 是一维数组，就不行了。

反向传播练习

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

要做的事

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

 

 

import numpy as np

def sigmoid(x):
    """
    Calculate sigmoid
    """
    return 1 / (1 + np.exp(-x))

x = np.array([0.5, 0.1, -0.2])
target = 0.6
learnrate = 0.5

weights_input_hidden = np.array([[0.5, -0.6],
                                 [0.1, -0.2],
                                 [0.1, 0.7]])

weights_hidden_output = np.array([0.1, -0.3])

## Forward pass 1x2
hidden_layer_input = np.dot(x, weights_input_hidden)
hidden_layer_output = sigmoid(hidden_layer_input)

# 1x1
output_layer_in = np.dot(hidden_layer_output, weights_hidden_output)
output = sigmoid(output_layer_in)
print('output',output)
## Backwards pass
## TODO: Calculate output error
error = target - output

# TODO: Calculate error term for output layer
output_error_term = error * (output*(1-output))

# TODO: Calculate error term for hidden layer
hidden_error_term = weights_hidden_output * output_error_term * (hidden_layer_output*(1-hidden_layer_output))
print('hidden_error_term',hidden_error_term)
# TODO: Calculate change in weights for hidden layer to output layer
delta_w_h_o = learnrate * output_error_term * hidden_layer_output

# TODO: Calculate change in weights for input layer to hidden layer
delta_w_i_h = learnrate * hidden_error_term * x[:,None]
print('view======================')
print(output_error_term)
print(hidden_layer_output)
print('hidden_error_term')
print(hidden_error_term)
print(x)
print('Change in weights for hidden layer to output layer:')
print(delta_w_h_o)
print('Change in weights for input layer to hidden layer:')
print(delta_w_i_h)