【深度学习】手写数字识别任务

数字识别是计算机从纸质文档、照片或其他来源接收、理解并识别可读的数字的能力，目前比较受关注的是手写数字识别。手写数字识别是一个典型的图像分类问题，已经被广泛应用于汇款单号识别、手写邮政编码识别等领域，大大缩短了业务处理时间，提升了工作效率和质量。

学习总结

本次学习先写总结，因为paddle教程和网络上的同学们都得到了不错的效果，而我按照paddle或者网上的步骤得不到预期的结果。希望有大神可以指教一下，问题到底出在哪里。 运行环境：

1、paddle的代码运行不过

paddle的代码： 我的代码：

2.运行效果不一致

数据处理用的是这种方式

from data_process import get_MNIST_dataloader train_loader, test_loader = get_MNIST_dataloader()

paddle的效果： 1、paddle一共有800批次，所以不知道paddle用的batch_size是不是和代码保持了一致。 2、paddle的损失差不多是0.1，而我的损失是2.

3.预测效果不一致

从paddle的最终结果看，是预测正确了的。我自己训练的结果没有一个是正确的。

深度学习步骤

再次回顾深度学习的步骤 1、数据处理 2、模型设计 3、训练配置 4、训练过程 5、模型保存 6、模型推理

代码目录结构，经过前面的学习，目录也进行了调整 image：准备用实际的jpg图片来预测 work: 保存了训练数据集和训练后的模型

1.数据处理

数据处理用两种形式，因为两种形式带来的效果差别有些大。 方式一：

# 数据处理部分之前的代码，加入部分数据处理的库 import gzip import json class MNISTDataset(Dataset): """ 步骤一:继承paddle.io.Dataset类 """ def __init__(self, datafile, mode='train', transform=None): """ 步骤二:实现构造函数 """ super().__init__() self.mode = mode self.transform = transform 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': # 获得训练数据集 self.imgs, self.labels = train_set[0], train_set[1] elif mode == 'valid': # 获得验证数据集 self.imgs, self.labels = val_set[0], val_set[1] elif mode == 'test': # 获得测试数据集 self.imgs, self.labels = eval_set[0], eval_set[1] else: raise Exception("mode can only be one of ['train', 'valid', 'test']") def __getitem__(self, index): """ 步骤三：实现__getitem__方法，定义指定index时如何获取数据 """ data = self.imgs[index] label = self.labels[index] return self.transform(data), label def __len__(self): """ 步骤四：实现__len__方法，返回数据集总数目 """ return len(self.imgs) def get_MNIST_dataloader(): datafile = './work/mnist.json.gz' # 下载数据集并初始化 DataSet train_dataset = MNISTDataset(datafile, mode='train', transform=transform) test_dataset = MNISTDataset(datafile, mode='test', transform=transform) print('train images: ', train_dataset.__len__(), ', test images: ', test_dataset.__len__()) # 定义并初始化数据读取器 train_loader = paddle.io.DataLoader( train_dataset, batch_size=64, shuffle=True, num_workers=1, drop_last=True) test_loader = paddle.io.DataLoader( test_dataset, batch_size=64, shuffle=False, num_workers=1, drop_last=True) print('step num:',len(train_loader)) return train_loader, test_loader

这种方式paddle官方说用transform进行归一化处理，但是通过查看mnist.json.gz里面的数据可以看出，数据集已经是[-1,1]之间的数据了。 方式二：

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)) 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 = [] print_0 = True for i in index_list: # 将数据处理成希望的类型 img = np.array(imgs[i]).astype('float32') label = np.array(labels[i]).astype('float32') if print_0: print("图像数据形状和对应数据为:", img) print("图像标签形状和对应数据为:", label.shape, label) print_0 = False 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 2.模型设计

使用与房价预测相同的简单神经网络解决手写数字识别问题，但是效果并不理想。原因是手写数字识别的输入是28×28的像素值，输出是0~9的数字标签，而线性回归模型无法捕捉二维图像数据中蕴含的复杂信息。

2.1.经典的全连接神经网络（MLP）

这里的代码是paddle官方的最终的代码 在paddle_model.py中实现模型设计

# 数据处理部分之后的代码,数据读取的部分调用Load_data函数 # 加载飞桨、NumPy和相关类库 import paddle import paddle.nn.functional as F from paddle.nn import Linear from tools import plot # from data_process import get_MNIST_dataloader # train_loader,_ = get_MNIST_dataloader() # 数据处理部分之后的代码,数据读取的部分调用Load_data函数 # 定义网络结构,同上一节所使用的网络结构 class MNIST(paddle.nn.Layer): def __init__(self): super(MNIST, self).__init__() # 定义两层全连接隐含层，输出维度是10，当前设定隐含节点数为10，可根据任务调整 self.fc1 = Linear(in_features=784, out_features=10) self.fc2 = Linear(in_features=10, out_features=10) # 定义一层全连接输出层，输出维度是1 self.fc3 = Linear(in_features=10, out_features=1) # 定义网络的前向计算，隐含层激活函数为sigmoid，输出层不使用激活函数 def forward(self, inputs): inputs = paddle.reshape(inputs, [inputs.shape[0], 784]) outputs1 = self.fc1(inputs) outputs1 = F.sigmoid(outputs1) outputs2 = self.fc2(outputs1) outputs2 = F.sigmoid(outputs2) outputs_final = self.fc3(outputs2) return outputs_final # 网络结构部分之后的代码，保持不变 def train(model): model.train() from data_process import load_data train_loader = load_data(mode='train') # 使用SGD优化器，learning_rate设置为0.01 opt = paddle.optimizer.SGD(learning_rate=0.01, parameters=model.parameters()) # 训练5轮 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, dtype="float32") labels = paddle.to_tensor(labels, dtype="float32") # 前向计算的过程 predicts = model(images) # 计算损失，取一个批次样本损失的平均值 loss = F.square_error_cost(predicts, labels) avg_loss = paddle.mean(loss) # 每训练200批次的数据，打印下当前Loss的情况 if batch_id % 200 == 0: loss_list.append(avg_loss.numpy()) 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(), './work/mnist_mlp.pdparams') return loss_list model = MNIST() params_info = paddle.summary(model, (1, 1, 28, 28)) loss_list = train(model) plot(loss_list) 2.2.卷积神经网络（CNN）

虽然使用经典的全连接神经网络可以提升一定的准确率，但其输入数据的形式导致丢失了图像像素间的空间信息，这影响了网络对图像内容的理解。对于计算机视觉问题，效果最好的模型仍然是卷积神经网络。卷积神经网络针对视觉问题的特点进行了网络结构优化，可以直接处理原始形式的图像数据，保留像素间的空间信息，因此更适合处理视觉问题。 卷积神经网络由多个卷积层和池化层组成，如图所示。卷积层负责对输入进行扫描以生成更抽象的特征表示，池化层对这些特征表示进行过滤，保留最关键的特征信息。

# 定义 SimpleNet 网络结构 import paddle from paddle.nn import Conv2D, MaxPool2D, Linear import paddle.nn.functional as F from data_process import get_MNIST_dataloader from tools import plot # 多层卷积神经网络实现 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) # 定义一层全连接层，输出维度是1 self.fc = Linear(in_features=980, out_features=10) # 定义网络前向计算过程，卷积后紧接着使用池化层，最后使用全连接层计算最终输出 # 卷积层激活函数使用Relu，全连接层不使用激活函数 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], -1]) x = self.fc(x) return x # 网络结构部分之后的代码，保持不变 def train(model): # 在使用GPU机器时，可以将use_gpu变量设置成True use_gpu = True from data_process import load_data train_loader = load_data(mode='train') # train_loader, test_loader = get_MNIST_dataloader() paddle.set_device('gpu:0') if use_gpu else paddle.set_device('cpu') model.train() learning_rate = 0.001 # 四种优化算法的设置方案，可以逐一尝试效果 opt = paddle.optimizer.SGD(learning_rate=learning_rate, parameters=model.parameters()) # opt = paddle.optimizer.Momentum(learning_rate=learning_rate, momentum=0.9, parameters=model.parameters()) # opt = paddle.optimizer.Adagrad(learning_rate=learning_rate, parameters=model.parameters()) # opt = paddle.optimizer.Adam(learning_rate=learning_rate, parameters=model.parameters()) # 训练5轮 EPOCH_NUM = 10 # MNIST图像高和宽 IMG_ROWS, IMG_COLS = 28, 28 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, dtype="float32") images = paddle.reshape(images, [images.shape[0], 1, IMG_ROWS, IMG_COLS]) labels = paddle.to_tensor(labels, dtype="int64") # 前向计算的过程 predicts = model(images) # [batch_size, 1] # 计算损失，取一个批次样本损失的平均值 loss = F.cross_entropy(predicts, labels) avg_loss = paddle.mean(loss) # 每训练200批次的数据，打印下当前Loss的情况 if batch_id % 200 == 0: loss_list.append(avg_loss.numpy()) 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(), './work/mnist_cnn.pdparams') return loss_list if __name__ == '__main__': model = MNIST() params_info = paddle.summary(model, (1, 1, 28, 28)) print(params_info) loss_list_conv = train(model) plot(loss_list_conv) 3.训练配置 4.训练过程

训练配置和训练过程的代码都在模型设计中一并给出了，这里只给出最终的训练效果。

4.1经典的全连接神经网络

4.2.卷积神经网络

5.保存模型 6.模型推理

经典的全连接神经网络与卷积神经网络除了模型地址不一样，其他都是一样的代码。

#加载飞桨、NumPy和相关类库 import paddle from paddle_model_cnn import MNIST import numpy as np from PIL import Image import matplotlib matplotlib.use('TkAgg') import matplotlib.pyplot as plt # 读取一张本地的样例图片，转变成模型输入的格式 def load_image(img_path): # 从img_path中读取图像，并转为灰度图 im = Image.open(img_path).convert('L') print(np.array(im)) im = im.resize((28, 28), Image.LANCZOS) im = np.array(im).reshape(1, 1, 28, 28).astype(np.float32) # 图像归一化，保持和数据集的数据范围一致 im = 1 - im / 255 return im def predict(): # 将模型参数保存到指定路径中 # 定义预测过程 model = MNIST() params_file_path = './work/mnist_cnn.pdparams' # 加载模型参数 param_dict = paddle.load(params_file_path) model.load_dict(param_dict) # 灌入数据 model.eval() for index in range(0, 10): img_path = 'image/{}.jpg'.format(index) tensor_img = load_image(img_path) # 模型反馈10个分类标签的对应概率 results = model(paddle.to_tensor(tensor_img)) # 取概率最大的标签作为预测输出 lab = np.argsort(results.numpy()) print("本次预测的数字是: ", lab[0][-1]) if __name__ == '__main__': predict() 6.1.全连接神经网络

6.2.卷积神经网络