之前运用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的新环境…
