什么是神经网络？人类有1000亿个被称为神经元的细胞，它们之间通过轴突连接。连接到某个神经元的轴突中，如果有足够多数量被触发，则这个神经元就会被触发。我们把这个过程称为“思考”。

我们可以在电脑上创建一个神经网络模型。不需要模拟分子级别的复杂生物逻辑，只需要模拟高层的逻辑。我们使用一个数学技能，成为矩阵。为了简单，我们只用一个神经元，它有三个输入和一个输出。

image

我们将训练这个神经元来解决下面的问题。前面4个样本是训练集，你能找到它的规律吗？新样本中的“？”应该是0还是1？

image

你可能会注意到，output值总是与input中最左侧的值相同。所以，新样本中的“？”应该是1. 但是，我们如何教神经元来正确回答这个问题？

我们会给每一个input一个权重，它可以是正数也可以是负数。如果权重是一个很大的正数或者很大的负数，它对神经元输出值的影响也就很大。再开始之前，我们先给每一个权重设置一个随机值。然后，开始训练的过程。

1. 把训练集中的样本作为输入，通过权重来调整它们。然后把它们代入一个特殊的公式来计算神经元的输出。

2. 计算误差(error)。误差就是神经元的输出和训练集期望的输出的差值。

3. 根据误差的方向，轻微的调整权重。

4. 重复上面的过程10000次。

最终，神经元的权重会达到一个合适的值。如果我们让神经元去思考一个相同模式的新条件，他会做出不错的预测。

这个过程被称为反向传播。

image

神经元输出公式

你可能会好奇，神经元输出公式有什么特别之处？首先，我们对input加权求和。

image

然后归一化，使得它的最终值介于0和1之间。我们使用数学里一个很方便的函数，叫Sigmoid函数。

image

它的曲线为

image

把第一个公式带入第二个，得出神经元输出的最终公式

image

你可能已经注意到，我没有使用最小阈值，这样会简单一些。

源代码

from numpy import exp, array, random, dot

class NeuralNetwork():
    def __init__(self):
        # 随机数发生器种子，以保证每次获得相同结果
        random.seed(1)
        # 对单个神经元建模，含有3个输入连接和一个输出连接
        # 对一个3 x 1的矩阵赋予随机权重值。范围-1～1，平均值为0
        self.synaptic_weights = 2 * random.random((3, 1)) - 1

    # Sigmoid函数，S形曲线
    # 用这个函数对输入的加权总和做正规化，使其范围在0～1
    def __sigmoid(self, x):
        return 1 / (1 + exp(-x))

    # Sigmoid函数的导数
    # Sigmoid曲线的梯度
    # 表示我们对当前权重的置信程度
    def __sigmoid_derivative(self, x):
        return x * (1 - x)

    # 通过试错过程训练神经网络
    # 每次都调整突触权重
    def train(self, training_set_inputs, training_set_outputs, number_of_training_iterations):
        for iteration in range(number_of_training_iterations):
            # 将训练集导入神经网络
            output = self.think(training_set_inputs)
            # 计算误差（实际值与期望值之差）
            error = training_set_outputs - output
            # 将误差、输入和S曲线梯度相乘
            # 对于置信程度低的权重，调整程度也大
            # 为0的输入值不会影响权重
            adjustment = dot(training_set_inputs.T, error * self.__sigmoid_derivative(output))
            # 调整权重
            self.synaptic_weights += adjustment

    # 神经网络一思考
    def think(self, inputs):
        # 把输入传递给神经网络
        return self.__sigmoid(dot(inputs, self.synaptic_weights))

if __name__ == "__main__":
    # 初始化神经网络
    neural_network = NeuralNetwork()
    print("随机的初始突触权重：")
    print(neural_network.synaptic_weights)
    # 训练集。四个样本，每个有3个输入和1个输出
    training_set_inputs = array([[0, 0, 1], [1, 1, 1], [1, 0, 1], [0, 1, 1]])
    training_set_outputs = array([[0, 1, 1, 0]]).T
    # 用训练集训练神经网络
    # 重复一万次，每次做微小的调整
    neural_network.train(training_set_inputs, training_set_outputs, 10000)
    print("训练后的突触权重：")
    print(neural_network.synaptic_weights)
    # 用新数据测试神经网络
    print("考虑新的形势 [1, 0, 0] -> ?: ")
    print(neural_network.think(array([1, 0, 0])))

运行

python3 NeuralNetwork.py

结果

随机的初始突触权重：
[[-0.16595599]
 [ 0.44064899]
 [-0.99977125]]
训练后的突触权重：
[[ 9.67299303]
 [-0.2078435 ]
 [-4.62963669]]
考虑新的形势 [1, 0, 0] -> ?: 
[0.99993704]
MacBook-Pro-5:sa

解析：

初始化方法

    def __init__(self):
        # 随机数发生器种子，以保证每次获得相同结果
        random.seed(1)
        # 对单个神经元建模，含有3个输入连接和一个输出连接
        # 对一个3 x 1的矩阵赋予随机权重值。范围-1～1
        self.synaptic_weights = 2 * random.random((3, 1)) - 1

random.random((3, 1)) 生成一个3x1的numpy.ndarray类型的数组，每个元素的取值范围是[0,1]

2 * random.random((3, 1)) - 1,则取值范围变为 [-1 , 1] 。比如某次synaptic_weights得出的值为：

array([[-0.16595599],
       [ 0.44064899],
       [-0.99977125]])

sigmoid方法和它的导数

    # Sigmoid函数，S形曲线
    # 用这个函数对输入的加权总和做正规化，使其范围在0～1
    def __sigmoid(self, x):
        return 1 / (1 + exp(-x))

    # Sigmoid函数的导数
    # Sigmoid曲线的梯度
    # 表示我们对当前权重的置信程度
    def __sigmoid_derivative(self, x):
        return x * (1 - x)

他们的曲线图如下所示：

image

sigmoid函数x取值范围是(-无穷,+无穷)，对应的y值为(0,1)。它是一个单调递增函数。

sigmoid导数的图形是一个钟型，x取值范围(-无穷,+无穷),当x＝0时y值最大，为0.25。越往两端，值越小。这表明，sigmoid函数在x=0这个点变化最大(确定性低)，越往两边变化越小(确定性高)。

执行神经网络

就是将输入赋值给神经网络的输入层，然后根据网络的权重计算输出。

    # 神经网络一思考
    def think(self, inputs):
        # 把输入传递给神经网络
        return self.__sigmoid(dot(inputs, self.synaptic_weights))

inputs是一个1X3的数组。synaptic_weights是一个3X1的数组。dot点乘方法。根据矩阵计算方法，1X3的矩阵点乘一个3X1的矩阵，结果是一个1X1的矩阵，即一个数字(output)。含义如下图所示。

image

训练

    # 通过试错过程训练神经网络
    # 每次都调整突触权重
    def train(self, training_set_inputs, training_set_outputs, number_of_training_iterations):
        for iteration in range(number_of_training_iterations):
            # 将训练集导入神经网络
            output = self.think(training_set_inputs)
            # 计算误差（实际值与期望值之差）
            error = training_set_outputs - output
            # 将误差、输入和S曲线梯度相乘
            # 对于置信程度低的权重，调整程度也大
            # 为0的输入值不会影响权重
            adjustment = dot(training_set_inputs.T, error * self.__sigmoid_derivative(output))
            # 调整权重
            self.synaptic_weights += adjustment

training_set_inputs:训练集的输入，是一个NX3的数组。

training_set_outputs: 训练集的输出，是一个NX1的数组。当然，这两个参数也可以合并为一个NX4的数组参数。

number_of_training_iterations:训练中的迭代次数。一个模型往往需要很多次的训练才能收敛。

训练前, 程序先生成一个随机NeuralNetwork，即[[weight1], [weight2],[weight3]],比如值为

-0.16595599
0.44064899
-0.99977125

进入迭代，不断计算output和error，比如第1轮的值如下表所示

计算出来的output与训练集中的output有差异，说明模型不够好，需要优化。所谓优化，就是调整神经网络的权重。调整的方向是由error的符号决定的；

调整的大小是由error、output以及input的值决定的。

1.error越大，也就是误差越大，则需要调整的幅度越大；即error值与调整幅度成正相关。

2.output绝对值越大，需要调整的幅度越小(sigmoid函数越靠近两侧，确定性越高，越不需要调整,sigmoid导数越小),用sigmoid导数代表这个因素。output绝对值与调整幅度成负相关，也即sigmoid_derivative(output)与调整幅度成正相关。

3.调整的幅度是要分摊给每一个input的，即input1、input2和input3分别承担一部分幅度。input绝对值越小(比如接近0），越不需要关心它，也就需要调整的幅度越小。反之则越大。input值与调整幅度成正相关。

根据上面的相关性逻辑，可以用下面的公式来计算调整幅度(adjustment)

adjustment = dot(training_set_inputs.T, error * self.__sigmoid_derivative(output))

training_set_inputs.T(转置矩阵)为3XN的矩阵；error:为NX1的矩阵；output为NX1的矩阵；

adjustment为一个3X1的矩阵，即与神经网络的权重对应。

第1轮优化，Old Network、adjustment和new Network的权重分别是：

第2轮优化，Old Network、adjustment和new Network的权重分别是：

...

第99轮优化，Old Network、adjustment和new Network的权重分别是：

第100轮优化，Old Network、adjustment和new Network的权重分别是：

可以发现：

1. 训练到后面是，adjustment已经变得很小。也就是说，模型已经很好，不需要太多调整。

2. 最后的New Network，weight1绝对值很大。也就是说，input中，第一个值(input1)对output的影响最大。从训练集中也可以发现这个规律（output跟input1是一样的）。