菜菜学paddle第四篇：改进卷积神经网络构建手写数字识别

前言：

        在《菜菜学paddle第三篇》我们利用了卷积神经网络构建了手写数字识别，但是遗憾的是，它的准确率让人大跌眼镜，本以为是金刚钻，却泥土的活也干不了。原因出在什么地方呢？

        不同的深度学习任务需要有各自适宜的损失函数。手写数字识别是分类任务，使用均方误差作为分类任务的损失函数存在逻辑和效果上的缺欠。

        本篇博文我们修改计算损失的函数，从均方误差（常用于回归问题F.square_error_cost()）到交叉熵误差（常用于分类问题F.cross_entropy）

一、数据加载

1、新建文件：CNNCrossEntropy.py

数据加载与前一篇不一样的地方在于label的类型，前一篇是浮点型数据类型，这一篇改成了整形：

label = np.reshape(labels[i], [1]).astype('int64')

import paddle
from paddle.nn import Conv2D, MaxPool2D, Linear
import paddle.nn.functional as F
import gzip
import json
import random
import numpy as np
 
# 定义数据集读取器
def load_data(mode='train'):
 
    # 加载数据
    datafile = './../work/mnist.json.gz'
    print('loading mnist dataset from {} ......'.format(datafile))
    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
 
    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']")
 
    #校验数据
    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

二、模型设计

1、继续在文件：CNNCrossEntropy.py里面添加模型代码：

class MNIST(paddle.nn.Layer):
    def __init__(self):
        super(MNIST, self).__init__()
        #二维卷积层
        self.conv1 = Conv2D(in_channels=1,out_channels=20,kernel_size=5,stride=1,padding=2)
        #最大池化层
        self.max_pool1 = MaxPool2D(kernel_size=2,stride=2)
        #二维卷积层
        self.conv2 = Conv2D(in_channels=20, out_channels=20,kernel_size=5,stride=1,padding=2)
        #最大池化层
        self.max_pool2 = MaxPool2D(kernel_size=2,stride=2)
        #全连接层
        self.fc = Linear(in_features=980,out_features=10)
 
    def forward(self, input):
        x = self.conv1(input)
        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)
        return x

2、既然是分类，那么全连接层输出的就不再是一个具体的数值了，而是10个数值的概率，我们在后续取值的时候，就看这十个值对应的概率最大的那个是什么，然后取最大的那个位置对应的数字。

三、模型训练

1、新建文件CNNTrainWithCrossEntropy.py

from CNNCrossEntropy import load_data,MNIST
import paddle
import paddle.nn.functional as F
 
def train(model):
    model.train()
    #调用加载数据的函数，获得MNIST训练数据集
    train_loader = load_data('train')
    # 使用SGD优化器，学习率设置为0.01
    opt = paddle.optimizer.SGD(learning_rate=0.01, parameters=model.parameters())
    # 训练10轮
    EPOCH_NUM = 10
    loss_list = []
    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)
            #每训练200批次的数据，打印下当前Loss的情况
            if batch_id % 200 == 0:
                loss = avg_loss.numpy()[0]
                loss_list.append(loss)
                print("epoch: {}, batch: {}, loss is: {}".format(epoch_id, batch_id, loss))
            #后向传播，更新参数的过程
            avg_loss.backward()
            # 最小化loss,更新参数
            opt.step()
            # 清除梯度
            opt.clear_grad()
    #保存模型参数
    paddle.save(model.state_dict(), 'mnist.crossentropy.pdparams')
    return loss_list
 
model = MNIST()
train(model)

2、这里就修改损失函数为交叉熵

loss = F.cross_entropy(predicts, labels)

四、模型验证

1、新建文件：CNNCrossEntropyEval.py

import paddle
from CNNCrossEntropy import MNIST, load_data
import numpy as np
 
model = MNIST()
params_file_path = 'mnist.crossentropy.pdparams'
# 加载模型参数
param_dict = paddle.load(params_file_path)
model.load_dict(param_dict)
# 定义预测过程
model.eval()
 
# 加载测试集
test_loader = load_data('eval')
success = 0
error = 0
for batch_id, data in enumerate(test_loader()):
    images, labels = data
    images = paddle.to_tensor(images)
    results = model(images)
    results = results.numpy().astype('int32')
    labels = labels.astype('int32')
    for i in range(0,100):
        label = labels[i][0]
        lab = results[i]
        result = np.argsort(lab)[-1]
        if (label == result) :
            success = success + 1
        else:
            error = error + 1
#  预测输出取整，即为预测的数字，打印结果
print("本次预测的正确的数量是{}， 错误的数量是{}".format(success, error))

2、预测结果：

loading mnist dataset from ./../work/mnist.json.gz ......
mnist dataset load done
本次预测的正确的数量是9831， 错误的数量是169

总结：

1、稍微改一下损失函数，让我们的预测准确率提升了一个好几个数量级，错误率控制在2%以下，这个错误率用在工业上，绝对的没问题了。

2、np.argsort(a)：将a中的元素从小到大排列，返回其在排列前对应的index(索引)输出。我们通过模型预测一个图片为0~9中每个数字的概率，然后把概率进行排序，最终取出概率最大的值对应的坐标，坐标就是对应的数字

3、我们在前向计算中明确了卷积层激活函数使用Relu，那么全连接层激活函数使用的是什么？