手写数字识别

MNIST数据集

这里介绍机器学习领域最有名气的数据集之一MNIST手写数据集。在众多论文中，它经常作为实验用的数据出现。

MNIST数据集是由0到9的数字图像构成的。
训练图像有6万张，测试图像有1万张

MNIST的图像数据是28 像素× 28 像素的灰度图像（1 通道），各个像素的取值在0 到255 之间。每个图像数据都相应地标有“7”“2”“1”等标签。这里的标签可以用来计算模型识别的准确率。

读入MNIST数据集并展示一张图片代码如下：

# coding: utf-8
import sys, os
sys.path.append(os.pardir)  # 为了导入父目录的文件而进行的设定
import numpy as np
from dataset.mnist import load_mnist
from PIL import Image


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)

这里的load_mnist函数定义于dataset文件夹，load_mnist函数以“( 训练图像, 训练标签)，( 测试图像，测试标签)”的形式返回读入的MNIST数据。下面解释load_mnist的参数。
normalize设置是否将输入图像正规化为0.0～1.0 的值。如果将该参数设置为False，则输入图像的像素会保持原来的0～255。
flatten设置是否展开输入图像（变成一维数组）。如果将该参数设置为False，则输入图像为1 × 28 × 28 的三维数组；若设置为True，则输入图像会保存为由784 个元素构成的一维数组。
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 表示。

pil_img = Image.fromarray(np.uint8(img))
这是把保存为NumPy数组的图像数据转换为PIL用的数据对象，这个转换由Image.fromarray()来完成。

PIL全称是Python Image Library，图像的显示需要用到它。

神经网络的推理过程

在这个神经网络中，输入层有784个神经元，输出层有10个神经元。784这个数字来自图像大小的28*28=784，输出层的10这个数字来源于10类别分类（数字0~9，共10个类别）。此外，这个神经网络有2 个隐藏层，第1 个隐藏层有50 个神经元，第2 个隐藏层有100 个神经元。这个50 和100 可以设置为任何值。

# coding: utf-8
import sys, os
sys.path.append(os.pardir)  # 为了导入父目录的文件而进行的设定
import numpy as np
import pickle
from dataset.mnist import load_mnist
from common.functions import sigmoid, softmax


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中的学习到的权重参数，这个文件中以字典变量的形式保存了权重和偏置参数。

什么是pickle？这个功能可以将程序运行中的对象保存为文件。如果加载保存过的pickle文件，可以立刻复原之前程序运行中的对象。

此外解释下如何计算的识别精度？
x是测试集的图像数据，t是测试集的图像标签，p= np.argmax(y)，np.argmax(y)函数用来取出数组中的最大值的索引，这个最大值就是最后的预测结果，将这个预测结果和正确解标签t进行比较，如正确预测则精度+1，最后accuracy_cnt除以总的图像数即为准确率。

这个识别过程并没有涉及network创建的时候，权重和偏置参数是怎么确定的，只是说从pickle文件中读取，参数的学习将在以后学到。

批处理

批处理对计算机的运算大有利处，可以大幅缩短每张图像的处理时间。这是因为大多数处理数值计算的库都进行了能够高效处理大型数组运算的最优化。并且，在神经网络的运算中，当数据传送成为瓶颈时，批处理可以减轻数据总线的负荷。

# coding: utf-8
import sys, os
sys.path.append(os.pardir)  # 为了导入父目录的文件而进行的设定
import numpy as np
import pickle
from dataset.mnist import load_mnist
from common.functions import sigmoid, softmax


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()

batch_size = 100 # 批数量
accuracy_cnt = 0

for i in range(0, len(x), batch_size):
    x_batch = x[i:i+batch_size]
    y_batch = predict(network, x_batch)
    p = np.argmax(y_batch, axis=1)
    accuracy_cnt += np.sum(p == t[i:i+batch_size])

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

x[i:i+batch_size]会取出从第i个到第i+batch_size个之间的数据。
本例中是像x[0:100]、x[100:200]……这样，从头开始以100 为单位将数据提取为批数据。

p = np.argmax(y_batch, axis=1)
y_batch是一个100*10的数组，axis=1是沿着第1维方向（行方向）来找最大的元素的索引。
矩阵的第0维是列方向，第1维是行方向
下面的代码是对 accuracy_cnt += np.sum(p == t[i:i+batch_size])这句的理解