4. 手写数字识别，推理，批处理

假设学习已经全部结束，我们使用学习到的参数，先实现神经网络的“推理处理”。这个推理处理也称为神经网络的前向传播（forward propagation）。
求解机器学习问题的步骤（分成学习和推理两个阶段进行）一样，使用神经网络解决问题时，也需要首先使用训练数据（学习数据）进行权重参数的学习；进行推理时，使用刚才学习到的参数，对输入数据进行分类。

1.MNIST数据集

这里使用的数据集是MNIST手写数字图像集。 MNIST是机器学习领域
最有名的数据集之一，被应用于从简单的实验到发表的论文研究等各种场合。
实际上，在阅读图像识别或机器学习的论文时， MNIST数据集经常作为实验用的数据出现。MNIST数据集是由0到9的数字图像构成的（图3-24）。训练图像有6万张，测试图像有1万张，这些图像可以用于学习和推理。 MNIST数据集的一般使用方法是，先用训练图像进行学习，再用学习到的模型度量能在多大程度上对测试图像进行正确的分类。

2. MNIST数据集下载

MNIST的图像数据是28像素 × 28像素的灰度图像（1通道），各个像素
的取值在0到255之间。每个图像数据都相应地标有“7”“2”“1”等标签。
本书提供了便利的Python脚本mnist.py，该脚本支持从下载MNIST数据
集到将这些数据转换成NumPy数组等处理（mnist.py在dataset目录下）。使用
mnist.py时，当前目录必须是ch01、 ch02、 ch03、…、 ch08目录中的一个。使用mnist.py中的load_mnist()函数，就可以按下述方式轻松读入MNIST数据。

# 4_download_mnist.py
import sys, os
sys.path.append(os.pardir)
# from mnist import load_mnist
from dataset.mnist import load_mnist(x_train, t_train), (x_test, t_test) = load_mnist(flatten=True, normalize=False)print(x_train.shape)
print(t_train.shape)
print(x_test.shape)
print(t_test.shape)
输出：
(60000, 784)
(60000,)
(10000, 784)
(10000,)

# 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 npurl_base = 'https://storage.googleapis.com/cvdf-datasets/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'
}dataset_dir = os.path.dirname(os.path.abspath(__file__))
save_file = dataset_dir + "/mnist.pkl"train_num = 60000
test_num = 10000
img_dim = (1, 28, 28)
img_size = 784def _download(file_name):file_path = dataset_dir + "/" + file_nameif os.path.exists(file_path):returnprint("Downloading " + file_name + " ... ")urllib.request.urlretrieve(url_base + file_name, file_path)print("Done")def download_mnist():for v in key_file.values():_download(v)def _load_label(file_name):file_path = dataset_dir + "/" + file_nameprint("Converting " + file_name + " to NumPy Array ...")with gzip.open(file_path, 'rb') as f:labels = np.frombuffer(f.read(), np.uint8, offset=8)print("Done")return labelsdef _load_img(file_name):file_path = dataset_dir + "/" + file_nameprint("Converting " + file_name + " to NumPy Array ...")    with gzip.open(file_path, 'rb') as f:data = np.frombuffer(f.read(), np.uint8, offset=16)data = data.reshape(-1, img_size)print("Done")return datadef _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 datasetdef 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]] = 1return Tdef load_mnist(normalize=True, flatten=True, one_hot_label=False):"""读入MNIST数据集Parameters----------normalize : 将图像的像素值正规化为0.0~1.0one_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.0if 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()

生成mnist.pkl

3.MNIST图像显示

我们试着显示MNIST图像，同时也确认一下数据。图像的显示
使用PIL（Python Image Library）模块。执行下述代码后，训练图像的第一
张就会显示出来，如图3-25所示（源代码在ch03/mnist_show.py中）

# 5_img_show.py
import sys, os
import numpy as np
sys.path.append(os.pardir)
from dataset.mnist import load_mnist
from PIL import Imagedef 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)print(x_train.shape)
print(t_train.shape)
print(x_test.shape)
print(t_test.shape)img = x_train[0]
label = t_train[0]
print(label)print(img.shape)
img = img.reshape(28,28)
print(img.shape)img_show(img)(60000, 784)
(60000,)
(10000, 784)
(10000,)
5
(784,)
(28, 28)

这里需要注意的是， flatten=True时读入的图像是以一列（一维） NumPy
数组的形式保存的。因此，显示图像时，需要把它变为原来的28像素 × 28
像素的形状。可以通过 reshape()方法的参数指定期望的形状，更改NumPy
数组的形状。此外，还需要把保存为NumPy数组的图像数据转换为PIL用
的数据对象，这个转换处理由Image.fromarray()来完成

4.神经网络的推理处理

下面，我们对这个MNIST数据集实现神经网络的推理处理。神经网络
的输入层有784个神经元，输出层有10个神经元。输入层的784这个数字来
源于图像大小的28 × 28 = 784，输出层的10这个数字来源于10类别分类（数
字0到9，共10类别）。此外，这个神经网络有2个隐藏层，第1个隐藏层有
50个神经元，第2个隐藏层有100个神经元。这个50和100可以设置为任何值。
下面我们先定义 get_data()、 init_network()、 predict()这3个函数（代码在
ch03/neuralnet_mnist.py中）。

sample_weight.pkl是一个示例，3层神经元模型的权重。

# 6_predict.py  使用pickle文件 sample_weight.pkl中的学习到的权重参数来实现推理
import sys, os
import pickle
import numpy as np
sys.path.append(os.pardir)
from dataset.mnist import load_mnistdef sigmoid(x):return 1 / (1 + np.exp(-x))def softmax(a):c = np.max(a)exp_a = np.exp(a - c)sum_exp_a = np.sum(exp_a)y = exp_a / sum_exp_areturn ydef get_data():(x_train, t_train), (x_test, t_test) = load_mnist(normalize=True, flatten=True, one_hot_label=False)return x_test,t_testdef init_network():with open("sample_weight.pkl",'rb') as f:network = pickle.load(f)return networkdef predict(network, x, i):W1, W2, W3 = network['W1'], network['W2'], network['W3']b1, b2, b3 = network['b1'], network['b2'], network['b3']a1 = np.dot(x, W1) + b1z1 = sigmoid(a1)a2 = np.dot(z1, W2) + b2z2 = sigmoid(a2)a3 = np.dot(z2, W3) + b3y = softmax(a3)if i == 0:print("W1.shape:" + str(W1.shape))print("W2.shape:" + str(W2.shape))print("W3.shape:" + str(W3.shape))return yx, t = get_data()
network = init_network()accuracy_cnt = 0
for i in range(len(x)):y = predict(network, x[i], i)p = np.argmax(y)if p == t[i]:accuracy_cnt += 1print(x.shape)
print(x[0].shape)print(str(float(accuracy_cnt))) 
print(str(len(x)))
print("Accuracy:" + str(float(accuracy_cnt) / len(x)))输出：
W1.shape:(784, 50)
W2.shape:(50, 100)
W3.shape:(100, 10)
(10000, 784)
(784,)
9352.0
10000
Accuracy:0.9352

init_network()会读入保存在pickle文件 sample_weight.pkl中的学习到的
权重参数 A。这个文件中以字典变量的形式保存了权重和偏置参数。剩余的2
个函数，和前面介绍的代码实现基本相同，无需再解释。现在，我们用这3
个函数来实现神经网络的推理处理。然后，评价它的识别精度（accuracy），
即能在多大程度上正确分类。

首先获得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 %的数
据被正确分类了。目前我们的目标是运行学习到的神经网络，所以不讨论识
别精度本身，不过以后我们会花精力在神经网络的结构和学习方法上，思考
如何进一步提高这个精度。实际上，我们打算把精度提高到99 %以上。
另外，在这个例子中，我们把load_mnist函数的参数normalize设置成了
True。将 normalize设置成 True后，函数内部会进行转换，将图像的各个像
素值除以255，使得数据的值在0.0～1.0的范围内。像这样把数据限定到某
个范围内的处理称为正规化（normalization）。此外，对神经网络的输入数据
进行某种既定的转换称为预处理（pre-processing）。这里，作为对输入图像的
一种预处理，我们进行了正规化。

5.批处理

以上就是处理MNIST数据集的神经网络的实现，现在我们来关注输入
数据和权重参数的“形状”。再看一下刚才的代码实现。

W1.shape:(784, 50)
W2.shape:(50, 100)
W3.shape:(100, 10)

如图 3-27 所示，输入数据的形状为 100 × 784，输出数据的形状为
100 × 10。这表示输入的100张图像的结果被一次性输出了。比如， x[0]和 y[0]中保存了第0张图像及其推理结果， x[1]和 y[1]中保存了第1张图像及
其推理结果，等等
批处理对计算机的运算大有利处，可以大幅缩短每张图像的处理时
间。那么为什么批处理可以缩短处理时间呢？这是因为大多数处理
数值计算的库都进行了能够高效处理大型数组运算的最优化。并且，
在神经网络的运算中，当数据传送成为瓶颈时，批处理可以减轻数
据总线的负荷（严格地讲，相对于数据读入，可以将更多的时间用在
计算上）。也就是说，批处理一次性计算大型数组要比分开逐步计算
各个小型数组速度更快。

# 7_predict_batch.py  使用pickle文件 sample_weight.pkl中的学习到的权重参数来实现推理
import sys, os
import pickle
import numpy as np
sys.path.append(os.pardir)
from dataset.mnist import load_mnistdef sigmoid(x):return 1 / (1 + np.exp(-x))def softmax(a):c = np.max(a)exp_a = np.exp(a - c)sum_exp_a = np.sum(exp_a)y = exp_a / sum_exp_areturn ydef get_data():(x_train, t_train), (x_test, t_test) = load_mnist(normalize=True, flatten=True, one_hot_label=False)return x_test,t_testdef init_network():with open("sample_weight.pkl",'rb') as f:network = pickle.load(f)return networkdef predict(network, x, i):W1, W2, W3 = network['W1'], network['W2'], network['W3']b1, b2, b3 = network['b1'], network['b2'], network['b3']a1 = np.dot(x, W1) + b1z1 = sigmoid(a1)a2 = np.dot(z1, W2) + b2z2 = sigmoid(a2)a3 = np.dot(z2, W3) + b3y = softmax(a3)if i == 0:print("W1.shape:" + str(W1.shape))print("W2.shape:" + str(W2.shape))print("W3.shape:" + str(W3.shape))return yx, 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, i)p = np.argmax(y_batch, axis=1)accuracy_cnt += np.sum(p == t[i:i+batch_size])print(x.shape)
print(x[0].shape)print(str(float(accuracy_cnt))) 
print(str(len(x)))
print("Accuracy:" + str(float(accuracy_cnt) / len(x)))
输出：
W1.shape:(784, 50)
W2.shape:(50, 100)
W3.shape:(100, 10)
(10000, 784)
(784,)
9352.0
10000
Accuracy:0.9352

我们来逐个解释粗体的代码部分。首先是 range()函数。 range()函数若
指定为range(start, end)，则会生成一个由start到end-1之间的整数构成的
列表。若像 range(start, end, step)这样指定3个整数，则生成的列表中的
下一个元素会增加step指定的值。我们来看一个例子。

>>> list( range(0, 10) )
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9] 
>>> list( range(0, 10, 3) )
[0, 3, 6, 9] 

在 range()函数生成的列表的基础上，通过 x[i:i+batch_size]从输入数
据中抽出批数据。 x[i:i+batch_n]会取出从第i个到第i+batch_n个之间的数据。
本例中是像x[0:100]、 x[100:200]……这样，从头开始以100为单位将数据提
取为批数据。
然后，通过argmax()获取值最大的元素的索引。不过这里需要注意的是，
我们给定了参数axis=1。这指定了在100 × 10的数组中，沿着第1维方向（以
第1维为轴）找到值最大的元素的索引（第0维对应第1个维度） A。这里也来
看一个例子

>>> x = np.array([[0.1, 0.8, 0.1], [0.3, 0.1, 0.6],
... [0.2, 0.5, 0.3], [0.8, 0.1, 0.1]])
>>> y = np.argmax(x, axis=1)
>>> print(y)
[1 2 1 0]

最后，我们比较一下以批为单位进行分类的结果和实际的答案。为此，
需要在NumPy数组之间使用比较运算符（==）生成由 True/False构成的布尔
型数组，并计算True的个数。我们通过下面的例子进行确认。

>>> y = np.array([1, 2, 1, 0])
>>> t = np.array([1, 2, 0, 0])
>>> print(y==t)
[True True False True]
>>> np.sum(y==t)
3

至此，基于批处理的代码实现就介绍完了。使用批处理，可以实现高速
且高效的运算。下一章介绍神经网络的学习时，我们将把图像数据作为打包
的批数据进行学习，届时也将进行和这里的批处理一样的代码实现。