神经网络学习5【train()函数编写 + 完整的神经网络代码】

上一篇文章讲了误差的传递与更新。至此这样一个简单的神经网络的脉络我们已经梳理清楚了。
紧接着，我们再回到已经写好输入和查询的神经网络框架中，去完善它。

train()函数

训练网络。训练任务分为两个部分:①针对给定的训练样本计算输出。②将计算得到的输出与所需输出对比，使用差值来指导网络权重的更新。

①针对给定的训练样本计算输出

我们已经完成了第一部分：

    # train the neural network
    def train(self, inputs_list, targets_list):

     # convert inputs list to 2d array
     inputs = numpy.array(inputs_list, ndmin=2).T
     targets = numpy.array(targets_list, ndmin=2).T

     # calculate signals into hidden layer
     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)
     pass

我们使用完全相同的方式从输入层前馈信号到最终输出层，所以代码与query()函数中的几乎完全一样。
注意：为什么在这里是完全一样的呢？我在第一遍看书与编写代码的过程中曾对这个问题疑惑过，但事实上，这是一个非常简单的问题。
虽然我们把这两个函数放在同一个类里面，但他们承担的工作并不能算是“一条流水线”上的，从这个角度来说，这两个函数完成的工作是毫不相关的。train()函数负责对训练集数据进行训练，找出能输出准确值的权重矩阵，在整个训练的过程中，它都需要针对给定的训练样本计算输出，，而query()是单纯的输出计算结果，更多的运用是在样本训练好之后，直接查询用的。

②网络权重的更新

首先，需要计算误差：

     # error is the (targets-actual)
     output_errors = targets - final_outputs

然后，可以计算出隐含层节点反向传播的误差。

     # hidden layer error is the output_errors, split by weights, recombined at hidden nodes
     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))

计算结束！

完整的神经网络代码

import numpy
import scipy.special

# neural network class definition


class NeuralNetwork:
    # initialise the neural network
    def __init__(self, inputnodes, hiddennodes, outputnodes, learningrate):
        # set number of nodes in each inputs,hidden,output layer
        self.inodes = inputnodes
        self.hnodes = hiddennodes
        self.onodes = outputnodes

        self.lr = learningrate

        # link weight matrices, wih and who
        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))

        self.activation_function = lambda x: scipy.special.expit(x)
        pass

    # train the neural network
    def train(self, inputs_list, targets_list):

        # convert inputs list to 2d array
        inputs = numpy.array(inputs_list, ndmin=2).T
        targets = numpy.array(targets_list, ndmin=2).T

        # calculate signals into hidden layer
        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)

        # error is the (targets-actual)
        output_errors = targets - final_outputs
        # hidden layer error is the output_errors, split by weights, recombined at hidden nodes
        hidden_errors = numpy.dot(self.who.T, output_errors)

        # update the weights for the links between the hidden and output layers
        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

    # query the neural network
    def query(self, inputs_list):
        # convert inputs list to 2d array
        inputs = numpy.array(inputs_list, ndmin=2).T

        # calculate signals into hidden layer
        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

到目前为止，这样就已经建立好了一个三层的神经网络。