PaddlePaddle框架学习（二）MNIST手写数字识别

之前运用pytorch实现了MINST手写数字识别，本篇内容将详细记录使用Paddle框架实现手写数字识别的全过程，大体脉络如下图所示。主要步骤分为五步：数据处理、模型设计、训练配置、训练过程、模型保存。纵向为baseline，横向为优化。

1.数据准备

1.1下载数据

按照官方给的介绍，理论上，Paddle可以自动下载内置的数据集。
比如下载MNIST的训练集，可以使用：

train_dataset = paddle.vision.datasets.MNIST(mode='train')

但实测发现，由于网络不稳定，无法正常下载，于是需要手动将数据下载下来。
由于服务器在国外，下载速度并不是很快，我下载之后已上传至我的资源，可以通过下面的传送门进行下载。
传送门

1.2数据构成

MNIST数据集分成三个部分：训练集、验证集、测试集。其中，每个集内有图片和对应的数字标签。训练集有50000份样本，验证集和测试集均有10000份样本。

1.3数据读取

# 声明数据集文件位置
datafile = './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

# 观察训练集数据
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.4数据划分

根据需要，将数据划分成多个batch

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:
        # 将数据处理成希望的类型
        img = np.array(imgs[i]).astype('float32')
        label = np.array(labels[i]).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

# 声明数据读取函数，从训练集中读取数据
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

1.5数据检验

主要校验图像数量和标签数据是否一致。

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

1.6整体封装

将上面的所有步骤封装成一个函数方便调用

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(labels))
   
   # 获得数据集长度
   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:
           # 将数据处理成希望的类型
           img = np.array(imgs[i]).astype('float32')
           label = np.array(labels[i]).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.7进一步思考

上一步已经把img构建出来，但是仍然是一个一维数据，无法在CNN中使用。于是将图片的宽高考虑进来，代码修改如下：

# 定义数据集读取器
def load_data(mode='train'):

   # 数据文件
   datafile = './mnist.json.gz'
   print('loading mnist dataset from {} ......'.format(datafile))
   data = json.load(gzip.open(datafile))
   train_set, val_set, eval_set = data

   # 数据集相关参数，图片高度IMG_ROWS, 图片宽度IMG_COLS
   IMG_ROWS = 28
   IMG_COLS = 28

   if mode == 'train':
       imgs = train_set[0]
       labels = train_set[1]
   elif mode == 'valid':
       imgs = val_set[0]
       labels = val_set[1]
   elif mode == 'eval':
       imgs = eval_set[0]
       labels = eval_set[1]

   imgs_length = len(imgs)

   assert len(imgs) == len(labels), \
         "length of train_imgs({}) should be the same as train_labels({})".format(
                 len(imgs), len(labels))

   index_list = list(range(imgs_length))

   # 读入数据时用到的batchsize
   BATCHSIZE = 100

   # 定义数据生成器
   def data_generator():
       if mode == 'train':
           random.shuffle(index_list)
       imgs_list = []
       labels_list = []
       for i in index_list:
           img = np.reshape(imgs[i], [1, IMG_ROWS, IMG_COLS]).astype('float32')
           label = np.reshape(labels[i], [1]).astype('int64')
           imgs_list.append(img)
           labels_list.append(label)
           if len(imgs_list) == 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

2.网络设计

2.1CNN网络构建

对于图像问题，全连接网络相当于将所有像素点变成一长条的张量，但是失去了像素之间的空间位置
信息，因此准确率不高。因此，对于图像问题，通常采用卷积神经网络（CNN）。

关于具体参数的选取，注释已经非常清楚。

class MNIST(paddle.nn.Layer):
    def __init__(self):
        super(MNIST, self).__init__()

        # 定义卷积层，输出特征通道out_channels设置为20，卷积核的大小kernel_size为5，卷积步长stride=1，padding=2
        self.conv1 = Conv2D(in_channels=1, out_channels=20, kernel_size=5, stride=1, padding=2)
        # 定义池化层，池化核的大小kernel_size为2，池化步长为2
        self.max_pool1 = MaxPool2D(kernel_size=2, stride=2)
        # 定义卷积层，输出特征通道out_channels设置为20，卷积核的大小kernel_size为5，卷积步长stride=1，padding=2
        self.conv2 = Conv2D(in_channels=20, out_channels=20, kernel_size=5, stride=1, padding=2)
        # 定义池化层，池化核的大小kernel_size为2，池化步长为2
        self.max_pool2 = MaxPool2D(kernel_size=2, stride=2)
        # 定义一层全连接层，输出维度是10
        self.fc = Linear(in_features=980, out_features=10)

    # 定义网络前向计算过程，卷积后紧接着使用池化层，最后使用全连接层计算最终输出
    # 卷积层激活函数使用Relu，全连接层激活函数使用softmax
    def forward(self, inputs):
        x = self.conv1(inputs)
        x = F.relu(x)
        x = self.max_pool1(x)
        x = self.conv2(x)
        x = F.relu(x)
        x = self.max_pool2(x)
        x = paddle.reshape(x, [x.shape[0], 980])
        x = self.fc(x)
        x = F.softmax(x)
        return x

2.2算法优化

之前采用的优化器是SGD（随机梯度下降），每次通过随机的抽取一批数据进行梯度下降，每次下降的方向是随机的。会导致下降的时候出现震荡。
除此之外，还有Momentum、AdaGrad和Adam等优化算法，这里简单记录。

SGD： 随机梯度下降算法，每次训练少量数据，抽样偏差导致的参数收敛过程中震荡
Momentum： 引入物理“动量”的概念，累积速度，减少震荡，使参数更新的方向更稳定
AdaGrad： 根据不同参数距离最优解的远近，动态调整学习率。学习率逐渐下降，依据各参数变化大小调整学习率
Adam： 由于动量和自适应学习率两个优化思路是正交的，因此可以将两个思路结合起来，这就是当前广泛应用的算法

3.模型训练

3.1开启GPU加速

未输入开启GPU的命令，它会自动用CPU进行训练，而CPU训练十分缓慢，经实测，GPU训练的速度是CPU的十倍以上。
开启GPU

#开启GPU
    use_gpu = True
    paddle.set_device('gpu:0') if use_gpu else paddle.set_device('cpu')

这里提一句paddlepaddle的python3.8版本不支持GPU…
如何查看自己的电脑支不支持

import paddle.fluid as fluid
support_gpu = fluid.is_compiled_with_cuda()
print((support_gpu))

返回True代表支持，False代表不支持。

3.2防止过拟合

过拟合(overfit)，简单来说，就是模型的学习能力太强，以至于学成“书呆子”，不会灵活变通。即在训练集上表现很好，在测试集上直接拉跨。

防止过拟合，可以通过引入正则项的方式来解决，这里不做详细的数学推导。

具体来说，在模型的优化目标（损失）中人为加入对参数规模的惩罚项。当参数越多或取值越大时，该惩罚项就越大。通过调整惩罚项的权重系数，可以使模型在“尽量减少训练损失”和“保持模型的泛化能力”之间取得平衡。泛化能力表示模型在没有见过的样本上依然有效。正则化项的存在，增加了模型在训练集上的损失。

使用方式比较简单

   opt = paddle.optimizer.Adam(learning_rate=0.001, weight_decay=paddle.regularizer.L2Decay(coeff=1e-5), parameters=model.parameters()) 

即在优化器函数中添加weight_decay，使用参数coeff调节正则化项的权重，权重越大时，对模型复杂度的惩罚越高。

3.3训练代码

def train(model):
    model.train()
    # 调用加载数据的函数
    train_loader = load_data('train')

    # 四种优化算法的设置方案，可以逐一尝试效果
    opt = paddle.optimizer.SGD(learning_rate=0.01, parameters=model.parameters())
    # opt = paddle.optimizer.Momentum(learning_rate=0.01, momentum=0.9, parameters=model.parameters())
    # opt = paddle.optimizer.Adagrad(learning_rate=0.01, parameters=model.parameters())
    # opt = paddle.optimizer.Adam(learning_rate=0.01, parameters=model.parameters())

    EPOCH_NUM = 3
    for epoch_id in range(EPOCH_NUM):
        for batch_id, data in enumerate(train_loader()):
            # 准备数据
            images, labels = data
            images = paddle.to_tensor(images)
            labels = paddle.to_tensor(labels)

            # 前向计算的过程
            predicts = model(images)

            # 计算损失，取一个批次样本损失的平均值
            loss = F.cross_entropy(predicts, labels)
            avg_loss = paddle.mean(loss)

            # 每训练了100批次的数据，打印下当前Loss的情况
            if batch_id % 200 == 0:
                print("epoch: {}, batch: {}, loss is: {}".format(epoch_id, batch_id, avg_loss.numpy()))

            # 后向传播，更新参数的过程
            avg_loss.backward()
            # 最小化loss,更新参数
            opt.step()
            # 清除梯度
            opt.clear_grad()

    # 保存模型参数
    paddle.save(model.state_dict(), 'mnist.pdparams')


# 创建模型
model = MNIST()
# 启动训练过程
train(model)

4.模型预测

# 定义预测过程
model = MNIST()
params_file_path = 'mnist.pdparams'
img_path = '12.jpg'
# 加载模型参数
param_dict = paddle.load(params_file_path)
model.load_dict(param_dict)
# 灌入数据
model.eval()
tensor_img = load_image(img_path)
#模型反馈10个分类标签的对应概率
results = model(paddle.to_tensor(tensor_img))
#取概率最大的标签作为预测输出
lab = np.argsort(results.numpy())
print("本次预测的数字是: ", lab[0][-1])

我用这张图片进行测试：

程序输出：

可以看出，模型的准确率还是可以的。

5.心得体会

关于paddlepaddle框架，有很多值得吐槽的地方。
1、下载问题
国产的框架，服务器却放在国外，导致下载安装起来十分不顺畅，费了很大功夫才装上。
2、不支持python3.8的GPU加速
好不容易配置好环境，发现python3.8不能支持GPU加速，浪费了自己一块好显卡。
3、源码报错
在将官网的源码拷贝到本地运行时，发现还会报错。有一个错误找了很长时间，在定义conv2卷积层时，参数类型是int，然后和源码中np.int64发生冲突，把源码改成了int才跑通代码。
4、官网给的案例代码写得比较乱
官网给的课程每一小节都单独地用一个项目包装，使用的都是jupyter notebook，全部复制下来在本地跑时有很多小问题。
……
当然除了问题之外，官网送的Tesla V100免费算力还是不错的。课程虽然不是很详细，但案例比较多，比起pytorch学习资料不多的情况下还是相当有进步。姑且还是忍着恶心，适应PaddlePaddle的新环境…