2022-07-29 16:44:23 星期五

（一）环境配置

使用ANACONDA集成环境，然后按照规则添加环境变量即可正常使用jupyter notebook运行python,过程非常简单，集成环境非常好用。

（二）数据集获取

数字识别一般为有监督学习，在此训练一个三层的神经网络用于识别数字，数据集则是采用MNIST的数据集，可以从这哥们的网站MNIST训练集和测试集获取，训练集为60000条28*28的手写数字，以逗号分隔，每个单独数字的第0位为目标数字。使用python写一个读取函数测试如下：
# 测试读取
import numpy
import matplotlib.pyplot

#导入数据
data_file = open("mnist_train.csv",'r')
data_list = data_file.readlines()
data_file.close()
len(data_list)
data_list[0]
all_values = data_list[0].split(',')
image_array = numpy.asfarray(all_values [1:]).reshape((28,28))
matplotlib.pyplot.imshow( image_array, cmap='Greys', interpolation="None")

可以看到如下结果，证明读取成功。
null

（三）编写神经网络

在这里直接附上代码，使用其生成一个三层的神经网络：
# 生成神经网络
import numpy
import scipy.special
import matplotlib.pyplot
%matplotlib inline

# 神经网络类的定义
class neuralNetwork :
    # 初始化神经网络
    def __init__( self, inputnodes, hiddennodes, outputnodes, learningrate ) :
        # 设置输出、输入和隐藏层的结点数
        self.inodes = inputnodes
        self.hnodes = hiddennodes
        self.onodes = outputnodes
        
        # 权重矩阵，使用随机生成的权重 
        # wih: weight input to hidden 
        # who: weight output to hidden
        # w11 w21
        # w12 w22
        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.lr = learningrate
        
        # 激活函数 sigmoid
        self.activation_function = lambda x: scipy.special.expit(x)
        
        pass
    
    
    # 训练神经网络
    def train(self, inputs_list, targets_list) :
        # 把输入转换为二维矩阵
        inputs = numpy.array(inputs_list, ndmin=2).T
        targets = numpy.array(targets_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, 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_outputs = self.activation_function(final_inputs)
        
        return final_outputs

（四）训练神经网络

在神经网络训练时进行多次迭代，按照书中指导在7个世代后获取到最佳准确度。
# 输入层输出层隐藏层数量
input_nodes = 784
hidden_nodes = 200
output_nodes = 10

# 学习速率
learning_rate = 0.1

# 建立神经网络
n = neuralNetwork(input_nodes, hidden_nodes, output_nodes, learning_rate)

# 输入数据集
training_data_file = open("mnist_train.csv",'r')
training_data_list = training_data_file.readlines()
training_data_file.close()

# 训练神经网络 多次运行
epochs = 7
for e in range(epochs):
    for record in training_data_list:
        # 每张图片由“  ，”分割,
        all_values = record.split(',')
        # 输入缩放
        inputs = (numpy.asfarray(all_values[1:]) / 255.0 * 0.99) + 0.01
        # 建立目标输出素组，均0.01，预期结点为 0.99
        targets = numpy.zeros(output_nodes) + 0.01
        # 所有数据的第0个数据为训练图片代表的数值
        targets[int(all_values[0])] = 0.99
        n.train(inputs, targets)
pass

（五）测试神经网络

使用测试集测试神经网络，并且打印测试时神经网络的正确率。
# 测试神经网络

# 导入文件
test_data_file = open("mnist_test.csv",'r')
test_data_list = test_data_file.readlines()
test_data_file.close()

# 为神经网络的表现赋分
f_correct = 0;f_error = 0;size = 0

for record in test_data_list:
    # 分割
    all_values = record.split(',')
    # 读取目标
    size += 1;
    correct_label = int(all_values[0])
    # 输入缩放
    inputs = (numpy.asfarray(all_values[1:]) / 255.0 * 0.99) + 0.01
    outputs = n.query(inputs)
    label = numpy.argmax(outputs)
    if(label == correct_label):
        f_correct += 1;
    else:
        f_error += 1;
    pass
pass

print("Accuracy : ",f_correct/size*100,"%")

null
经过测试，训练后的神经网络准确率为97.5%，对于一个仅有200个隐藏结点的神经网络来说，这样的准确率已经比较好了。