如何用Python创建一个多层神经网络
- 2019 年 10 月 6 日
- 笔记
英文原文：https://medium.com/technology-invention-and-more/how-to-build-a-multi-layered-neural-network-in-python-53ec3d1d326a
问题
在之前的博文里， 我们学习了如何创建一个神经网络。不过，如果我们面临一个更复杂的问题，如何识别“？”是什么？
|
|
Input |
output |
|---|---|---|
|
Example 1 |
0 0 1 |
0 |
|
Example 2 |
0 1 1 |
1 |
|
Example 3 |
1 0 1 |
1 |
|
Example 4 |
0 1 0 |
1 |
|
Example 5 |
1 0 0 |
1 |
|
Example 6 |
1 1 1 |
0 |
|
Example 7 |
0 0 0 |
0 |
|
New situation |
1 1 0 |
? |
|---|
仔细观察会发现，input3是一个无关项。前两列通过“异或”运算后得到output。 因此，我们知道，“？”的值应该是0.
不过，单层神经网络已经处理不了这样的逻辑了。在input和output之间不存在“一对一”的关系，这种情况被称为“非线性模式”。
我们必须创建一个隐藏层，比如有4个神经元(Layer1)。这可以使得神经网络来思考input的组合情况。
蓝色线是神经元之间的链接。这个图是由 https://github.com/miloharper/visualise-neural-network 工具自动生成的。
图中可以看到，Layer1是Layer2的输入。现在，我们可以从训练数据中寻找Layer1和output的关系。在神经网络的训练过程中，通过调整两层的权重，相关性会得到放大。
实际上，图像识别跟这个很相似。像素和苹果之间没有直接的关联。但是，像素的组合与苹果存在一个直接的关联。
给神经网络增加更多层，它就会做更复杂的思考。
Python源码地址: https://github.com/miloharper/multi-layer-neural-network
这个神经网络是从之前文章中修改而来的。总和解释参见文章《Python代码搭建简单的神经网络》。
不同之处是现在有多层。当神经网络计算Layer2的error时，它会反向把它传播回Layer1， 然后调整Layer1到权重。这被称为“反向传播(back propagation)”
运行代码
python main.py
结果
Stage 1) Random starting synaptic weights: Layer 1 (4 neurons, each with 3 inputs): [[-0.16595599 0.44064899 -0.99977125 -0.39533485] [-0.70648822 -0.81532281 -0.62747958 -0.30887855] [-0.20646505 0.07763347 -0.16161097 0.370439 ]] Layer 2 (1 neuron, with 4 inputs): [[-0.5910955 ] [ 0.75623487] [-0.94522481] [ 0.34093502]] Stage 2) New synaptic weights after training: Layer 1 (4 neurons, each with 3 inputs): [[ 0.3122465 4.57704063 -6.15329916 -8.75834924] [ 0.19676933 -8.74975548 -6.1638187 4.40720501] [-0.03327074 -0.58272995 0.08319184 -0.39787635]] Layer 2 (1 neuron, with 4 inputs): [[ -8.18850925] [ 10.13210706] [-21.33532796] [ 9.90935111]] Stage 3) Considering a new situation [1, 1, 0] -> ?: [ 0.0078876]
首先，神经网络随机为神经链接分配权重，然后使用训练集进行训练。
然后，它会对之前没有遇到过到新情况 [1, 1, 0]进行思考，并做出预测。预测值是0.0078876。正确答案是0，已经非常接近。
很酷！不过计算机在背后做了很多看不见的矩阵运算。
代码解析
1.神经元层
#神经元层 class NeuronLayer(): # number_of_neurons:神经元数量; number_of_inputs_per_neuron:每个神经元的输入数 def __init__(self, number_of_neurons, number_of_inputs_per_neuron): self.synaptic_weights = 2 * random.random((number_of_inputs_per_neuron, number_of_neurons)) - 1
new 一个NeuronLayer会生成一层神经元。比如layer1 = NeuronLayer(4, 3)就是生成layer 1，有4个神经元，每个神经元有3个输入。实际上就是一个3行4列的数组。 注意，__init__的参数与random的参数顺序不一样。
2.神经网络
class NeuralNetwork(): def __init__(self, layer1, layer2): self.layer1 = layer1 self.layer2 = layer2
这是神经网络class。因为这个神经网络有两层，所以有2个参数layer1,layer2。它们是NeuronLayer类型。当然，这种写法扩展性并不好，如果需要三层网络，还需要修改代码。如果改成数组存储每一层神经元，会提高扩展性。不过那样可能性又会低一点。这里为了方便解释，这里就写4死layer1,layer2来存储每层网络。
3.思考
# The neural network thinks. def think(self, inputs): output_from_layer1 = self.__sigmoid(dot(inputs, self.layer1.synaptic_weights)) output_from_layer2 = self.__sigmoid(dot(output_from_layer1, self.layer2.synaptic_weights)) return output_from_layer1, output_from_layer2
第一层的输出＝输入＊layer1的权重 (NX3的矩阵 * 3X4的矩阵=NX4的矩阵)
第二层的输出＝第一层的输出＊layer2的权重 (NX4的矩阵 ＊ 4X1的矩阵 ＝ NX1的矩阵)
输出每一层的输出值
注：NXK的矩阵表示N个样本，每个样本输出K个值。
4.训练
# We train the neural network through a process of trial and error. # Adjusting the synaptic weights each time. def train(self, training_set_inputs, training_set_outputs, number_of_training_iterations): for iteration in range(number_of_training_iterations): # Pass the training set through our neural network output_from_layer_1, output_from_layer_2 = self.think(training_set_inputs) # Calculate the error for layer 2 (The difference between the desired output # and the predicted output). layer2_error = training_set_outputs - output_from_layer_2 layer2_delta = layer2_error * self.__sigmoid_derivative(output_from_layer_2) # Calculate the error for layer 1 (By looking at the weights in layer 1, # we can determine by how much layer 1 contributed to the error in layer 2). layer1_error = layer2_delta.dot(self.layer2.synaptic_weights.T) layer1_delta = layer1_error * self.__sigmoid_derivative(output_from_layer_1) # Calculate how much to adjust the weights by layer1_adjustment = training_set_inputs.T.dot(layer1_delta) layer2_adjustment = output_from_layer_1.T.dot(layer2_delta) # Adjust the weights. self.layer1.synaptic_weights += layer1_adjustment self.layer2.synaptic_weights += layer2_adjustment
训练中迭代number_of_training_iterations次，每一次都会：
1. 思考，把训练集作为输入，用神经网络思考，得出输出(output_from_layer_1, output_from_layer_2)。output_from_layer_1是NX4的矩阵，output_from_layer_2是NX1的矩阵。
2. 比较layer2的输出和期望输出，得出layer2输出误差（layer2_error）。layer2_error是NX1的矩阵。
3. 计算layer2输出的S梯度值self.__sigmoid_derivative(output_from_layer_2),得出置信程度。对于置信程度低的权重，调整程度也大。
误差越大，权重调整程度也大。所以要再乘以误差(layer2_error)。即
layer2_delta=layer2_error * self.__sigmoid_derivative(output_from_layer_2)
layer2_delta就是layer2的输出需要调整的步长。layer2_delta是NX1的矩阵。
4. layer2有1个神经元，每个神经元有4个输出。layer2.synaptic_weights是一个4X1的矩阵。它的转置矩阵layer2.synaptic_weights.T是一个1X4的矩阵。
layer1_error = layer2_delta.dot(self.layer2.synaptic_weights.T)
layer2的输出要调整，比如要调整layer1的输出。layer2需要调整的值(layer2_delta)越大，就说明layer1的输出有误差(layer1_error)应该越大。乘正比关系；另外，与layer2的权重也乘正比关系，因为layer2的输出是layer1输出.dot.layer2.synaptic_weights。
layer1_error是一个NX4的矩阵。它表示layer1输出的4个值，每个值的误差。
5. layer1_delta与layer2_delta的计算方法一样。
layer1_delta = layer1_error * self.__sigmoid_derivative(output_from_layer_1)
layer1_delta是一个NX4的矩阵，表示每一个输出值在本次iteration需要调整的步长。
6.
layer1_adjustment = training_set_inputs.T.dot(layer1_delta) layer2_adjustment = output_from_layer_1.T.dot(layer2_delta)
training_set_inputs 是一个NX3的矩阵；training_set_inputs.T是一个3XN的矩阵。layer1_delta是一个NX3的矩阵。因此layer1_adjustment是一个3X4的矩阵。
layer1.synaptic_weights也是一个3X4的矩阵。layer1_adjustment就是每个权重需要调整的值。
同理，layer2_adjustment是layer2.synaptic_weights中每个权重需要调整的值。layer2_adjustment和layer2.synaptic_weights都是4X1的矩阵。
7. 调整权重
self.layer1.synaptic_weights += layer1_adjustment self.layer2.synaptic_weights += layer2_adjustment
继续下一个迭代的训练
