以MNIST为例进行完整数据读取与处理


在实际项目中，我们通常需要对模型进行调优。需要自己编写适合当前任务的数据处理程序，一般涉及如下五个环节：

  • 读入数据
  • 划分数据集
  • 生成批次数据
  • 训练样本集乱序
  • 效验数据有效性

这里使用飞桨平台进行运行，所以在数据读取与处理前，首先要加载飞桨平台和数据处理库，代码如下：

1
2
3
4
5
6
7
8
9
#数据处理部分之前的代码，加入部分数据处理的库
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数据集为例，其数据结构如图所示：

图 ：MNIST数据集的存储结构

data包含三个元素的列表：train_set、val_set、test_set.

  • train_set(训练集)：包含50000张手写数字图片和对应的标签，用于确定模型参数。

train_set包含两个元素的列表：train_images、train_labels.

train_imgs:[50000,784]的二维列表，包含50000张图片。每张图片用一个长度为784的向量表示，内容是28*28尺寸的像素灰度值（黑白图片）

train_labels:[50000,]的列表，表示这些图片对应的分类标签，即0·9之间的一个数字。

  • val_set(验证集)：包含10000张手写数字图片和对应的标签，用于调节模型超参数（如多个网络模型、正则化权重的最优选择，在多个训练模型中找最好的模型）
  • test_set(测试集)：包含1000张手写数字图片和对应的标签，用于估计应用效果（没有在模型中应用过的数据，更贴近模型在真实场景应用的效果）

在本地“./WORK/"目录下读取文件名为'mnist.json.gz'的MNIST数据，并拆分训练集、验证集和测试集，代码如下所示：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
#声明数据集文件位置
datafile = './work/mnist.json.gz'
print('loading mnist dataset from{} ......'.format(datafile))
#加载json数据文件
data = json.load(gzip.open(datafile))
print('mnist dataset load done')
#读取到的数据区分训练集、验证集和测试集。因为mnist数据集本身就已经划分好训练集、验证集和测试集，所以这里直接进行导入
train_set,val_set,eval_set = data

#数据集相关参数，图片高度IMG_ROW,图片宽度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))

结果如下：

1
2
3
4
5
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，分别对应返回的数据是训练集、验证集和测试集。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
imags,labels = train_set[0], train_set[1]
#获得数据集的长度
imgs_length = len(imgs)
print("训练数据集数量："，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

结果是：

1
训练数据集数量:  50000
1
2
3
4
5
6
7
8
9
10
#声明数据读取函数，从训练集中读取数据
train_loader = data_generator
#以迭代的形式读取数据
for batch_id,data inenumerate(train_loader()):
    image_data,label_data = data
    if batch_id == 0:
        #打印数据shape和类型
       print("打印第一个batch数据的维度：")
       print("图像维度：{}，标签维度：{}".format(image_data.shape,label_data.shape))
    break

输出结果是

1
2
打印第一个batch数据的维度:
图像维度: (100, 1, 28, 28), 标签维度: (100, 1)

效验数据有效性：

在实际应用中，原始数据可能存在标注不准确、数据杂乱或格式不统一等情况。因此在完成数据处理流程后，还需要进行数据效验，一般有两种方式：

  • 机器效验：加入一些效验和清理数据的操作
  • 人工效验：先打印数据输出结果，观察是否是设置的格式，再从训练的结果验证数据处理和读取数据的有效性。

接下来就分别展示两种不同的效验方式：

机器效验：

如下代码所示，如果数据集中的图片数量和标签数量不等，说明数据逻辑存在问题，可使用assert语句效验图像数量和标签数据是否一致。

1
2
3
imgs_length = len(imgs)

assert len(imgs) == len(labels)

人工效验：

人工效验是指打印数据输出结果，观察是否是预期的格式。实现数据处理和加载函数后，我们可以调用它读取一次数据，观察数据的shape和类型是否与函数中的设置一致。

1
2
3
4
5
6
7
8
9
10
#声明数据读取函数，从训练集中读取数据
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
1
2
打印第一个batch数据的维度，以及数据的类型:
图像维度: (100, 1, 28, 28), 标签维度: (100, 1), 图像数据类型: <class 'numpy.ndarray'>, 标签数据类型: <class 'numpy.ndarray'>

封装数据读取与处理函数

以上，我们从读取数据，划分数据集，到打乱训练数据，构建数据读取器以及数据效验，完成了一整套一般性的数据处理流程，下面将这些步骤放在一个函数中实现，方便在神经网络训练时直接调用。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
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

下面定义一层神经网络，利用定义好的数据处理函数，完成神经网络训练。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
#数据处理之后的代码，数据读取的部分调用Load_data函数
#定义网络结构
class MNIST(fluid.dypraph.Layer):
    def__init__(self,name_scope):
        super(MNIST,self).__init__(name_scope)
        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("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')

结果如下

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
loading mnist dataset from ./work/mnist.json.gz ......
mnist dataset load done
训练数据集数量:  50000
epoch: 0, batch: 0, loss is: [17.273615]
epoch: 0, batch: 200, loss is: [4.6803107]
epoch: 0, batch: 400, loss is: [3.7592587]
epoch: 1, batch: 0, loss is: [5.3405128]
epoch: 1, batch: 200, loss is: [3.946857]
epoch: 1, batch: 400, loss is: [4.416728]
epoch: 2, batch: 0, loss is: [2.7133915]
epoch: 2, batch: 200, loss is: [2.8620245]
epoch: 2, batch: 400, loss is: [3.0233452]
epoch: 3, batch: 0, loss is: [3.8684494]
epoch: 3, batch: 200, loss is: [3.6623435]
epoch: 3, batch: 400, loss is: [4.4169235]
epoch: 4, batch: 0, loss is: [3.4422498]
epoch: 4, batch: 200, loss is: [3.493916]
epoch: 4, batch: 400, loss is: [2.8242683]
epoch: 5, batch: 0, loss is: [3.7098367]
epoch: 5, batch: 200, loss is: [3.662263]
epoch: 5, batch: 400, loss is: [4.4998116]
epoch: 6, batch: 0, loss is: [3.181002]
epoch: 6, batch: 200, loss is: [3.0345955]
epoch: 6, batch: 400, loss is: [2.9564946]
epoch: 7, batch: 0, loss is: [4.350371]
epoch: 7, batch: 200, loss is: [3.2424948]
epoch: 7, batch: 400, loss is: [3.030394]
epoch: 8, batch: 0, loss is: [3.5799572]
epoch: 8, batch: 200, loss is: [4.317978]
epoch: 8, batch: 400, loss is: [2.884202]
epoch: 9, batch: 0, loss is: [3.0298193]
epoch: 9, batch: 200, loss is: [3.953648]
epoch: 9, batch: 400, loss is: [3.0385325]

异步读取数据

上面提到的数据读取采用的是同步数据读取方式。对于样本量较大、数据读取较慢场景，建议采用异步数据读取方式。异步数据读取时，数据读取和模型训练并形执行，从而加快了数据读取速度，牺牲一小部分内存换取数据读取效率的提升，二者关系如图所示：

图 ：同步数据读取和异步数据读取示意图

  • 同步数据读取：数据读取与模型训练串行。当模型需要数据时，才运行数据读取函数获得当前批次的数据。在读取数据期间，模型一直等待数据读取结束才进行训练，数据读取速度相对较慢。
  • 异步数据读取：数据读取和模型训练并行。读取到的数据不断的放入缓存区，无需等待模型训练就可以启动下一轮数据读取。当模型训练完一个批次后，不用等待数据读取过程，直接从缓存区获得下一批次数据进行训练，从而加快了数据读取速度。
  • 异步队列：数据读取和模型训练交互的仓库，二者均可从仓库中读取数据，它的存在使得两者的工作节奏可以结合。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
# 定义数据读取后存放的位置，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

结果如下

1
2
3
4
5
6
7
8
9
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]

异步数据读取并训练的完整代码如下所示

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
with fluid.dygraph.guard():
    model = MNIST("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')

结果如下

1
2
3
4
5
6
7
8
9
10
11
12
loading mnist dataset from ./work/mnist.json.gz ......
mnist dataset load done
训练数据集数量:  50000
epoch: 0, batch: 0, loss is: [28.888733]
epoch: 0, batch: 200, loss is: [3.8076816]
epoch: 0, batch: 400, loss is: [3.6661437]
epoch: 1, batch: 0, loss is: [4.047027]
epoch: 1, batch: 200, loss is: [3.5504844]
epoch: 1, batch: 400, loss is: [4.3825784]
epoch: 2, batch: 0, loss is: [3.7348306]
epoch: 2, batch: 200, loss is: [2.794263]
epoch: 2, batch: 400, loss is: [3.013347]

fluid.io.DataLoader.from_generator参数名称、参数含义、默认值如下：

  • 参数含义如下：

    • feed_list 仅在paddle静态图中使用，动态图中设置为None，本教程默认使用动态图的建模方式。
    • capacity 表示在DataLoader中维护的队列容量，如果读取数据的速度很快，建议设置为更大的值。
    • use_double_buffer 是一个布尔型的参数，设置为True时Dataloader会预先异步读取下一个batch的数据放到缓存区。
    • iterable 表示创建的Dataloader对象是否是可迭代的，一般设置为True。
    • return_list 在动态图模式下需要设置为True，静态图模式下设置为False。

  • 参数名和默认值如下：

    • feed_list=None,
    • capacity=None,
    • use_double_buffer=True,
    • iterable=True,
    • return_list=False