（笔记）第二章：一个案例吃透深度学习（上）
第二章主要通过手写数字识别的案例来介绍深度学习
目录
- 一. 使用飞桨完成手写数字识别模型
- 手写数字识别任务
- MNIST数据集
- 构建手写数字识别的神经网络模型
- 代码比较
- 二. 通过极简方案快速构建手写数字识别模型
- 前提条件
- 数据处理
- 模型设计
- 训练配置
- 训练过程
- 模型测试
- 三.【手写数字识别】之数据处理
- 概述
- 前提条件
- 读入数据并划分数据集
- 训练样本乱序、生成批次数据
- 校验数据有效性
- 封装数据读取与处理函数
- 异步数据读取
- 2020.8.13 作业
一. 使用飞桨完成手写数字识别模型
手写数字识别任务
数字识别是计算机从纸质文档、照片或其他来源接收、理解并识别可读的数字的能力，目前比较受关注的是手写数字识别。手写数字识别是一个典型的图像分类问题，已经被广泛应用于汇款单号识别、手写邮政编码识别等领域，大大缩短了业务处理时间，提升了工作效率和质量。
在处理手写邮政编码的简单图像分类任务时，可以使用基于MNIST数据集的手写数字识别模型。MNIST是深度学习领域标准、易用的成熟数据集，包含60000条训练样本和10000条测试样本。
- 任务输入：一系列手写数字图片，其中每张图片都是28x28的像素矩阵。
- 任务输出：经过了大小归一化和居中处理，输出对应的0~9的数字标签。
MNIST数据集
MNIST数据集是从NIST的Special Database 3（SD-3）和Special Database 1（SD-1）构建而来。Yann LeCun等人从SD-1和SD-3中各取一半数据作为MNIST训练集和测试集，其中训练集来自250位不同的标注员，且训练集和测试集的标注员完全不同。
MNIST数据集的发布，吸引了大量科学家训练模型。1998年，LeCun分别用单层线性分类器、多层感知器（Multilayer Perceptron, MLP）和多层卷积神经网络LeNet进行实验，使得测试集的误差不断下降（从12%下降到0.7%）。在研究过程中，LeCun提出了卷积神经网络（Convolutional Neural Network，CNN），大幅度地提高了手写字符的识别能力，也因此成为了深度学习领域的奠基人之一。
如今在深度学习领域，卷积神经网络占据了至关重要的地位，从最早LeCun提出的简单LeNet，到如今ImageNet大赛上的优胜模型VGGNet、GoogLeNet、ResNet等，人们在图像分类领域，利用卷积神经网络得到了一系列惊人的结果。
构建手写数字识别的神经网络模型
代码比较
模型均为数据处理、定义网络结构和训练过程三个部分
二. 通过极简方案快速构建手写数字识别模型
前提条件
加载与手写数字识别相关的库
#加载飞桨和相关类库
import paddle
import paddle.fluid as fluid
from paddle.fluid.dygraph.nn import Linear
import numpy as np
import os
from PIL import Image
数据处理
通过paddle.dataset.mnist.train()函数设置数据读取器，batch_size设置为8，即一个批次有8张图片和8个标签，代码如下所示。
# 如果～/.cache/paddle/dataset/mnist/目录下没有MNIST数据，API会自动将MINST数据下载到该文件夹下
# 设置数据读取器，读取MNIST数据训练集
trainset = paddle.dataset.mnist.train()
# 包装数据读取器，每次读取的数据数量设置为batch_size=8
train_reader = paddle.batch(trainset, batch_size=8)
paddle.batch函数将MNIST数据集拆分成多个批次，通过如下代码读取第一个批次的数据内容，观察打印结果。
# 以迭代的形式读取数据
for batch_id, data in enumerate(train_reader()):
# 获得图像数据，并转为float32类型的数组
img_data = np.array([x[0] for x in data]).astype('float32')
# 获得图像标签数据，并转为float32类型的数组
label_data = np.array([x[1] for x in data]).astype('float32')
# 打印数据形状
print("图像数据形状和对应数据为:", img_data.shape, img_data[0])
print("图像标签形状和对应数据为:", label_data.shape, label_data[0])
break
print("\n打印第一个batch的第一个图像，对应标签数字为{}".format(label_data[0]))
# 显示第一batch的第一个图像
import matplotlib.pyplot as plt
img = np.array(img_data[0]+1)*127.5
img = np.reshape(img, [28, 28]).astype(np.uint8)
plt.figure("Image") # 图像窗口名称
plt.imshow(img)
plt.axis('on') # 关掉坐标轴为 off
plt.title('image') # 图像题目
plt.show()
图像数据形状和对应数据为: (8, 784) [-1. -1. -1. -1. -1. -1.
-1. -1. -1. -1. -1. -1.
-1. -1. -1. -1. -1. -1.
-1. -1. -1. -1. -1. -1.
-1. -1. -1. -1. -1. -1.
-1. -1. -1. -1. -1. -1.
-1. -1. -1. -1. -1. -1.
-1. -1. -1. -1. -1. -1.
-1. -1. -1. -1. -1. -1.
-1. -1. -1. -1. -1. -1.
-1. -1. -1. -1. -1. -1.
-1. -1. -1. -1. -1. -1.
-1. -1. -1. -1. -1. -1.
-1. -1. -1. -1. -1. -1.
-1. -1. -1. -1. -1. -1.
-1. -1. -1. -1. -1. -1.
-1. -1. -1. -1. -1. -1.
-1. -1. -1. -1. -1. -1.
-1. -1. -1. -1. -1. -1.
-1. -1. -1. -1. -1. -1.
-1. -1. -1. -1. -1. -1.
-1. -1. -1. -1. -1. -1.
-1. -1. -1. -1. -1. -1.
-1. -1. -1. -1. -1. -1.
-1. -1. -1. -1. -1. -1.
-1. -1. -0.9764706 -0.85882354 -0.85882354 -0.85882354
-0.01176471 0.06666672 0.37254906 -0.79607844 0.30196083 1.
0.9372549 -0.00392157 -1. -1. -1. -1.
-1. -1. -1. -1. -1. -1.
-1. -1. -0.7647059 -0.7176471 -0.26274508 0.20784318
0.33333337 0.9843137 0.9843137 0.9843137 0.9843137 0.9843137
0.7647059 0.34901965 0.9843137 0.8980392 0.5294118 -0.4980392
-1. -1. -1. -1. -1. -1.
-1. -1. -1. -1. -1. -0.6156863
0.8666667 0.9843137 0.9843137 0.9843137 0.9843137 0.9843137
0.9843137 0.9843137 0.9843137 0.96862745 -0.27058822 -0.35686272
-0.35686272 -0.56078434 -0.69411767 -1. -1. -1.
-1. -1. -1. -1. -1. -1.
-1. -1. -1. -0.85882354 0.7176471 0.9843137
0.9843137 0.9843137 0.9843137 0.9843137 0.5529412 0.427451
0.9372549 0.8901961 -1. -1. -1. -1.
-1. -1. -1. -1. -1. -1.
-1. -1. -1. -1. -1. -1.
-1. -1. -0.372549 0.22352946 -0.1607843 0.9843137
0.9843137 0.60784316 -0.9137255 -1. -0.6627451 0.20784318
-1. -1. -1. -1. -1. -1.
-1. -1. -1. -1. -1. -1.
-1. -1. -1. -1. -1. -1.
-1. -0.8901961 -0.99215686 0.20784318 0.9843137 -0.29411763
-1. -1. -1. -1. -1. -1.
-1. -1. -1. -1. -1. -1.
-1. -1. -1. -1. -1. -1.
-1. -1. -1. -1. -1. -1.
-1. 0.09019613 0.9843137 0.4901961 -0.9843137 -1.
-1. -1. -1. -1. -1. -1.
-1. -1. -1. -1. -1. -1.
-1. -1. -1. -1. -1. -1.
-1. -1. -1. -1. -1. -0.9137255
0.4901961 0.9843137 -0.45098037 -1. -1. -1.
-1. -1. -1. -1. -1. -1.
-1. -1. -1. -1. -1. -1.
-1. -1. -1. -1. -1. -1.
-1. -1. -1. -1. -0.7254902 0.8901961
0.7647059 0.254902 -0.15294117 -0.99215686 -1. -1.
-1. -1. -1. -1. -1. -1.
-1. -1. -1. -1. -1. -1.
-1. -1. -1. -1. -1. -1.
-1. -1. -1. -0.36470586 0.88235295 0.9843137
0.9843137 -0.06666666 -0.8039216 -1. -1. -1.
-1. -1. -1. -1. -1. -1.
-1. -1. -1. -1. -1. -1.
-1. -1. -1. -1. -1. -1.
-1. -1. -0.64705884 0.45882356 0.9843137 0.9843137
0.17647064 -0.7882353 -1. -1. -1. -1.
-1. -1. -1. -1. -1. -1.
-1. -1. -1. -1. -1. -1.
-1. -1. -1. -1. -1. -1.
-1. -0.8745098 -0.27058822 0.9764706 0.9843137 0.4666667
-1. -1. -1. -1. -1. -1.
-1. -1. -1. -1. -1. -1.
-1. -1. -1. -1. -1. -1.
-1. -1. -1. -1. -1. -1.
-1. 0.9529412 0.9843137 0.9529412 -0.4980392 -1.
-1. -1. -1. -1. -1. -1.
-1. -1. -1. -1. -1. -1.
-1. -1. -1. -1. -1. -1.
-1. -1. -0.6392157 0.0196079 0.43529415 0.9843137
0.9843137 0.62352943 -0.9843137 -1. -1. -1.
-1. -1. -1. -1. -1. -1.
-1. -1. -1. -1. -1. -1.
-1. -1. -1. -1. -0.69411767 0.16078436
0.79607844 0.9843137 0.9843137 0.9843137 0.9607843 0.427451
-1. -1. -1. -1. -1. -1.
-1. -1. -1. -1. -1. -1.
-1. -1. -1. -1. -1. -1.
-0.8117647 -0.10588235 0.73333335 0.9843137 0.9843137 0.9843137
0.9843137 0.5764706 -0.38823527 -1. -1. -1.
-1. -1. -1. -1. -1. -1.
-1. -1. -1. -1. -1. -1.
-1. -1. -0.81960785 -0.4823529 0.67058825 0.9843137
0.9843137 0.9843137 0.9843137 0.5529412 -0.36470586 -0.9843137
-1. -1. -1. -1. -1. -1.
-1. -1. -1. -1. -1. -1.
-1. -1. -1. -1. -0.85882354 0.3411765
0.7176471 0.9843137 0.9843137 0.9843137 0.9843137 0.5294118
-0.372549 -0.92941177 -1. -1. -1. -1.
-1. -1. -1. -1. -1. -1.
-1. -1. -1. -1. -1. -1.
-0.5686275 0.34901965 0.77254903 0.9843137 0.9843137 0.9843137
0.9843137 0.9137255 0.04313731 -0.9137255 -1. -1.
-1. -1. -1. -1. -1. -1.
-1. -1. -1. -1. -1. -1.
-1. -1. -1. -1. 0.06666672 0.9843137
0.9843137 0.9843137 0.6627451 0.05882359 0.03529418 -0.8745098
-1. -1. -1. -1. -1. -1.
-1. -1. -1. -1. -1. -1.
-1. -1. -1. -1. -1. -1.
-1. -1. -1. -1. -1. -1.
-1. -1. -1. -1. -1. -1.
-1. -1. -1. -1. -1. -1.
-1. -1. -1. -1. -1. -1.
-1. -1. -1. -1. -1. -1.
-1. -1. -1. -1. -1. -1.
-1. -1. -1. -1. -1. -1.
-1. -1. -1. -1. -1. -1.
-1. -1. -1. -1. -1. -1.
-1. -1. -1. -1. -1. -1.
-1. -1. -1. -1. -1. -1.
-1. -1. -1. -1. -1. -1.
-1. -1. -1. -1. -1. -1.
-1. -1. -1. -1. ]
图像标签形状和对应数据为: (8,) 5.0
打印第一个batch的第一个图像，对应标签数字为5.0
从打印结果看，从数据加载器train_reader()中读取一次数据，可以得到形状为（8, 784）的图像数据和形状为（8,）的标签数据。其中，形状中的数字8与设置的batch_size大小对应，784为MINIST数据集中每个图像的像素大小(28*28)。
此外，从打印的图像数据来看，图像数据的范围是[-1, 1]，表明这是已经完成图像归一化后的图像数据，并且空白背景部分的值是-1。将图像数据反归一化，并使用matplotlib工具包将其显示出来，如图2 所示。可以看到图片显示的数字是5，和对应标签数字一致。
模型设计
输入像素的位置排布信息对理解图像内容非常重要（如将原始尺寸为2828图像的像素按照7112的尺寸排布，那么其中的数字将不可识别），因此网络的输入设计为2828的尺寸，而不是1784，以便于模型能够正确处理像素之间的空间信息。
事实上，采用只有一层的简单网络（对输入求加权和）时并没有处理位置关系信息，因此可以猜测出此模型的预测效果有限。在后续优化环节中，介绍的卷积神经网络则更好的考虑了这种位置关系信息，模型的预测效果也会显著提升。
# 定义mnist数据识别网络结构，同房价预测网络
class MNIST(fluid.dygraph.Layer):
def __init__(self):
super(MNIST, self).__init__()
# 定义一层全连接层，输出维度是1，激活函数为None，即不使用激活函数
self.fc = Linear(input_dim=784, output_dim=1, act=None)
# 定义网络结构的前向计算过程
def forward(self, inputs):
outputs = self.fc(inputs)
return outputs
训练配置
训练配置需要先生成模型实例（设为“训练”状态），再设置优化算法和学习率（使用随机梯度下降SGD，学习率设置为0.001）
# 定义飞桨动态图工作环境
with fluid.dygraph.guard():
# 声明网络结构
model = MNIST()
# 启动训练模式
model.train()
# 定义数据读取函数，数据读取batch_size设置为16
train_loader = paddle.batch(paddle.dataset.mnist.train(), batch_size=16)
# 定义优化器，使用随机梯度下降SGD优化器，学习率设置为0.001
optimizer = fluid.optimizer.SGDOptimizer(learning_rate=0.001, parameter_list=model.parameters())
训练过程
训练过程采用二层循环嵌套方式，训练完成后需要保存模型参数，以便后续使用。
- 内层循环：负责整个数据集的一次遍历，遍历数据集采用分批次（batch）方式。
- 外层循环：定义遍历数据集的次数，本次训练中外层循环10次，通过参数EPOCH_NUM设置。
# 通过with语句创建一个dygraph运行的context
# 动态图下的一些操作需要在guard下进行
with fluid.dygraph.guard():
model = MNIST()
model.train()
train_loader = paddle.batch(paddle.dataset.mnist.train(), batch_size=16)
optimizer = fluid.optimizer.SGDOptimizer(learning_rate=0.001, parameter_list=model.parameters())
EPOCH_NUM = 10
for epoch_id in range(EPOCH_NUM):
for batch_id, data in enumerate(train_loader()):
#准备数据，格式需要转换成符合框架要求
image_data = np.array([x[0] for x in data]).astype('float32')
label_data = np.array([x[1] for x in data]).astype('float32').reshape(-1, 1)
# 将数据转为飞桨动态图格式
image = fluid.dygraph.to_variable(image_data)
label = fluid.dygraph.to_variable(label_data)
#前向计算的过程
predict = model(image)
#计算损失，取一个批次样本损失的平均值
loss = fluid.layers.square_error_cost(predict, label)
avg_loss = fluid.layers.mean(loss)
#每训练了1000批次的数据，打印下当前Loss的情况
if batch_id !=0 and batch_id % 1000 == 0:
print("epoch: {}, batch: {}, loss is: {}".format(epoch_id, batch_id, avg_loss.numpy()))
#后向传播，更新参数的过程
avg_loss.backward()
optimizer.minimize(avg_loss)
model.clear_gradients()
# 保存参数模型
fluid.save_dygraph(model.state_dict(), 'mnist')
epoch: 0, batch: 1000, loss is: [1.9930017]
epoch: 0, batch: 2000, loss is: [4.154718]
epoch: 0, batch: 3000, loss is: [3.6867192]
epoch: 1, batch: 1000, loss is: [1.8840479]
epoch: 1, batch: 2000, loss is: [3.9615493]
epoch: 1, batch: 3000, loss is: [3.571951]
epoch: 2, batch: 1000, loss is: [1.8552303]
epoch: 2, batch: 2000, loss is: [3.8447387]
epoch: 2, batch: 3000, loss is: [3.478206]
epoch: 3, batch: 1000, loss is: [1.8574116]
epoch: 3, batch: 2000, loss is: [3.7891026]
epoch: 3, batch: 3000, loss is: [3.3986287]
epoch: 4, batch: 1000, loss is: [1.8686529]
epoch: 4, batch: 2000, loss is: [3.7633772]
epoch: 4, batch: 3000, loss is: [3.3304935]
epoch: 5, batch: 1000, loss is: [1.8818314]
epoch: 5, batch: 2000, loss is: [3.7523682]
epoch: 5, batch: 3000, loss is: [3.2721722]
epoch: 6, batch: 1000, loss is: [1.8947674]
epoch: 6, batch: 2000, loss is: [3.7489102]
epoch: 6, batch: 3000, loss is: [3.2223685]
epoch: 7, batch: 1000, loss is: [1.906798]
epoch: 7, batch: 2000, loss is: [3.7494824]
epoch: 7, batch: 3000, loss is: [3.179892]
epoch: 8, batch: 1000, loss is: [1.9177693]
epoch: 8, batch: 2000, loss is: [3.7522564]
epoch: 8, batch: 3000, loss is: [3.1436672]
epoch: 9, batch: 1000, loss is: [1.9276911]
epoch: 9, batch: 2000, loss is: [3.7562196]
epoch: 9, batch: 3000, loss is: [3.1127257]
从训练过程中Loss发生的变化可以发现，虽然Loss整体上在降低，但到训练的最后一轮，Loss值依然较高。可以猜测手写数字识别完全复用房价预测的代码，训练效果并不好。接下来我们通过模型测试，获取模型训练的真实效果。
模型测试
模型测试的主要目的是验证训练好的模型是否能正确识别出数字，包括如下四步：
- 声明实例
- 加载模型：加载训练过程中保存的模型参数。
- 灌入数据：将测试样本传入模型，模型的状态设置为校验状态（eval），显式告诉框架我们接下来只会使用前向计算的流程，不会计算梯度和梯度反向传播。
- 获取预测结果，取整后作为预测标签输出。
在模型测试之前，需要先从’./work/example_0.jpg’文件中读取样例图片，并进行归一化处理。
# 导入图像读取第三方库
import matplotlib.image as mpimg
import matplotlib.pyplot as plt
import cv2
import numpy as np
# 读取图像
img1 = cv2.imread('./work/example_0.png')
example = mpimg.imread('./work/example_0.png')
# 显示图像
plt.imshow(example)
plt.show()
im = Image.open('./work/example_0.png').convert('L')
print(np.array(im).shape)
im = im.resize((28, 28), Image.ANTIALIAS)
plt.imshow(im)
plt.show()
print(np.array(im).shape)
convert()是图像实例对象的一个方法，接受一个 mode 参数，用以指定一种色彩模式
1 ------------------（1位像素，黑白，每字节一个像素存储）
L ------------------（8位像素，黑白）
P ------------------（8位像素，使用调色板映射到任何其他模式）
RGB------------------（3x8位像素，真彩色）
RGBA------------------（4x8位像素，带透明度掩模的真彩色）
CMYK--------------------（4x8位像素，分色）
YCbCr--------------------（3x8位像素，彩色视频格式）
I-----------------------（32位有符号整数像素）
F------------------------（32位浮点像素）
# 读取一张本地的样例图片，转变成模型输入的格式
def load_image(img_path):
# 从img_path中读取图像，并转为灰度图
im = Image.open(img_path).convert('L')
print(np.array(im))
im = im.resize((28, 28), Image.ANTIALIAS)
im = np.array(im).reshape(1, -1).astype(np.float32)
# 图像归一化，保持和数据集的数据范围一致
im = 1 - im / 127.5
return im
# 定义预测过程
with fluid.dygraph.guard():
model = MNIST()
params_file_path = 'mnist'
img_path = './work/example_0.png'
# 加载模型参数
model_dict, _ = fluid.load_dygraph("mnist")
model.load_dict(model_dict)
# 灌入数据
model.eval()
tensor_img = load_image(img_path)
result = model(fluid.dygraph.to_variable(tensor_img))
# 预测输出取整，即为预测的数字，打印结果
print("本次预测的数字是", result.numpy().astype('int32'))
[[255 255 255 ... 255 255 255]
[255 255 255 ... 255 255 255]
[255 255 255 ... 255 255 255]
...
[255 255 255 ... 255 255 255]
[255 255 255 ... 255 255 255]
[255 255 255 ... 255 255 255]]
本次预测的数字是 [[4]]
从打印结果来看，模型预测出的数字是与实际输出的图片的数字不一致。这里只是验证了一个样本的情况，如果我们尝试更多的样本，可发现许多数字图片识别结果是错误的。因此完全复用房价预测的实验并不适用于手写数字识别任务！
接下来我们会对手写数字识别实验模型进行逐一改进，直到获得令人满意的结果。
三.【手写数字识别】之数据处理
概述
主要介绍手写数字识别模型中，数据处理的优化方法
在工业实践中，我们面临的任务和数据环境千差万别，通常需要自己编写适合当前任务的数据处理程序，一般涉及如下五个环节：
- 读入数据
- 划分数据集
- 生成批次数据
- 训练样本集乱序
- 校验数据有效性
前提条件
加载飞桨和数据处理库
# 加载飞桨和相关数据处理的库
import paddle
import paddle.fluid as fluid
from paddle.fluid.dygraph.nn import Linear
import numpy as np
import os
import gzip
import json
import random
读入数据并划分数据集
保存到本地的数据存储格式多种多样，如MNIST数据集以json格式存储在本地，其数据存储结构如图所示
data包含三个元素的列表：train_set、val_set、 test_set。
- train_set（训练集）：包含50000条手写数字图片和对应的标签，用于确定模型参数。
- val_set（验证集）：包含10000条手写数字图片和对应的标签，用于调节模型超参数（如多个网络结构、正则化权重的最优选择）。
- test_set（测试集）：包含10000条手写数字图片和对应的标签，用于估计应用效果（没有在模型中应用过的数据，更贴近模型在真实场景应用的效果）。
train_set包含两个元素的列表：train_images、train_labels。
- train_images：[5000, 784]的二维列表，包含5000张图片。每张图片用一个长度为784的向量表示，内容是28*28尺寸的像素灰度值（黑白图片）。
- train_labels：[5000, ]的列表，表示这些图片对应的分类标签，即0-9之间的一个数字。
在本地./work/目录下读取文件名称为mnist.json.gz的MNIST数据，并拆分成训练集、验证集和测试集
# 声明数据集文件位置
datafile = './work/mnist.json.gz'
print('loading mnist dataset from {} ......'.format(datafile))
# 加载json数据文件
data = json.load(gzip.open(datafile))
print('mnist dataset load done')
# 读取到的数据区分训练集，验证集，测试集
train_set, val_set, eval_set = data
# 数据集相关参数，图片高度IMG_ROWS, 图片宽度IMG_COLS
IMG_ROWS = 28
IMG_COLS = 28
# 打印数据信息
imgs, labels = train_set[0], train_set[1]
print("训练数据集数量: ", len(imgs))
# 观察验证集数量
imgs, labels = val_set[0], val_set[1]
print("验证数据集数量: ", len(imgs))
# 观察测试集数量
imgs, labels = val= eval_set[0], eval_set[1]
print("测试数据集数量: ", len(imgs))
loading mnist dataset from ./work/mnist.json.gz ......
mnist dataset load done
训练数据集数量: 50000
验证数据集数量: 10000
测试数据集数量: 10000
训练样本乱序、生成批次数据
- 训练样本乱序： 先将样本按顺序进行编号，建立ID集合index_list。然后将index_list乱序，最后按乱序后的顺序读取数据。
说明: 通过大量实验发现，模型对最后出现的数据印象更加深刻。训练数据导入后，越接近模型训练结束，最后几个批次数据对模型参数的影响越大。为了避免模型记忆影响训练效果，需要进行样本乱序操作。
- 生成批次数据： 先设置合理的batch_size，再将数据转变成符合模型输入要求的np.array格式返回。同时，在返回数据时将Python生成器设置为yield模式，以减少内存占用。
在执行如上两个操作之前，需要先将数据处理代码封装成load_data函数，方便后续调用。load_data有三种模型：train、valid、eval，分为对应返回的数据是训练集、验证集、测试集。
imgs, labels = train_set[0], train_set[1]
print("训练数据集数量: ", len(imgs))
# 获得数据集长度
imgs_length = len(imgs)
# 定义数据集每个数据的序号，根据序号读取数据
index_list = list(range(imgs_length))
# 读入数据时用到的批次大小
BATCHSIZE = 100
# 随机打乱训练数据的索引序号
random.shuffle(index_list)
# 定义数据生成器，返回批次数据
def data_generator():
imgs_list = []
labels_list = []
for i in index_list:
# 将数据处理成期望的格式，比如类型为float32，shape为[1, 28, 28]
img = np.reshape(imgs[i], [1, IMG_ROWS, IMG_COLS]).astype('float32')
label = np.reshape(labels[i], [1]).astype('float32')
imgs_list.append(img)
labels_list.append(label)
if len(imgs_list) == BATCHSIZE:
# 获得一个batchsize的数据，并返回
yield np.array(imgs_list), np.array(labels_list)
# 清空数据读取列表
imgs_list = []
labels_list = []
# 如果剩余数据的数目小于BATCHSIZE，
# 则剩余数据一起构成一个大小为len(imgs_list)的mini-batch
if len(imgs_list) > 0:
yield np.array(imgs_list), np.array(labels_list)
return data_generator
训练数据集数量: 50000
# 声明数据读取函数，从训练集中读取数据
train_loader = data_generator
# 以迭代的形式读取数据
for batch_id, data in enumerate(train_loader()):
image_data, label_data = data
if batch_id == 0:
# 打印数据shape和类型
print("打印第一个batch数据的维度:")
print("图像维度: {}, 标签维度: {}".format(image_data.shape, label_data.shape))
break
打印第一个batch数据的维度:
图像维度: (100, 1, 28, 28), 标签维度: (100, 1)
校验数据有效性
在实际应用中，原始数据可能存在标注不准确、数据杂乱或格式不统一等情况。因此在完成数据处理流程后，还需要进行数据校验，一般有两种方式：
- 机器校验：加入一些校验和清理数据的操作。
- 人工校验：先打印数据输出结果，观察是否是设置的格式；再从训练的结果验证数据处理和读取的有效性。
机器校验
如下代码所示，如果数据集中的图片数量和标签数量不等，说明数据逻辑存在问题，可使用assert语句校验图像数量和标签数据是否一致。
imgs_length = len(imgs)
assert len(imgs) == len(labels), \
"length of train_imgs({}) should be the same as train_labels({})".format(len(imgs), len(label))
人工校验
人工校验是指打印数据输出结果，观察是否是预期的格式。实现数据处理和加载函数后，我们可以调用它读取一次数据，观察数据的shape和类型是否与函数中设置的一致。
# 声明数据读取函数，从训练集中读取数据
train_loader = data_generator
# 以迭代的形式读取数据
for batch_id, data in enumerate(train_loader()):
image_data, label_data = data
if batch_id == 0:
# 打印数据shape和类型
print("打印第一个batch数据的维度，以及数据的类型:")
print("图像维度: {}, 标签维度: {}, 图像数据类型: {}, 标签数据类型: {}".format(image_data.shape, label_data.shape, type(image_data), type(label_data)))
break
打印第一个batch数据的维度，以及数据的类型:
图像维度: (100, 1, 28, 28), 标签维度: (100, 1), 图像数据类型: <class 'numpy.ndarray'>, 标签数据类型: <class 'numpy.ndarray'>
封装数据读取与处理函数
我们从读取数据、划分数据集、到打乱训练数据、构建数据读取器以及数据校验，完成了一整套一般性的数据处理流程，下面将这些步骤放在一个函数中实现，方便在神经网络训练时直接调用。
def load_data(mode='train'):
datafile = './work/mnist.json.gz'
print('loading mnist dataset from {} ......'.format(datafile))
# 加载json数据文件
data = json.load(gzip.open(datafile))
print('mnist dataset load done')
# 读取到的数据区分训练集，验证集，测试集
train_set, val_set, eval_set = data
if mode=='train':
# 获得训练数据集
imgs, labels = train_set[0], train_set[1]
elif mode=='valid':
# 获得验证数据集
imgs, labels = val_set[0], val_set[1]
elif mode=='eval':
# 获得测试数据集
imgs, labels = eval_set[0], eval_set[1]
else:
raise Exception("mode can only be one of ['train', 'valid', 'eval']")
print("训练数据集数量: ", len(imgs))
# 校验数据
imgs_length = len(imgs)
assert len(imgs) == len(labels), \
"length of train_imgs({}) should be the same as train_labels({})".format(len(imgs), len(label))
# 获得数据集长度
imgs_length = len(imgs)
# 定义数据集每个数据的序号，根据序号读取数据
index_list = list(range(imgs_length))
# 读入数据时用到的批次大小
BATCHSIZE = 100
# 定义数据生成器
def data_generator():
if mode == 'train':
# 训练模式下打乱数据
random.shuffle(index_list)
imgs_list = []
labels_list = []
for i in index_list:
# 将数据处理成希望的格式，比如类型为float32，shape为[1, 28, 28]
img = np.reshape(imgs[i], [1, IMG_ROWS, IMG_COLS]).astype('float32')
label = np.reshape(labels[i], [1]).astype('float32')
imgs_list.append(img)
labels_list.append(label)
if len(imgs_list) == BATCHSIZE:
# 获得一个batchsize的数据，并返回
yield np.array(imgs_list), np.array(labels_list)
# 清空数据读取列表
imgs_list = []
labels_list = []
# 如果剩余数据的数目小于BATCHSIZE，
# 则剩余数据一起构成一个大小为len(imgs_list)的mini-batch
if len(imgs_list) > 0:
yield np.array(imgs_list), np.array(labels_list)
return data_generator
下面定义一层神经网络，利用定义好的数据处理函数，完成神经网络的训练。
#数据处理部分之后的代码，数据读取的部分调用Load_data函数
# 定义网络结构，同上一节所使用的网络结构
class MNIST(fluid.dygraph.Layer):
def __init__(self):
super(MNIST, self).__init__()
self.fc = Linear(input_dim=784, output_dim=1, act=None)
def forward(self, inputs):
inputs = fluid.layers.reshape(inputs, (-1, 784))
outputs = self.fc(inputs)
return outputs
# 训练配置，并启动训练过程
with fluid.dygraph.guard():
model = MNIST()
model.train()
#调用加载数据的函数
train_loader = load_data('train')
optimizer = fluid.optimizer.SGDOptimizer(learning_rate=0.001, parameter_list=model.parameters())
EPOCH_NUM = 10
for epoch_id in range(EPOCH_NUM):
for batch_id, data in enumerate(train_loader()):
#准备数据，变得更加简洁
image_data, label_data = data
image = fluid.dygraph.to_variable(image_data)
label = fluid.dygraph.to_variable(label_data)
#前向计算的过程
predict = model(image)
#计算损失，取一个批次样本损失的平均值
loss = fluid.layers.square_error_cost(predict, label)
avg_loss = fluid.layers.mean(loss)
#每训练了200批次的数据，打印下当前Loss的情况
if batch_id % 200 == 0:
print("epoch: {}, batch: {}, loss is: {}".format(epoch_id, batch_id, avg_loss.numpy()))
#后向传播，更新参数的过程
avg_loss.backward()
optimizer.minimize(avg_loss)
model.clear_gradients()
#保存模型参数
fluid.save_dygraph(model.state_dict(), 'mnist')
loading mnist dataset from ./work/mnist.json.gz ......
mnist dataset load done
训练数据集数量: 50000
epoch: 0, batch: 0, loss is: [27.306248]
epoch: 0, batch: 200, loss is: [3.989477]
epoch: 0, batch: 400, loss is: [3.981485]
epoch: 1, batch: 0, loss is: [4.3411803]
epoch: 1, batch: 200, loss is: [3.7052267]
epoch: 1, batch: 400, loss is: [3.5528533]
epoch: 2, batch: 0, loss is: [4.433687]
epoch: 2, batch: 200, loss is: [3.8280768]
epoch: 2, batch: 400, loss is: [3.0520294]
epoch: 3, batch: 0, loss is: [3.9780524]
epoch: 3, batch: 200, loss is: [3.1700268]
epoch: 3, batch: 400, loss is: [3.707583]
epoch: 4, batch: 0, loss is: [2.8681827]
epoch: 4, batch: 200, loss is: [4.1315126]
epoch: 4, batch: 400, loss is: [4.118986]
epoch: 5, batch: 0, loss is: [3.8768215]
epoch: 5, batch: 200, loss is: [3.6394894]
epoch: 5, batch: 400, loss is: [3.8572407]
epoch: 6, batch: 0, loss is: [2.7586095]
epoch: 6, batch: 200, loss is: [3.4620507]
epoch: 6, batch: 400, loss is: [5.003905]
epoch: 7, batch: 0, loss is: [2.858216]
epoch: 7, batch: 200, loss is: [3.808558]
epoch: 7, batch: 400, loss is: [2.4269226]
epoch: 8, batch: 0, loss is: [3.1913364]
epoch: 8, batch: 200, loss is: [4.7364173]
epoch: 8, batch: 400, loss is: [2.7952008]
epoch: 9, batch: 0, loss is: [2.806769]
epoch: 9, batch: 200, loss is: [3.2677271]
epoch: 9, batch: 400, loss is: [3.190882]
异步数据读取
上面提到的数据读取采用的是同步数据读取方式。对于样本量较大、数据读取较慢的场景，建议采用异步数据读取方式。异步读取数据时，数据读取和模型训练并行执行，从而加快了数据读取速度，牺牲一小部分内存换取数据读取效率的提升，二者关系如图所示
- 同步数据读取：数据读取与模型训练串行。当模型需要数据时，才运行数据读取函数获得当前批次的数据。在读取数据期间，模型一直等待数据读取结束才进行训练，数据读取速度相对较慢。
- 异步数据读取：数据读取和模型训练并行。读取到的数据不断的放入缓存区，无需等待模型训练就可以启动下一轮数据读取。当模型训练完一个批次后，不用等待数据读取过程，直接从缓存区获得下一批次数据进行训练，从而加快了数据读取速度。
- 异步队列：数据读取和模型训练交互的仓库，二者均可以从仓库中读取数据，它的存在使得两者的工作节奏可以解耦。
# 定义数据读取后存放的位置，CPU或者GPU，这里使用CPU
# place = fluid.CUDAPlace(0) 时，数据才读取到GPU上
place = fluid.CPUPlace()
with fluid.dygraph.guard(place):
# 声明数据加载函数，使用训练模式
train_loader = load_data(mode='train')
# 定义DataLoader对象用于加载Python生成器产生的数据
data_loader = fluid.io.DataLoader.from_generator(capacity=5, return_list=True)
# 设置数据生成器
data_loader.set_batch_generator(train_loader, places=place)
# 迭代的读取数据并打印数据的形状
for i, data in enumerate(data_loader):
image_data, label_data = data
print(i, image_data.shape, label_data.shape)
if i>=5:
break
loading mnist dataset from ./work/mnist.json.gz ......
mnist dataset load done
训练数据集数量: 50000
0 [100, 1, 28, 28] [100, 1]
1 [100, 1, 28, 28] [100, 1]
2 [100, 1, 28, 28] [100, 1]
3 [100, 1, 28, 28] [100, 1]
4 [100, 1, 28, 28] [100, 1]
5 [100, 1, 28, 28] [100, 1]
与同步数据读取相比，异步数据读取仅增加了三行代码
place = fluid.CPUPlace()
# 设置读取的数据是放在CPU还是GPU上。
data_loader = fluid.io.DataLoader.from_generator(capacity=5, return_list=True)
# 创建一个DataLoader对象用于加载Python生成器产生的数据。数据会由Python线程预先读取，并异步送入一个队列中。
data_loader.set_batch_generator(train_loader, place)
# 用创建的DataLoader对象设置一个数据生成器set_batch_generator，输入的参数是一个Python数据生成器train_loader和服务器资源类型place（标明CPU还是GPU）
fluid.io.DataLoader.from_generator参数名称和含义如下：
- feed_list：仅在PaddlePaddle静态图中使用，动态图中设置为“None”，本教程默认使用动态图的建模方式；
- capacity：表示在DataLoader中维护的队列容量，如果读取数据的速度很快，建议设置为更大的值；
- use_double_buffer：是一个布尔型的参数，设置为“True”时，Dataloader会预先异步读取下一个batch的数据并放到缓存区；
- iterable：表示创建的Dataloader对象是否是可迭代的，一般设置为“True”；
- return_list：在动态图模式下需要设置为“True”。
异步数据读取并训练的完整案例代码如下所示
with fluid.dygraph.guard():
model = MNIST()
model.train()
#调用加载数据的函数
train_loader = load_data('train')
# 创建异步数据读取器
place = fluid.CPUPlace()
data_loader = fluid.io.DataLoader.from_generator(capacity=5, return_list=True)
data_loader.set_batch_generator(train_loader, places=place)
optimizer = fluid.optimizer.SGDOptimizer(learning_rate=0.001, parameter_list=model.parameters())
EPOCH_NUM = 3
for epoch_id in range(EPOCH_NUM):
for batch_id, data in enumerate(data_loader):
image_data, label_data = data
image = fluid.dygraph.to_variable(image_data)
label = fluid.dygraph.to_variable(label_data)
predict = model(image)
loss = fluid.layers.square_error_cost(predict, label)
avg_loss = fluid.layers.mean(loss)
if batch_id % 200 == 0:
print("epoch: {}, batch: {}, loss is: {}".format(epoch_id, batch_id, avg_loss.numpy()))
avg_loss.backward()
optimizer.minimize(avg_loss)
model.clear_gradients()
fluid.save_dygraph(model.state_dict(), 'mnist')
loading mnist dataset from ./work/mnist.json.gz ......
mnist dataset load done
训练数据集数量: 50000
epoch: 0, batch: 0, loss is: [44.275467]
epoch: 0, batch: 200, loss is: [3.2244885]
epoch: 0, batch: 400, loss is: [4.147104]
epoch: 1, batch: 0, loss is: [3.8324347]
epoch: 1, batch: 200, loss is: [3.3452053]
epoch: 1, batch: 400, loss is: [3.5833535]
epoch: 2, batch: 0, loss is: [3.2671225]
epoch: 2, batch: 200, loss is: [3.7591367]
epoch: 2, batch: 400, loss is: [3.359116]
从异步数据读取的训练结果来看，损失函数下降与同步数据读取训练结果一致。注意，异步读取数据只在数据量规模巨大时会带来显著的性能提升，对于多数场景采用同步数据读取的方式已经足够。
2020.8.13 作业
查询API文档，写一个cifar-10数据集的数据读取器，并执行乱序，分批次读取，打印第一个batch数据的shape、类型信息。
import paddle
import numpy as np
import random
# 设置数据读取器，读取cifar-10数据训练集
trainset = paddle.dataset.cifar.train10(cycle=False)
# 包装数据读取器，每次读取的数据数量设置为batch_size=100
train_reader = paddle.batch(trainset, batch_size=100)
for batch_id, data in enumerate(train_reader()):
# 获得图像数据，并转为float32类型的数组
img_data = np.array([x[0] for x in data]).astype('float32')
# 获得图像标签数据，并转为float32类型的数组
label_data = np.array([x[1] for x in data]).astype('float32')
break
img, label = img_data, label_data
img_length = len(img)
index_list = list(range(img_length))
#标号乱序
random.shuffle(index_list)
batchsize=100
def data_generator():
img_list = []
label_list = []
for i in index_list:
# 处理数据
img_ = np.reshape(img[i], [3, 32, 32]).astype('float32')
label_ = np.reshape(label[i], [1]).astype('float32')
img_list.append(img_)
label_list.append(label_)
if len(img_list) == batchsize:
# 返回一个batchsize的数据
yield np.array(img_list), np.array(label_list)
# 清空列表
img_list = []
label_list = []
# 如果剩余数据的数目小于batchsize，则剩余数据一起构成一个大小为len(img_list)的mini-batch
if len(img_list) > 0:
yield np.array(img_list), np.array(label_list)
return data_generator
# 从训练集中读取数据
train_loader = data_generator
# 读取数据
for batch_id, data in enumerate(train_loader()):
image_data, label_data = data
if batch_id == 0:
# 打印数据shape和类型
print("打印第一个batch数据的shape和类型:")
print("图像维度: {}, 标签维度: {}".format(image_data.shape, label_data.shape))
break
打印第一个batch数据的shape和类型:
图像维度: (100, 3, 32, 32), 标签维度: (100, 1)