数字识别

本教程源代码目录在book/recognize_digits,初次使用请您参考Book文档使用说明。

说明:

  • 硬件环境要求：本文可支持在CPU、GPU下运行
  • Docker镜像支持的CUDA/cuDNN版本：如果使用了Docker运行Book，请注意：这里所提供的默认镜像的GPU环境为 CUDA 8/cuDNN 5，对于NVIDIA Tesla V100等要求CUDA 9的 GPU，使用该镜像可能会运行失败。
  • 文档和脚本中代码的一致性问题：请注意：为使本文更加易读易用，我们拆分、调整了train.py的代码并放入本文。本文中代码与train.py的运行结果一致，可直接运行train.py进行验证。

背景介绍

当我们学习编程的时候，编写的第一个程序一般是实现打印"Hello World"。而机器学习（或深度学习）的入门教程，一般都是 MNIST 数据库上的手写识别问题。原因是手写识别属于典型的图像分类问题，比较简单，同时MNIST数据集也很完备。MNIST数据集作为一个简单的计算机视觉数据集，包含一系列如图1所示的手写数字图片和对应的标签。图片是28x28的像素矩阵，标签则对应着0~9的10个数字。每张图片都经过了大小归一化和居中处理。

数字识别 - 图1图1. MNIST图片示例

MNIST数据集是从 NIST 的Special Database 3（SD-3）和Special Database 1（SD-1）构建而来。由于SD-3是由美国人口调查局的员工进行标注，SD-1是由美国高中生进行标注，因此SD-3比SD-1更干净也更容易识别。Yann LeCun等人从SD-1和SD-3中各取一半作为MNIST的训练集（60000条数据）和测试集（10000条数据），其中训练集来自250位不同的标注员，此外还保证了训练集和测试集的标注员是不完全相同的。

MNIST吸引了大量的科学家基于此数据集训练模型，1998年，LeCun分别用单层线性分类器、多层感知器（Multilayer Perceptron, MLP）和多层卷积神经网络LeNet进行实验，使得测试集上的误差不断下降（从12%下降到0.7%）[1]。在研究过程中，LeCun提出了卷积神经网络（Convolutional Neural Network），大幅度地提高了手写字符的识别能力，也因此成为了深度学习领域的奠基人之一。此后，科学家们又基于K近邻（K-Nearest Neighbors）算法[2]、支持向量机（SVM）[3]、神经网络[4-7]和Boosting方法[8]等做了大量实验，并采用多种预处理方法（如去除歪曲、去噪、模糊等）来提高识别的准确率。

如今的深度学习领域，卷积神经网络占据了至关重要的地位，从最早Yann LeCun提出的简单LeNet，到如今ImageNet大赛上的优胜模型VGGNet、GoogLeNet、ResNet等（请参见图像分类 教程），人们在图像分类领域，利用卷积神经网络得到了一系列惊人的结果。

本教程中，我们从简单的Softmax回归模型开始，带大家了解手写字符识别，并向大家介绍如何改进模型，利用多层感知机（MLP）和卷积神经网络（CNN）优化识别效果。

模型概览

基于MNIST数据集训练一个分类器，在介绍本教程使用的三个基本图像分类网络前，我们先给出一些定义：

数字识别 - 图2是输入：MNIST图片是数字识别 - 图3 的二维图像，为了进行计算，我们将其转化为数字识别 - 图4维向量，即数字识别 - 图5。

数字识别 - 图6是输出：分类器的输出是10类数字（0-9），即数字识别 - 图7，每一维数字识别 - 图8代表图片分类为第数字识别 - 图9类数字的概率。

数字识别 - 图10是图片的真实标签：数字识别 - 图11也是10维，但只有一维为1，其他都为0。例如某张图片上的数字为2，则它的标签为数字识别 - 图12

Softmax回归(Softmax Regression)

最简单的Softmax回归模型是先将输入层经过一个全连接层得到特征，然后直接通过 softmax 函数计算多个类别的概率并输出[9]。

输入层的数据

数字识别 - 图13传到输出层，在激活操作之前，会乘以相应的权重数字识别 - 图14 ，并加上偏置变量数字识别 - 图15 ，具体如下：

数字识别 - 图16

其中

数字识别 - 图17

图2为softmax回归的网络图，图中权重用蓝线表示、偏置用红线表示、+1代表偏置参数的系数为1。

数字识别 - 图18图2. softmax回归网络结构图

对于有

数字识别 - 图19 个类别的多分类问题，指定数字识别 - 图20 个输出节点，数字识别 - 图21 维结果向量经过softmax将归一化为数字识别 - 图22 个[0,1]范围内的实数值，分别表示该样本属于这数字识别 - 图23 个类别的概率。此处的数字识别 - 图24 即对应该图片为数字数字识别 - 图25 的预测概率。

在分类问题中，我们一般采用交叉熵代价损失函数（cross entropy loss），公式如下：

数字识别 - 图26

多层感知机(Multilayer Perceptron, MLP)

Softmax回归模型采用了最简单的两层神经网络，即只有输入层和输出层，因此其拟合能力有限。为了达到更好的识别效果，我们考虑在输入层和输出层中间加上若干个隐藏层[10]。

  • 经过第一个隐藏层，可以得到数字识别 - 图27，其中数字识别 - 图28代表激活函数，常见的有sigmoid、tanh或ReLU等函数。
  • 经过第二个隐藏层，可以得到数字识别 - 图29。
  • 最后，再经过输出层，得到的数字识别 - 图30，即为最后的分类结果向量。图3为多层感知器的网络结构图，图中权重用蓝线表示、偏置用红线表示、+1代表偏置参数的系数为1。

数字识别 - 图31图3. 多层感知器网络结构图

卷积神经网络(Convolutional Neural Network, CNN)

在多层感知器模型中，将图像展开成一维向量输入到网络中，忽略了图像的位置和结构信息，而卷积神经网络能够更好的利用图像的结构信息。LeNet-5是一个较简单的卷积神经网络。图4显示了其结构：输入的二维图像，先经过两次卷积层到池化层，再经过全连接层，最后使用softmax分类作为输出层。下面我们主要介绍卷积层和池化层。

数字识别 - 图32图4. LeNet-5卷积神经网络结构

卷积层

卷积层是卷积神经网络的核心基石。在图像识别里我们提到的卷积是二维卷积，即离散二维滤波器（也称作卷积核）与二维图像做卷积操作，简单的讲是二维滤波器滑动到二维图像上所有位置，并在每个位置上与该像素点及其领域像素点做内积。卷积操作被广泛应用与图像处理领域，不同卷积核可以提取不同的特征，例如边沿、线性、角等特征。在深层卷积神经网络中，通过卷积操作可以提取出图像低级到复杂的特征。

数字识别 - 图33图5. 卷积层图片

图5给出一个卷积计算过程的示例图，输入图像大小为

数字识别 - 图34，即数字识别 - 图35大小的3通道（RGB，也称作深度）彩色图像。

这个示例图中包含两（用

数字识别 - 图36表示）组卷积核，即图中数字识别 - 图37 和数字识别 - 图38。在卷积计算中，通常对不同的输入通道采用不同的卷积核，如图示例中每组卷积核包含（数字识别 - 图39个数字识别 - 图40（用数字识别 - 图41表示）大小的卷积核。另外，这个示例中卷积核在图像的水平方向（数字识别 - 图42方向）和垂直方向（数字识别 - 图43方向）的滑动步长为2（用数字识别 - 图44表示）；对输入图像周围各填充1（用数字识别 - 图45表示）个0，即图中输入层原始数据为蓝色部分，灰色部分是进行了大小为1的扩展，用0来进行扩展。经过卷积操作得到输出为数字识别 - 图46（用数字识别 - 图47表示）大小的特征图，即数字识别 - 图48大小的2通道特征图，其中数字识别 - 图49计算公式为：数字识别 - 图50，数字识别 - 图51同理。 而输出特征图中的每个像素，是每组滤波器与输入图像每个特征图的内积再求和，再加上偏置数字识别 - 图52，偏置通常对于每个输出特征图是共享的。输出特征图数字识别 - 图53中的最后一个数字识别 - 图54计算如图5右下角公式所示。

在卷积操作中卷积核是可学习的参数，经过上面示例介绍，每层卷积的参数大小为

数字识别 - 图55。在多层感知器模型中，神经元通常是全部连接，参数较多。而卷积层的参数较少，这也是由卷积层的主要特性即局部连接和共享权重所决定。

  • 局部连接：每个神经元仅与输入神经元的一块区域连接，这块局部区域称作感受野（receptive field）。在图像卷积操作中，即神经元在空间维度（spatial dimension，即上图示例H和W所在的平面）是局部连接，但在深度上是全部连接。对于二维图像本身而言，也是局部像素关联较强。这种局部连接保证了学习后的过滤器能够对于局部的输入特征有最强的响应。局部连接的思想，也是受启发于生物学里面的视觉系统结构，视觉皮层的神经元就是局部接受信息的。

  • 权重共享：计算同一个深度切片的神经元时采用的滤波器是共享的。例如图4中计算

数字识别 - 图56的每个每个神经元的滤波器均相同，都为数字识别 - 图57，这样可以很大程度上减少参数。共享权重在一定程度上讲是有意义的，例如图片的底层边缘特征与特征在图中的具体位置无关。但是在一些场景中是无意的，比如输入的图片是人脸，眼睛和头发位于不同的位置，希望在不同的位置学到不同的特征 (参考斯坦福大学公开课)。请注意权重只是对于同一深度切片的神经元是共享的，在卷积层，通常采用多组卷积核提取不同特征，即对应不同深度切片的特征，不同深度切片的神经元权重是不共享。另外，偏重对同一深度切片的所有神经元都是共享的。

通过介绍卷积计算过程及其特性，可以看出卷积是线性操作，并具有平移不变性（shift-invariant），平移不变性即在图像每个位置执行相同的操作。卷积层的局部连接和权重共享使得需要学习的参数大大减小，这样也有利于训练较大卷积神经网络。

关于卷积的更多内容可参考阅读。

池化层

数字识别 - 图58图6. 池化层图片

池化是非线性下采样的一种形式，主要作用是通过减少网络的参数来减小计算量，并且能够在一定程度上控制过拟合。通常在卷积层的后面会加上一个池化层。池化包括最大池化、平均池化等。其中最大池化是用不重叠的矩形框将输入层分成不同的区域，对于每个矩形框的数取最大值作为输出层，如图6所示。

更详细的关于卷积神经网络的具体知识可以参考斯坦福大学公开课、Ufldl 和 图像分类教程。

常见激活函数介绍

  • sigmoid激活函数：数字识别 - 图59

  • tanh激活函数：数字识别 - 图60

实际上，tanh函数只是规模变化的sigmoid函数，将sigmoid函数值放大2倍之后再向下平移1个单位：tanh(x) = 2sigmoid(2x) - 1 。

  • ReLU激活函数：数字识别 - 图61

更详细的介绍请参考维基百科激活函数。

数据介绍

PaddlePaddle在API中提供了自动加载MNIST数据的模块paddle.dataset.mnist。加载后的数据位于/home/username/.cache/paddle/dataset/mnist下：

文件名称说明
train-images-idx3-ubyte训练数据图片，60,000条数据
train-labels-idx1-ubyte训练数据标签，60,000条数据
t10k-images-idx3-ubyte测试数据图片，10,000条数据
t10k-labels-idx1-ubyte测试数据标签，10,000条数据

Fluid API 概述

演示将使用最新的 Fluid API。Fluid API是最新的 PaddlePaddle API。它在不牺牲性能的情况下简化了模型配置。我们建议使用 Fluid API，它易学易用的特性将帮助您快速完成机器学习任务。。

下面是 Fluid API 中几个重要概念的概述：

  • inference_program：指定如何从数据输入中获得预测的函数，这是指定网络流的地方。

  • train_program：指定如何从 inference_program 和标签值中获取 loss 的函数，这是指定损失计算的地方。

  • optimizer_func: 指定优化器配置的函数，优化器负责减少损失并驱动训练，Paddle 支持多种不同的优化器。

在下面的代码示例中，我们将深入了解它们。

配置说明

加载 PaddlePaddle 的 Fluid API 包。

  1. from __future__ import print_function # 将python3中的print特性导入当前版本
  2. import os
  3. from PIL import Image # 导入图像处理模块
  4. import matplotlib.pyplot as plt
  5. import numpy
  6. import paddle # 导入paddle模块
  7. import paddle.fluid as fluid

Program Functions 配置

我们需要设置 inference_program 函数。我们想用这个程序来演示三个不同的分类器，每个分类器都定义为 Python 函数。我们需要将图像数据输入到分类器中。Paddle 为读取数据提供了一个特殊的层 layer.data 层。让我们创建一个数据层来读取图像并将其连接到分类网络。

  • Softmax回归：只通过一层简单的以softmax为激活函数的全连接层，就可以得到分类的结果。
  1. def softmax_regression():
  2.     """
  3.     定义softmax分类器：
  4.         一个以softmax为激活函数的全连接层
  5.     Return:
  6.         predict_image -- 分类的结果
  7.     """
  8.     # 输入的原始图像数据，大小为28*28*1
  9.     img = fluid.layers.data(name='img', shape=[1, 28, 28], dtype='float32')
  10.     # 以softmax为激活函数的全连接层，输出层的大小必须为数字的个数10
  11.     predict = fluid.layers.fc(
  12.         input=img, size=10, act='softmax')
  13.     return predict
  • 多层感知器：下面代码实现了一个含有两个隐藏层（即全连接层）的多层感知器。其中两个隐藏层的激活函数均采用ReLU，输出层的激活函数用Softmax。
  1. def multilayer_perceptron():
  2.     """
  3.     定义多层感知机分类器：
  4.         含有两个隐藏层（全连接层）的多层感知器
  5.         其中前两个隐藏层的激活函数采用 ReLU，输出层的激活函数用 Softmax
  6.  
  7.     Return:
  8.         predict_image -- 分类的结果
  9.     """
  10.     # 输入的原始图像数据，大小为28*28*1
  11.     img = fluid.layers.data(name='img', shape=[1, 28, 28], dtype='float32')
  12.     # 第一个全连接层，激活函数为ReLU
  13.     hidden = fluid.layers.fc(input=img, size=200, act='relu')
  14.     # 第二个全连接层，激活函数为ReLU
  15.     hidden = fluid.layers.fc(input=hidden, size=200, act='relu')
  16.     # 以softmax为激活函数的全连接输出层，输出层的大小必须为数字的个数10
  17.     prediction = fluid.layers.fc(input=hidden, size=10, act='softmax')
  18.     return prediction
  • 卷积神经网络LeNet-5: 输入的二维图像，首先经过两次卷积层到池化层，再经过全连接层，最后使用以softmax为激活函数的全连接层作为输出层。
  1. def convolutional_neural_network():
  2.     """
  3.     定义卷积神经网络分类器：
  4.         输入的二维图像，经过两个卷积-池化层，使用以softmax为激活函数的全连接层作为输出层
  5.  
  6.     Return:
  7.         predict -- 分类的结果
  8.     """
  9.     # 输入的原始图像数据，大小为28*28*1
  10.     img = fluid.layers.data(name='img', shape=[1, 28, 28], dtype='float32')
  11.     # 第一个卷积-池化层
  12.     # 使用20个5*5的滤波器，池化大小为2，池化步长为2，激活函数为Relu
  13.     conv_pool_1 = fluid.nets.simple_img_conv_pool(
  14.         input=img,
  15.         filter_size=5,
  16.         num_filters=20,
  17.         pool_size=2,
  18.         pool_stride=2,
  19.         act="relu")
  20.     conv_pool_1 = fluid.layers.batch_norm(conv_pool_1)
  21.     # 第二个卷积-池化层
  22.     # 使用50个5*5的滤波器，池化大小为2，池化步长为2，激活函数为Relu
  23.     conv_pool_2 = fluid.nets.simple_img_conv_pool(
  24.         input=conv_pool_1,
  25.         filter_size=5,
  26.         num_filters=50,
  27.         pool_size=2,
  28.         pool_stride=2,
  29.         act="relu")
  30.     # 以softmax为激活函数的全连接输出层，输出层的大小必须为数字的个数10
  31.     prediction = fluid.layers.fc(input=conv_pool_2, size=10, act='softmax')
  32.     return prediction

Train Program 配置

然后我们需要设置训练程序 train_program。它首先从分类器中进行预测。在训练期间，它将从预测中计算 avg_cost。

注意: 训练程序应该返回一个数组，第一个返回参数必须是 avg_cost。训练器使用它来计算梯度。

请随意修改代码，测试 Softmax 回归 softmax_regression, MLP 和 卷积神经网络 convolutional neural network 分类器之间的不同结果。

  1. def train_program():
  2.     """
  3.     配置train_program
  4.  
  5.     Return:
  6.         predict -- 分类的结果
  7.         avg_cost -- 平均损失
  8.         acc -- 分类的准确率
  9.  
  10.     """
  11.     # 标签层，名称为label,对应输入图片的类别标签
  12.     label = fluid.layers.data(name='label', shape=[1], dtype='int64')
  13.  
  14.     # predict = softmax_regression() # 取消注释将使用 Softmax回归
  15.     # predict = multilayer_perceptron() # 取消注释将使用 多层感知器
  16.     predict = convolutional_neural_network() # 取消注释将使用 LeNet5卷积神经网络
  17.  
  18.     # 使用类交叉熵函数计算predict和label之间的损失函数
  19.     cost = fluid.layers.cross_entropy(input=predict, label=label)
  20.     # 计算平均损失
  21.     avg_cost = fluid.layers.mean(cost)
  22.     # 计算分类准确率
  23.     acc = fluid.layers.accuracy(input=predict, label=label)
  24.     return predict, [avg_cost, acc]

Optimizer Function 配置

在下面的 Adam optimizer，learning_rate 是学习率，它的大小与网络的训练收敛速度有关系。

  1. def optimizer_program():
  2.     return fluid.optimizer.Adam(learning_rate=0.001)

数据集 Feeders 配置

下一步，我们开始训练过程。paddle.dataset.mnist.train()和paddle.dataset.mnist.test()分别做训练和测试数据集。这两个函数各自返回一个reader——PaddlePaddle中的reader是一个Python函数，每次调用的时候返回一个Python yield generator。

下面shuffle是一个reader decorator，它接受一个reader A，返回另一个reader B。reader B 每次读入buffer_size条训练数据到一个buffer里，然后随机打乱其顺序，并且逐条输出。

batch是一个特殊的decorator，它的输入是一个reader，输出是一个batched reader。在PaddlePaddle里，一个reader每次yield一条训练数据，而一个batched reader每次yield一个minibatch。

  1. # 一个minibatch中有64个数据
  2. BATCH_SIZE = 64
  3.  
  4. # 每次读取训练集中的500个数据并随机打乱，传入batched reader中，batched reader 每次 yield 64个数据
  5. train_reader = paddle.batch(
  6.         paddle.reader.shuffle(
  7.             paddle.dataset.mnist.train(), buf_size=500),
  8.         batch_size=BATCH_SIZE)
  9. # 读取测试集的数据，每次 yield 64个数据
  10. test_reader = paddle.batch(
  11.             paddle.dataset.mnist.test(), batch_size=BATCH_SIZE)

构建训练过程

现在，我们需要构建一个训练过程。将使用到前面定义的训练程序 train_program, place 和优化器 optimizer,并包含训练迭代、检查训练期间测试误差以及保存所需要用来预测的模型参数。

Event Handler 配置

我们可以在训练期间通过调用一个handler函数来监控训练进度。我们将在这里演示两个 event_handler 程序。请随意修改 Jupyter Notebook ，看看有什么不同。

event_handler 用来在训练过程中输出训练结果

  1. def event_handler(pass_id, batch_id, cost):
  2.     # 打印训练的中间结果，训练轮次，batch数，损失函数
  3.     print("Pass %d, Batch %d, Cost %f" % (pass_id,batch_id, cost))
  1. from paddle.utils.plot import Ploter
  2.  
  3. train_prompt = "Train cost"
  4. test_prompt = "Test cost"
  5. cost_ploter = Ploter(train_prompt, test_prompt)
  6.  
  7. # 将训练过程绘图表示
  8. def event_handler_plot(ploter_title, step, cost):
  9.     cost_ploter.append(ploter_title, step, cost)
  10.     cost_ploter.plot()

event_handler_plot 可以用来在训练过程中画图如下：

png

开始训练

可以加入我们设置的 event_handler 和 data reader，然后就可以开始训练模型了。设置一些运行需要的参数，配置数据描述feed_order 用于将数据目录映射到 train_program创建一个反馈训练过程中误差的train_test

定义网络结构：

  1. # 该模型运行在单个CPU上
  2. use_cuda = False # 如想使用GPU，请设置为 True
  3. place = fluid.CUDAPlace(0) if use_cuda else fluid.CPUPlace()
  4.  
  5. # 调用train_program 获取预测值，损失值，
  6. prediction, [avg_loss, acc] = train_program()
  7.  
  8. # 输入的原始图像数据，大小为28*28*1
  9. img = fluid.layers.data(name='img', shape=[1, 28, 28], dtype='float32')
  10. # 标签层，名称为label,对应输入图片的类别标签
  11. label = fluid.layers.data(name='label', shape=[1], dtype='int64')
  12. # 告知网络传入的数据分为两部分，第一部分是img值，第二部分是label值
  13. feeder = fluid.DataFeeder(feed_list=[img, label], place=place)
  14.  
  15. # 选择Adam优化器
  16. optimizer = fluid.optimizer.Adam(learning_rate=0.001)
  17. optimizer.minimize(avg_loss)

设置训练过程的超参：

  1. PASS_NUM = 5 #训练5轮
  2. epochs = [epoch_id for epoch_id in range(PASS_NUM)]
  3.  
  4. # 将模型参数存储在名为 save_dirname 的文件中
  5. save_dirname = "recognize_digits.inference.model"
  1. def train_test(train_test_program,
  2.                    train_test_feed, train_test_reader):
  3.  
  4.     # 将分类准确率存储在acc_set中
  5.     acc_set = []
  6.     # 将平均损失存储在avg_loss_set中
  7.     avg_loss_set = []
  8.     # 将测试 reader yield 出的每一个数据传入网络中进行训练
  9.     for test_data in train_test_reader():
  10.         acc_np, avg_loss_np = exe.run(
  11.             program=train_test_program,
  12.             feed=train_test_feed.feed(test_data),
  13.             fetch_list=[acc, avg_loss])
  14.         acc_set.append(float(acc_np))
  15.         avg_loss_set.append(float(avg_loss_np))
  16.     # 获得测试数据上的准确率和损失值
  17.     acc_val_mean = numpy.array(acc_set).mean()
  18.     avg_loss_val_mean = numpy.array(avg_loss_set).mean()
  19.     # 返回平均损失值，平均准确率
  20.     return avg_loss_val_mean, acc_val_mean

创建执行器：

  1. exe = fluid.Executor(place)
  2. exe.run(fluid.default_startup_program())

设置 main_program 和 test_program ：

  1. main_program = fluid.default_main_program()
  2. test_program = fluid.default_main_program().clone(for_test=True)

开始训练：

  1. lists = []
  2. step = 0
  3. for epoch_id in epochs:
  4.     for step_id, data in enumerate(train_reader()):
  5.         metrics = exe.run(main_program,
  6.                           feed=feeder.feed(data),
  7.                           fetch_list=[avg_loss, acc])
  8.         if step % 100 == 0: #每训练100次 打印一次log
  9.             print("Pass %d, Batch %d, Cost %f" % (step, epoch_id, metrics[0]))
  10.             event_handler_plot(train_prompt, step, metrics[0])
  11.         step += 1
  12.  
  13.     # 测试每个epoch的分类效果
  14.     avg_loss_val, acc_val = train_test(train_test_program=test_program,
  15.                                        train_test_reader=test_reader,
  16.                                        train_test_feed=feeder)
  17.  
  18.     print("Test with Epoch %d, avg_cost: %s, acc: %s" %(epoch_id, avg_loss_val, acc_val))
  19.     event_handler_plot(test_prompt, step, metrics[0])
  20.  
  21.     lists.append((epoch_id, avg_loss_val, acc_val))
  22.  
  23.     # 保存训练好的模型参数用于预测
  24.     if save_dirname is not None:
  25.         fluid.io.save_inference_model(save_dirname,
  26.                                       ["img"], [prediction], exe,
  27.                                       model_filename=None,
  28.                                       params_filename=None)
  29.  
  30. # 选择效果最好的pass
  31. best = sorted(lists, key=lambda list: float(list[1]))[0]
  32. print('Best pass is %s, testing Avgcost is %s' % (best[0], best[1]))
  33. print('The classification accuracy is %.2f%%' % (float(best[2]) * 100))

训练过程是完全自动的，event_handler里打印的日志类似如下所示。

Pass表示训练轮次，Batch表示训练全量数据的次数，cost表示当前pass的损失值。

每训练完一个Epoch后，计算一次平均损失和分类准确率。

  1. Pass 0, Batch 0, Cost 0.125650
  2. Pass 100, Batch 0, Cost 0.161387
  3. Pass 200, Batch 0, Cost 0.040036
  4. Pass 300, Batch 0, Cost 0.023391
  5. Pass 400, Batch 0, Cost 0.005856
  6. Pass 500, Batch 0, Cost 0.003315
  7. Pass 600, Batch 0, Cost 0.009977
  8. Pass 700, Batch 0, Cost 0.020959
  9. Pass 800, Batch 0, Cost 0.105560
  10. Pass 900, Batch 0, Cost 0.239809
  11. Test with Epoch 0, avg_cost: 0.053097883707459624, acc: 0.9822850318471338

训练之后，检查模型的预测准确度。用 MNIST 训练的时候，一般 softmax回归模型的分类准确率约为 92.34%，多层感知器为97.66%，卷积神经网络可以达到 99.20%。

应用模型

可以使用训练好的模型对手写体数字图片进行分类，下面程序展示了如何使用训练好的模型进行推断。

生成预测输入数据

infer_3.png 是数字 3 的一个示例图像。把它变成一个 numpy 数组以匹配数据feed格式。

  1. def load_image(file):
  2.     im = Image.open(file).convert('L')
  3.     im = im.resize((28, 28), Image.ANTIALIAS)
  4.     im = numpy.array(im).reshape(1, 1, 28, 28).astype(numpy.float32)
  5.     im = im / 255.0 * 2.0 - 1.0
  6.     return im
  7.  
  8. cur_dir = os.getcwd()
  9. tensor_img = load_image(cur_dir + '/image/infer_3.png')

Inference 创建及预测

通过load_inference_model来设置网络和经过训练的参数。我们可以简单地插入在此之前定义的分类器。

  1. inference_scope = fluid.core.Scope()
  2. with fluid.scope_guard(inference_scope):
  3.     # 使用 fluid.io.load_inference_model 获取 inference program desc,
  4.     # feed_target_names 用于指定需要传入网络的变量名
  5.     # fetch_targets 指定希望从网络中fetch出的变量名
  6.     [inference_program, feed_target_names,
  7.      fetch_targets] = fluid.io.load_inference_model(
  8.      save_dirname, exe, None, None)
  9.  
  10.     # 将feed构建成字典 {feed_target_name: feed_target_data}
  11.     # 结果将包含一个与fetch_targets对应的数据列表
  12.     results = exe.run(inference_program,
  13.                             feed={feed_target_names[0]: tensor_img},
  14.                             fetch_list=fetch_targets)
  15.     lab = numpy.argsort(results)
  16.  
  17.     # 打印 infer_3.png 这张图片的预测结果
  18.     img=Image.open('image/infer_3.png')
  19.     plt.imshow(img)
  20.     print("Inference result of image/infer_3.png is: %d" % lab[0][0][-1])

预测结果

如果顺利，预测结果输入如下：Inference result of image/infer_3.png is: 3 , 说明我们的网络成功的识别出了这张图片！

总结

本教程的softmax回归、多层感知机和卷积神经网络是最基础的深度学习模型，后续章节中复杂的神经网络都是从它们衍生出来的，因此这几个模型对之后的学习大有裨益。同时，我们也观察到从最简单的softmax回归变换到稍复杂的卷积神经网络的时候，MNIST数据集上的识别准确率有了大幅度的提升，原因是卷积层具有局部连接和共享权重的特性。在之后学习新模型的时候，希望大家也要深入到新模型相比原模型带来效果提升的关键之处。此外，本教程还介绍了PaddlePaddle模型搭建的基本流程，从dataprovider的编写、网络层的构建，到最后的训练和预测。对这个流程熟悉以后，大家就可以用自己的数据，定义自己的网络模型，并完成自己的训练和预测任务了。

参考文献