训练网络

　　解决训练任务，包括两部分内容：

第一部分：针对给定的训练样本计算输出。这与query()函数所做的工作没什么区别。

第二部分：将计算所得到的输出与期望的目标值做对比，使用差值来指导网络权重的更新。

其中，第一部分的代码如下所示：

    def train(self,input_list,target_list):
        # 转换输入输出列表到二维数组
        inputs = numpy.array(input_list, ndmin=2).T
        targets = numpy.array(target_list,ndmin= 2).T
        # 计算到隐藏层的信号
        hidden_inputs = numpy.dot(self.wih, inputs)
        # 计算隐藏层输出的信号
        hidden_outputs = self.activation_function(hidden_inputs)
        # 计算到输出层的信号
        final_inputs = numpy.dot(self.who, hidden_outputs)
        final_outputs = self.activation_function(final_inputs)

这部分与query()中的区别在于多了一个期望值，因为我们需要期望值来训练网络，所以这部分必不可少。

第二部分：

1.首先需要计算误差，也就是期望值减去输出的实际值，以此可表示为：

output_errors = targets - final_outputs

2.那么，如何根据得到的输出误差来更新隐藏层和输出层，输入层和隐藏层之间的权重呢？首先，输出的误差来源于隐藏层传播的误差，隐藏层各个节点的误差具体分配多少呢？

　　　　　　　　　　　　　　　　　　　　errors_hidden = weights^T_{hidden_output} * errors_output

使用python上式可表示为：

hidden_errors = numpy.dot(self.who.T,output_errors)

其次，利用公式更新权重：

　　　　　　ΔW_j,k = α * E_k * sigmod(Ok) * (1 - sigmod(O_K)) * O_j^T

使用python可表示为：

#隐藏层和输出层权重更新
        self.who += self.lr * numpy.dot((output_errors*final_outputs*(1.0-final_outputs)),
                                        numpy.transpose(hidden_outputs))
        #输入层和隐藏层权重更新
        self.wih += self.lr * numpy.dot((hidden_errors * hidden_outputs * (1.0 - hidden_outputs)),
                                        numpy.transpose(inputs))

因此，完整的神经网络代码表示为：

import numpy
import scipy.special

# 神经网络类定义
class NeuralNetwork():
    # 初始化神经网络
    def __init__(self, inputnodes, hiddennodes, outputnodes, learningrate):
        # 设置输入层节点，隐藏层节点和输出层节点的数量
        self.inodes = inputnodes
        self.hnodes = hiddennodes
        self.onodes = outputnodes
        # 学习率设置
        self.lr = learningrate
        # 权重矩阵设置 正态分布
        self.wih = numpy.random.normal(0.0, pow(self.hnodes, -0.5), (self.hnodes, self.inodes))
        self.who = numpy.random.normal(0.0, pow(self.onodes, -0.5), (self.onodes, self.hnodes))
        # 激活函数设置，sigmod()函数
        self.activation_function = lambda x: scipy.special.expit(x)
        pass

    # 训练神经网络
    def train(self,input_list,target_list):
        # 转换输入输出列表到二维数组
        inputs = numpy.array(input_list, ndmin=2).T
        targets = numpy.array(target_list,ndmin= 2).T
        # 计算到隐藏层的信号
        hidden_inputs = numpy.dot(self.wih, inputs)
        # 计算隐藏层输出的信号
        hidden_outputs = self.activation_function(hidden_inputs)
        # 计算到输出层的信号
        final_inputs = numpy.dot(self.who, hidden_outputs)
        final_outputs = self.activation_function(final_inputs)

        output_errors = targets - final_outputs
        hidden_errors = numpy.dot(self.who.T,output_errors)

        #隐藏层和输出层权重更新
        self.who += self.lr * numpy.dot((output_errors*final_outputs*(1.0-final_outputs)),
                                        numpy.transpose(hidden_outputs))
        #输入层和隐藏层权重更新
        self.wih += self.lr * numpy.dot((hidden_errors * hidden_outputs * (1.0 - hidden_outputs)),
                                        numpy.transpose(inputs))
        pass
    # 查询神经网络
    def query(self, input_list):
        # 转换输入列表到二维数组
        inputs = numpy.array(input_list, ndmin=2).T
        # 计算到隐藏层的信号
        hidden_inputs = numpy.dot(self.wih, inputs)
        # 计算隐藏层输出的信号
        hidden_outputs = self.activation_function(hidden_inputs)
        # 计算到输出层的信号
        final_inputs = numpy.dot(self.who, hidden_outputs)
        final_outputs = self.activation_function(final_inputs)

        return final_outputs