使用NumPy搭建基础人工神经网络

本文使用Python科学计算库NmPy完成基础的人工神经网络搭建，并将其应用于对MNIST手写体数字数据集的训练和分类。

人工神经网络可以有数层，每一层有数个神经元节点，通过训练节点间的参数，即权重，来调节节点连接强度，以此训练模型。具体的，该网络正向前馈信号，反向传播误差，并使用梯度下降方法优化参数，最终使参数收敛。人工神经网络可以用于解决相当复杂的多分类问题。

有关人工神经网络的详细描述，敬请查看《从零讲述人工神经网络》。

MNIST数据集：常用于数据科学和机器学习领域非常出名的手写体数字数据集，其中的每一张手写体数字图片大小为28×28的灰度图像。本文使用的数据集已经经过了预处理，以csv格式存储所有数据样本。其中每一行表示一个样本图片，共785个值，其中第一个值为0~9的标签，后跟784个0~255的灰度像素值。数据集已提前划分好训练集和测试集，存储在对应文件中，分别包含6w和1w条数据。

👉 数据集下载

让我们写一个简单的程序以将MNIST数据集可视化。

import numpy as np
import matplotlib.pyplot as plt

def show_picture(values):  
    image_array = np.asfarray(values[1:]).reshape((28,28))
    plt.imshow(image_array, cmap='Greys', interpolation='None')
    plt.xlabel(str(values[0]))


with open('mnist_dataset/mnist_train.csv','r') as f:
    training_data_list = f.readlines()

plt.figure(figsize=(12, 6))
for i in range(1, 11):
    plt.subplot(2, 5, i)
    show_picture(training_data_list[i-1].split(','))
plt.show()

这里我们显示出了训练集中的前十张样本图片，将真实标签打印在每张图片下方。

接下来开始真正的神经网络的搭建。我们计划搭建一个3层人工神经网络，分别对应输入层、隐藏层和输出层。其中每一层的节点数量均可以自由调节。

搭建模型类，初始化节点数量、随机初始权重、学习率和Sigmoid激活函数。

import numpy as np

class NeuralNetwork:
    def __init__(self, inputnodes, hiddennodes, outputnodes, learningrate):
        # number of nodes of each layer
        self.inodes = inputnodes
        self.hnodes = hiddennodes
        self.onodes = outputnodes

        # initialise weights (random distribution)
        self.wih = np.random.normal(0.0, np.power(self.hnodes, -0.5), (self.hnodes, self.inodes))
        self.who = np.random.normal(0.0, np.power(self.onodes, -0.5), (self.onodes, self.hnodes))

        # learning rate
        self.lr = learningrate

        # activation function (Sigmoid)
        self.activation_function = lambda x: 1 / (1 + np.exp(-x))

编写查询函数，通过一轮前馈信号得到输出的分类结果（one-hot vector）。

    def query(self, inputs_list):
        # input layer
        inputs = np.array(inputs_list, ndmin=2).T

        # hidden layer
        hidden_inputs = self.wih @ inputs
        hidden_outputs = self.activation_function(hidden_inputs)

        # output layer
        final_inputs = self.who @ hidden_outputs
        final_outputs = self.activation_function(final_inputs)

        return final_outputs

训练函数，在每一轮训练中，信号前馈传递，误差反向传播，且通过梯度下降法更新权重。

    def train(self, inputs_list, targets_list):
        # input layer
        inputs = np.array(inputs_list, ndmin=2).T
        targets = np.array(targets_list, ndmin=2).T

        # hidden layer
        hidden_inputs = self.wih @ inputs
        hidden_outputs = self.activation_function(hidden_inputs)

        # output layer
        final_inputs = self.who @ hidden_outputs
        final_outputs = self.activation_function(final_inputs)

        # errors used in gradient descent (different from defined loss)
        output_errors = targets - final_outputs
        hidden_errors = self.who.T @ output_errors

        # update weights (gradient descent)
        self.who -= self.lr * (-output_errors * final_outputs * (1 - final_outputs) @ hidden_outputs.T)
        self.wih -= self.lr * (-hidden_errors * hidden_outputs * (1 - hidden_outputs) @ inputs.T)

最后进行模型的训练和测试。将输入节点数量设置为图片的像素数量，输出节点数量为类别数量，隐藏层节点数量可以自由调节。我们将进行5轮迭代训练，每轮训练都会遍历整个训练数据集。最终读取测试集测试并记录正确率。

input_nodes = 784
hidden_nodes = 200
output_nodes = 10
learning_rate = 0.1

# Build Model
nn = NeuralNetwork(input_nodes, hidden_nodes, output_nodes, learning_rate)


with open('mnist_dataset/mnist_train.csv','r') as f:
    training_data_list = f.readlines()

# Train
print('Training...')
epochs = 5
for e in range(epochs):
    print('epoch', e + 1, '/', epochs)
    for t, record in enumerate(training_data_list):
        all_values = record.split(',')
        # normalise input into 0.01-0.99
        inputs = np.asfarray(all_values[1:]) / 255.0 * 0.99 + 0.01
        # generate target value (one-hot vector)
        targets = np.zeros(output_nodes) + 0.01
        targets[int(all_values[0])] = 0.99
        nn.train(inputs, targets)
        if (t + 1) % 1000 == 0:
            print('sample', str(t + 1), '/', len(training_data_list), '\r', end='')
    print()
print()


with open('mnist_dataset/mnist_test.csv', 'r') as f:
    test_data_list = f.readlines()

# Test
print('Testing...')
scorecard = []
for record in test_data_list:
    all_values = record.split(',')
    correct_label = int(all_values[0])
    inputs = np.asfarray(all_values[1:]) / 255.0 * 0.99 + 0.01
    outputs = nn.query(inputs)
    label = np.argmax(outputs)
    scorecard.append(1 if label == correct_label else 0)

# Accuracy
scorecard_array = np.asarray(scorecard)
print('Accuracy:', scorecard_array.sum() / scorecard_array.size)

最终运行花费大概10多分钟的时间，正确率约0.97，结果非常理想。

模型参考：《Python神经网络编程》