阅读 234

利用飞桨实现数字识别

作者:燕清

数字识别,是机器学习和深度学习的经典案例。为此,此时用飞桨深度学习平台,也实现此案例。在本例中所用的数据集来自MNIST。


图1.MNIST图片示例

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

提示: 本文代码已经发布到在线实验平台,请关注本文微信公众号(扫描文末二维码),并回复:姓名+手机号+‘案例’,即可获得。

概述

首先,理解本文所使用的如下定义:

  • X,代表输入:MNIST图片是28×28 的二维图像,为了进行计算,我们将其转化为784维向量,即X=(x_0,x_1,…,x_{783})。
  • Y,代表分类器预测的输出:分类器的输出是10类数字(0-9),即Y=(y_0,y_1,…,y_9),每一维y_i代表图片分类为第i类数字的概率。
  • Labe,代表数字图片的真实标签:Label=(l_0,l_1,…,l_9),也是10维,但只有一个特征为1,其他都为0,即用稀疏矩阵表示数字。例如某张图片上的数字为2,则它对应的样本为(0,0,1,0,…,0)

Softmax回归(Softmax Regression)

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

X传到输出层,在激活操作之前,会乘以相应的权重 W ,并加上偏置变量 b ,如下式所示:

y_i = softmax(\sum_jW_{i,j}x_j + b_i)

其中

softmax(x_i) = \frac{e^{x_i}}{\sum_je^{x_j}}

对于有 N 个类别的多分类问题,指定 N 个输出节点,N 维向量经过softmax将区间化为 N 个[0,1]范围内的实数值,分别表示该样本属于这 N 个类别的概率。此处的 y_i 即对应该图片为数字 i 的预测概率。

在分类问题中,我们一般采用交叉熵损失函数(cross entropy loss),公式如下:

L_{cross-entropy}(label, y) = -\sum_i label_i log(y_i)

多层感知机(Multilayer Perceptron, MLP)

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

  1. 经过第一个隐藏层,可以得到 H_1=ϕ(W_1X+b_1),其中ϕ代表激活函数,常见的有sigmoid、tanh或ReLU等函数。
  2. 经过第二个隐藏层,可以得到 H_2=ϕ(W_2H_1+b_2)
  3. 最后,再经过输出层,得到的Y=softmax(W_3H_2+b_3),即为最后的分类结果。

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

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


图2. LeNet-5卷积神经网络结构

操作过程

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是最新的 PaddlePaddle API,它在不牺牲性能的情况下简化了模型配置,建议使用。

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

  1. inference_program:指定如何从数据输入中获得预测的函数, 这是指定网络流的地方。
  2. train_program:指定如何从 inference_program 和标签值中获取 loss 的函数, 这是指定损失计算的地方。
  3. optimizer_func: 指定优化器配置的函数,优化器负责减少损失并驱动训练,Paddle 支持多种不同的优化器。

加载 PaddlePaddle 的 Fluid API 包。

import os
from PIL import Image # 导入图像处理模块
import matplotlib.pyplot as plt
import numpy
import paddle # 导入paddle模块
import paddle.fluid as fluid
复制代码

Program Functions 配置

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

  • Softmax回归:只通过一层简单的以softmax为激活函数的全连接层,就可以得到分类的结果。
def softmax_regression():
    """
    定义softmax分类器:
        一个以softmax为激活函数的全连接层
    Return:
        predict_image -- 分类的结果
    """
    # 输入的原始图像数据,大小为28*28*1
    img = fluid.data(name='img', shape=[None, 1, 28, 28], dtype='float32')
    # 以softmax为激活函数的全连接层,输出层的大小必须为数字的个数10
    predict = fluid.layers.fc(
        input=img, size=10, act='softmax')
    return predict
复制代码
  • 多层感知器:下面代码实现了一个含有两个隐藏层(即全连接层)的多层感知器。其中两个隐藏层的激活函数均采用ReLU,输出层的激活函数用Softmax。
def multilayer_perceptron():
    """
    定义多层感知机分类器:
        含有两个隐藏层(全连接层)的多层感知器
        其中前两个隐藏层的激活函数采用 ReLU,输出层的激活函数用 Softmax

    Return:
        predict_image -- 分类的结果
    """
    # 输入的原始图像数据,大小为28*28*1
    img = fluid.data(name='img', shape=[None, 1, 28, 28], dtype='float32')
    # 第一个全连接层,激活函数为ReLU
    hidden = fluid.layers.fc(input=img, size=200, act='relu')
    # 第二个全连接层,激活函数为ReLU
    hidden = fluid.layers.fc(input=hidden, size=200, act='relu')
    # 以softmax为激活函数的全连接输出层,输出层的大小必须为数字的个数10
    prediction = fluid.layers.fc(input=hidden, size=10, act='softmax')
    return prediction
复制代码
  • 卷积神经网络LeNet-5: 输入的二维图像,首先经过两次卷积层到池化层,再经过全连接层,最后使用以softmax为激活函数的全连接层作为输出层。
def convolutional_neural_network():
    """
    定义卷积神经网络分类器:
        输入的二维图像,经过两个卷积-池化层,使用以softmax为激活函数的全连接层作为输出层

    Return:
        predict -- 分类的结果
    """
    # 输入的原始图像数据,大小为28*28*1
    img = fluid.data(name='img', shape=[None, 1, 28, 28], dtype='float32')
    # 第一个卷积-池化层
    # 使用20个5*5的滤波器,池化大小为2,池化步长为2,激活函数为Relu
    conv_pool_1 = fluid.nets.simple_img_conv_pool(
        input=img,
        filter_size=5,
        num_filters=20,
        pool_size=2,
        pool_stride=2,
        act="relu")
    conv_pool_1 = fluid.layers.batch_norm(conv_pool_1)
    # 第二个卷积-池化层
    # 使用50个5*5的滤波器,池化大小为2,池化步长为2,激活函数为Relu
    conv_pool_2 = fluid.nets.simple_img_conv_pool(
        input=conv_pool_1,
        filter_size=5,
        num_filters=50,
        pool_size=2,
        pool_stride=2,
        act="relu")
    # 以softmax为激活函数的全连接输出层,输出层的大小必须为数字的个数10
    prediction = fluid.layers.fc(input=conv_pool_2, size=10, act='softmax')
    return prediction
复制代码

Train Program 配置

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

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

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

def train_program():
    """
    配置train_program

    Return:
        predict -- 分类的结果
        avg_cost -- 平均损失
        acc -- 分类的准确率

    """
    # 标签层,名称为label,对应输入图片的类别标签
    label = fluid.data(name='label', shape=[None, 1], dtype='int64')

    # predict = softmax_regression() # 取消注释将使用 Softmax回归
    # predict = multilayer_perceptron() # 取消注释将使用 多层感知器
    predict = convolutional_neural_network() # 取消注释将使用 LeNet5卷积神经网络

    # 使用类交叉熵函数计算predict和label之间的损失函数
    cost = fluid.layers.cross_entropy(input=predict, label=label)
    # 计算平均损失
    avg_cost = fluid.layers.mean(cost)
    # 计算分类准确率
    acc = fluid.layers.accuracy(input=predict, label=label)
    return predict, [avg_cost, acc]
复制代码

Optimizer Function 配置

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

def optimizer_program():
    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。

# 一个minibatch中有64个数据
BATCH_SIZE = 64

# 每次读取训练集中的500个数据并随机打乱,传入batched reader中,batched reader 每次 yield 64个数据
train_reader = paddle.batch(
        paddle.reader.shuffle(
            paddle.dataset.mnist.train(), buf_size=500),
        batch_size=BATCH_SIZE)
# 读取测试集的数据,每次 yield 64个数据
test_reader = paddle.batch(
            paddle.dataset.mnist.test(), batch_size=BATCH_SIZE)
复制代码

构建训练过程

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

Event Handler 配置

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

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

def event_handler(pass_id, batch_id, cost):
    # 打印训练的中间结果,训练轮次,batch数,损失函数
    print("Pass %d, Batch %d, Cost %f" % (pass_id,batch_id, cost))
复制代码
from paddle.utils.plot import Ploter

train_prompt = "Train cost"
test_prompt = "Test cost"
cost_ploter = Ploter(train_prompt, test_prompt)

# 将训练过程绘图表示
def event_handler_plot(ploter_title, step, cost):
    cost_ploter.append(ploter_title, step, cost)
    cost_ploter.plot()
复制代码

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

开始训练

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

定义网络结构:

# 该模型运行在单个CPU上
use_cuda = True # 如想使用GPU,请设置为 True
place = fluid.CUDAPlace(0) if use_cuda else fluid.CPUPlace()

# 调用train_program 获取预测值,损失值,
prediction, [avg_loss, acc] = train_program()

# 输入的原始图像数据,名称为img,大小为28*28*1
# 标签层,名称为label,对应输入图片的类别标签
# 告知网络传入的数据分为两部分,第一部分是img值,第二部分是label值
feeder = fluid.DataFeeder(feed_list=['img', 'label'], place=place)

# 选择Adam优化器
optimizer = optimizer_program()
optimizer.minimize(avg_loss)
复制代码

设置训练过程的超参:

PASS_NUM = 5 #训练5轮
epochs = [epoch_id for epoch_id in range(PASS_NUM)]

# 将模型参数存储在名为 save_dirname 的文件中
save_dirname = "recognize_digits.inference.model"
复制代码
def train_test(train_test_program,
                   train_test_feed, train_test_reader):

    # 将分类准确率存储在acc_set中
    acc_set = []
    # 将平均损失存储在avg_loss_set中
    avg_loss_set = []
    # 将测试 reader yield 出的每一个数据传入网络中进行训练
    for test_data in train_test_reader():
        acc_np, avg_loss_np = exe.run(
            program=train_test_program,
            feed=train_test_feed.feed(test_data),
            fetch_list=[acc, avg_loss])
        acc_set.append(float(acc_np))
        avg_loss_set.append(float(avg_loss_np))
    # 获得测试数据上的准确率和损失值
    acc_val_mean = numpy.array(acc_set).mean()
    avg_loss_val_mean = numpy.array(avg_loss_set).mean()
    # 返回平均损失值,平均准确率
    return avg_loss_val_mean, acc_val_mean
复制代码

创建执行器:

exe = fluid.Executor(place)
exe.run(fluid.default_startup_program())
复制代码

设置 main_program 和 test_program :

main_program = fluid.default_main_program()
test_program = fluid.default_main_program().clone(for_test=True)
复制代码

开始训练:

lists = []
step = 0

for epoch_id in epochs:
    for step_id, data in enumerate(train_reader()):
        metrics = exe.run(main_program,
                          feed=feeder.feed(data),
                          fetch_list=[avg_loss, acc])
        if step % 10 == 0: #每训练100次 打印一次log
            event_handler_plot(train_prompt, step, metrics[0])
        step += 1

    # 测试每个epoch的分类效果
    avg_loss_val, acc_val = train_test(train_test_program=test_program,
                                      train_test_reader=test_reader,
                                      train_test_feed=feeder)

    event_handler_plot(test_prompt, step, metrics[0])

    lists.append((epoch_id, avg_loss_val, acc_val))

    # 保存训练好的模型参数用于预测
    if save_dirname is not None:
        fluid.io.save_inference_model(save_dirname,
                                      ["img"], [prediction], exe,
                                      model_filename=None,
                                      params_filename=None)

复制代码
# 选择效果最好的pass
best = sorted(lists, key=lambda list: float(list[1]))[0]
print('Best pass is %s, testing Avgcost is %s' % (best[0], best[1]))
print('The classification accuracy is %.2f%%' % (float(best[2]) * 100))
复制代码

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

注:在aistudio中ploter和print存在原生bug,取消print后ploter方可使用

应用模型

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

生成预测输入数据

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

def load_image(file):
    # 读取图片文件,并将它转成灰度图
    im = Image.open(file).convert('L')
    # 将输入图片调整为 28*28 的高质量图
    im = im.resize((28, 28), Image.ANTIALIAS)
    # 将图片转换为numpy
    im = numpy.array(im).reshape(1, 1, 28, 28).astype(numpy.float32)
    # 对数据作归一化处理
    im = im / 255.0 * 2.0 - 1.0
    return im

tensor_img = load_image('work/infer_3.png')
复制代码

Inference 创建及预测

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

inference_scope = fluid.core.Scope()
with fluid.scope_guard(inference_scope):
    # 使用 fluid.io.load_inference_model 获取 inference program desc,
    # feed_target_names 用于指定需要传入网络的变量名
    # fetch_targets 指定希望从网络中fetch出的变量名
    [inference_program, feed_target_names,
     fetch_targets] = fluid.io.load_inference_model(
     save_dirname, exe, None, None)

    # 将feed构建成字典 {feed_target_name: feed_target_data}
    # 结果将包含一个与fetch_targets对应的数据列表
    results = exe.run(inference_program,
                            feed={feed_target_names[0]: tensor_img},
                            fetch_list=fetch_targets)
    lab = numpy.argsort(results)

    # 打印 infer_3.png 这张图片的预测结果
    img=Image.open('work/infer_3.png')
    plt.imshow(img)
    print("Inference result of work/infer_3.png is: %d" % lab[0][0][-1])
复制代码

关注微信公众号:老齐教室。读深度文章,得精湛技艺,享绚丽人生。

WechatIMG6

关注下面的标签,发现更多相似文章
评论