MNIST数据集，图像识别（五）

本篇博客将会提高神经网络对MNIST数据集预测的准确率。

1、标准化样本数据

对于MNIST数据集来讲，它们都是1字节的像素，不需要将它们的取值缩放到一个相似的范围之内（特征缩放）。

为了使得样本数据的取值接近于零，我们需要进行标准化处理，对标准化可以理解为：“重新调整输入，使其平均值为0，标准差为1”。标准差衡量的是一个变量“分布”的情况。

2、超参数的调优

本次实例中，超参数是历元epochs，隐藏节点的数量n_hidden_nodes，学习率lr。

选择历元数量的常见方法：从一个比较高的数字开始，找到在准确率趋于平稳的历元数量。

隐藏节点越多，训练速度就越慢，但在处理一些粗糙的数据时，会使得网络模型更加灵活。

学习率越小，训练速度就越慢，但这些小的步长可以帮助网络模型接近最小的损失，可以对一些值进行尝试。对于隐藏节点和学习率，这里编写了一个python程序，锁定一个范围，进行调试。在此，将不进行展示。

3、代码

mnist_standardized.py

import numpy as np
import struct
import gzip# 加载图像
def load_images(filename):# 打开并解压文件with gzip.open(filename, 'rb') as f:# 定义变量存储文件里的标题信息，struct.unpack()函数是根据模式字符串从二进制文件中读取数据_ignored, n_images, columns, rows = struct.unpack('>IIII', f.read(16))# 往Numpy的字节数组中读取所有的像素all_pixels = np.frombuffer(f.read(), dtype=np.uint8)# 将像素重塑为一个矩阵，其每一行都是一个图像，并返回return all_pixels.reshape(n_images, columns * rows)# 计算训练样本数据集的平均值和标准差
# 可以使用这个函数来标准化训练集、验证集和测试集
def standardize(training_set, test_set):average = np.average(training_set)standard_deviation = np.std(training_set)training_set_standardize = (training_set - average) / standard_deviation  # 标准化样本数据，将每个输入变量值减去这些变量的平均值，再除以这些变量的标准差test_set_standardize = (test_set - average) / standard_deviationreturn training_set_standardize, test_set_standardizeX_train_raw = load_images("../data/mnist/train-images-idx3-ubyte.gz")
X_test_raw = load_images("../data/mnist/t10k-images-idx3-ubyte.gz")
X_train, X_test_all = standardize(X_train_raw, X_test_raw)
X_validation, X_test = np.split(X_test_all, 2)# 加载标签
def load_labels(filename):with gzip.open(filename, 'rb') as f:# 跳过标题字节f.read(8)# 将所有的标签放入一个列表all_labels = f.read()# 将标签列表重塑为一列的矩阵return np.frombuffer(all_labels, dtype=np.uint8).reshape(-1, 1)def one_hot_encode(Y):n_labels = Y.shape[0]n_classes = 10encoded_Y = np.zeros((n_labels, n_classes))for i in range(n_labels):label = Y[i]encoded_Y[i][label] = 1return encoded_YY_train_unencoded = load_labels("../data/mnist/train-labels-idx1-ubyte.gz")
Y_train = one_hot_encode(Y_train_unencoded)
Y_test_all = load_labels("../data/mnist/t10k-labels-idx1-ubyte.gz")
Y_validation, Y_test = np.split(Y_test_all, 2)

neural_network.py

import numpy as npdef sigmoid(z):return 1 / (1 + np.exp(-z))def softmax(logits):exponentials = np.exp(logits)return exponentials / np.sum(exponentials, axis=1).reshape(-1, 1)# 从S型函数输出计算S型函数的梯度，帮助计算w1与w2
def sigmoid_gradient(sigmoid):return np.multiply(sigmoid, (1 - sigmoid))def loss(Y, y_hat):return -np.sum(Y * np.log(y_hat)) / Y.shape[0]def prepend_bias(X):return np.insert(X, 0, 1, axis=1)# 将训练样本数据集分成若干个批量
def prepare_batches(X_train, Y_train, batch_size):x_batches = []y_batches = []n_examples = X_train.shape[0]for batch in range(0, n_examples, batch_size):batch_end = batch + batch_sizex_batches.append(X_train[batch:batch_end])y_batches.append(Y_train[batch:batch_end])return x_batches, y_batchesdef forward(X, w1, w2):h = sigmoid(np.matmul(prepend_bias(X), w1))y_hat = softmax(np.matmul(prepend_bias(h), w2))return (y_hat, h)# 反向传播算法
def back(X, Y, y_hat, w2, h):w2_gradient = np.matmul(prepend_bias(h).T, (y_hat - Y)) / X.shape[0]w1_gradient = np.matmul(prepend_bias(X).T, np.matmul(y_hat - Y, w2[1:].T)* sigmoid_gradient(h)) / X.shape[0]return w1_gradient, w2_gradientdef classify(X, w1, w2):y_hat, _ = forward(X, w1, w2)labels = np.argmax(y_hat, axis=1)return labels.reshape(-1, 1)# 初始化权重，采用w=正负根号下r分之一，r是权重矩阵的行数
def initialize_weights(n_input_variables, n_hidden_nodes, n_classes):w1_rows = n_input_variables + 1w1 = np.random.randn(w1_rows, n_hidden_nodes) * np.sqrt(1 / w1_rows)  # 从标准正态分布中抽取一个随机数矩阵w2_rows = n_hidden_nodes + 1w2 = np.random.randn(w2_rows, n_classes) * np.sqrt(1 / w2_rows)return w1, w2def report(epoch, batch, X_train, Y_train, X_test, Y_test, w1, w2):y_hat, _ = forward(X_train, w1, w2)training_loss = loss(Y_train, y_hat)classifications = classify(X_test, w1, w2)accuracy = np.average(classifications == Y_test) * 100.0print("%5d-%d, Loss: %.8f, Accuracy: %.2f%%" %(epoch, batch, training_loss, accuracy))def train(X_train, Y_train, X_test, Y_test, n_hidden_nodes, epochs, batch_size, lr):n_input_variables = X_train.shape[1]n_classes = Y_train.shape[1]w1, w2 = initialize_weights(n_input_variables, n_hidden_nodes, n_classes)x_batches, y_batches = prepare_batches(X_train, Y_train, batch_size)# epoch是历元的意思，遍历训练集中的所有小批量样本数据for epoch in range(epochs):# 对单个小批量样本数据进行梯度下降的一步迭代计算for batch in range(len(x_batches)):y_hat, h = forward(x_batches[batch], w1, w2)w1_gradient, w2_gradient = back(x_batches[batch], y_batches[batch], y_hat, w2, h)w1 = w1 - (w1_gradient * lr)w2 = w2 - (w2_gradient * lr)report(epoch, batch, X_train, Y_train, X_test, Y_test, w1, w2)return w1, w2

开始测试

import mnist_standardized as mns
import neural_network as nnnn.train(mns.X_train, mns.Y_train, mns.X_test, mns.Y_test, n_hidden_nodes=100, epochs=10, batch_size=256, lr=1)

训练的结果：

修改一下 neural_network.py 和测试中的代码，提高准确率：

import mnist_standardized as mns
import neural_network as nnnn.train(mns.X_train, mns.Y_train, mns.X_test, mns.Y_test, n_hidden_nodes=1200, epochs=100, batch_size=600, lr=0.8)

参考文献：

Programming Machine Learning: Form Coding to Deep Learning.[M],Paolo Perrotta,2021.6.