BP神经网络在python下的自主搭建梳理

本实验使用mnist数据集完成手写数字识别的测试。识别正确率认为是95%

完整代码如下：

 #!/usr/bin/env python

 # coding: utf-8

 # In[1]:

 import numpy

 import scipy.special

 import matplotlib.pyplot

 # In[2]:

 class neuralNetwork:

     def __init__(self, inputNodes, hiddenNodes, outputNodes,learningRate):

         self.iNodes = inputNodes

         self.oNodes = outputNodes

         self.hNodes = hiddenNodes

         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))

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

         #print(self.wih)

         pass

     def train(self,inputs_list, target_list):

         inputs = numpy.array(inputs_list, ndmin=2).T

         targets = numpy.array(target_list, ndmin=2).T

         #print(inputs)

         #print(targets)

         hidden_inputs = numpy.dot(self.wih,inputs)

         #print(self.wih.shape)

         #print(inputs.shape)

         hidden_outputs = self.activation_function(hidden_inputs)

         #print(hidden_inputs)

         final_inputs = numpy.dot(self.who,hidden_outputs)

         #print(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, inputs_list):

         inputs = numpy.array(inputs_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_outpus = self.activation_function(final_inputs)

         return final_outpus

         pass

 # In[3]:

 inputNodes = 784

 outputNodes = 10

 hiddenNodes = 100

 learningRate = 0.1

 nN = neuralNetwork(inputNodes, hiddenNodes, outputNodes, learningRate)

 # In[4]:

 data_file = open("mnist_train.csv",'r')

 data_list = data_file.readlines()

 data_file.close()

 # In[5]:

 epochs = 1

 for e in range(epochs) :

     for record in data_list:

         all_values = record.split(',')

         inputs = numpy.asfarray( all_values [1:])/255.0*0.99+0.01

         targets = numpy.zeros(outputNodes) + 0.01

         targets[int (all_values[0])] = 0.99

         nN.train(inputs,targets)

         pass

     pass

 # In[6]:

 test_data_file = open("mnist_test.csv",'r')

 test_data_list = test_data_file.readlines()

 test_data_file.close()

 # In[7]:

 scorecard = []

 for record in test_data_list:

     all_values = record.split(',')

     correct_label = int(all_values[0])

     inputs = numpy.asfarray( all_values [1:])/255.0*0.99+0.01

     outputs = nN.query(inputs)

     label = numpy.argmax(outputs)

     if(label == correct_label):

         scorecard.append(1)

     else:

         scorecard.append(0)

         pass

     pass

 # In[8]:

 scorecard_array = numpy.asarray(scorecard)

 print ("performance = " ,scorecard_array.sum()/scorecard_array.size)

 # In[9]:

 import scipy.misc

 img_array = scipy.misc.imread('test.png',flatten="True")

 img_data = 255.0 - img_array . reshape(784)

 img_data = (img_data /255.0 * 0.99 ) + 0.01

 op=nN.query(img_data)

 print(op)

 print(numpy.argmax(op))

 # In[10]:

 all_values = data_list[1].split(',')

 image_array = numpy.asfarray( all_values [1:]).reshape((28,28))

 matplotlib.pyplot.imshow(image_array, cmap = 'Greys',interpolation='None')

IN[9]到IN[10]的代码分别用于测试自己制作的数字识别效果和显示图像。可去掉。

代码运行过程需要mnist数据集，链接：https://pan.baidu.com/s/120GTdZ8Tivkp1KD9VQ_XeQ

BP神经网络的结构：https://www.cnblogs.com/bai2018/p/10353768.html

在输入层的神经元数据选取上，和像素数量一致。MNIST采用28X28的像素点，则输入层的神经元数量为28*28=784个

输入层和隐层，输出层和隐层之间的权值选取为随机数。使用正态分布的随机数较好。

隐层的神经元数量合适即可，取值为经验法，假设为100个

输出层神经元表示数据0-9，则使用10个神经元，分别表示数字0-9的可能性概率。

训练过程中使用的学习效率，取0.2吧。。。

将权重，各层神经元值，误差等，表示为矩阵数据进行处理。

正向传递数据查询结果，误差的反向传递改变权重等过程，涉及到的数学推导：https://www.cnblogs.com/bai2018/p/10353814.html

巴特西

BP神经网络在python下的自主搭建梳理

最新文章

热门文章