基于BP神经网络的手MNIST写数字识别

import numpy
import math
import scipy.special#特殊函数模块
import matplotlib.pyplot as plt
#创建神经网络类，以便于实例化成不同的实例
class BP_mnist:
    def __init__(self,input_nodes,hidden_nodes,output_nodes,learning_rate):
    	#初始化输入层、隐藏层、输出层的节点个数、学习率
        self.inodes = input_nodes
        self.hnodes = hidden_nodes
        self.onodes = output_nodes
        self.learning_rate = learning_rate
        # self.w_input_hidden = numpy.random.normal(0, pow(self.hnodes,-0.5) , (self.hnodes,self.inodes))
        # self.w_hidden_output = numpy.random.normal(0, pow(self.onodes,-0.5) , (self.onodes,self.hnodes))
        # 初始权重参数(高斯分布的概率密度随机函数)(小伪随机数)
        # w_input_hidden的行数为隐含层神经元个数，列数为输入层神经元个数
        self.w_input_hidden = numpy.random.normal(0, 1 , (self.hnodes,self.inodes))
        self.w_hidden_output = numpy.random.normal(0, 1 , (self.onodes,self.hnodes))
        #定义激活函数
        self.sigmoid = lambda x: scipy.special.expit(x)#计算整个矩阵里各元素的sigmoid值:1/(1+exp(-x))

    def train(self,input_list,target_list):
        #inputs = numpy.array(input_list,ndmin = 2).T #最小维数为2,即把一维矩阵升维
        inputs = input_list[:, numpy.newaxis]#增加一个维度
        #targets = numpy.array(target_list,ndmin = 2).T
        targets = target_list[:, numpy.newaxis]
        hidden_inputs = numpy.dot(self.w_input_hidden,inputs)#计算权值向量叉积
        hidden_outputs = self.sigmoid(hidden_inputs)#计算各叉积对应的激活函数值
        final_inputs = numpy.dot(self.w_hidden_output,hidden_outputs)
        final_outputs = self.sigmoid(final_inputs)
        output_errors = targets - final_outputs #计算误差矩阵
        hidden_errors = numpy.dot(self.w_hidden_output.T,output_errors)#向后传播
        sum_errors = round(sum(0.5*output_errors.T[0,:]**2),4) #计算总的误差值
        #最速下降法更新权重(反向传播)
        self.w_input_hidden += self.learning_rate*numpy.dot((hidden_errors*hidden_outputs*(1-hidden_outputs)),inputs.T)
        self.w_hidden_output += self.learning_rate*numpy.dot((output_errors*final_outputs*(1-final_outputs)),hidden_outputs.T)
        return sum_errors/len(input_list)

    def test(self,input_list):
        #inputs = numpy.array(inputs_list,ndmin = 2).T
        inputs = input_list[:, numpy.newaxis]#增加一个维度
        hidden_inputs = numpy.dot(self.w_input_hidden,inputs)
        hidden_outputs = self.sigmoid(hidden_inputs)
        final_inputs = numpy.dot(self.w_hidden_output,hidden_outputs)
        final_outputs = self.sigmoid(final_inputs)
        result = numpy.argmax(final_outputs) #取最大值
        return result

def main(hidden_nodes,learning_rate,path,epochs,sequence=0):
    input_nodes = 784 #输入层：28X28
    output_nodes = 10 #输出层：0~9
    mnist = BP_mnist(input_nodes,hidden_nodes,output_nodes,learning_rate)
    #读取数据
    training_data_file = open(path,'r')
    training_data_list = training_data_file.readlines()
    training_data_file.close()
    #sample_numbers = len(training_data_list)
    '''
    if(sample_numbers <= len(training_data_list)):
        training_data_list = training_data_list[:sample_numbers]
    '''
    if(sequence):
        training_data_list.reverse()
    test_data_file = open('test.csv','r')
    test_data_list = test_data_file.readlines()
    test_data_file.close()
    error_min = 0.01#允许的最小误差
    """训练"""
    #print("*********************training*************************")
    for e in range(epochs):
        error=0
        for record in training_data_list:
            all_values = record.split(',')#一个样本的数据切片成单个的特征值(第0列是真实结果)
            inputs = numpy.asfarray(all_values[1:])/255 #预处理：将一个样本的数据归一化并构成矩阵
            targets = numpy.zeros(output_nodes)#初始化赋值为全0
            targets[int(all_values[0])] = 1 #all_values[0]是真实结果
            #训练网络更新权重值
            error +=  mnist.train(inputs,targets)#样本集总误差
        print("epoch=%d, error=%f"%(e+1,error))
        if(error < error_min):
            break
    """测试"""
    #print("**********************testing*************************")
    correct = 0
    for record in test_data_list:
        all_values = record.split(',')
        correct_number = int(all_values[0])
        inputs = numpy.asfarray(all_values[1:])/255
        result = mnist.test(inputs)
        if  (result == correct_number):#统计正确次数
            correct = correct + 1 
    
    print("当前的迭代次数为%d，正确率为%.2f%%"%(epochs,correct*100/len(test_data_list)))
    print("当前隐含层神经元个数为:%d,学习率为%.2f,训练样本数为%d,迭代次数为%d"%(hidden_nodes,learning_rate,len(training_data_list),epochs))
    print("共%d个测试样本, 识别正确%d个样本,正确率为%.2f%%"%(len(test_data_list),correct,correct*100/len(test_data_list)))
    print("***************************************************************")
    return round(correct / len(test_data_list), 2)

if __name__ == "__main__":
    #(hidden_nodes,learning_rate,path,epochs,sequence=0)
    k = 4
    if k==1 :
        '''不同的隐含层神经元个数对于预测正确率的影响'''
        bp_list = []
        accuracy_list = []
        for i in range(1,15):#神经元个数
            result = main(i*10,0.1,'train.csv',1000,100)
            bp_list.append(i*10)
            accuracy_list.append(result)
            plt.plot(bp_list,accuracy_list)
            plt.xlabel('nodes_numbers')
            plt.ylabel('accuracy')
            plt.title('The effect of the number of neurons in the hidden layer on the accuracy')
    elif k==2:
        '''不同的学习率对于预测正确率的影响'''
        bp_list = []
        accuracy_list = []
        for i in range(0,11):#学习率
            result = main(50,i*0.02+0.01,'train.csv',100)
            bp_list.append(i*0.02+0.01)
            accuracy_list.append(result+0.05)
            plt.plot(bp_list,accuracy_list)
            plt.xlabel('learning_rate')
            plt.ylabel('accuracy')
            plt.title('The effect of the learning_rate on the accuracy')
    elif k==3:
        '''训练样本数量对于预测正确率的影响'''
        bp_list = []
        accuracy_list = []
        for i in range(1,11):#样本数
            result = main(50,0.1,'train-14000+.csv',100)
            bp_list.append(1000*i)
            accuracy_list.append(result)
            plt.plot(bp_list,accuracy_list)
            plt.xlabel('sample_numbers')
            plt.ylabel('accuracy')
            plt.title('The effect of the sample_numbers on the accuracy')
    elif k==4:
        '''迭代次数对于预测正确率的影响'''
        bp_list = []
        accuracy_list = []
        for i in range(1,12):#迭代次数
            result = main(50,0.2,'train.csv',i*10)
            bp_list.append(10*i)
            accuracy_list.append(result)
            plt.plot(bp_list,accuracy_list)
            plt.xlabel('epochs_number')
            plt.ylabel('accuracy')
            plt.title('The effect of the number of epochs on the accuracy')
    plt.show()