深度学习（鱼书）day04–手写数字识别项目实战

鱼书的相关源代码下载：
点击链接：http://www.ituring.com.cn/book/1921
点击“随书下载”

第三项就是源代码：

解压后，在pycharm（或其它IDE）中打开此文件夹查看或运行即可。（红框内是本人自建的文件）

一、MNIST数据集

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

• 这里我们来进行手写数字图像的分类。假设学习已经全部结束，我们使用学习到的参数，先实现神经网络的“推理处理”。这个推理处理也称为神经网络的前向传播（forward propagation）。

• 这里使用的数据集是MNIST手写数字图像集。MNIST是机器学习领域最有名的数据集之一，被应用于从简单的实验到发表的论文研究等各种场合。MNIST数据集是由0到9的数字图像构成的。训练图像有6万张，测试图像有1万张，这些图像可以用于学习和推理。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数据。

import sys, os
sys.path.append(os.pardir)  # 为了导入父目录中的文件而进行的设定
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)

load_mnist()它负责加载并预处理 MNIST 数据集，使其适合机器学习模型的训练和测试。

def 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']) 

下面详细解释这个函数的功能、参数和返回值：

参数说明

1. normalize（默认 True）
   • 是否对图像像素值进行归一化（将 0-255的像素值缩放到 0.0-1.0的浮点数）。
   • 如果设为 False，则保持原始的 0-255的 uint8格式。
2. flatten（默认 True）
   • 是否将图像展平为一维数组（784维向量）。
   • 如果设为 False，则保留原始图像形状 (1, 28, 28)（单通道，28×28 像素）。
3. one_hot_label（默认 False）
   • 是否将标签转换为 one-hot 编码（例如，数字 3变为 [0, 0, 0, 1, 0, 0, 0, 0, 0, 0]）。
   • 如果设为 False，则标签保持为原始的数字（0-9）。

Python有 pickle这个便利的功能。这个功能可以将程序运行中的对象保存为文件。如果加载保存过的 pickle文件，可以立刻复原之前程序运行中的对象。用于读入MNIST数据集的load_mnist()函数内部也使用了 pickle功能（在第 2次及以后读入时）。利用 pickle功能，可以高效地完成MNIST数据的准备工作。

显示MNIST图像：

import sys, os
sys.path.append(os.pardir)  # 为了导入父目录中的文件而进行的设定
from dataset.mnist import load_mnist
import numpy as np
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)img = x_train[1]
label = t_train[1]
print(label)
print(img.shape)img = img.reshape(28, 28)
print(img.shape)img_show(img)

注意的是，flatten=True时读入的图像是以一列（一维）NumPy数组的形式保存的，因此，显示图像时，需要把它变为原来的28像素 × 28像素的形状

二、神经网络的推理处理

神经网络的输入层有784个神经元，输出层有10个神经元。

输入层的784这个数字来源于图像大小的28 × 28 = 784，输出层的10这个数字来源于10类别分类（数字0到9，共10类别）。

此外，这个神经网络有2个隐藏层，第1个隐藏层有50个神经元，第2个隐藏层有100个神经元。这个50和100可以设置为任何值。下面我们先定义**get_data()、init_network()、predict()**这3个函数。

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_testdef init_network():with open("sample_weight.pkl", 'rb') as f:network = pickle.load(f)return networkdef 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) + b1z1 = sigmoid(a1)a2 = np.dot(z1,W2)z2 = sigmoid(a2)a3 = np.dot(z2, W3) + b3y = softmax(a3)return y

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

因为之前我们假设学习已经完成，所以学习到的参数被保存下来。假设保存在sample_weight.pkl文件中，在推理阶段，我们直接加载这些已经学习到的参数。

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

predict()函数以NumPy数组的形式输出各个标签对应的概率。比如输出[0.1, 0.3, 0.2, …, 0.04]的数组，该数组表示“0”的概率为0.1，“1”的概率为0*.*3。

我们取出这个概率列表中的最大值的索引（第几个元素的概率最高），作为预测结果。可以用np.argmax(x)函数取出数组中的最大值的索引，np.argmax(x)将获取被赋给参数x的数组中的最大值元素的索引。

最后，比较神经网络所预测的答案和正确解标签，将回答正确的概率作为识别精度。

正规化：将normalize设置成True后，函数内部会进行转换，将图像的各个像素值除以255，使得数据的值在0.0～1.0的范围内。像这样把数据限定到某个范围内的处理称为正规化（normalization）。

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

实际上，很多预处理都会考虑到数据的整体分布。比如，利用数据整体的均值或标准差，移动数据，使数据整体以 0为中心分布，或者进行正规化，把数据的延展控制在一定范围内。除此之外，还有将数据整体的分布形状均匀化的方法，即数据白化（whitening）等。

三、批处理

network = init_network()
W1, W2, W3 = network['W1'], network['W2'], network['W3']
print(x.shape)
print(x[0].shape)
print(W1.shape)
print(W2.shape)
print(W3.shape)

通过上述结果来确认一下多维数组的对应维度的元素个数是否一致，省略了偏置：

现在我们来考虑打包输入多张图像的情形。比如，我们想用predict()函数一次性打包处理100张图像。为此，可以把x的形状改为100 × 784，将100张图像打包作为输入数据：

输出数据的形状为100 × 10。这表示输入的100张图像的结果被一次性输出了。比如，x[0]和y[0]中保存了第0张图像及其推理结果，x[1]和y[1]中保存了第1张图像及其推理结果。

这种打包式的输入数据称为批（batch）。批有“捆”的意思，图像就如同纸币一样扎成一捆。

批处理可以缩短处理时间。这是因为大多数处理数计算的库都进行了能够高效处理大型数组运算的最优化。并且，在神经网络的运算中，当数据传送成为瓶颈时，批处理可以减轻数据总线的负荷（严格地讲，相对于数据读入，可以将更多的时间用在计算上）。也就是说，批处理一次性计算大型数组要比分开逐步计算各个小型数组速度更快。

batch_size = 100 # 批数量
accuracy_cnt = 0
for i in range(0,len(x),batch_size):batch_x = x[i:i+batch_size]batch_y = predict(network, x[i:i+batch_size])p = np.argmax(batch_y,axis=1)  # 获取概率最大的下标accuracy_cnt += np.sum(p == t[i:i+batch_size])
print("Accuracy:" + str(float(accuracy_cnt) / len(x)))

部分代码详解：

range()函数若指定为range(start, end)，则会生成一个由start到end-1之间的整数构成的列表。range(start, end, step)这样指定3个整数，则生成的列表中的下一个元素会增加step指定的值。

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

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

通过argmax()获取值最大的元素的索引。不过这里需要注意的是，我们给定了参数axis=1。这指定了在100 × 10的数组中，沿着**第1维方向（以第1维为轴）**找到值最大的元素的索引（第0维对应第1个维度）

• 矩阵的第0维是列方向，第1维是行方向。

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]

使用比较运算符（==）生成由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

本文参考了该博主的文章