[人工智能]简单全连接神经网络手写数字识别（Mnist数据集）

梳理了全连接神经网络模型前向传播和反向传播的工作流程步骤，仅为入门学习用，实际应用应采用TensorFlow等其他框架

数据集下载链接：
训练集：https://pjreddie.com/media/files/mnist_train.csv
测试集：https://pjreddie.com/media/files/mnist_test.csv

环境：Python3.8

import numpy
import scipy.special


class neuralNetwork:
    # 初始化
    def __init__(self, inputnodes, hiddennodes, outputnodes, learningrate):
        # 输入节点
        self.inodes = inputnodes
        # 隐藏节点
        self.hnodes = hiddennodes
        # 输出节点
        self.onodes = outputnodes
        # 输入层、隐藏层权重
        self.wih = numpy.random.normal(0, pow(self.hnodes, -0.5), (self.hnodes, self.inodes))
        # 隐藏层、输出层权重
        self.who = numpy.random.normal(0, pow(self.hnodes, -0.5), (self.onodes, self.hnodes))
        # 学习率
        self.lr = learningrate
        # sigmoid激活函数
        self.activation_fuction = 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_fuction(hidden_inputs)
        # 输出层输入
        final_inputs = numpy.dot(self.who, hidden_outputs)
        # 输出层输出
        final_outputs = self.activation_fuction(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 - final_outputs)),
                                        numpy.transpose(hidden_outputs))
        # 输入层、隐藏层权值更新
        self.wih += self.lr * numpy.dot((hidden_errors * hidden_outputs * (1 - hidden_outputs)),
                                        numpy.transpose(inputs))
        pass

    # 使用模型预测结果
    def query(self, inputs_list):
        # 输入值
        inputs = numpy.array(inputs_list, ndmin=2).T
        # 隐藏层输入
        hidden_nodes = numpy.dot(self.wih, inputs)
        # 隐藏层输出
        hidden_outputs = self.activation_fuction(hidden_nodes)
        # 输出值输入
        final_inputs = numpy.dot(self.who, hidden_outputs)
        # 输出值输出
        final_outputs = self.activation_fuction(final_inputs)
        return final_outputs

    pass


# 28*28=784个像素点对应输入层784个输入节点
input_nodes = 784
# 隐藏节点
hidden_nodes = 100
# 输出节点10个对应0~9十个数字
output_nodes = 10
# 学习率
learning_rate = 0.3
# 实例化对象，设置前向传播
n = neuralNetwork(input_nodes, hidden_nodes, output_nodes, learning_rate)

# 从训练集中获取数据
traning_data_file=open("mnist_dataset/mnist_train.csv",'r')
traning_data_list=traning_data_file.readlines()
traning_data_file.close()
# 遍历数据集
for record in traning_data_list:
    all_values = record.split(',')
    # all_values[0]为真实结果，此步骤将图片所有像素点的值缩小值0~1
    inputs=(numpy.asfarray(all_values[1:])/255.0*0.99)+0.01
    targets = numpy.zeros(output_nodes)+0.01
    # 将结果在targets中对应位置设为0.99
    targets[int(all_values[0])]=0.99
    # 开始训练
    n.train(inputs,targets)

# 从测试集中获取数据
test_data_file=open("mnist_dataset/mnist_test.csv",'r')
test_list=test_data_file.readlines()
test_data_file.close()
scorecard=[]
for record in test_list:
    all_values = record.split(',')
    correct_label=int(all_values[0])
    print(correct_label,"correct_label")
    inputs=(numpy.asfarray(all_values[1:])/255.0*0.99)+0.01
    outputs=n.query(inputs)
    # 输出矩阵中最大元素值对应的位置，即为预测结果
    label=numpy.argmax(outputs)
    print(label,"networ's answer")
    if(label==correct_label):
        scorecard.append(1)
    else:
        scorecard.append(0)
scorecard_array=numpy.asarray(scorecard)
print("performance:",scorecard_array.sum()/scorecard_array.size)