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

前言：

        从“菜菜学paddle第二篇”文章中，我们看到使用全连接网络构建的手写数字识别模型的准确率不高，今天就通过搭建卷积神经网络来构建手写数字识别，看看它的准确率。

        对于计算机视觉问题，效果最好的模型仍然是卷积神经网络。卷积神经网络针对视觉问题的特点进行了网络结构优化，可以直接处理原始形式的图像数据，保留像素间的空间信息，因此更适合处理视觉问题。

一、数据加载

1、新建文件： CNN.py

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('float32')
            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、需要注意的点是下面两行代码：

img = np.reshape(imgs[i], [1, IMG_ROWS, IMG_COLS]).astype('float32')
label = np.reshape(labels[i], [1]).astype('float32')

因为Conv2D的入参的数据形式[batch_size, 1, hight, width]，其中第二维代表图像的通道数（在MNIST数据集中每张图片的通道数为1，传统RGB图片通道数为3）。

二、模型设计

1、在（一）新建的文件CNN.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=1)
 
    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], -1])
        x = self.fc(x)
        return x

2、模型定义了两个隐层，每个隐层包含一个卷积层和一个池化层

3、激活函数使用relu

三、模型训练

1、新建文件：CNNTrain.py

from CNN 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.square_error_cost(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.pdparams')
    return loss_list
 
model = MNIST()
train(model)

四、模型预测

1、新建文件CNNEval.py：

import paddle
from CNN import MNIST
from CNN import load_data
 
model = MNIST()
params_file_path = 'mnist.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]
        result = results[i][0]
        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
本次预测的正确的数量是982， 错误的数量是9018

总结：

1、简单的卷积神经网络并没有提高预测的准确性

2、在训练的过程中，偶尔会出现损失值不下降的问题，输出的结果是nan，只能重新训练

3、训练耗费的资源要比前面的模型多了很多倍，我的笔记本直接卡住了。

4、准确率不高怎么办呢？调整一下池化层？替换损失函数？更换优化器？