{ "cells": [ { "cell_type": "markdown", "metadata": {}, "source": [ "#
手写数字分类识别入门体验
" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## 实现一个图片分类应用\n", "## 概述\n", "下面我们通过一个实际样例,带领大家体验MindSpore基础的功能,对于一般的用户而言,完成整个样例实践会持续20~30分钟。\n", "\n", "本例子会实现一个简单的图片分类的功能,整体流程如下:\n", "\n", "1. 处理需要的数据集,这里使用了MNIST数据集。\n", "\n", "2. 定义一个网络,这里我们使用LeNet网络。\n", "\n", "3. 自定义回调函数收集模型的损失值和精度值。\n", "\n", "4. 加载数据集并进行训练,训练完成后,查看结果及保存模型文件。\n", "\n", "5. 加载保存的模型,进行推理。\n", "\n", "6. 验证模型,加载测试数据集和训练后的模型,验证结果精度。" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "说明:
你可以在这里找到完整可运行的样例代码:。" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## 训练的数据集下载" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "#### 方法一:\n", "从以下网址下载,并将数据包解压缩后放至Jupyter的工作目录下:
训练数据集:{\"\", \"\"}\n", "
测试数据集:{\"\", \"\"}
我们用下面代码查询jupyter的工作目录。" ] }, { "cell_type": "code", "execution_count": 1, "metadata": { "ExecuteTime": { "end_time": "2020-09-04T06:15:58.114167Z", "start_time": "2020-09-04T06:15:58.105497Z" } }, "outputs": [ { "data": { "text/plain": [ "'C:\\\\Users\\\\Administrator'" ] }, "execution_count": 1, "metadata": {}, "output_type": "execute_result" } ], "source": [ "import os\n", "\n", "os.getcwd()" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "训练数据集放在----`Jupyter工作目录+\\MNIST_Data\\train\\`,此时train文件夹内应该包含两个文件,`train-images-idx3-ubyte`和`train-labels-idx1-ubyte`
测试数据集放在----`Jupyter工作目录+\\MNIST_Data\\test\\`,此时test文件夹内应该包含两个文件,`t10k-images-idx3-ubyte`和`t10k-labels-idx1-ubyte`" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "#### 方法二:\n", "直接执行下面代码,会自动进行训练集的下载与解压,但是整个过程根据网络好坏情况会需要花费几分钟时间。" ] }, { "cell_type": "code", "execution_count": 2, "metadata": { "ExecuteTime": { "end_time": "2020-09-04T06:15:58.130999Z", "start_time": "2020-09-04T06:15:58.115177Z" } }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "******Downloading the MNIST dataset******\n" ] } ], "source": [ "import urllib.request \n", "from urllib.parse import urlparse\n", "import gzip \n", "import os\n", "\n", "def unzip_file(gzip_path):\n", " \"\"\"\n", " unzip dataset file\n", " \n", " Args:\n", " gzip_path (str): dataset file path\n", " \"\"\"\n", " open_file = open(gzip_path.replace('.gz',''), 'wb')\n", " gz_file = gzip.GzipFile(gzip_path)\n", " open_file.write(gz_file.read())\n", " gz_file.close()\n", " \n", "def download_dataset():\n", " \"\"\"Download the dataset from http://yann.lecun.com/exdb/mnist/.\"\"\"\n", " print(\"******Downloading the MNIST dataset******\")\n", " train_path = \"./MNIST_Data/train/\" \n", " test_path = \"./MNIST_Data/test/\"\n", " train_path_check = os.path.exists(train_path)\n", " test_path_check = os.path.exists(test_path)\n", " if train_path_check == False and test_path_check == False:\n", " os.makedirs(train_path)\n", " os.makedirs(test_path)\n", " train_url = {\"http://yann.lecun.com/exdb/mnist/train-images-idx3-ubyte.gz\", \"http://yann.lecun.com/exdb/mnist/train-labels-idx1-ubyte.gz\"}\n", " test_url = {\"http://yann.lecun.com/exdb/mnist/t10k-images-idx3-ubyte.gz\", \"http://yann.lecun.com/exdb/mnist/t10k-labels-idx1-ubyte.gz\"}\n", " \n", " for url in train_url:\n", " url_parse = urlparse(url)\n", " # split the file name from url\n", " file_name = os.path.join(train_path,url_parse.path.split('/')[-1])\n", " if not os.path.exists(file_name.replace('.gz', '')):\n", " file = urllib.request.urlretrieve(url, file_name)\n", " unzip_file(file_name)\n", " os.remove(file_name)\n", " \n", " for url in test_url:\n", " url_parse = urlparse(url)\n", " # split the file name from url\n", " file_name = os.path.join(test_path,url_parse.path.split('/')[-1])\n", " if not os.path.exists(file_name.replace('.gz', '')):\n", " file = urllib.request.urlretrieve(url, file_name)\n", " unzip_file(file_name)\n", " os.remove(file_name)\n", "\n", "download_dataset()" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "这样就完成了数据集的下载解压缩工作。" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## 处理MNIST数据集" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "由于我们后面会采用LeNet这样的卷积神经网络对数据集进行训练,而采用LeNet在训练数据时,对数据格式是有所要求的,所以接下来的工作需要我们先查看数据集内的数据是什么样的,这样才能构造一个针对性的数据转换函数,将数据集数据转换成符合训练要求的数据形式。" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "更多的LeNet网络的介绍不在此赘述,希望详细了解LeNet网络,可以查询。" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### 查看原始数据集数据" ] }, { "cell_type": "code", "execution_count": 3, "metadata": { "ExecuteTime": { "end_time": "2020-09-04T06:15:59.235677Z", "start_time": "2020-09-04T06:15:58.132025Z" } }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "The type of mnist_ds: \n", "Number of pictures contained in the mnist_ds: 60000\n", "The item of mnist_ds: dict_keys(['image', 'label'])\n", "Tensor of image in item: (28, 28, 1)\n", "The label of item: 1\n" ] }, { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": { "needs_background": "light" }, "output_type": "display_data" } ], "source": [ "from mindspore import context\n", "import matplotlib.pyplot as plt\n", "import matplotlib\n", "import numpy as np\n", "import mindspore.dataset as ds\n", "\n", "context.set_context(mode=context.GRAPH_MODE, device_target=\"CPU\") \n", "train_data_path = \"./MNIST_Data/train\"\n", "test_data_path = \"./MNIST_Data/test\"\n", "mnist_ds = ds.MnistDataset(train_data_path)\n", "print('The type of mnist_ds:', type(mnist_ds))\n", "print(\"Number of pictures contained in the mnist_ds:\", mnist_ds.get_dataset_size())\n", "\n", "dic_ds = mnist_ds.create_dict_iterator()\n", "item = dic_ds.get_next()\n", "img = item[\"image\"]\n", "label = item[\"label\"]\n", "\n", "print(\"The item of mnist_ds:\", item.keys())\n", "print(\"Tensor of image in item:\", img.shape) \n", "print(\"The label of item:\", label)\n", "\n", "plt.imshow(np.squeeze(img))\n", "plt.title(\"number:%s\"% item[\"label\"])\n", "plt.show()" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "从上面的运行情况我们可以看到,训练数据集`train-images-idx3-ubyte`和`train-labels-idx1-ubyte`对应的是6万张图片和6万个数字下标,载入数据后经过`create_dict_iterator`转换字典型的数据集,取其中的一个数据查看,这是一个key为`image`和`label`的字典,其中的`image`的张量(高度28,宽度28,通道1)和`label`为对应图片的数字。" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### 数据处理" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "数据集对于训练非常重要,好的数据集可以有效提高训练精度和效率,在加载数据集前,我们通常会对数据集进行一些处理。\n", "#### 定义数据集及数据操作\n", "我们定义一个函数`create_dataset`来创建数据集。在这个函数中,我们定义好需要进行的数据增强和处理操作:\n", "1. 定义数据集。\n", "2. 定义进行数据增强和处理所需要的一些参数。\n", "3. 根据参数,生成对应的数据增强操作。\n", "4. 使用`map`映射函数,将数据操作应用到数据集。\n", "5. 对生成的数据集进行处理。" ] }, { "cell_type": "code", "execution_count": 4, "metadata": { "ExecuteTime": { "end_time": "2020-09-04T06:15:59.246575Z", "start_time": "2020-09-04T06:15:59.236934Z" } }, "outputs": [], "source": [ "import mindspore.dataset.transforms.vision.c_transforms as CV\n", "import mindspore.dataset.transforms.c_transforms as C\n", "from mindspore.dataset.transforms.vision import Inter\n", "from mindspore.common import dtype as mstype\n", "\n", "\n", "def create_dataset(data_path, batch_size=32, repeat_size=1,\n", " num_parallel_workers=1):\n", " \"\"\" \n", " create dataset for train or test\n", " \n", " Args:\n", " data_path (str): Data path\n", " batch_size (int): The number of data records in each group\n", " repeat_size (int): The number of replicated data records\n", " num_parallel_workers (int): The number of parallel workers\n", " \"\"\"\n", " # define dataset\n", " mnist_ds = ds.MnistDataset(data_path)\n", "\n", " # define some parameters needed for data enhancement and rough justification\n", " resize_height, resize_width = 32, 32\n", " rescale = 1.0 / 255.0\n", " shift = 0.0\n", " rescale_nml = 1 / 0.3081\n", " shift_nml = -1 * 0.1307 / 0.3081\n", "\n", " # according to the parameters, generate the corresponding data enhancement method\n", " resize_op = CV.Resize((resize_height, resize_width), interpolation=Inter.LINEAR)\n", " rescale_nml_op = CV.Rescale(rescale_nml, shift_nml)\n", " rescale_op = CV.Rescale(rescale, shift)\n", " hwc2chw_op = CV.HWC2CHW()\n", " type_cast_op = C.TypeCast(mstype.int32)\n", "\n", " # using map to apply operations to a dataset\n", " mnist_ds = mnist_ds.map(input_columns=\"label\", operations=type_cast_op, num_parallel_workers=num_parallel_workers)\n", " mnist_ds = mnist_ds.map(input_columns=\"image\", operations=resize_op, num_parallel_workers=num_parallel_workers)\n", " mnist_ds = mnist_ds.map(input_columns=\"image\", operations=rescale_op, num_parallel_workers=num_parallel_workers)\n", " mnist_ds = mnist_ds.map(input_columns=\"image\", operations=rescale_nml_op, num_parallel_workers=num_parallel_workers)\n", " mnist_ds = mnist_ds.map(input_columns=\"image\", operations=hwc2chw_op, num_parallel_workers=num_parallel_workers)\n", " \n", " # process the generated dataset\n", " buffer_size = 10000\n", " mnist_ds = mnist_ds.shuffle(buffer_size=buffer_size)\n", " mnist_ds = mnist_ds.batch(batch_size, drop_remainder=True)\n", " mnist_ds = mnist_ds.repeat(repeat_size)\n", "\n", " return mnist_ds\n" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "其中\n", "- `batch_size`:每组包含的数据个数,现设置每组包含32个数据。\n", "- `repeat_size`:数据集复制的数量。\n", "\n", "先进行`shuffle`、`batch`操作,再进行`repeat`操作,这样能保证1个`epoch`内数据不重复。" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "接下来我们查看将要进行训练的数据集内容是什么样的。" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "首先,查看数据集内包含多少组数据。" ] }, { "cell_type": "code", "execution_count": 5, "metadata": { "ExecuteTime": { "end_time": "2020-09-04T06:15:59.350173Z", "start_time": "2020-09-04T06:15:59.247581Z" } }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Number of groups in the dataset: 1875\n" ] } ], "source": [ "datas = create_dataset(train_data_path)\n", "print('Number of groups in the dataset:', datas.get_dataset_size())" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "其次,取出其中一组数据,查看包含的`key`,图片数据的张量,以及下标`labels`的值。" ] }, { "cell_type": "code", "execution_count": 6, "metadata": { "ExecuteTime": { "end_time": "2020-09-04T06:15:59.716300Z", "start_time": "2020-09-04T06:15:59.351186Z" }, "scrolled": false }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Tensor of image: (32, 1, 32, 32)\n", "labels: [0 3 0 7 0 8 7 8 6 2 5 5 7 4 7 6 3 8 3 2 7 3 4 0 7 5 5 0 6 1 7 4]\n" ] } ], "source": [ "data = datas.create_dict_iterator().get_next()\n", "images = data[\"image\"] \n", "labels = data[\"label\"] \n", "print('Tensor of image:', images.shape)\n", "print('labels:', labels)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "最后,查看`image`的图像和下标对应的值。" ] }, { "cell_type": "code", "execution_count": 7, "metadata": { "ExecuteTime": { "end_time": "2020-09-04T06:16:00.326012Z", "start_time": "2020-09-04T06:15:59.717311Z" } }, "outputs": [ { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": { "needs_background": "light" }, "output_type": "display_data" } ], "source": [ "count = 1\n", "for i in images:\n", " plt.subplot(4, 8, count) \n", " plt.imshow(np.squeeze(i))\n", " plt.title('num:%s'%labels[count-1])\n", " plt.xticks([])\n", " count += 1\n", " plt.axis(\"off\")\n", "plt.show()" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "通过上述三个查询操作,看到经过变换后的图片,数据集内分成了1875组数据,每组数据中含有32张图片,每张图片像数值为32×32,数据全部准备好后,就可以进行下一步的数据训练了。" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## 构造神经网络" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "在对手写字体识别上,通常采用卷积神经网络架构(CNN)进行学习预测,最经典的属1998年由Yann LeCun创建的LeNet5架构,
其中分为:
1、输入层;
2、卷积层C1;
3、池化层S2;
4、卷积层C3;
5、池化层S4;
6、全连接F6;
7、全连接;
8、全连接OUTPUT。
结构示意如下图:" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### LeNet5结构图" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "\"LeNet5\"" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "在构建LeNet5前,我们需要对全连接层以及卷积层进行初始化。\n", "\n", "`Normal`:参数初始化方法,MindSpore支持`TruncatedNormal`、`Normal`、`Uniform`等多种参数初始化方法,具体可以参考MindSpore API的`mindspore.common.initializer`模块说明。\n", "\n" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "使用MindSpore定义神经网络需要继承`mindspore.nn.cell.Cell`,`Cell`是所有神经网络(`Conv2d`等)的基类。\n", "\n", "神经网络的各层需要预先在`__init__`方法中定义,然后通过定义`construct`方法来完成神经网络的前向构造,按照LeNet5的网络结构,定义网络各层如下:" ] }, { "cell_type": "code", "execution_count": 8, "metadata": { "ExecuteTime": { "end_time": "2020-09-04T06:16:00.336989Z", "start_time": "2020-09-04T06:16:00.328353Z" } }, "outputs": [], "source": [ "import mindspore.nn as nn\n", "from mindspore.common.initializer import Normal\n", "\n", "class LeNet5(nn.Cell):\n", " \"\"\"Lenet network structure.\"\"\"\n", " # define the operator required\n", " def __init__(self, num_class=10, num_channel=1):\n", " super(LeNet5, self).__init__()\n", " self.conv1 = nn.Conv2d(num_channel, 6, 5, pad_mode='valid')\n", " self.conv2 = nn.Conv2d(6, 16, 5, pad_mode='valid')\n", " self.fc1 = nn.Dense(16 * 5 * 5, 120, weight_init=Normal(0.02))\n", " self.fc2 = nn.Dense(120, 84, weight_init=Normal(0.02))\n", " self.fc3 = nn.Dense(84, num_class, weight_init=Normal(0.02))\n", " self.relu = nn.ReLU()\n", " self.max_pool2d = nn.MaxPool2d(kernel_size=2, stride=2)\n", " self.flatten = nn.Flatten()\n", "\n", " # use the preceding operators to construct networks\n", " def construct(self, x):\n", " x = self.max_pool2d(self.relu(self.conv1(x)))\n", " x = self.max_pool2d(self.relu(self.conv2(x)))\n", " x = self.flatten(x)\n", " x = self.relu(self.fc1(x))\n", " x = self.relu(self.fc2(x))\n", " x = self.fc3(x) \n", " return x" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "构建完成后,可以使用`print(LeNet5())`将神经网络中的各层参数全部打印出来,也可以使用`LeNet().{layer名称}`打印相应的参数信息。下面例子选择打印第一个卷积层和第一个全连接层的相应参数,使用如下:" ] }, { "cell_type": "code", "execution_count": 9, "metadata": { "ExecuteTime": { "end_time": "2020-09-04T06:16:00.652544Z", "start_time": "2020-09-04T06:16:00.338003Z" } }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "layer conv1: Conv2d\n", "****************************************\n", "layer fc1: Dense\n" ] } ], "source": [ "network = LeNet5()\n", "print(\"layer conv1:\", network.conv1)\n", "print(\"*\"*40)\n", "print(\"layer fc1:\", network.fc1)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## 自定义回调函数收集模型的损失值和精度值" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "自定义一个收集每一步训练的`step`,每训练一个`step`模型对应的`loss`值,每训练25个`step`模型对应的验证精度值`acc`的类`StepLossAccInfo`,该类继承了`Callback`类,可以自定义训练过程中的处理措施,非常方便,等训练完成后,可将数据绘图查看`step`与`loss`的变化情况,step与acc的变化情况。" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "参数解释如下:\n", "\n", "- `model`:函数的模型Model。\n", "- `eval_dataset`:验证数据集。\n", "- `step_loss`:收集step和loss值的字典,数据格式`{\"step\": [], \"loss_value\": []}`。\n", "- `steps_eval`:收集step和模型精度值的字典,数据格式为`{\"step\": [], \"acc\": []}`。\n" ] }, { "cell_type": "code", "execution_count": 10, "metadata": { "ExecuteTime": { "end_time": "2020-09-04T06:16:00.660140Z", "start_time": "2020-09-04T06:16:00.653553Z" } }, "outputs": [], "source": [ "from mindspore.train.callback import Callback\n", "\n", "# custom callback function\n", "class StepLossAccInfo(Callback):\n", " def __init__(self, model, eval_dataset, step_loss, steps_eval):\n", " self.model = model\n", " self.eval_dataset = eval_dataset\n", " self.step_loss = step_loss\n", " self.steps_eval = steps_eval\n", " \n", " def step_end(self, run_context):\n", " cb_params = run_context.original_args()\n", " cur_epoch = cb_params.cur_epoch_num\n", " cur_step = (cur_epoch-1)*1875 + cb_params.cur_step_num\n", " self.step_loss[\"loss_value\"].append(str(cb_params.net_outputs))\n", " self.step_loss[\"step\"].append(str(cur_step))\n", " if cur_step % 125 == 0:\n", " acc = self.model.eval(self.eval_dataset, dataset_sink_mode=False)\n", " self.steps_eval[\"step\"].append(cur_step)\n", " self.steps_eval[\"acc\"].append(acc[\"Accuracy\"])\n", " " ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## 搭建训练网络并进行训练" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "构建完成神经网络后,就可以着手进行训练网络的构建,模型训练函数为`Model.train`,参数主要包含:\n", "1. 每个`epoch`需要遍历完成图片的`batch`数:`epoch_size`;\n", "2. 数据集`ds_train`;\n", "3. 回调函数`callbacks`包含`ModelCheckpoint`、`LossMonitor`和`Callback`模型检测参数;\n", "4. 数据下沉模式`dataset_sink_mode`,此参数默认`True`需设置成`False`,因为此功能不支持CPU模式。" ] }, { "cell_type": "code", "execution_count": 11, "metadata": { "ExecuteTime": { "end_time": "2020-09-04T06:16:00.675920Z", "start_time": "2020-09-04T06:16:00.661139Z" } }, "outputs": [], "source": [ "# training related modules\n", "from mindspore import Tensor\n", "from mindspore.train.serialization import load_checkpoint, load_param_into_net\n", "from mindspore.train.callback import ModelCheckpoint, CheckpointConfig, LossMonitor\n", "from mindspore.train import Model\n", "from mindspore.nn.metrics import Accuracy\n", "\n", "def train_net(model, epoch_size, mnist_path, repeat_size, ckpoint_cb, step_loss_info):\n", " \"\"\"Define the training method.\"\"\"\n", " print(\"============== Starting Training ==============\")\n", " # load training dataset\n", " ds_train = create_dataset(os.path.join(mnist_path, \"train\"), 32, repeat_size)\n", " model.train(epoch_size, ds_train, callbacks=[ckpoint_cb, LossMonitor(125), step_loss_info], dataset_sink_mode=False)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### 定义损失函数及优化器\n", "\n", "在进行定义之前,先简单介绍损失函数及优化器的概念。\n", "\n", "损失函数:又叫目标函数,用于衡量预测值与实际值差异的程度。深度学习通过不停地迭代来缩小损失函数的值。定义一个好的损失函数,可以有效提高模型的性能。\n", "\n", "优化器:用于最小化损失函数,从而在训练过程中改进模型。\n", "\n", "定义了损失函数后,可以得到损失函数关于权重的梯度。梯度用于指示优化器优化权重的方向,以提高模型性能。\n", "\n", "MindSpore支持的损失函数有`SoftmaxCrossEntropyWithLogits`、`L1Loss`、`MSELoss`等。这里使用`SoftmaxCrossEntropyWithLogits`损失函数。" ] }, { "cell_type": "code", "execution_count": 12, "metadata": { "ExecuteTime": { "end_time": "2020-09-04T06:16:24.850821Z", "start_time": "2020-09-04T06:16:00.676924Z" }, "scrolled": true }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "============== Starting Training ==============\n", "epoch: 1 step: 125, loss is 2.3081794\n", "epoch: 1 step: 250, loss is 2.2945735\n", "epoch: 1 step: 375, loss is 2.3107677\n", "epoch: 1 step: 500, loss is 2.3018627\n", "epoch: 1 step: 625, loss is 2.3044233\n", "epoch: 1 step: 750, loss is 2.3034055\n", "epoch: 1 step: 875, loss is 1.1475224\n", "epoch: 1 step: 1000, loss is 0.20896824\n", "epoch: 1 step: 1125, loss is 0.35238677\n", "epoch: 1 step: 1250, loss is 0.1871425\n", "epoch: 1 step: 1375, loss is 0.071077615\n", "epoch: 1 step: 1500, loss is 0.07669073\n", "epoch: 1 step: 1625, loss is 0.12473262\n", "epoch: 1 step: 1750, loss is 0.010296674\n", "epoch: 1 step: 1875, loss is 0.11679248\n" ] } ], "source": [ "import os\n", "from mindspore.nn.loss import SoftmaxCrossEntropyWithLogits\n", "\n", "if os.name == \"nt\":\n", " # clean up old run files before in Windows\n", " os.system('del/f/s/q *.ckpt *.meta')\n", "else:\n", " # clean up old run files before in Linux\n", " os.system('rm -f *.ckpt *.meta *.pb')\n", "\n", "lr = 0.01\n", "momentum = 0.9 \n", "\n", "# create the network\n", "network = LeNet5()\n", "\n", "# define the optimizer\n", "net_opt = nn.Momentum(network.trainable_params(), lr, momentum)\n", "\n", "# define the loss function\n", "net_loss = SoftmaxCrossEntropyWithLogits(sparse=True, reduction='mean')\n", "\n", "# define the model\n", "model = Model(network, net_loss, net_opt, metrics={\"Accuracy\": Accuracy()} )\n", "\n", "epoch_size = 1\n", "mnist_path = \"./MNIST_Data\"\n", "# save the network model and parameters for subsequence fine-tuning\n", "config_ck = CheckpointConfig(save_checkpoint_steps=375, keep_checkpoint_max=16)\n", "# group layers into an object with training and evaluation features\n", "ckpoint_cb = ModelCheckpoint(prefix=\"checkpoint_lenet\", config=config_ck)\n", "# define step_loss dictionary for saving loss value and step number information\n", "eval_dataset = create_dataset(\"./MNIST_Data/test\")\n", "step_loss = {\"step\": [], \"loss_value\": []}\n", "steps_eval = {\"step\": [], \"acc\": []}\n", "# collect the steps,loss and accuracy informations\n", "step_loss_acc_info = StepLossAccInfo(model , eval_dataset, step_loss, steps_eval)\n", "\n", "repeat_size = 1\n", "train_net(model, epoch_size, mnist_path, repeat_size, ckpoint_cb, step_loss_acc_info)\n" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "训练完成后,能在Jupyter的工作路径上生成多个模型文件,名称具体含义`checkpoint_{网络名称}-{第几个epoch}_{第几个step}.ckpt`。" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "#### 查看损失函数随着训练步数的变化情况" ] }, { "cell_type": "code", "execution_count": 13, "metadata": { "ExecuteTime": { "end_time": "2020-09-04T06:16:24.980730Z", "start_time": "2020-09-04T06:16:24.850821Z" }, "scrolled": true }, "outputs": [ { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": { "needs_background": "light" }, "output_type": "display_data" } ], "source": [ "steps = step_loss[\"step\"]\n", "loss_value = step_loss[\"loss_value\"]\n", "steps = list(map(int, steps))\n", "loss_value = list(map(float, loss_value))\n", "plt.plot(steps, loss_value, color=\"red\")\n", "plt.xlabel(\"Steps\")\n", "plt.ylabel(\"Loss_value\")\n", "plt.title(\"Loss function value change chart\")\n", "plt.show()" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "从上面可以看出来大致分为三个阶段:\n", "\n", "阶段一:开始训练loss值在2.2上下浮动,训练收益感觉并不明显。\n", "\n", "阶段二:训练到某一时刻,loss值减少迅速,训练收益大幅增加。\n", "\n", "阶段三:loss值收敛到一定小的值后,loss值开始振荡在一个小的区间上无法趋0,再继续增加训练并无明显收益,至此训练结束。" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## 数据测试验证模型精度" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "搭建测试网络的过程主要为:\n", "\n", "1. 载入模型`.cptk`文件中的参数`param`;\n", "2. 将参数`param`载入到神经网络LeNet5中;\n", "3. 载入测试数据集;\n", "4. 调用函数`model.eval`传入参数测试数据集`ds_eval`,就生成模型`checkpoint_lenet-{epoch}_1875.ckpt`的精度值。\n", "\n", "> `dataset_sink_mode`表示数据集下沉模式,不支持CPU,所以这里设置成`False`。" ] }, { "cell_type": "code", "execution_count": 14, "metadata": { "ExecuteTime": { "end_time": "2020-09-04T06:16:25.898285Z", "start_time": "2020-09-04T06:16:24.981730Z" } }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "============== Starting Testing ==============\n", "============== Accuracy:{'Accuracy': 0.9665464743589743} ==============\n" ] } ], "source": [ "# testing relate modules \n", "def test_net(network, model, mnist_path):\n", " \"\"\"Define the evaluation method.\"\"\"\n", " print(\"============== Starting Testing ==============\")\n", " # load the saved model for evaluation\n", " param_dict = load_checkpoint(\"checkpoint_lenet-1_1875.ckpt\")\n", " # load parameter to the network\n", " load_param_into_net(network, param_dict)\n", " # load testing dataset\n", " ds_eval = create_dataset(os.path.join(mnist_path, \"test\"))\n", " acc = model.eval(ds_eval, dataset_sink_mode=False)\n", " print(\"============== Accuracy:{} ==============\".format(acc))\n", "\n", "test_net(network, model, mnist_path)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "经过1875步训练后生成的模型精度超过95%,模型优良。\n", "我们可以看一下模型随着训练步数变化,精度随之变化的情况。" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "`eval_show`将绘制每25个`step`与模型精度值的折线图,其中`steps_eval`存储着模型的step数和对应模型精度值信息。" ] }, { "cell_type": "code", "execution_count": 15, "metadata": { "ExecuteTime": { "end_time": "2020-09-04T06:16:26.021313Z", "start_time": "2020-09-04T06:16:25.899301Z" } }, "outputs": [ { "data": { "image/png": "iVBORw0KGgoAAAANSUhEUgAAAYIAAAEWCAYAAABrDZDcAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4xLjMsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy+AADFEAAAgAElEQVR4nO3debwcZZ3v8c83CVkIhEAS1iQEkC2yDCQsXhdUMBBU0HEj6giiojPgcl1mmMGrqKNzRVGvyoiojCwa1HHLnIBBWUQQ8HRCIASChABJIEICgQRCQpbf/eOpJp2TPuf0Oae7q5fv+/WqV9dev64+p35Vz1P1lCICMzNrX4PyDsDMzPLlRGBm1uacCMzM2pwTgZlZm3MiMDNrc04EZmZtzonA+kTSJEkhaUgF854l6dZ6xNUuJL1H0vUDWP46SWdWM6Zetlfx34vlx4mghUl6RNKLksZ2GT8/++eclE9k1l8R8ZOImFbJvJIulHR1l+WnR8QVtYmuPrK/3ZflHUcrcSJofQ8DM4oDkg4HRuQXTmNoxjPUZoy5mtr9+9eSE0Hruwp4X8nwmcCVpTNI2kXSlZJWSnpU0mclDcqmDZb0dUmrJC0B3lhm2R9JWiHpMUn/LmlwJYFJ+oWkv0l6VtItkl5eMm2EpIuzeJ6VdKukEdm0V0n6s6RnJC2TdFY2/mZJHyxZxzZFU9mZ5LmSHgQezMb9v2wdayTNlfTqkvkHS/o3SQ9JWptNnyDpEkkXd/ku/yPpE2W+46WSvt5l3G8lfTLrP79k/fdJemuX+G+T9E1JTwMXlvlOZeOXdArwb8C7JD0n6e6u+0jSoOy3flTSk9nfwC7ZtGKRzpmSlma//wU9/Jbd/l6Z95Rbj6RjJd2e/ZYrJH1X0tDufjNJt2ST7s6+17u6i8n6ICLctWgHPAKcBDwAHAoMBpYB+wIBTMrmuxL4LbAzMAn4K/CBbNpHgEXABGA34KZs2SHZ9N8A3wdGArsDfwE+nE07C7i1h/jOzrY5DPgWML9k2iXAzcA+Wdz/K5tvIrCWdJWzAzAG+LtsmZuBD5asY5vtZ3H/PvseI7Jx783WMQT4FPA3YHg27TPAAuBgQMCR2bzHAo8Dg7L5xgLrgD3KfMfXZPtc2fCuwAvA3tnwO4C9SSdl7wKeB/YqiX8T8NEsvhFlvlNP8V8IXN0lnpf2Ubb/FwP7AzsBvwKuyqZNyvbXD7LtHglsAA7t5rfs7vfqcT3AFOD4LP5JwP3AJ3r5zQJ4Wd7/X63U5R6Auxr+uFsTwWeB/wBOyf6phmT/TJOyf9oNwOSS5T4M3Jz13wh8pGTatGzZIcAe2bIjSqbPAG7K+rc5aPUS6+hsvbtkB8UXgCPLzPevwK+7WcdLB7ly28/W//pe4lhd3C4pgZ7ezXz3A2/I+s8Dru1mPgFLgddkwx8Cbuxh+/OL28ziX9pleo/7tEv8F9JzIrgB+KeSaQcDG0sOygGML5n+F+CMMtvs6feqeD3ZtE+U/r7lfjOcCKreuWioPVwFvJt0ELmyy7SxwFDg0ZJxj5LO7CCdrS7rMq1oX9JZ+Yrs0v4Z0tXB7r0FlBW7/N+sWGQNKWkV4xkLDAceKrPohG7GV6r0uyDpU5Luz4ozniElomLlek/buoJ0Nk72eVW5mSIdua5haz3Nu4GflGz/fUqV98X9d1jJ9reLt6te4u/N3mz/uxcTfNHfSvrXka4cuurp9+pxPZIOktSRFRGuAb5SJv4e94ENnBNBG4iIR0mVxqeSLv9LrSKdBe5bMm4i8FjWv4J0QCydVrSMdEUwNiJGZ92oiHg5vXs3cDrpimUX0pkjpDPoVcB64IAyyy3rZjykYpUdS4b3LDPPS83tZuXp/wK8E9g1IkYDz2Yx9Latq4HTJR1JKnb7TTfzAcwE3i5pX+A44JfZ9vclFZmcB4zJtn9vyfa3iberCuLvrWnhx9n+d98EPNHLcl319Hv15nukoscDI2IUqV5DXeZxE8k15kTQPj5AusR+vnRkRGwGfg58WdLO2cHpk6QDHdm0j0kaL2lX4PySZVcA1wMXSxqVVT4eIOmECuLZmZREniIdvL9Sst4twOXANyTtnV09vELSMNLZ9EmS3ilpiKQxkv4uW3Q+8PeSdlS6vfADFcSwCVgJDJH0OWBUyfQfAl+SdKCSIySNyWJcDnSSrgR+GREvdLeRiLgr28YPgTkR8Uw2aSTpILcSQNL7SVcEleot/ieAScoq/suYCfxvSftJ2on0G/wsIjb1IYbefq9KvsMa4DlJhwD/WMEyT5DqNaxKnAjaREQ8FBGFbiZ/lHQ2vQS4Ffgp6R8b0hnrHOBuYB7bX1G8j1S0dB+pfPq/gb0qCOlKUlHEY9myd3SZ/mlSRW0n8DTwVVLl7FLSlc2nsvHzSRWQAN8EXiQdKK6gpAimG3OA60iV44+SzmpLiyG+QUqE15MOVj9i21tvrwAOp5tioS5mkq5+flocERH3ARcDt2cxHw7cVsG6Ko3/F9nnU5LmlVn+8iz2W0hXjOtJfwv9Ufb3qnC5d5NuAPgB8LMKlrkQuCIrTntnv6K1bRTvZDCzPpL0GtKV06TsrNisKfmKwKwfJO0AfBz4oZOANTsnArM+knQo8AypCOxbOYdjNmAuGjIza3M1uyKQdHn22Pq93UyXpG9LWizpHklH1yoWMzPrXi0bcfox8F22f4CpaDpwYNYdR7qf+LjeVjp27NiYNGlSdSI0M2sTc+fOXRUR48pNq1kiiIhb1HMzx6cDV2ZPXt4habSkvbJ707s1adIkCoXu7oI0M7NyJD3a3bQ8K4v3Ydt7npeztVmDbUg6R1JBUmHlypV1Cc7MrF3kmQi6PkYO3TxKHhGXRcTUiJg6blzZKxszM+unPBPBcrZtw2Y8qe0TMzOrozwTwSzgfdndQ8cDz/ZWP2BmZtVXs8piSTOB1wJjJS0HPk9qspiIuBS4ltRmzGJSs7Tvr1UsZmbWvVreNTSjl+kBnFur7ZuZWWXcxISZWZur5QNlZmbWX2vWwPLl23ZvfCNMmVL1TTkRmJnVUwQ888z2B/nly2HZsq39a9duu5wEu+/uRGBmLWzzZnj+eXjuudR17d+woXz34ot9n1Ycv2ULjBgBO+6YPnvq78t8a9f2fKBft27b7z5oEOy1F4wfD5Mnw7Rpqb/YTZiQpg8dWpNd70RgZtWxbh386U/wxBPbHsS7HtTLDT/3HKxf37/tDhoEw4aV74YO3dq/667bTxs0CF54IcX+wgupe/rpbYeL/Rs29C++wYNh773TAf3II+FNb9r2ID9+POy5J+ywQ//WXwVOBGbWf088AR0dMGsW/P736YDZ1ciRsNNOqSv2jxqVDo6l00qndx3ecUcYPrz8wX7w4Pp81y1btiaHrkmia//Ikeksfvx42GOP+sXYT04EZla5CLj//nTg/+1v4c4707h994UPfjCd7R5wwNYD+YgR6ay7FQwalA7wI0fmHUnVORGYWc82bYJbb00H/1mz4KGH0vipU+ELX4DTT4fDD0+VmdaUnAjMbHtr1sCcOenAP3s2rF6dimFOPBE+85l05r9P2caCrQk5EZg1shUrYP78VNE5ZkzqRo+uTXHL0qXwP/+TDv433QQbN6btnXZa6qZNS8U91nKcCMwaTQTcdht897vwy1+moplSgwZtmxjGjIGxY7cdLtcNG7b9du66a2t5//z5afyBB8LHP56KfF7xioav6LSBcyIwaxTr1sHMmSkBzJ8Pu+wCH/tYOiA//zw89dTWbtWqrf3Ll8Pdd6f+rvenl9ppp61JYbfdYNGitKwEr3wlXHRROvM/+OD6fWdrCE4EZnlbsgS+9z340Y9SWfzhh8P3vw/veU/f71BZv758sijXHXMMfOlLqdkCv/CprTkRmOVhyxb4wx/S2X9HRyrueetb4aMfhVe/uv934AwfnipxXZFrfeBEYFZPa9bAj38Ml1wCf/1rajvmggvgwx9ODx+Z5cCJwKwe7rsvHfyvvDI1p3DccXDVVfCOd2xfiWtWZ04EZrWyaVMq9vnOd+DGG1PbNjNmwLnnpvJ5swbhRGBWbatWwQ9/mCqAly5Nbc585SupCQZXyloDciIwq5Z589LZ/8yZqaXK170OvvUtePObYYj/1axx+a/TrBpuuy3d7bPjjnD22an45+Uvzzsqs4o4EZhVw89+lip9H300PbBl1kRapH1YsxxFpErhE090ErCm5ERgNlCLFsHDD6cWOc2akBOB2UDNnp0+Tz013zjM+smJwGygOjrgiCNg4sS8IzHrFycCs4FYvTq9veuNb8w7ErN+cyIwG4jrr4fNm10/YE3NicBsIDo60p1Cxx2XdyRm/eZEYNZfmzfDddfB9Ol+i5c1NScCs/668870ghcXC1mTcyIw66+OjnQlcPLJeUdiNiBOBGb9NXs2vOpVMHp03pGYDYgTgVl/LF0K99zjYiFrCU4EZv1RfJrYzw9YC3AiMOuP2bNh//3hkEPyjsRswJwIzPpq3Tq44YZULCTlHY3ZgDkRmPXVjTfC+vUuFrKW4URg1lezZ8PIkXDCCXlHYlYVNU0Ekk6R9ICkxZLOLzN9oqSbJN0l6R5JbsfXGlvxJTTTpqU3kpm1gJolAkmDgUuA6cBkYIakyV1m+yzw84g4CjgD+M9axWNWFQsWwPLlLhayllLLK4JjgcURsSQiXgSuAU7vMk8Ao7L+XYDHaxiP2cB1dKRPv4TGWkgtE8E+wLKS4eXZuFIXAu+VtBy4FvhouRVJOkdSQVJh5cqVtYjVrDIdHTBlCuy1V96RmFVNLRNBufvqosvwDODHETEeOBW4StJ2MUXEZRExNSKmjhs3rgahmlVg1Sq44w4/TWwtp5aJYDkwoWR4PNsX/XwA+DlARNwODAfG1jAms/677rpUWexEYC2mlomgEzhQ0n6ShpIqg2d1mWcpcCKApENJicBlP9aYOjpgjz3g6KPzjsSsqmqWCCJiE3AeMAe4n3R30EJJX5R0Wjbbp4APSbobmAmcFRFdi4/M8rdxI8yZk+4WGuTHb6y1DKnlyiPiWlIlcOm4z5X03we8spYxmFXFbbfBs8+6WMhakk9tzCoxezbssAOcdFLekZhVnROBWSU6OuC1r4Wdd847ErOqcyIw681DD8GiRS4WspblRGDWG7+ExlqcE4FZbzo60gtoDjgg70jMasKJwKwna9fCzTf7asBamhOBWU/+8If0DIHrB6yFORGY9aSjA3bZBV7px12sdTkRmHVnyxa49lo4+eT0DIFZi3IiMOvOvHnwt7+5WMhanhOBWXc6OkCC6dPzjsSsppwIzLozezYcfzyMdcvo1tqcCMzKWbECCgUXC1lbcCIwK+farNFcPz9gbcCJwKyc2bNh/Hg44oi8IzGrOScCs642bIDrr0/FQir36m2z1uJEYNbVLbfA88+7WMjaRq+JQFJB0rmSdq1HQGa56+iA4cPh9a/POxKzuqjkiuAMYG+gU9I1kk6WfL1sLSoiJYITT4Qdd8w7GrO66DURRMTiiLgAOAj4KXA5sFTSFyTtVusAzerqgQdgyRIXC1lbqaiOQNIRwMXA14BfAm8H1gA31i40sxx0dKRPJwJrI0N6m0HSXOAZ4EfA+RGxIZt0pyQ3yWitpaMj3TI6cWLekZjVTa+JAHhHRCwpNyEi/r7K8Zjl55ln4NZb4Z//Oe9IzOqqkqKhD0oaXRyQtKukf69hTGb5mDMHNm92sxLWdipJBNMj4pniQESsBk6tXUhmOZk9G8aMgeOOyzsSs7qqJBEMljSsOCBpBDCsh/nNms/mzal9oenTYfDgvKMxq6tK6giuBm6Q9F9AAGcDV9Q0KrN6u/NOeOopFwtZW+o1EUTERZIWACcCAr4UEXNqHplZPc2ena4ETj4570jM6q6SKwIi4jrguhrHYpafjg541atg9Oje5zVrMZW0NXS8pE5Jz0l6UdJmSWvqEZxZXSxdCvfc42Iha1uVVBZ/F5gBPAiMAD4IfKeWQZnVlV9CY22u0qKhxZIGR8Rm4L8k/bnGcZnVT0cH7L8/HHJI3pGY5aKSRLBO0lBgvqSLgBXAyNqGZVYn69bBDTfAhz7kl9BY26qkaOgfsvnOA54HJgBvq2VQZnVz002wfr3rB6yt9XhFIGkw8OWIeC+wHvhCXaIyq5eODhg5Ek44Ie9IzHLT4xVBVicwLisaMmstEen5gTe8AYb5YXlrX5XUETwC3CZpFqloCICI+EatgjKriwULYNky+Pzn847ELFeV1BE8DnRk8+5c0vVK0imSHpC0WNL53czzTkn3SVoo6aeVBm42YMWX0JzqNhStvVXSxES/6gWy+oVLgDcAy0nvPJ4VEfeVzHMg8K/AKyNitaTd+7Mts36ZPRumTIG99so7ErNcVfKGsptIjc1tIyJe38uixwKLiy+1kXQNcDpwX8k8HwIuyZq2JiKerDBus4FZtQpuvx0+97m8IzHLXSV1BJ8u6R9OunV0UwXL7QMsKxleDnRt6P0gAEm3AYOBCyPid11XJOkc4ByAiX6FoFXD736XKot926hZRUVDc7uMuk3SHytYd7mnc7peWQwBDgReC4wH/iTpsNIX4WQxXAZcBjB16tTtrk7M+qyjA/bYA44+Ou9IzHJXSdHQbiWDg4ApwJ4VrHs56eGzovGkiueu89wRERuBhyU9QEoMnRWs36x/Nm5MVwRvexsMquR+CbPWVknR0FzSmbxIRUIPAx+oYLlO4EBJ+wGPAWcA7+4yz29IDdr9WNJYUlHRkspCN+unP/8Znn3WjcyZZSopGtqvPyuOiE2SzgPmkMr/L4+IhZK+CBQiYlY2bZqk+4DNwGci4qn+bM+sYh0dsMMO6UEyM0MRPRe5SzoX+Emx3F7SrsCMiPjPOsS3nalTp0ahUMhj09YqDj0UJkyA66/POxKzupE0NyKmlptWSQHph0orb7NbPT9UreDM6uqJJ2DRIpg2Le9IzBpGJYlgkLS1fd7sQTG3PWTNqXg1eVzXO5nN2lcllcVzgJ9LupRUafwRYLt7/c2aQqGQ3jtw1FF5R2LWMCpJBP9CepjrH0l3Dl0P/LCWQZnVTGdnqiPYaae8IzFrGJUkghHADyLiUnipaGgYsK6WgZlVXUS6IjjllLwjMWsoldQR3EBKBkUjgD/UJhyzGnrssVRZPLXsjRNmbauSRDA8Ip4rDmT9O9YuJLMaKVYUOxGYbaOSRPC8pJcaZJE0BXihdiGZ1UihAIMHw5FH5h2JWUOppI7gE8AvJBXbCdoLeFftQjKrkUIBDjsMRozofV6zNlJJExOdkg4BDibdNbQoayTOrHlEpDuG3vrWvCMxaziVXBFASgKTSe8jOEoSEXFl7cIyq7JHHoGnn4Zjjsk7ErOGU0kz1J8nvS9gMnAtMB24FXAisObhimKzblVSWfx24ETgbxHxfuBI0nMEZs2jUIChQ1MdgZlto5JE8EJEbAE2SRoFPAnsX9uwzKqsUIAjjoBhPocx66qSRFCQNBr4AeklNfOAv9Q0KrNq2rIF5s51sZBZNyq5a+ifst5LJf0OGBUR99Q2LLMqWrw4vZHMicCsrErvGgIgIh6pURxmtVOsKPYdQ2Zl+c3d1voKBRg+HCZPzjsSs4bkRGCtr1BI7x8Y0qcLYLO20e1/hqTdelowIp6ufjhmVbZ5M8ybB2efnXckZg2rp1OkuaQ3kqnMtMC3kFozeOABeP55VxSb9aDbRBAR+9UzELOa6OxMn64oNutWr3UESt4r6f9kwxMlHVv70MyqoFBIr6U86KC8IzFrWJVUFv8n8Arg3dnwWuCSmkVkVk2FAhx9dHoPgZmVVUkiOC4izgXWA0TEamBoTaMyq4aNG2H+fNcPmPWikkSwMXthfQBIGgdsqWlUZtVw332wfr0TgVkvKkkE3wZ+Dewu6cukJqi/UtOozKqhWFHsRGDWo0raGvqJpLmkpqgFvCUi7q95ZGYDVSjALrvAy16WdyRmDa3SB8qeBGaWTvMDZdbwCoV0NaByj8KYWVGlD5RNBFZn/aOBpYCfM7DGtWED3HMPfPKTeUdi1vC6rSOIiP0iYn9gDvDmiBgbEWOANwG/qleAZv2yYEG6a8j1A2a9qqSy+JiIuLY4EBHXASfULiSzKvA7is0qVklzjKskfRa4mlRU9F7gqZpGZTZQnZ0wZgzsu2/ekZg1vEquCGYA40i3kP4G2D0bZ9a4CoXUvpAris16Vcnto08DH89eXL8lIp6rfVhmA7BuHSxcCKedlnckZk2hkkbnDpd0F7AAWChprqTDah+aWT/dfXd6D4HrB8wqUknR0PeBT0bEvhGxL/Ap4LLahmU2AK4oNuuTShLByIi4qTgQETcDIytZuaRTJD0gabGk83uY7+2SQpL/c23gCgXYc0/Ye++8IzFrCpUkgiWS/o+kSVn3WeDh3hbKGqq7BJgOTAZmSNru7eGSdgY+BtzZt9DNutHZ6SeKzfqgkkRwNumuoV+R7hwaB7y/guWOBRZHxJKIeBG4Bji9zHxfAi4ia+babEDWroVFi/xGMrM+qOSuodWkM/a+2gdYVjK8HDiudAZJRwETIqJD0qe7W5Gkc4BzACZOnNiPUKxt3HUXRLh+wKwPemp0blZPC0ZEb/fmdffS++L6BwHfBM7qZT1ExGVkFdRTp06NXma3dlasKJ4yJd84zJpIT1cEryCd0c8kld/3tcB1OTChZHg88HjJ8M7AYcDNSmW5ewKzJJ0WEYU+bsssKRRgwgTYY4+8IzFrGj0lgj2BN5CeIn43MBuYGRELK1x3J3CgpP2Ax4Az2PreYyLiWWBscVjSzcCnnQRsQIpNT5tZxXpqfXRzRPwuIs4EjgcWk87eP1rJiiNiE3AeqfXS+4GfR8RCSV+U5Ec+rfqeeQYefNCJwKyPeqwsljQMeCPpqmAS6bWVFTdBnbVaem2XcZ/rZt7XVrpes7Lmzk2fvmPIrE96qiy+glSGfx3whYi4t25RmfWHK4rN+qWnK4J/AJ4HDgI+pq0P5wiIiBhV49jM+qZQgP33h912631eM3tJt4kgIip52MyscRQKcOyxeUdh1nR8sLfWsGoVPPKIK4rN+sGJwFqDWxw16zcnAmsNrig26zcnAmsNhQIcfDCM8j0MZn3lRGCtwU8Um/WbE4E1vxUr4LHHnAjM+smJwJqfK4rNBsSJwJpfoQCDBsFRR+UdiVlTciKw5lcowOTJMLKiV2mbWRdOBNbcIlxRbDZATgTW3JYvhyefdCIwGwAnAmturig2GzAnAmtunZ0wZAgceWTekZg1LScCa26FAhx+OAwfnnckZk3LicCalyuKzarCicCa18MPw+rVTgRmA+REYM3LFcVmVeFEYM2rUIChQ+Gww/KOxKypORFY8+rsTHcLDR2adyRmTc2JwJrTli0wdy4cc0zekZg1PScCa04PPghr17p+wKwKnAisObmi2KxqnAisORUKMGIEHHpo3pGYNT0nAmtOhUJ6/8CQIXlHYtb0nAis+WzaBPPmuVjIrEqcCKz5LFoE69b5jiGzKnEisObjimKzqnIisOZTKMBOO8FBB+UdiVlLcCKw5lMowJQp6YX1ZjZg/k+y5vLiizB/vouFzKrIicCay8KFsGGDE4FZFTkRWHMpVhT7jiGzqnEisOZSKMDo0bD//nlHYtYynAisuRRfTSnlHYlZy3AisOaxfj0sWOD6AbMqq2kikHSKpAckLZZ0fpnpn5R0n6R7JN0gad9axmNN7p57YONGJwKzKqtZIpA0GLgEmA5MBmZImtxltruAqRFxBPDfwEW1isdagJ8oNquJWl4RHAssjoglEfEicA1weukMEXFTRKzLBu8AxtcwHmt2hQKMGwcTJ+YdiVlLqWUi2AdYVjK8PBvXnQ8A15WbIOkcSQVJhZUrV1YxRGsqrig2q4laJoJy/61RdkbpvcBU4GvlpkfEZRExNSKmjhs3roohWtNYty49TOZiIbOqq+VbPZYDE0qGxwOPd51J0knABcAJEbGhhvFYM5s/P72w3onArOpqeUXQCRwoaT9JQ4EzgFmlM0g6Cvg+cFpEPFnDWKzZdXamTycCs6qrWSKIiE3AecAc4H7g5xGxUNIXJZ2WzfY1YCfgF5LmS5rVzeqs3RUKsPfeqTOzqqrpC18j4lrg2i7jPlfSf1Itt28tpFhRbGZV5yeLrfGtWQMPPOBEYFYjTgTW+O66CyKcCMxqxInAGl/xieIpU/KNw6xFORFY4+vsTE8T77573pGYtSQnAmt8hYJfRGNWQ04E1thWr4aHHnL9gFkNORFYY5s7N306EZjVjBOBNTZXFJvVnBOBNbZCAQ44AHbdNe9IzFqWE4E1ts5OFwuZ1ZgTgTWuJ5+EpUt9x5BZjTkRWONyRbFZXTgRWOMqFNLbyI46Ku9IzFpaTVsfbSiXXw4XX1ybdUekrtjf3Wdf5imn6ysaS4f7Mq1r7OX6exvuKc5KYuourtJxK1fCwQfDqFG9b8vM+q19EsGYMTB5cu3WL209iPX02Zd5SvXloNzbtP4mlN7mrSSeSuIr7X/LW8pvw8yqpn0Swemnp87MzLbhOgIzszbnRGBm1uacCMzM2pwTgZlZm3MiMDNrc04EZmZtzonAzKzNORGYmbU5RSVNBTQQSSuBR/OOo4uxwKq8g+iDZorXsdZOM8XbTLFCY8a7b0SMKzeh6RJBI5JUiIimaSKzmeJ1rLXTTPE2U6zQfPG6aMjMrM05EZiZtTknguq4LO8A+qiZ4nWstdNM8TZTrNBk8bqOwMyszfmKwMyszTkRmJm1OSeCXkiaIOkmSfdLWijp49n4CyU9Jml+1p1assy/Slos6QFJJ+cQ8yOSFmRxFbJxu0n6vaQHs89ds/GS9O0s3nskHV3HOA8u2X/zJa2R9IlG2reSLpf0pKR7S8b1eV9KOjOb/0FJZ9Yx1q9JWpTF82tJo7PxkyS9ULKPLy1ZZkr297M4+z49vOu06vH2+beXdEo2brGk8+sY689K4nxE0vxsfO77ts8iwl0PHbAXcHTWvzPwV2AycCHw6TLzTwbuBoYB+wEPAYPrHPMjwNgu4y4Czs/6zwe+mvWfClwHCDgeuDOn/TwY+BuwbyPtW+A1wNHAvf3dl8BuwJLsc23kQzMAAAY0SURBVNesf9c6xToNGJL1f7Uk1kml83VZz1+AV2Tf4zpgeh33bZ9++6x7CNgfGJrNM7kesXaZfjHwuUbZt33tfEXQi4hYERHzsv61wP3APj0scjpwTURsiIiHgcXAsbWPtFenA1dk/VcAbykZf2UkdwCjJe2VQ3wnAg9FRE9Pjdd930bELcDTZeLoy748Gfh9RDwdEauB3wOn1CPWiLg+IjZlg3cA43taRxbvqIi4PdKR60q2fr+ax9uD7n77Y4HFEbEkIl4ErsnmrVus2Vn9O4GZPa2jnvu2r5wI+kDSJOAo4M5s1HnZJfflxeIBUpJYVrLYcnpOHLUQwPWS5ko6Jxu3R0SsgJTcgN2z8Y0QL8AZbPuP1Kj7Fvq+Lxsl7rNJZ6FF+0m6S9IfJb06G7cPKb6iPGLty2/fCPv21cATEfFgybhG3bdlORFUSNJOwC+BT0TEGuB7wAHA3wErSJeGkC75uqr3PbqvjIijgenAuZJe08O8uccraShwGvCLbFQj79uedBdf7nFLugDYBPwkG7UCmBgRRwGfBH4qaRT5x9rX3z7veAFmsO1JTKPu2245EVRA0g6kJPCTiPgVQEQ8ERGbI2IL8AO2FlEsByaULD4eeLye8UbE49nnk8Cvs9ieKBb5ZJ9PZrPnHi8pYc2LiCegsfdtpq/7Mte4s8rpNwHvyYokyIpYnsr655LK2Q/KYi0tPqprrP347fPet0OAvwd+VhzXqPu2J04EvcjK/34E3B8R3ygZX1qO/lageDfBLOAMScMk7QccSKogqle8IyXtXOwnVRbem8VVvFvlTOC3JfG+L7vj5Xjg2WKxRx1tc0bVqPu2RF/35RxgmqRds6KOadm4mpN0CvAvwGkRsa5k/DhJg7P+/Un7ckkW71pJx2d/++8r+X71iLevv30ncKCk/bIryzOyeevlJGBRRLxU5NOo+7ZHeddWN3oHvIp0+XYPMD/rTgWuAhZk42cBe5UscwHpLOAB6nxXAOnuibuzbiFwQTZ+DHAD8GD2uVs2XsAlWbwLgKl1jndH4Clgl5JxDbNvSQlqBbCRdEb3gf7sS1L5/OKse38dY11MKkMv/u1ems37tuzv425gHvDmkvVMJR2AHwK+S9YCQZ3i7fNvn/0//jWbdkG9Ys3G/xj4SJd5c9+3fe3cxISZWZtz0ZCZWZtzIjAza3NOBGZmbc6JwMyszTkRmJm1OScCawtKrZrumHccPclarby39znNqsuJwNrFJ0jPLLSs7ClXsz5zIrCWkj1ZPVvS3ZLulfQuSR8D9gZuknRTNt80SbdLmifpF1lbUsV3OXxV0l+y7mVltnFh1iDazZKWZOvf7oxe0qclXZj13yzpm5JuUXq3xTGSfqX0foJ/L1n9EElXZI2u/XfxKkapHfs/Zg0Jzilp4uJmSV+R9Efg4zXZqdbynAis1ZwCPB4RR0bEYcDvIuLbpDZdXhcRr5M0FvgscFKkxvkKpMbBitZExLGkJz+/1c12DiE1L30s8PmsParevBgRrwEuJTUtcC5wGHCWpDHZPAcDl0XEEcAa4J+ydX8HeHtETAEuB75cst7REXFCRFyMWT/4UtJazQLg65K+CnRExJ/KzHM86UUnt6UmXxgK3F4yfWbJ5ze72c7siNgAbJD0JLBHBbEV28BZACyMrE0nSUtIDac9AyyLiNuy+a4GPgb8jpQwfp/FO5jU3EHRzzAbACcCaykR8VdJU0jtz/yHpOsj4otdZhPpRTEzultNN/2lNpT0byb9L21i26vs4d0ss6XL8lvY+r/YdXvFppYXRsQruonl+W7Gm1XERUPWUiTtDayLiKuBr5NeLwiwlvSqUUhv6nplsfxf0o6SDipZzbtKPkuvFHrzBLC7pDGShpGafu6riZKKB/wZwK2kRtbGFcdL2kHSy/uxbrOyfEVgreZw4GuStpBaivzHbPxlwHWSVmT1BGcBM7MDNqQ6g79m/cMk3Uk6UeruqmE7EbFR0hdJb7B7GFjUj/jvB86U9H1S66bfi4gXJb0d+LakXUj/t98itXBpNmBufdSshKRHSM1Hr8o7FrN6cdGQmVmb8xWBmVmb8xWBmVmbcyIwM2tzTgRmZm3OicDMrM05EZiZtbn/D0Tt+QBYrVmKAAAAAElFTkSuQmCC\n", "text/plain": [ "
" ] }, "metadata": { "needs_background": "light" }, "output_type": "display_data" } ], "source": [ "def eval_show(steps_eval):\n", " plt.xlabel(\"step number\")\n", " plt.ylabel(\"Model accuracy\")\n", " plt.title(\"Model accuracy variation chart\")\n", " plt.plot(steps_eval[\"step\"], steps_eval[\"acc\"], \"red\")\n", " plt.show()\n", "\n", "eval_show(steps_eval)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "从图中可以看出训练得到的模型精度变化分为三个阶段:1、缓慢上升,2、迅速上升,3、缓慢上升趋近于不到1的某个值时附近振荡,说明随着训练数据的增加,会对模型精度有着正相关的影响,但是随着精度到达一定程度,训练收益会降低。" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## 模型预测应用" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "我们尝试使用生成的模型应用到分类预测单个或者单组图片数据上,具体步骤如下:" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "1. 需要将要测试的数据转换成适应LeNet5的数据类型。\n", "2. 提取出`image`的数据。\n", "3. 使用函数`model.predict`预测`image`对应的数字。需要说明的是`predict`返回的是`image`对应0-9的概率值。\n", "4. 调用`plot_pie`将预测的各数字的概率显示出来。负概率的数字会被去掉。" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "载入要测试的数据集并调用`create_dataset`转换成符合格式要求的数据集,并选取其中一组32张图片进行预测。" ] }, { "cell_type": "code", "execution_count": 16, "metadata": { "ExecuteTime": { "end_time": "2020-09-04T06:16:26.982886Z", "start_time": "2020-09-04T06:16:26.022325Z" } }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "All the figures in this group are predicted correctly!\n", "[4 4 2 4 3 0 0 4 4 0 6 8 2 1 7 7 5 9 2 6 7 4 3 3 3 5 1 6 6 2 5 9] <--Predicted figures\n", "[4 4 2 4 3 0 0 4 4 0 6 8 2 1 7 7 5 9 2 6 7 4 3 3 3 5 1 6 6 2 5 9] <--The right number\n" ] }, { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": { "needs_background": "light" }, "output_type": "display_data" } ], "source": [ "ds_test = create_dataset(test_data_path).create_dict_iterator()\n", "data = ds_test.get_next()\n", "images = data[\"image\"]\n", "labels = data[\"label\"]\n", "\n", "output = model.predict(Tensor(data['image']))\n", "prb = output.asnumpy()\n", "pred = np.argmax(output.asnumpy(), axis=1)\n", "err_num = []\n", "index = 1\n", "for i in range(len(labels)):\n", " plt.subplot(4, 8, i+1)\n", " color = 'blue' if pred[i] == labels[i] else 'red'\n", " plt.title(\"pre:{}\".format(pred[i]), color=color)\n", " plt.imshow(np.squeeze(images[i]))\n", " plt.axis(\"off\")\n", " if color == 'red':\n", " index = 0\n", " print(\"Row {}, column {} is incorrectly identified as {}, the correct value should be {}\".format(int(i/8)+1, i%8+1, pred[i], labels[i]), '\\n')\n", "if index:\n", " print(\"All the figures in this group are predicted correctly!\")\n", "print(pred, \"<--Predicted figures\") \n", "print(labels, \"<--The right number\")\n", "plt.show()" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "构建一个概率分析的饼图函数,本例展示了当前`batch`中的前两张图片的分析饼图。\n", "\n", "备注:`prb`为上一段代码中,存储这组数对应的数字概率。" ] }, { "cell_type": "code", "execution_count": 17, "metadata": { "ExecuteTime": { "end_time": "2020-09-04T06:16:27.131596Z", "start_time": "2020-09-04T06:16:26.984263Z" } }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Figure 1 probability of corresponding numbers [0-9]:\n", " [-2.2434433 -5.460074 -0.27407748 -3.74839 13.366689 -1.8540848\n", " 1.6585187 -1.8376697 0.1426354 0.26712573]\n" ] }, { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" }, { "name": "stdout", "output_type": "stream", "text": [ "Figure 2 probability of corresponding numbers [0-9]:\n", " [-3.8317444 1.3081287 -1.564763 -0.72753066 4.7249494 -0.22273807\n", " -3.6146772 0.6123574 -1.3609397 4.722361 ]\n" ] }, { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "# define the pie drawing function of probability analysis\n", "def plot_pie(prbs):\n", " dict1 = {}\n", " # remove the negative number and build the dictionary dict1. The key is the number and the value is the probability value\n", " for i in range(10):\n", " if prbs[i] > 0:\n", " dict1[str(i)] = prbs[i]\n", "\n", " label_list = dict1.keys()\n", " size = dict1.values()\n", " colors = [\"red\", \"green\", \"pink\", \"blue\", \"purple\", \"orange\", \"gray\"] \n", " color = colors[: len(size)]\n", " plt.pie(size, colors=color, labels=label_list, labeldistance=1.1, autopct=\"%1.1f%%\", shadow=False, startangle=90, pctdistance=0.6)\n", " plt.axis(\"equal\")\n", " plt.legend()\n", " plt.title(\"Image classification\")\n", " plt.show()\n", " \n", " \n", "for i in range(2):\n", " print(\"Figure {} probability of corresponding numbers [0-9]:\\n\".format(i+1), prb[i])\n", " plot_pie(prb[i])" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "以上过程就是这次手写数字分类训练的全部体验过程。" ] } ], "metadata": { "kernelspec": { "display_name": "Python 3", "language": "python", "name": "python3" }, "language_info": { "codemirror_mode": { "name": "ipython", "version": 3 }, "file_extension": ".py", "mimetype": "text/x-python", "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", "version": "3.7.6" } }, "nbformat": 4, "nbformat_minor": 4 }