机器学习入门（07）— MNIST 数据集手写数字的识别

和求解机器学习问题的步骤（分成学习和推理两个阶段进行）一样，使用神经网络解决问题时，也需要首先使用训练数据（学习数据）进行权重参数的学习；进行推理时，使用刚才学习到的参数，对输入数据进行分类。

1. MNIST 数据集

MNIST 数据集是由 0 到 9 的数字图像构成的（图3-24）。训练图像有 6 万张，测试图像有1 万张，这些图像可以用于学习和推理。

MNIST 数据集的一般使用方法是，先用训练图像进行学习，再用学习到的模型度量能在多大程度上对测试图像进行正确的分类。

MNIST 的图像数据是 28 像素 × 28 像素的灰度图像（1 通道），各个像素的取值在0 到 255 之间。每个图像数据都相应地标有“7”“2”“1”等标签。

2. 代码实现

2.1 下载并读取数据

mnist.py 代码实现

# coding: utf-8
try:
    import urllib.request
except ImportError:
    raise ImportError('You should use Python 3.x')

import os.path
import gzip
import pickle
import os
import numpy as np


url_base = 'http://yann.lecun.com/exdb/mnist/'
key_file = {
    'train_img': 'train-images-idx3-ubyte.gz',
    'train_label': 'train-labels-idx1-ubyte.gz',
    'test_img': 't10k-images-idx3-ubyte.gz',
    'test_label': 't10k-labels-idx1-ubyte.gz'
}

current_dir = os.path.dirname(os.path.abspath(__file__))
save_file = os.path.join(current_dir, "mnist.pkl")

train_num = 60000
test_num = 10000
img_dim = (1, 28, 28)
img_size = 784


def download_mnist():
    for data_name in key_file.values():
        file_path = os.path.join(current_dir, data_name)

        if os.path.exists(file_path):
            print("{} exists, return".format(data_name))
            return

        print("download {} start...".format(data_name))
        urllib.request.urlretrieve(url_base + data_name, file_path)
        print("download {} end...".format(data_name))


def _load_label(file_name):
    file_path = os.path.join(current_dir, file_name)
    
    print("Converting {} to NumPy Array ...".format(file_name))
    with gzip.open(file_path, 'rb') as f:
            labels = np.frombuffer(f.read(), np.uint8, offset=8)
    print("Converting Done")
    
    return labels


def _load_img(file_name):
    file_path = os.path.join(current_dir, file_name)

    print("Converting {} to NumPy Array ...".format(file_name))
    with gzip.open(file_path, 'rb') as f:
            data = np.frombuffer(f.read(), np.uint8, offset=16)
    data = data.reshape(-1, img_size)
    print("Converting Done")
    
    return data


def _convert_numpy():
    dataset = {}
    dataset['train_img'] = _load_img(key_file['train_img'])
    dataset['train_label'] = _load_label(key_file['train_label'])    
    dataset['test_img'] = _load_img(key_file['test_img'])
    dataset['test_label'] = _load_label(key_file['test_label'])
    
    return dataset


def init_mnist():
    download_mnist()
    dataset = _convert_numpy()
    print("Creating pickle file ...")
    with open(save_file, 'wb') as f:
        pickle.dump(dataset, f, -1)
    print("Done!")


def _change_one_hot_label(X):
    T = np.zeros((X.size, 10))
    for idx, row in enumerate(T):
        row[X[idx]] = 1
        
    return T
    

def load_mnist(normalize=True, one_hot_label=False, flatten=True):
    """读入MNIST数据集
    
    Parameters
    ----------
    normalize : 将图像的像素值正规化为0.0~1.0
    one_hot_label : 
        one_hot_label为True的情况下，标签作为one-hot数组返回
        one-hot数组是指[0,0,1,0,0,0,0,0,0,0]这样的数组
    flatten : 是否将图像展开为一维数组
    
    Returns
    -------
    (训练图像, 训练标签), (测试图像, 测试标签)
    """
    if not os.path.exists(save_file):
        init_mnist()
        
    with open(save_file, 'rb') as f:
        dataset = pickle.load(f)
    
    if normalize:
        for key in ('train_img', 'test_img'):
            dataset[key] = dataset[key].astype(np.float32)
            dataset[key] /= 255.0
            
    if one_hot_label:
        dataset['train_label'] = _change_one_hot_label(dataset['train_label'])
        dataset['test_label'] = _change_one_hot_label(dataset['test_label'])
    
    if not flatten:
        for key in ('train_img', 'test_img'):
            dataset[key] = dataset[key].reshape(-1, 1, 28, 28)

    return (dataset['train_img'], dataset['train_label']), (dataset['test_img'], dataset['test_label']) 


if __name__ == '__main__':
    init_mnist()

load_mnist 函数以“( 训练图像, 训练标签)，( 测试图像，测试标签)”的形式返回读入的 MNIST 数据。此外，还可以像

load_mnist(normalize=True, flatten=True, one_hot_label=False) 

这样，设置 3 个参数。

• 第 1 个参数 normalize 设置是否将输入图像正规化为 0.0～1.0 的值。如果将该参数设置为 False ，则输入图像的像素会保持原来的 0～255。
• 第 2 个参数 flatten 设置是否展开输入图像（变成一维数组）。如果将该参数设置为 False，则输入图像为 1 × 28 × 28 的三维数组；若设置为 True，则输入图像会保存为由 784 个元素构成的一维数组。
• 第 3 个参数 one_hot_label 设置是否将标签保存为 onehot 表示（one-hot representation）。one-hot 表示是仅正确解标签为 1，其余皆为 0 的数组，就像 [0,0,1,0,0,0,0,0,0,0] 这样。当 one_hot_label 为 False 时，只是像 7、2 这样简单保存正确解标签；当 one_hot_label 为 True 时，标签则保存为 one-hot 表示。

2.2 显示数据

mnist_show.py 代码实现：

import numpy as np
from PIL import Image
from mnist import load_mnist


def img_show(img):
    pil_img = Image.fromarray(np.uint8(img))
    pil_img.show()


(x_train, t_train), (x_test, t_test) = load_mnist(flatten=True, normalize=False)

img = x_train[0]
label = t_train[0]
print(label)  # 5

print(img.shape)  # (784,)
img = img.reshape(28, 28)  # 把图像的形状变为原来的尺寸
print(img.shape)  # (28, 28)

img_show(img)

需要注意的是，flatten=True 时读入的图像是以一列（一维）NumPy 数组的形式保存的。因此，显示图像时，需要把它变为原来的 28 像素× 28像素的形状。可以通过reshape() 方法的参数指定期望的形状，更改 NumPy数组的形状。

此外，还需要把保存为 NumPy 数组的图像数据转换为 PIL 用的数据对象，这个转换处理由Image.fromarray() 来完成。

2.3 神经网络推理

对这个 MNIST 数据集实现神经网络的推理处理。神经网络的输入层有 784 个神经元，输出层有 10 个神经元。输入层的 784 这个数字来源于图像大小的 28 × 28 = 784，输出层的 10 这个数字来源于10 类别分类（数字0 到9，共10 类别）。

此外，这个神经网络有 2 个隐藏层，第 1 个隐藏层有 50 个神经元，第 2 个隐藏层有 100 个神经元。这个 50 和 100 可以设置为任何值。

neuralnet_mnist.py 代码实现

# coding: utf-8

import pickle
import numpy as np

from mnist import load_mnist


def sigmoid(x):
    return 1 / (1 + np.exp(-x))


def softmax(x):
    if x.ndim == 2:
        x = x.T
        x = x - np.max(x, axis=0)
        y = np.exp(x) / np.sum(np.exp(x), axis=0)
        return y.T

    x = x - np.max(x) # 溢出对策
    return np.exp(x) / np.sum(np.exp(x))


def get_data():
    (x_train, t_train), (x_test, t_test) = load_mnist(normalize=True, flatten=True, one_hot_label=False)
    return x_test, t_test


def init_network():
    with open("sample_weight.pkl", 'rb') as f:
        network = pickle.load(f)
    return network


def predict(network, x):
    W1, W2, W3 = network['W1'], network['W2'], network['W3']
    b1, b2, b3 = network['b1'], network['b2'], network['b3']

    a1 = np.dot(x, W1) + b1
    z1 = sigmoid(a1)
    a2 = np.dot(z1, W2) + b2
    z2 = sigmoid(a2)
    a3 = np.dot(z2, W3) + b3
    y = softmax(a3)

    return y


x, t = get_data()
network = init_network()
accuracy_cnt = 0
for i in range(len(x)):
    y = predict(network, x[i])
    p = np.argmax(y)    # 获取概率最高的元素的索引
    if p == t[i]:
        accuracy_cnt += 1

print("Accuracy:" + str(float(accuracy_cnt) / len(x)))

init_network() 会读入保存在 pickle 文件 sample_weight.pkl 中的学习到的权重参数A 。这个文件中以字典变量的形式保存了权重和偏置参数。

首先获得 MNIST 数据集，生成网络。接着，用 for 语句逐一取出保存在 x 中的图像数据，用 predict() 函数进行分类。

predict() 函数以 NumPy 数组的形式输出各个标签对应的概率。比如输出 [0.1, 0.3, 0.2, …, 0.04] 的数组，该数组表示“0”的概率为0.1，“1”的概率为0.3，等等。然后，我们取出这个概率列表中的最大值的索引（第几个元素的概率最高），作为预测结果。

可以用 np.argmax(x) 函数取出数组中的最大值的索引，np.argmax(x) 将获取被赋给参数 x 的数组中的最大值元素的索引。最后，比较神经网络所预测的答案和正确解标签，将回答正确的概率作为识别精度。

执行代码输出结果是：

Accuracy:0.9352

这表示有93.52%的数据被正确分类了。

在这个例子中，我们把 load_mnist 函数的参数 normalize 设置成了True 。将normalize 设置成 True 后，函数内部会进行转换，将图像的各个像素值除以 255，使得数据的值在0.0～1.0 的范围内。

像这样把数据限定到某个范围内的处理称为正规化（normalization ）或者叫归一化处理。

此外，对神经网络的输入数据进行某种既定的转换称为预处理（pre-processing ）。这里，作为对输入图像的一种预处理，我们进行了归一化处理。

2.4 批处理

参考：《深度学习入门：基于Python的理论与实现》