MindSpore框架应用之手写数字识别educoder

任务描述

本关任务：编写图片分类的预测程序。

相关知识

卷积神经网络是图像处理中常用的一种模型，常用来进行图像的分类、追踪、重建等。
LeNet−5是卷积神经网络中较为简单的一种，它的模型如下所示：

从上图可以看出，LeNet−5由两个卷积层（Convolutions）、两个下采样层（池化层，Subsampling）以及三个全连接层组成（Full connection和Gaussian connection）。

数据来源

手写数字识别是非常基础的计算机视觉入门案例，手写数字的图片如下所示：

手写数字任务的目的就是将图片中的数字用程序识别出来。

预处理数据集

拿到数据集之后不能直接使用，需要进行一些预处理，以提高数据的质量。
关于数据预处理中用到的函数，详细请参考系列实训的第三篇：MindSpore中的数据预处理
我们定义一个函数来对数据集进行预处理（详情见educoder）

定义网络

LeNet−5中包含卷积层和全连接层，这两层需要进行初始化，MindSpore中使用TruncatedNormal函数进行初始化。

定义损失函数与优化器

损失函数是深度学习中的基本概念，就是表示预测值与实际值差异的函数。深度学习通过不停地迭代来缩小损失函数的值。

损失函数关于权重的梯度，用于指示优化器（优化器的作用是最小化损失函数）进行权重优化的方向，优化的目的是提高模型的性能。这里我们使用SoftmaxCrossEntropyWithLogits作为损失函数；

训练

训练的作用是通过数据集来构建网络，求出网络中的所有参数。

预测

编程要求

补充右侧编辑器Begin和End之间的代码，实现对test文件夹下数据的预测。你需要补充的代码在相关知识最后的预测部分有详细的介绍，补充的代码按照以下步骤对数据进行预测：

加载模型参数，参数文件的地址是checkpoint_lenet-1_1875.ckpt；
使用参数对网络实例化；
加载测试数据集；
预测，打印处数据集的预测精度。

代码如下：

【完成！对你有帮助的话，不忘点个赞哟~~~】

# coding=utf-8  
import os  
import mindspore.dataset as ds  
import mindspore.nn as nn  
from mindspore import context  
from mindspore.train.serialization import load_checkpoint, load_param_into_net  
from mindspore.train.callback import ModelCheckpoint, CheckpointConfig, LossMonitor  
from mindspore.train import Model  
from mindspore.common.initializer import TruncatedNormal  
import mindspore.dataset.transforms.vision.c_transforms as CV  
import mindspore.dataset.transforms.c_transforms as C  
from mindspore.dataset.transforms.vision import Inter  
from mindspore.nn.metrics import Accuracy  
from mindspore.common import dtype as mstype  
from mindspore.nn.loss import SoftmaxCrossEntropyWithLogits
def create_dataset(data_path, batch_size=32, repeat_size=1,  
                   num_parallel_workers=1):  
    """ 创建训练和测试数据集  
    参数列表:  
        data_path: 数据集路径  
        batch_size: 每组中数据的数量  
        repeat_size: 数据重复次数  
        num_parallel_workers: 负责处理的线程的数量  
    """  
    # 定义数据集  
    mnist_ds = ds.MnistDataset(data_path)
    # 定义参数  
    resize_height, resize_width = 32, 32  
    rescale = 1.0 / 255.0  
    shift = 0.0  
    rescale_nml = 1 / 0.3081  
    shift_nml = -1 * 0.1307 / 0.3081
    # 定义map函数  
    resize_op = CV.Resize((resize_height, resize_width), interpolation=Inter.LINEAR) # 将图片进行resize成32x32大小的函数  
    rescale_nml_op = CV.Rescale(rescale_nml, shift_nml)  # 归一化图片  
    rescale_op = CV.Rescale(rescale, shift)  # rescale图片  
    hwc2chw_op = CV.HWC2CHW()  # 改变图片的shape以适应网络  
    type_cast_op = C.TypeCast(mstype.int32)  # 改变类型以适应网络
    # 对数据集使用map函数  
    mnist_ds = mnist_ds.map(input_columns="label", operations=type_cast_op,  
                            num_parallel_workers=num_parallel_workers)  # 改变标签的数据类型  
    mnist_ds = mnist_ds.map(input_columns="image", operations=resize_op,  
                            num_parallel_workers=num_parallel_workers)  # 对图片resize  
    mnist_ds = mnist_ds.map(input_columns="image", operations=rescale_op,  
                            num_parallel_workers=num_parallel_workers)  # 对图片rescale  
    mnist_ds = mnist_ds.map(input_columns="image", operations=rescale_nml_op,  
                            num_parallel_workers=num_parallel_workers)  # 图片归一化  
    mnist_ds = mnist_ds.map(input_columns="image", operations=hwc2chw_op,  
                            num_parallel_workers=num_parallel_workers)  # reshape图片
    # 数据集批处理  
    buffer_size = 10000  
    mnist_ds = mnist_ds.shuffle(buffer_size=buffer_size)  # 混洗  
    mnist_ds = mnist_ds.batch(batch_size, drop_remainder=True)  # 分批  
    mnist_ds = mnist_ds.repeat(repeat_size)  # 重复  
    return mnist_ds
def conv(in_channels, out_channels, kernel_size, stride=1, padding=0):  
    """卷积层初始化"""  
    weight = weight_variable()  
    return nn.Conv2d(in_channels, out_channels,  
                     kernel_size=kernel_size, stride=stride, padding=padding,  
                     weight_init=weight, has_bias=False, pad_mode="valid")
def fc_with_initialize(input_channels, out_channels):  
    """全连接层初始化"""  
    weight = weight_variable()  
    bias = weight_variable()  
    return nn.Dense(input_channels, out_channels, weight, bias)
def weight_variable():  
    """初始化"""  
    return TruncatedNormal(0.02)
class LeNet5(nn.Cell): # nn.Cell是所有神经网络的基类  
    """Lenet网络结构"""  
    def __init__(self):  
        super(LeNet5, self).__init__()  
        self.conv1 = conv(1, 6, 5) # 卷积层  
        self.conv2 = conv(6, 16, 5) # 卷积层  
        self.fc1 = fc_with_initialize(16 * 5 * 5, 120) # 全连接层  
        self.fc2 = fc_with_initialize(120, 84) # 全连接层  
        self.fc3 = fc_with_initialize(84, 10) # 全连接层  
        self.relu = nn.ReLU()  
        self.max_pool2d = nn.MaxPool2d(kernel_size=2, stride=2)  
        self.flatten = nn.Flatten()
    """进行网络的前向构造"""  
    def construct(self, x):  
        x = self.conv1(x) # 卷积层  
        x = self.relu(x)  
        x = self.max_pool2d(x) # 池化层  
        x = self.conv2(x) # 卷积层  
        x = self.relu(x)  
        x = self.max_pool2d(x) # 池化层  
        x = self.flatten(x)  
        x = self.fc1(x) # 全连接层  
        x = self.relu(x)  
        x = self.fc2(x) # 全连接层  
        x = self.relu(x)  
        x = self.fc3(x) # 全连接层  
        return x
if __name__ == "__main__":  
    context.set_context(mode=context.GRAPH_MODE, device_target="CPU")  
    momentum = 0.9  
    epoch_size = 1  
    mnist_path = r"./"  
    # 定义损失函数  
    net_loss = SoftmaxCrossEntropyWithLogits(is_grad=False, sparse=True, reduction='mean')  
    # 创建网络  
    network = LeNet5()  
    # 定义优化器  
    net_opt = nn.Momentum(network.trainable_params(), 0.01, momentum)  
    # 定义模型  
    model = Model(network, net_loss, net_opt, metrics={"Accuracy": Accuracy()})
    ######### Begin #########  
    # 加载训练好的模型参数  
    param_dict = load_checkpoint("checkpoint_lenet-1_1875.ckpt")  
    # 模型实例化  
    load_param_into_net(network, param_dict)  
    # 加载测试数据  
    ds_eval = create_dataset(os.path.join(mnist_path, "test"))  
    # 预测  
    acc = model.eval(ds_eval, dataset_sink_mode=False)  
    # 打印预测结果  
    print(acc["Accuracy"])  
    ######### End #########