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

学习总结

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

1、paddle的代码运行不过

paddle的代码：

我的代码：

2.运行效果不一致

数据处理用的是这种方式

from data_process import get_MNIST_dataloadertrain_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 jsonclass MNISTDataset(Dataset):"""步骤一:继承paddle.io.Dataset类"""def __init__(self, datafile, mode='train', transform=None):"""步骤二:实现构造函数"""super().__init__()self.mode = modeself.transform = transformprint('loading mnist dataset from {} ......'.format(datafile))# 加载json数据文件data = json.load(gzip.open(datafile))print('mnist dataset load done')# 读取到的数据区分训练集,验证集,测试集train_set, val_set, eval_set = dataif 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), labeldef __len__(self):"""步骤四：实现__len__方法，返回数据集总数目"""return len(self.imgs)def get_MNIST_dataloader():datafile = './work/mnist.json.gz'# 下载数据集并初始化 DataSettrain_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 = dataif 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 = Truefor 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 = Falseimgs_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-batchif 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)# 定义一层全连接输出层，输出维度是1self.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_datatrain_loader = load_data(mode='train')# 使用SGD优化器，learning_rate设置为0.01opt = paddle.optimizer.SGD(learning_rate=0.01, parameters=model.parameters())# 训练5轮EPOCH_NUM = 10loss_list = []for epoch_id in range(EPOCH_NUM):for batch_id, data in enumerate(train_loader()):# 准备数据images, labels = dataimages = 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_listmodel = 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=2self.conv1 = Conv2D(in_channels=1, out_channels=20, kernel_size=5, stride=1, padding=2)# 定义池化层，池化核的大小kernel_size为2，池化步长为2self.max_pool1 = MaxPool2D(kernel_size=2, stride=2)# 定义卷积层，输出特征通道out_channels设置为20，卷积核的大小kernel_size为5，卷积步长stride=1，padding=2self.conv2 = Conv2D(in_channels=20, out_channels=20, kernel_size=5, stride=1, padding=2)# 定义池化层，池化核的大小kernel_size为2，池化步长为2self.max_pool2 = MaxPool2D(kernel_size=2, stride=2)# 定义一层全连接层，输出维度是1self.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变量设置成Trueuse_gpu = Truefrom data_process import load_datatrain_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, 28loss_list = []for epoch_id in range(EPOCH_NUM):for batch_id, data in enumerate(train_loader()):# 准备数据images, labels = dataimages = 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_listif __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 matplotlibmatplotlib.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 / 255return imdef 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.卷积神经网络