{ "cells": [ { "cell_type": "markdown", "metadata": {}, "source": [ "# Implementing an Image Classification Application\n", "\n", "`Linux` `Windows` `Ascend` `GPU` `CPU` `Whole Process` `Beginner` `Intermediate` `Expert`\n", "\n", "[![](https://gitee.com/mindspore/docs/raw/r1.3/resource/_static/logo_source.png)](https://gitee.com/mindspore/docs/blob/r1.3/docs/mindspore/programming_guide/source_en/quick_start/quick_start.ipynb) [![](https://gitee.com/mindspore/docs/raw/r1.3/resource/_static/logo_notebook.png)](https://mindspore-website.obs.cn-north-4.myhuaweicloud.com/notebook/r1.3/programming_guide/en/mindspore_quick_start.ipynb) [![](https://gitee.com/mindspore/docs/raw/r1.3/resource/_static/logo_modelarts.png)](https://authoring-modelarts-cnnorth4.huaweicloud.com/console/lab?share-url-b64=aHR0cHM6Ly9taW5kc3BvcmUtd2Vic2l0ZS5vYnMuY24tbm9ydGgtNC5teWh1YXdlaWNsb3VkLmNvbS9ub3RlYm9vay9yMS4zL3Byb2dyYW1taW5nX2d1aWRlL2VuL21pbmRzcG9yZV9xdWlja19zdGFydC5pcHluYg==&imageid=65f636a0-56cf-49df-b941-7d2a07ba8c8c)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Overview\n", "\n", "This document uses a practice example to demonstrate the basic functions of MindSpore. For common users, it takes 20 to 30 minutes to complete the practice.\n", "\n", "During the practice, a simple image classification function is implemented. The overall process is as follows:\n", "\n", "1. Process the required dataset. The MNIST dataset is used in this example.\n", "2. Define a network. The LeNet network is used in this example.\n", "3. The loss value and precision value of the model collected by the custom callback function.\n", "4. Define the loss function and optimizer.\n", "5. Load the dataset and perform training. After the training is complete, check the result and save the model file.\n", "6. Load the saved model for inference.\n", "7. Validate the model, load the test dataset and trained model, and validate the result accuracy.\n", "\n", "This is a simple and basic application process. Other advanced and complex applications can be extended based on this basic process.\n", "\n", "> This document is applicable to CPU, GPU and Ascend environments.\n", ">\n", "> You can find the complete executable sample code at ." ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Preparations\n", "\n", "Before you start, check whether MindSpore has been correctly installed. If not, install MindSpore on your computer by visiting [MindSpore installation page](https://www.mindspore.cn/install/en). \n", "\n", "In addition, you shall have basic mathematical knowledge such as Python coding basics, probability, and matrix.\n", "\n", "Start your MindSpore experience now." ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Downloading the Dataset\n", "\n", "The `MNIST` dataset used in this example consists of 10 classes of 28 x 28 pixels grayscale images. It has a training set of 60,000 examples, and a test set of 10,000 examples.\n", "\n", "Execute the following command in jupyter notebook to download the MNIST dataset.\n", "\n", "> Download the MNIST dataset at . This page provides four download links of dataset files. The first two links are required for data training, and the last two links are required for data test." ] }, { "cell_type": "code", "execution_count": 1, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "./datasets/MNIST_Data\n", "├── test\n", "│   ├── t10k-images-idx3-ubyte\n", "│   └── t10k-labels-idx1-ubyte\n", "└── train\n", " ├── train-images-idx3-ubyte\n", " └── train-labels-idx1-ubyte\n", "\n", "2 directories, 4 files\n" ] } ], "source": [ "!mkdir -p ./datasets/MNIST_Data/train ./datasets/MNIST_Data/test\n", "!wget -NP ./datasets/MNIST_Data/train https://mindspore-website.obs.myhuaweicloud.com/notebook/datasets/mnist/train-labels-idx1-ubyte --no-check-certificate\n", "!wget -NP ./datasets/MNIST_Data/train https://mindspore-website.obs.myhuaweicloud.com/notebook/datasets/mnist/train-images-idx3-ubyte --no-check-certificate\n", "!wget -NP ./datasets/MNIST_Data/test https://mindspore-website.obs.myhuaweicloud.com/notebook/datasets/mnist/t10k-labels-idx1-ubyte --no-check-certificate\n", "!wget -NP ./datasets/MNIST_Data/test https://mindspore-website.obs.myhuaweicloud.com/notebook/datasets/mnist/t10k-images-idx3-ubyte --no-check-certificate\n", "!tree ./datasets/MNIST_Data" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Importing Python Libraries and Modules\n", "\n", "Before start, you need to import Python libraries.\n", "\n", "Currently, only the `os` library is required. Other libraries are not described here." ] }, { "cell_type": "code", "execution_count": 2, "metadata": {}, "outputs": [], "source": [ "import os" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "For details about MindSpore modules, search on the [MindSpore API Page](https://www.mindspore.cn/docs/api/en/r1.3/index.html).\n", "\n", "### Configuring the Running Information\n", "\n", "Before compiling code, you need to learn basic information about the hardware and backend required for MindSpore running.\n", "\n", "You can use `context.set_context` to configure the information required for running, such as the running mode, backend information, and hardware information.\n", "\n", "Import the `context` module and configure the required information." ] }, { "cell_type": "code", "execution_count": 3, "metadata": {}, "outputs": [], "source": [ "from mindspore import context\n", "\n", "context.set_context(mode=context.GRAPH_MODE, device_target=\"CPU\")" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "This example runs in graph mode. You can configure hardware information based on actual requirements. For example, if the code runs on the Ascend AI processor, set `--device_target` to `Ascend`. This rule also applies to the code running on the CPU and GPU. For details about parameters, see the API description for `context.set_context`.\n", "\n", "## Processing Data\n", "\n", "Datasets are important for training. A good dataset can effectively improve training accuracy and efficiency. Generally, before loading a dataset, you need to perform some operations on the dataset.\n", "\n", "A convolutional neural network such as LeNet is used to train the dataset. During data training, the data format is required. Therefore, you need to check the data in the dataset first. In this way, a targeted data conversion function can be constructed to convert the data in the dataset into a data format that meets the training requirements.\n", "\n", "Execute the following code to view the original dataset data:" ] }, { "cell_type": "code", "execution_count": 4, "metadata": {}, "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: 9\n" ] }, { "data": { "image/png": "iVBORw0KGgoAAAANSUhEUgAAAPsAAAEICAYAAACZA4KlAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjMuNCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8QVMy6AAAACXBIWXMAAAsTAAALEwEAmpwYAAANqklEQVR4nO3da6hl5X3H8e+vdhyJWtSYTiZqo7X2hQ12bE9NINJYbBNjWjRvJNMQRhDHgEIDFiKmECkVbGlMLWlDxmodizGGJOIUbKORgrUt4lEmOl4SjSg6jk6C2qiN4yX/vtjLcDye2+z7Oc/3A5u99rrs9Z/F/M6z9nr22k+qCklr3y9NugBJ42HYpUYYdqkRhl1qhGGXGmHYpUYYdi0oyRNJ/nDSdWh4DLsmIsmfJNmV5OUk/53kxEnXtNYZdo1Ukl9eYN4JwA3AZ4HDgH8Fdiy0robHsK8y3en1nye5P8n/JrkpyUFJzk1y17x1K8lvdNPXJfnHJP/Wtab/leS9Sf4uyQtJHkly8rzd/V6Sh7rl/5zkoDnv/cdJdiZ5sWuZT5pX4+eT3A+8skCIPwb8Z1XdVVVvAH8NHAV8ZIiHSvMY9tXpHOAM4DjgJODc/djuL4AjgX3A/wD3da+/BVw5b/1P0wvm8cBvdtvS/VG4FrgAeDfwNXot8/o5224GPgEcVlVvdH+c/nTO8sybDvCBFf471AfDvjr9fVU9U1XP0zsF3rTC7W6uqnur6lXgZuDVqrq+qt4EbgLmt+xfqaqnuv1cTi/AAFuBr1XV3VX1ZlVtp/fH40Pzanyqqn4GUFUnVdXXu2XfAz6S5LQkBwKXAgcC79qPY6D9ZNhXp2fnTP8fcMgKt3tuzvTPFng9/32emjP9JPC+bvr9wMXdKfyLSV4EjpmzfP62b1NVjwBbgK8Ae+idWTwEPL3Cf4f64AWRteMV5rSMSd47hPc8Zs70rwHPdNNPAZdX1eVLbLvk7ZRV9S16Hx1IchhwHnBP35VqWbbsa8f3gd9Ksqm7kHbZEN7zwiRHJzkC+AK9U32Aq4HPJvlgeg5O8okkh670jZP8bpIDkrwH2Abs6Fp8jYhhXyOq6ofAX9L7PPwocNfSW6zI14HbgMeBHwF/1e1rFjif3mn4C8BjLHORMMmDST49Z9ZVwIvAD7r3OH8I9WoJ8ccrpDbYskuNMOxSIwy71AjDLjVirP3sB2Z9HcTB49yl1JRXeYXXal8WWjZQ2JOcQa8L5QDgn6rqiqXWP4iD+WBOH2SXkpZwd92x6LK+T+OTHAD8A/Bx4ERgs/ckS9NrkM/spwCPVdXjVfUa8A3grOGUJWnYBgn7Ubz9Zoenu3lvk2Rrktkks6+zb4DdSRrEyK/GV9W2qpqpqpl1rF9+A0kjMUjYd/P2u6KO7uZJmkKDhP0e4IQkx3U/QPApYMdwypI0bH13vXU/NXQR8F16XW/XVtWDQ6tM0lAN1M9eVbcCtw6pFkkj5NdlpUYYdqkRhl1qhGGXGmHYpUYYdqkRhl1qhGGXGmHYpUYYdqkRhl1qhGGXGmHYpUYYdqkRhl1qhGGXGmHYpUYYdqkRhl1qhGGXGmHYpUYYdqkRhl1qhGGXGmHYpUYYdqkRhl1qhGGXGmHYpUYYdqkRAw3ZnOQJ4CXgTeCNqpoZRlGShm+gsHf+oKp+MoT3kTRCnsZLjRg07AXcluTeJFsXWiHJ1iSzSWZfZ9+Au5PUr0FP40+tqt1JfhW4PckjVXXn3BWqahuwDeBXckQNuD9JfRqoZa+q3d3zXuBm4JRhFCVp+PoOe5KDkxz61jTwUWDXsAqTNFyDnMZvAG5O8tb7fL2q/n0oVWnN+O4zOyddwkh87H2bJl3Cfus77FX1OPDbQ6xF0gjZ9SY1wrBLjTDsUiMMu9QIwy41Yhg3wmgVW6tdY3onW3apEYZdaoRhlxph2KVGGHapEYZdaoRhlxphP/sYDNqXPcjtlPaj92c13sK6HFt2qRGGXWqEYZcaYdilRhh2qRGGXWqEYZcaYT/7KmBf+fgtd8xXYz+8LbvUCMMuNcKwS40w7FIjDLvUCMMuNcKwS42wn30MluuTbbUf3eMyXsu27EmuTbI3ya45845IcnuSR7vnw0dbpqRBreQ0/jrgjHnzLgHuqKoTgDu615Km2LJhr6o7gefnzT4L2N5NbwfOHm5Zkoat38/sG6pqTzf9LLBhsRWTbAW2AhzEu/rcnaRBDXw1vqoKqCWWb6uqmaqaWcf6QXcnqU/9hv25JBsBuue9wytJ0ij0G/YdwJZuegtwy3DKkTQqy35mT3IjcBpwZJKngS8CVwDfTHIe8CRwziiLXO1a7i9eqi+95eMyCcuGvao2L7Lo9CHXImmE/Lqs1AjDLjXCsEuNMOxSIwy71AhvcR2CtdyFNOhtqKv12KzGn4peji271AjDLjXCsEuNMOxSIwy71AjDLjXCsEuNsJ99hdZqf/Fa7SdfzlrsR1+OLbvUCMMuNcKwS40w7FIjDLvUCMMuNcKwS42wn32NW6v95Np/tuxSIwy71AjDLjXCsEuNMOxSIwy71AjDLjXCfvaO/dFrT4v3rC9l2ZY9ybVJ9ibZNWfeZUl2J9nZPc4cbZmSBrWS0/jrgDMWmP/lqtrUPW4dblmShm3ZsFfVncDzY6hF0ggNcoHuoiT3d6f5hy+2UpKtSWaTzL7OvgF2J2kQ/Yb9q8DxwCZgD/ClxVasqm1VNVNVM+tY3+fuJA2qr7BX1XNV9WZV/Ry4GjhluGVJGra+wp5k45yXnwR2LbaupOmwbD97khuB04AjkzwNfBE4LckmoIAngAtGV6KkYVg27FW1eYHZ14ygFkkj5NdlpUYYdqkRhl1qhGGXGmHYpUZ4i2tn0KGNpWlnyy41wrBLjTDsUiMMu9QIwy41wrBLjTDsUiPsZ2/cNH+/wJ+CHi5bdqkRhl1qhGGXGmHYpUYYdqkRhl1qhGGXGmE/+wqt1T5f79Nvhy271AjDLjXCsEuNMOxSIwy71AjDLjXCsEuNWMmQzccA1wMb6A3RvK2qrkpyBHATcCy9YZvPqaoXRleq+mE/ut6ykpb9DeDiqjoR+BBwYZITgUuAO6rqBOCO7rWkKbVs2KtqT1Xd102/BDwMHAWcBWzvVtsOnD2iGiUNwX59Zk9yLHAycDewoar2dIuepXeaL2lKrTjsSQ4Bvg18rqp+OndZVRW9z/MLbbc1yWyS2dfZN1Cxkvq3orAnWUcv6DdU1Xe62c8l2dgt3wjsXWjbqtpWVTNVNbOO9cOoWVIflg17kgDXAA9X1ZVzFu0AtnTTW4Bbhl+epGFZyS2uHwY+AzyQZGc371LgCuCbSc4DngTOGUmFWrPW6m3D02rZsFfVXUAWWXz6cMuRNCp+g05qhGGXGmHYpUYYdqkRhl1qhGGXGuFPSa8C3qaqYbBllxph2KVGGHapEYZdaoRhlxph2KVGGHapEfaza6S8Z3162LJLjTDsUiMMu9QIwy41wrBLjTDsUiMMu9QIwy41wrBLjTDsUiMMu9QIwy41wrBLjTDsUiMMu9SIZe9nT3IMcD2wAShgW1VdleQy4Hzgx92ql1bVraMqVNPJ+9VXj5X8eMUbwMVVdV+SQ4F7k9zeLftyVf3t6MqTNCzLhr2q9gB7uumXkjwMHDXqwiQN1359Zk9yLHAycHc366Ik9ye5Nsnhi2yzNclsktnX2TdYtZL6tuKwJzkE+Dbwuar6KfBV4HhgE72W/0sLbVdV26pqpqpm1rF+8Iol9WVFYU+yjl7Qb6iq7wBU1XNV9WZV/Ry4GjhldGVKGtSyYU8S4Brg4aq6cs78jXNW+ySwa/jlSRqWlVyN/zDwGeCBJDu7eZcCm5Nsotcd9wRwwQjqE3ZvaThWcjX+LiALLLJPXVpF/Aad1AjDLjXCsEuNMOxSIwy71AjDLjXCsEuNMOxSIwy71AjDLjXCsEuNMOxSIwy71AjDLjUiVTW+nSU/Bp6cM+tI4CdjK2D/TGtt01oXWFu/hlnb+6vqPQstGGvY37HzZLaqZiZWwBKmtbZprQusrV/jqs3TeKkRhl1qxKTDvm3C+1/KtNY2rXWBtfVrLLVN9DO7pPGZdMsuaUwMu9SIiYQ9yRlJfpDksSSXTKKGxSR5IskDSXYmmZ1wLdcm2Ztk15x5RyS5Pcmj3fOCY+xNqLbLkuzujt3OJGdOqLZjkvxHkoeSPJjkz7r5Ez12S9Q1luM29s/sSQ4Afgj8EfA0cA+wuaoeGmshi0jyBDBTVRP/AkaS3wdeBq6vqg908/4GeL6qruj+UB5eVZ+fktouA16e9DDe3WhFG+cOMw6cDZzLBI/dEnWdwxiO2yRa9lOAx6rq8ap6DfgGcNYE6ph6VXUn8Py82WcB27vp7fT+s4zdIrVNharaU1X3ddMvAW8NMz7RY7dEXWMxibAfBTw15/XTTNd47wXcluTeJFsnXcwCNlTVnm76WWDDJItZwLLDeI/TvGHGp+bY9TP8+aC8QPdOp1bV7wAfBy7sTlenUvU+g01T3+mKhvEelwWGGf+FSR67foc/H9Qkwr4bOGbO66O7eVOhqnZ3z3uBm5m+oaife2sE3e5574Tr+YVpGsZ7oWHGmYJjN8nhzycR9nuAE5Icl+RA4FPAjgnU8Q5JDu4unJDkYOCjTN9Q1DuALd30FuCWCdbyNtMyjPdiw4wz4WM38eHPq2rsD+BMelfkfwR8YRI1LFLXrwPf7x4PTro24EZ6p3Wv07u2cR7wbuAO4FHge8ARU1TbvwAPAPfTC9bGCdV2Kr1T9PuBnd3jzEkfuyXqGstx8+uyUiO8QCc1wrBLjTDsUiMMu9QIwy41wrBLjTDsUiP+HwkwTbYrVWKZAAAAAElFTkSuQmCC", "text/plain": [ "
" ] }, "metadata": { "needs_background": "light" }, "output_type": "display_data" } ], "source": [ "import matplotlib.pyplot as plt\n", "import matplotlib\n", "import numpy as np\n", "import mindspore.dataset as ds\n", "\n", "train_data_path = \"./datasets/MNIST_Data/train\"\n", "test_data_path = \"./datasets/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 = next(dic_ds)\n", "img = item[\"image\"].asnumpy()\n", "label = item[\"label\"].asnumpy()\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\"].asnumpy())\n", "plt.show()" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "From the above operation, we can see that the training datasets `train-images-idx3-ubyte` and `train-labels-idx1-ubyte` correspond to 60,000 images and 60,000 digital labels. After loading the data, the dictionary data set is converted by `create_dict_iterator`. View one of the data, which is a dictionary with keys `image` and `label`. The tensor of `image` (height: 28; width: 28; channel: 1) and `label` are numbers corresponding to the image." ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Defining the Dataset and Data Operations\n", "\n", "Define the `create_dataset` function to create a dataset. In this function, define the data augmentation and processing operations to be performed.\n", "\n", "1. Define the dataset.\n", "2. Define parameters required for data augmentation and processing.\n", "3. Generate corresponding data augmentation operations according to the parameters.\n", "4. Use the `map` mapping function to apply data operations to the dataset.\n", "5. Process the generated dataset.\n", "\n", "After the definition is completed, use `create_datasets` to perform data augmentation on the original data, and extract a `batch` of data to view the changes after data augmentation." ] }, { "cell_type": "code", "execution_count": 5, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Number of groups in the dataset: 1875\n" ] } ], "source": [ "import mindspore.dataset.vision.c_transforms as CV\n", "import mindspore.dataset.transforms.c_transforms as C\n", "from mindspore.dataset.vision import Inter\n", "from mindspore 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(operations=type_cast_op, input_columns=\"label\", num_parallel_workers=num_parallel_workers)\n", " mnist_ds = mnist_ds.map(operations=resize_op, input_columns=\"image\", num_parallel_workers=num_parallel_workers)\n", " mnist_ds = mnist_ds.map(operations=rescale_op, input_columns=\"image\", num_parallel_workers=num_parallel_workers)\n", " mnist_ds = mnist_ds.map(operations=rescale_nml_op, input_columns=\"image\", num_parallel_workers=num_parallel_workers)\n", " mnist_ds = mnist_ds.map(operations=hwc2chw_op, input_columns=\"image\", 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", "\n", "ms_dataset = create_dataset(train_data_path)\n", "print('Number of groups in the dataset:', ms_dataset.get_dataset_size())" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "After the data augmentation function is called, the dataset `size` changes from 60000 to 1875, which meets the expectations of the `mnist_ds.batch` operation in data augmentation ($60000/32=1875$).\n", "\n", "In the preceding augmentation process:\n", "\n", "- The `label` data enhancement operation in the dataset:\n", "\n", " - `C.TypeCast`: Convert the data type to `int32`.\n", "\n", "- The `image` data enhancement operation in the dataset: \n", "\n", " - `datasets.MnistDataset`: Convert the dataset into MindSpore trainable data. \n", " - `CV.Resize`: Resize image data pixels to meet the data size requirements of the LeNet network.\n", " - `CV.Rescale`: Standardize and normalize image data so that the value of each pixel is in the range (0,1), which can improve training efficiency. \n", " - `CV.HWC2CHW`: Transform the image data tensor, the tensor form is changed from `height x width x channel` (HWC) to `channel x height x width` (CHW), which is convenient for data training.\n", "\n", "- Other enhancement operations:\n", "\n", " - `mnist_ds.shuffle`: Randomly store data in a memory that can hold 10,000 images for shuffle. \n", " - `mnist_ds.batch`: Extract 32 images from the shuffled 10,000 image addresses to form a `batch`, the parameter `batch_size` indicates the number of data contained in each group, and each group is now set to contain 32 data. \n", " - `mnist_ds.repeat`: The `batch` data is replicated and enhanced. The parameter `repeat_size` indicates the number of replicated datasets.\n", "\n", "Perform the `shuffle` and `batch` operations, and then perform the `repeat` operation to ensure that data is unique during one `epoch`.\n", "\n", "> MindSpore supports multiple data processing and augmentation operations, which are usually used in combined. For details, see section [Data Processing](https://www.mindspore.cn/docs/programming_guide/en/r1.3/dataset_sample.html) and [Data Augmentation](https://www.mindspore.cn/docs/programming_guide/en/r1.3/augmentation.html) in the MindSpore tutorials." ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Viewing Enhanced Data\n", "\n", "Obtain a group of data from the 1875 groups of data and view the data tensor and `label`." ] }, { "cell_type": "code", "execution_count": 6, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Tensor of image: (32, 1, 32, 32)\n", "Labels: [5 5 6 4 7 0 1 2 2 8 7 4 3 3 6 5 8 9 6 6 9 7 9 8 2 9 0 2 4 3 9 3]\n" ] } ], "source": [ "data = next(ms_dataset.create_dict_iterator(output_numpy=True))\n", "images = data[\"image\"]\n", "labels = data[\"label\"]\n", "print('Tensor of image:', images.shape)\n", "print('Labels:', labels)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Visualize the tensor data and the value corresponding to `label`." ] }, { "cell_type": "code", "execution_count": 7, "metadata": {}, "outputs": [ { "data": { "image/png": "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", "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": [ "Through the above query operation, you can see the transformed images. The dataset is divided into 1875 groups of data. Each group of data contains 32 images. The resolution of each image is 32 x 32. After all the data is prepared, you can proceed to the next step of data training.\n", "\n", "## Defining the Network\n", "\n", "The LeNet network is relatively simple. In addition to the input layer, the LeNet network has seven layers, including two convolutional layers, two down-sample layers (pooling layers), and three full connection layers. Each layer contains different numbers of training parameters, as shown in the following figure:\n", "\n", "> For details about the LeNet network, visit .\n", "\n", "You can initialize the full connection layers and convolutional layers by `Normal`.\n", "\n", "MindSpore supports multiple parameter initialization methods, such as `TruncatedNormal`, `Normal`, and `Uniform`, default value is `Normal`. For details, see the description of the `mindspore.common.initializer` module in the MindSpore API.\n", "\n", "To use MindSpore for neural network definition, inherit `mindspore.nn.Cell`. `Cell` is the base class of all neural networks (such as `Conv2d`).\n", "\n", "Define each layer of a neural network in the `__init__` method in advance, and then define the `construct` method to complete the forward construction of the neural network. According to the structure of the LeNet network, define the network layers as follows:" ] }, { "cell_type": "code", "execution_count": 8, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "layer conv1: Conv2d\n", "****************************************\n", "layer fc1: Dense\n" ] } ], "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\n", "\n", "network = LeNet5()\n", "print(\"layer conv1:\", network.conv1)\n", "print(\"*\"*40)\n", "print(\"layer fc1:\", network.fc1)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "After the construction is completed, you can use `print(LeNet5())` to print out all the parameters of each layer in the neural network, or use `LeNet().{layer name}` to print the corresponding parameter information. This example chooses to print the corresponding parameters of the first convolutional layer and the first fully connected layer.\n", "\n", "## Custom Callback Function to Collect the Model Loss Value and Precision Value\n", "\n", "Customize a data collection callback class `StepLossAccInfo`, it is used to collect two types of information:\n", "\n", "1. Information about the relationship between `step` and `loss` values during training;\n", "\n", "2. Information of each 125 training `step` and corresponding model accuracy value `accuracy`.\n", "\n", "This class inherits the `Callback` class. You can customize operations during training. After the training is completed, the data can be drawn into a graph to view the changes in `step` and `loss`, as well as the `step` and `accuracy` changes.\n", "\n", "The following code will be used as a callback function to be called in the model training function `model.train`. The following visualizes the information collected during the model verification stage." ] }, { "cell_type": "code", "execution_count": 9, "metadata": {}, "outputs": [], "source": [ "from mindspore.train.callback import Callback\n", "\n", "# custom callback function\n", "class StepLossAccInfo(Callback):\n", " def __init__(self, model, eval_dataset, steps_loss, steps_eval):\n", " self.model = model\n", " self.eval_dataset = eval_dataset\n", " self.steps_loss = steps_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.steps_loss[\"loss_value\"].append(str(cb_params.net_outputs))\n", " self.steps_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\"])" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "In the preceding information:\n", "\n", "- `model`: computational graph model.\n", "- `eval_dataset`: validation dataset.\n", "- `steps_loss`: Collect the relationship between step and loss value, the data format is `{\"step\": [], \"loss_value\": []}`.\n", "- `steps_eval`: Collect information about the model accuracy value `accuracy` corresponding to step, the data format is `{\"step\": [], \"acc\": []}`.\n", "\n", "## Defining the Loss Function and Optimizer\n", "\n", "Before definition, this section briefly describes concepts of loss function and optimizer.\n", "\n", "- Loss function: It is also called objective function and is used to measure the difference between a predicted value and an actual value. Deep learning reduces the value of the loss function by continuous iteration. Defining a good loss function can effectively improve the model performance.\n", "\n", "- Optimizer: It is used to minimize the loss function, improving the model during training.\n", "\n", "After the loss function is defined, the weight-related gradient of the loss function can be obtained. The gradient is used to indicate the weight optimization direction for the optimizer, improving model performance.\n", "\n", "Loss functions supported by MindSpore include `SoftmaxCrossEntropyWithLogits`, `L1Loss`, `MSELoss`. The loss function `SoftmaxCrossEntropyWithLogits` is used in this example.\n", "\n", "The optimizers supported by MindSpore include `Adam`, `AdamWeightDecay`, `Momentum`, etc. The popular `Momentum` optimizer is used here." ] }, { "cell_type": "code", "execution_count": 10, "metadata": {}, "outputs": [], "source": [ "import mindspore.nn as nn\n", "from mindspore.nn import SoftmaxCrossEntropyWithLogits\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')" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Training the Network\n", "\n", "After completing the construction of the neural network, you can start network training. The network training can be conveniently performed through the `Model.train` interface provided by MindSpore. The parameters mainly include:\n", "\n", "1. `epoch_size`: specifies the number of batches of images that need to be traversed by each epoch.\n", "2. `ds_train`: specifies the training dataset.\n", "3. MindSpore-provided callback mechanism. The callback function `callbacks` contains `ModelCheckpoint`, `LossMonitor`, and `Callback` arguments, where `ModelCheckpoint` is used to save network models and parameters for performing fine-tuning.\n", "4. `dataset_sink_mode`: specifies the dataset sink mode. The default value `True` needs to be set to `False` because this mode does not support the CPU computing platform." ] }, { "cell_type": "code", "execution_count": 11, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "epoch: 1 step: 125, loss is 0.13396409\n", "epoch: 1 step: 250, loss is 0.1545082\n", "epoch: 1 step: 375, loss is 0.12724978\n", "epoch: 1 step: 500, loss is 0.034271903\n", "epoch: 1 step: 625, loss is 0.13005787\n", "epoch: 1 step: 750, loss is 0.010596659\n", "epoch: 1 step: 875, loss is 0.008820764\n", "epoch: 1 step: 1000, loss is 0.09243655\n", "epoch: 1 step: 1125, loss is 0.054233808\n", "epoch: 1 step: 1250, loss is 0.074425355\n", "epoch: 1 step: 1375, loss is 0.005053058\n", "epoch: 1 step: 1500, loss is 0.13170624\n", "epoch: 1 step: 1625, loss is 0.028616104\n", "epoch: 1 step: 1750, loss is 0.12095115\n", "epoch: 1 step: 1875, loss is 0.013343395\n" ] } ], "source": [ "import os\n", "from mindspore import Tensor, Model\n", "from mindspore.train.callback import ModelCheckpoint, CheckpointConfig, LossMonitor\n", "from mindspore.nn import Accuracy\n", "\n", "epoch_size = 1\n", "mnist_path = \"./datasets/MNIST_Data\"\n", "model_path = \"./models/ckpt/mindspore_quick_start/\"\n", "\n", "repeat_size = 1\n", "ds_train = create_dataset(os.path.join(mnist_path, \"train\"), 32, repeat_size)\n", "eval_dataset = create_dataset(os.path.join(mnist_path, \"test\"), 32)\n", "\n", "# clean up old run files before in Linux\n", "os.system('rm -f {0}*.ckpt {0}*.meta {0}*.pb'.format(model_path))\n", "\n", "# define the model\n", "model = Model(network, net_loss, net_opt, metrics={\"Accuracy\": Accuracy()} )\n", "\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\", directory=model_path, config=config_ck)\n", "\n", "steps_loss = {\"step\": [], \"loss_value\": []}\n", "steps_eval = {\"step\": [], \"acc\": []}\n", "# collect the steps,loss and accuracy information\n", "step_loss_acc_info = StepLossAccInfo(model , eval_dataset, steps_loss, steps_eval)\n", "\n", "model.train(epoch_size, ds_train, callbacks=[ckpoint_cb, LossMonitor(125), step_loss_acc_info], dataset_sink_mode=False)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "After training, multiple model files will be generated and saved under the pre-set directory." ] }, { "cell_type": "code", "execution_count": 12, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "./models/ckpt/mindspore_quick_start/\n", "├── checkpoint_lenet-1_1125.ckpt\n", "├── checkpoint_lenet-1_1500.ckpt\n", "├── checkpoint_lenet-1_1875.ckpt\n", "├── checkpoint_lenet-1_375.ckpt\n", "├── checkpoint_lenet-1_750.ckpt\n", "└── checkpoint_lenet-graph.meta\n", "\n", "0 directories, 6 files\n" ] } ], "source": [ "!tree $model_path" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "The meaning of the file name: `{Customized name configured in ModelCheckpoint}-{The number of epoch}-{The number of step}`.\n", "\n", "> To use free control loop iterations, traversing data sets, etc., you can refer to the \"Customizing a Training Cycle\" part of the official website programming guide \"[Training](https://www.mindspore.cn/docs/programming_guide/en/r1.3/train.html#customizing-a-training-cycle)\".\n", "\n", "### Checking the Loss Value of the Model with the Change of Training Steps" ] }, { "cell_type": "code", "execution_count": 13, "metadata": {}, "outputs": [ { "data": { "image/png": "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", "text/plain": [ "
" ] }, "metadata": { "needs_background": "light" }, "output_type": "display_data" } ], "source": [ "steps = steps_loss[\"step\"]\n", "loss_value = steps_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(\"Change chart of model loss value\")\n", "plt.show()" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Judging from the above, it can be divided into three stages:\n", "\n", "Stage 1: When the training starts, the loss value is around 2.2, which indicates that the training performance is not satisfied.\n", "\n", "Stage 2: When the training arrives at a certain point, the loss value decreases sharply and the training performance is greatly improved.\n", "\n", "Stage 3: After the loss value converges to a small value, it tends to get close to 0. At this point, the training performance is steady and cannot be further improved, leading to the result that the training is terminated.\n", "\n", "## Validating the Model\n", "\n", "After obtaining the model file, validate the model generalization capability.\n", "\n", "The process of building a network for verification is as follows:\n", "\n", "1. Load the model by reading the parameter `param_dict` in the `.ckpt` file.\n", "2. Load the parameter `param_dict` to the neural network, Lenet.\n", "3. Load the test dataset.\n", "4. Call the function, `model.eval`, to transfer the parameters of the test dataset, `ds_eval`. Compute the accuracy of `checkpoint_lenet-{epoch}_1875.ckpt`" ] }, { "cell_type": "code", "execution_count": 14, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "============== Starting Testing ==============\n", "============== Accuracy:{'Accuracy': 0.9758613782051282} ==============\n" ] } ], "source": [ "from mindspore import load_checkpoint, load_param_into_net\n", "\n", "# 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(\"./models/ckpt/mindspore_quick_start/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": [ "In the preceding information:\n", "\n", "- `load_checkpoint`：This API is used to load the CheckPoint model parameter file and return a parameter dictionary.\n", "\n", "- `checkpoint_lenet-1_1875.ckpt`：name of the saved CheckPoint model file.\n", "\n", "- `load_param_into_net`：This API is used to load parameters to the network.\n", "\n", "When the training step reaches 1875, the accuracy of the model is over 95%, meaning the model performance is good.\n", "\n", "We can check the change of the model accuracy as the training step changes.\n", "\n", "`eval_show` draws the line chart of model accuracy every 25 `step`. In particular, `steps_eval` stores the training step of the model and the corresponding accuracy information." ] }, { "cell_type": "code", "execution_count": 15, "metadata": {}, "outputs": [ { "data": { "image/png": "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", "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": [ "In the figure, it can be seen that the change of the model accuracy can be divided in three stages:\n", "\n", "Stage 1: When the training starts, the model accuracy rises slowly.\n", "\n", "Stage 2: At a certain point, the model accuracy rises sharply.\n", "\n", "Stage 3: The model accuracy nearly comes to 1 without reaching.\n", "\n", "During the training process, as the training data increases, it will have a positive correlation with the model accuracy, but as the accuracy reaches a certain level, the training gains will decrease.\n", "\n", "## Inference and Prediction\n", "\n", "Apply the trained model to predict a single image or a set of images. The procedure is as follows:\n", "\n", "1. Transform the test data to the data that fits LeNet.\n", "2. Extract the `image` data.\n", "3. Call the function, `model.predict`, to predict the corresponding digit in each `image`. To be noted, `predict` will returns the probability of predicting 0 to 9 for each `image`.\n", "4. Call the `plot_pie` function to display the probability of predictions. Negative probabilities will be removed and not be displayed.\n", "\n", "Load the dataset to be predicted and call the `create_dataset` function to transform the test dataset into required formats. Select a set of 32 images for inference and prediction." ] }, { "cell_type": "code", "execution_count": 16, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Row 1, column 7 is incorrectly identified as 5, the correct value should be 3 \n", "\n", "[2 0 1 3 0 0 5 8 7 2 6 2 7 3 1 2 9 5 4 6 0 3 0 8 3 9 5 1 9 6 4 2] <--Predicted figures\n", "[2 0 1 3 0 0 3 8 7 2 6 2 7 3 1 2 9 5 4 6 0 3 0 8 3 9 5 1 9 6 4 2] <--The right number\n" ] }, { "data": { "image/png": "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", "text/plain": [ "
" ] }, "metadata": { "needs_background": "light" }, "output_type": "display_data" } ], "source": [ "ds_test = create_dataset(test_data_path).create_dict_iterator()\n", "data = next(ds_test)\n", "images = data[\"image\"].asnumpy()\n", "labels = data[\"label\"].asnumpy()\n", "\n", "output = model.predict(Tensor(data['image']))\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": [ "Draw a pie chart for probability analysis. In this example, it displays a pie chart for the current `batch` in the first image.\n", "\n", "`prb` stores the preceding 32 prediction numbers and corresponding output results. The classification result `prb[0]` corresponding to the first image is obtained, and the sigmol formula $\\frac{1}{1+e^{-x}}$ is used to obtain the probability of [0-9] corresponding to the image. The number whose probability value is greater than 0.5 is analyzed in the pie chart." ] }, { "cell_type": "code", "execution_count": 17, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "The probability of corresponding numbers [0-9] in Figure 1:\n", " [0.054608213813288335, 0.04007988333681419, 0.9999934046689553, 0.9469836696068331, 0.347608619405929, 0.020873059274634436, 0.0013652782671098932, 0.9990516692085604, 0.39083703602997244, 0.036189847324771866]\n" ] }, { "data": { "image/png": "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", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "import numpy as np\n", "# define the pie drawing function of probability analysis\n", "\n", "prb = output.asnumpy()\n", "\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", "print(\"The probability of corresponding numbers [0-9] in Figure 1:\\n\", list(map(lambda x:1/(1+np.exp(-x)), prb[0])))\n", "plot_pie(prb[0])" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "That's the whole experience of the handwritten number classification application." ] } ], "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.5" } }, "nbformat": 4, "nbformat_minor": 5 }