[Paddle学习笔记][03][数字识别]

说明：

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

实验代码：

 

import paddle
import paddle.fluid as fluid
from paddle.utils.plot import Ploter

import numpy
import os
from PIL import Image
import matplotlib.pyplot as plt

%matplotlib inline

# 全局变量
epochs = 5 # 训练迭代周期
save_dirname = "./model/Recognize_Digits.model" # 模型保存路径
infer_dirname = "./data/mnist/test/4/116.png" # 预测图像路径

# 测试模型
def test(executor, program, reader, feeder, fetch_list):
    avg_loss_set = [] # 平均损失值集
    acc_set = [] # 分类准确率集
    for test_data in reader(): # 将测试数据输出的每一个数据传入网络进行训练
        metrics = executor.run(
            program=program,
            feed=feeder.feed(test_data),
            fetch_list=fetch_list)
        avg_loss_set.append(float(metrics[0]))
        acc_set.append(float(metrics[1]))
    avg_loss_val_mean = numpy.array(avg_loss_set).mean() # 计算平均损失值
    acc_val_mean = numpy.array(acc_set).mean() # 计算平均准确率
    return avg_loss_val_mean, acc_val_mean # 返回平均损失值和平均准确率
    
# 训练模型
def train():
    # 读取数据
    batch_size = 64 # 每批64张图像
    train_reader = paddle.batch(
        paddle.reader.shuffle(paddle.dataset.mnist.train(), buf_size=500), # 每次读取500条数据，并随机打乱
        batch_size=batch_size)
    test_reader = paddle.batch(
        paddle.dataset.mnist.test(),
        batch_size=batch_size)
    
    # 配置训练网络
    img = fluid.data(name='img', shape=[None, 1, 28, 28], dtype='float32') # 数据层: 输出n*1*28*28
    label = fluid.data(name='label', shape=[None, 1], dtype='int64')       # 数据层: 输出n*1
    
    # softmax_regression
#     prediction = fluid.layers.fc(input=img, size=10, act='softmax')        # 全连接层: 输出n*10
    
    # multilayer_perceptron
#     hidden = fluid.layers.fc(input=img, size=200, act='relu')              # 全连接层: 输出n*200
#     hidden = fluid.layers.fc(input=hidden, size=200, act='relu')           # 全连接层: 输出n*200
#     prediction = fluid.layers.fc(input=hidden, size=10, act='softmax')     # 全连接层: 输出n*10

    # convolutional_neural_network
    # 卷积层: 输出n*20*24*24, c=k, w/h=(w/h-f+2*p)/s+1
    conv_1 = fluid.layers.conv2d(input=img   , num_filters=20, filter_size=5, act='relu')
    # 池化层: 输出n*20*12*12, c=c, w/h=(w/h-f+2*p)/s+1
    pool_1 = fluid.layers.pool2d(input=conv_1, pool_size=2, pool_stride=2)
    # 归一化层: 输出n*20*12*12
    norm_1 = fluid.layers.batch_norm(pool_1)
    # 卷积层: 输出n*50*8*8
    conv_2 = fluid.layers.conv2d(input=norm_1, num_filters=50, filter_size=5, act='relu')
    # 池化层: 输出n*50*4*4
    pool_2 = fluid.layers.pool2d(input=conv_2, pool_size=2, pool_stride=2)
    # 全连接层: 输出n*10
    prediction = fluid.layers.fc(input=pool_2, size=10, act='softmax')
    
    loss = fluid.layers.cross_entropy(input=prediction, label=label)       # 损失值层: 输出n*10, 交叉熵损失
    avg_loss = fluid.layers.mean(loss)                                     # 损失值层: 输出n*1, 平均损失值
    acc = fluid.layers.accuracy(input=prediction, label=label)             # 准确率层: 输出n*10，分类准确率
    
    # 获取网络
    startup_program = fluid.default_startup_program() # 获取默认启动程序
    main_program = fluid.default_main_program() # 获取默认主程序
    test_program = main_program.clone(for_test=True) # 克隆测试主程序
    
    # 配置优化方法
    optimizer = fluid.optimizer.Adam(learning_rate=0.001) #Adam算法
    optimizer.minimize(avg_loss) # 最小化平均损失
    
    # 运行启动程序
    place = fluid.CUDAPlace(0) # 获取GPU设备
    exe = fluid.Executor(place) # 获取训练执行器
    exe.run(startup_program) # 运行启动程序
    
    # 开始训练模型
    step = 0 # 周期计数
    lists = [] # 测试结果
    feeder = fluid.DataFeeder(feed_list=[img, label], place=place) # 获取数据读取器
    exe_test = fluid.Executor(place) # 获取测试执行器

    train_prompt = "Train loss"
    test_prompt = "Test loss"
    loss_ploter = Ploter(train_prompt, test_prompt) # 绘制训练损失值图
    
    for epoch_id in range(epochs):
        # 训练模型
        for train_data in train_reader():
            train_metrics = exe.run(
                program=main_program,
                feed=feeder.feed(train_data),
                fetch_list=[avg_loss, acc])
            
            if step % 100 == 0: # 每100个批次记录并输出一下训练损失值
                loss_ploter.append(train_prompt, step, train_metrics[0])
                loss_ploter.plot()
                print("Pass %4d, Epoch %d, Loss %f" % (step, epoch_id, train_metrics[0]))
            
            step += 1 # 增加计数
            
        # 测试模型
        test_metrics = test(
            executor=exe_test,
            program=test_program,
            reader=test_reader,
            feeder=feeder,
            fetch_list=[avg_loss, acc])
        
        loss_ploter.append(test_prompt, step, test_metrics[0])
        loss_ploter.plot()
        print("Test with Epoch %d, avg_loss: %f, acc: %f" % (epoch_id, test_metrics[0], test_metrics[1]))       
        lists.append((epoch_id, test_metrics[0], test_metrics[1])) # 保存测试结果
        
        # 保存模型
        if save_dirname is not None:
            fluid.io.save_inference_model(save_dirname, ['img'], [prediction], exe)
            
    # 输出最好结果
    best = sorted(lists, key=lambda list: float(list[1]))[0]
    print("Best pass is %d, testing avg_loss is %f" % (best[0], best[1]))
    print("The classification accuracy is %.2f%%" % (float(best[2]) * 100))

# 加载图像
def load_image(file):
    im = Image.open(file).convert('L') # 读取图像文件，并转成灰度图
    im = im.resize((28, 28), Image.ANTIALIAS) # 调整为28*28，高质量图
    im = numpy.array(im).reshape(1, 1, 28, 28).astype(numpy.float32) # 转换为numpy类型
    im = im / 255.0 * 2.0 - 1.0 # 对数据归一化处理(-1,1)
    return im
    
# 数据推断
def infer():
    # 是否存在推断模型
    if save_dirname is None:
        return
    
    # 加载图像
    tensor_img = load_image(infer_dirname)
    
    # 数据推断
    place = fluid.CUDAPlace(0) # 获取GPU设备
    infer_exe = fluid.Executor(place) # 获取推断执行器
    inference_scope = fluid.core.Scope() # 获取推断作用域
    
    with fluid.scope_guard(inference_scope):
        # 加载推断模型
        [inference_program, feed_target_names, fetch_targets
            ] = fluid.io.load_inference_model(save_dirname, infer_exe)
        
        # 进行数据推断
        results = infer_exe.run(
            program=inference_program,
            feed={feed_target_names[0]: tensor_img},
            fetch_list=fetch_targets)
        
        # 输出推断结果
        label = numpy.argsort(results[0][0]) # 对10类概率值位置从小到大排序
        print(results[0][0]) # 10类概率值
        print(label) # 10类概率从大到小对应标签
        print("Inference result is: %d" % label[-1]) # 输出概最大率值标签
        img = Image.open(infer_dirname) # 打开推断图像
        plt.imshow(img) # 显示推断图像
        
    
# 主函数
def main():
    # 训练模型
    train()
    
    # 数据推断
    infer()

# 主函数
if __name__ == '__main__':
    main()

 

实验结果：

Test with Epoch 4, avg_loss: 0.047326, acc: 0.987361

Best pass is 3, testing avg_loss is 0.041124

The classification accuracy is 98.72%

[1.8291370e-14 1.3467998e-08 2.3033226e-11 1.5657427e-08 9.9999630e-01

1.2488571e-08 3.6087099e-11 1.4171575e-09 2.1537630e-06 1.5523912e-06]

[0 2 6 7 5 1 3 9 8 4]

Inference result is: 4

参考资料：

https://www.paddlepaddle.org.cn/documentation/docs/zh/user_guides/simple_case/recognize_digits/README.cn.html

https://github.com/PaddlePaddle/book/blob/develop/02.recognize_digits/train.py