{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "fa7e3e52",
   "metadata": {},
   "source": [
    "# ResNet50网络进行图像分类\n",
    "\n",
    "[![在线运行](https://mindspore-website.obs.cn-north-4.myhuaweicloud.com/website-images/r1.7/resource/_static/logo_modelarts.png)](https://authoring-modelarts-cnnorth4.huaweicloud.com/console/lab?share-url-b64=aHR0cHM6Ly9vYnMuZHVhbHN0YWNrLmNuLW5vcnRoLTQubXlodWF3ZWljbG91ZC5jb20vbWluZHNwb3JlLXdlYnNpdGUvbm90ZWJvb2svcjEuNy90dXRvcmlhbHMvYXBwbGljYXRpb24vemhfY24vY3YvbWluZHNwb3JlX3Jlc25ldDUwLmlweW5i&imageid=9d63f4d1-dc09-4873-b669-3483cea777c0) [![下载Notebook](https://mindspore-website.obs.cn-north-4.myhuaweicloud.com/website-images/r1.7/resource/_static/logo_notebook.png)](https://obs.dualstack.cn-north-4.myhuaweicloud.com/mindspore-website/notebook/r1.7/tutorials/application/zh_cn/cv/mindspore_resnet50.ipynb) [![下载样例代码](https://mindspore-website.obs.cn-north-4.myhuaweicloud.com/website-images/r1.7/resource/_static/logo_download_code.png)](https://obs.dualstack.cn-north-4.myhuaweicloud.com/mindspore-website/notebook/r1.7/tutorials/application/zh_cn/cv/mindspore_resnet50.py) [![查看源文件](https://mindspore-website.obs.cn-north-4.myhuaweicloud.com/website-images/r1.7/resource/_static/logo_source.png)](https://gitee.com/mindspore/docs/blob/r1.7/tutorials/application/source_zh_cn/cv/resnet50.ipynb)\n",
    "\n",
    "图像分类是最基础的计算机视觉应用，属于有监督学习类别，如给定一张图像(猫、狗、飞机、汽车等等)，判断图像所属的类别。本章将介绍使用ResNet50网络对CIFAR-10数据集进行分类。\n",
    "\n",
    "## ResNet网络介绍\n",
    "\n",
    "ResNet50网络是2015年由微软实验室的何恺明提出，获得ILSVRC2015图像分类竞赛第一名。在ResNet网络提出之前，传统的卷积神经网络都是将一系列的卷积层和池化层堆叠得到的，但当网络堆叠到一定深度时，就会出现退化问题。下图是在CIFAR-10数据集上使用56层网络与20层网络训练误差和测试误差图，由图中数据可以看出，56层网络比20层网络训练误差和测试误差更大，随着网络的加深，其误差并没有如预想的一样减小。\n",
    "\n",
    "![resnet-1](https://mindspore-website.obs.cn-north-4.myhuaweicloud.com/website-images/r1.7/tutorials/application/source_zh_cn/cv/images/resnet_1.png)\n",
    "\n",
    "ResNet网络提出了残差网络结构(Residual Network)来减轻退化问题，使用ResNet网络可以实现搭建较深的网络结构（突破1000层）。论文中使用ResNet网络在CIFAR-10数据集上的训练误差与测试误差图如下图所示，图中虚线表示训练误差，实线表示测试误差。由图中数据可以看出，ResNet网络层数越深，其训练误差和测试误差越小。\n",
    "\n",
    "![resnet-4](https://mindspore-website.obs.cn-north-4.myhuaweicloud.com/website-images/r1.7/tutorials/application/source_zh_cn/cv/images/resnet_4.png)\n",
    "\n",
    "> 了解ResNet网络更多详细内容，参见[ResNet论文](https://arxiv.org/pdf/1512.03385.pdf)。\n",
    "\n",
    "## 数据集准备与加载\n",
    "\n",
    "[CIFAR-10数据集](http://www.cs.toronto.edu/~kriz/cifar.html)共有60000张32*32的彩色图像，分为10个类别，每类有6000张图，数据集一共有50000张训练图片和10000张评估图片。如下示例使用`mindvision.classification.dataset.Cifar10`接口下载并加载CIFAR-10数据集。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "1f9b81fb",
   "metadata": {},
   "outputs": [],
   "source": [
    "from mindvision.classification.dataset import Cifar10\n",
    "\n",
    "# 数据集根目录\n",
    "data_dir = \"./datasets\"\n",
    "\n",
    "# 下载解压并加载CIFAR-10训练数据集\n",
    "dataset_train = Cifar10(path=data_dir, split='train', batch_size=6, resize=32, download=True)\n",
    "ds_train = dataset_train.run()\n",
    "step_size = ds_train.get_dataset_size()\n",
    "# 下载解压并加载CIFAR-10测试数据集\n",
    "dataset_val = Cifar10(path=data_dir, split='test', batch_size=6, resize=32, download=True)\n",
    "ds_val = dataset_val.run()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "21e86f95",
   "metadata": {},
   "source": [
    "CIFAR-10数据集文件的目录结构如下：\n",
    "\n",
    "```Text\n",
    "datasets/\n",
    "├── cifar-10-batches-py\n",
    "│   ├── batches.meta\n",
    "│   ├── data_batch_1\n",
    "│   ├── data_batch_2\n",
    "│   ├── data_batch_3\n",
    "│   ├── data_batch_4\n",
    "│   ├── data_batch_5\n",
    "│   ├── readme.html\n",
    "│   └── test_batch\n",
    "└── cifar-10-python.tar.gz\n",
    "\n",
    "```\n",
    "\n",
    "对CIFAR-10训练数据集进行可视化。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "c3ffabb3",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Image shape: (6, 3, 32, 32), Label: [6 4 4 5 2 1]\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 6 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "\n",
    "data = next(ds_train.create_dict_iterator())\n",
    "\n",
    "images = data[\"image\"].asnumpy()\n",
    "labels = data[\"label\"].asnumpy()\n",
    "print(f\"Image shape: {images.shape}, Label: {labels}\")\n",
    "\n",
    "plt.figure()\n",
    "for i in range(1, 7):\n",
    "    plt.subplot(2, 3, i)\n",
    "    image_trans = np.transpose(images[i - 1], (1, 2, 0))\n",
    "    mean = np.array([0.4914, 0.4822, 0.4465])\n",
    "    std = np.array([0.2023, 0.1994, 0.2010])\n",
    "    image_trans = std * image_trans + mean\n",
    "    image_trans = np.clip(image_trans, 0, 1)\n",
    "    plt.title(f\"{dataset_train.index2label[labels[i - 1]]}\")\n",
    "    plt.imshow(image_trans)\n",
    "    plt.axis(\"off\")\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "76c96f76",
   "metadata": {},
   "source": [
    "## 构建网络\n",
    "\n",
    "残差网络结构(Residual Network)是ResNet网络的主要亮点，ResNet使用残差网络结构后可有效地减轻退化问题，实现更深的网络结构设计，提高网络的训练精度。本节首先讲述如何构建残差网络结构，然后通过堆叠残差网络来构建ResNet50网络。\n",
    "\n",
    "### 构建残差网络结构\n",
    "\n",
    "残差网络结构图如下图所示，残差网络由两个分支构成：一个主分支，一个shortcuts（图中弧线表示）。主分支通过堆叠一系列的卷积操作得到，shotcuts从输入直接到输出，主分支输出的特征矩阵$F(x)$加上shortcuts输出的特征矩阵$x$得到$F(x)+x$，通过Relu激活函数后即为残差网络最后的输出。\n",
    "\n",
    "![residual](https://mindspore-website.obs.cn-north-4.myhuaweicloud.com/website-images/r1.7/tutorials/application/source_zh_cn/cv/images/resnet_3.png)\n",
    "\n",
    "残差网络结构主要由两种，一种是Building Block，适用于较浅的ResNet网络，如ResNet18和ResNet34；另一种是Bottleneck，适用于层数较深的ResNet网络，如ResNet50、ResNet101和ResNet152。\n",
    "\n",
    "#### Building Block\n",
    "\n",
    "Building Block结构图如下图所示，主分支有两层卷积网络结构：\n",
    "\n",
    "+ 主分支第一层网络以输入channel为64为例，首先通过一个$3\\times3$的卷积层，然后通过Batch Normalization层，最后通过Relu激活函数层，输出channel为64；\n",
    "+ 主分支第二层网络的输入channel为64，首先通过一个$3\\times3$的卷积层，然后通过Batch Normalization层，输出channel为64。\n",
    "\n",
    "最后将主分支输出的特征矩阵与shortcuts输出的特征矩阵相加，通过Relu激活函数即为Building Block最后的输出。\n",
    "\n",
    "![building-block-5](https://mindspore-website.obs.cn-north-4.myhuaweicloud.com/website-images/r1.7/tutorials/application/source_zh_cn/cv/images/resnet_5.png)\n",
    "\n",
    "主分支与shortcuts输出的特征矩阵相加时，需要保证主分支与shortcuts输出的特征矩阵shape相同。如果主分支与shortcuts输出的特征矩阵shape不相同，如输出channel是输入channel的一倍时，shortcuts上需要使用数量与输出channel相等，大小为$1\\times1$的卷积核进行卷积操作；若输出的图像较输入图像缩小一倍，则要设置shortcuts中卷积操作中的`stride`为2，主分支第一层卷积操作的`stride`也需设置为2。\n",
    "\n",
    "如下代码定义`ResidualBlockBase`类实现Building Block结构。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "c7ac0e2d",
   "metadata": {},
   "outputs": [],
   "source": [
    "from typing import Type, Union, List, Optional\n",
    "from mindvision.classification.models.blocks import ConvNormActivation\n",
    "from mindspore import nn\n",
    "\n",
    "\n",
    "class ResidualBlockBase(nn.Cell):\n",
    "    expansion: int = 1  # 最后一个卷积核数量与第一个卷积核数量相等\n",
    "\n",
    "    def __init__(self, in_channel: int, out_channel: int,\n",
    "                 stride: int = 1, norm: Optional[nn.Cell] = None,\n",
    "                 down_sample: Optional[nn.Cell] = None) -> None:\n",
    "        super(ResidualBlockBase, self).__init__()\n",
    "        if not norm:\n",
    "            norm = nn.BatchNorm2d\n",
    "\n",
    "        self.conv1 = ConvNormActivation(in_channel, out_channel,\n",
    "                                        kernel_size=3, stride=stride, norm=norm)\n",
    "        self.conv2 = ConvNormActivation(out_channel, out_channel,\n",
    "                                        kernel_size=3, norm=norm, activation=None)\n",
    "        self.relu = nn.ReLU()\n",
    "        self.down_sample = down_sample\n",
    "\n",
    "    def construct(self, x):\n",
    "        \"\"\"ResidualBlockBase construct.\"\"\"\n",
    "        identity = x  # shortcuts分支\n",
    "\n",
    "        out = self.conv1(x)  # 主分支第一层：3*3卷积层\n",
    "        out = self.conv2(out)  # 主分支第二层：3*3卷积层\n",
    "\n",
    "        if self.down_sample:\n",
    "            identity = self.down_sample(x)\n",
    "        out += identity  # 输出为主分支与shortcuts之和\n",
    "        out = self.relu(out)\n",
    "\n",
    "        return out"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "aaa15d3c",
   "metadata": {},
   "source": [
    "#### Bottleneck\n",
    "\n",
    "Bottleneck结构图如下图所示，在输入相同的情况下Bottleneck结构相对Building Block结构的参数数量更少，更适合层数较深的网络，ResNet50使用的残差结构就是Bottleneck。该结构的主分支有三层卷积结构，分别为$1\\times1$的卷积层、$3\\times3$卷积层和$1\\times1$的卷积层，其中$1\\times1$的卷积层分别起降维和升维的作用。\n",
    "\n",
    "+ 主分支第一层网络以输入channel为256为例，首先通过数量为64，大小为$1\\times1$的卷积核进行降维，然后通过Batch Normalization层，最后通过Relu激活函数层，其输出channel为64；\n",
    "+ 主分支第二层网络通过数量为64，大小为$3\\times3$的卷积核提取特征，然后通过Batch Normalization层，最后通过Relu激活函数层，其输出channel为64；\n",
    "+ 主分支第三层通过数量为256，大小$1\\times1$的卷积核进行升维，然后通过Batch Normalization层，其输出channel为256。\n",
    "\n",
    "最后将主分支输出的特征矩阵与shortcuts输出的特征矩阵相加，通过Relu激活函数即为Bottleneck最后的输出。\n",
    "\n",
    "![building-block-6](https://mindspore-website.obs.cn-north-4.myhuaweicloud.com/website-images/r1.7/tutorials/application/source_zh_cn/cv/images/resnet_6.png)\n",
    "\n",
    "主分支与shortcuts输出的特征矩阵相加时，需要保证主分支与shortcuts输出的特征矩阵shape相同。如果主分支与shortcuts输出的特征矩阵shape不相同，如输出channel是输入channel的一倍时，shortcuts上需要使用数量与输出channel相等，大小为$1\\times1$的卷积核进行卷积操作；若输出的图像较输入图像缩小一倍，则要设置shortcuts中卷积操作中的`stride`为2，主分支第二层卷积操作的`stride`也需设置为2。\n",
    "\n",
    "如下代码定义`ResidualBlock`类实现Bottleneck结构。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "0d46f98e",
   "metadata": {},
   "outputs": [],
   "source": [
    "class ResidualBlock(nn.Cell):\n",
    "    expansion = 4  # 最后一个卷积核的数量是第一个卷积核数量的4倍\n",
    "\n",
    "    def __init__(self, in_channel: int, out_channel: int,\n",
    "                 stride: int = 1, norm: Optional[nn.Cell] = None,\n",
    "                 down_sample: Optional[nn.Cell] = None) -> None:\n",
    "        super(ResidualBlock, self).__init__()\n",
    "        if not norm:\n",
    "            norm = nn.BatchNorm2d\n",
    "\n",
    "        self.conv1 = ConvNormActivation(in_channel, out_channel,\n",
    "                                        kernel_size=1, norm=norm)\n",
    "        self.conv2 = ConvNormActivation(out_channel, out_channel,\n",
    "                                        kernel_size=3, stride=stride, norm=norm)\n",
    "        self.conv3 = ConvNormActivation(out_channel, out_channel * self.expansion,\n",
    "                                        kernel_size=1, norm=norm, activation=None)\n",
    "        self.relu = nn.ReLU()\n",
    "        self.down_sample = down_sample\n",
    "\n",
    "    def construct(self, x):\n",
    "        identity = x  # shortscuts分支\n",
    "\n",
    "        out = self.conv1(x)  # 主分支第一层：1*1卷积层\n",
    "        out = self.conv2(out)  # 主分支第二层：3*3卷积层\n",
    "        out = self.conv3(out)  # 主分支第三层：1*1卷积层\n",
    "\n",
    "        if self.down_sample:\n",
    "            identity = self.down_sample(x)\n",
    "\n",
    "        out += identity  # 输出为主分支与shortcuts之和\n",
    "        out = self.relu(out)\n",
    "\n",
    "        return out"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d1d8dfc9",
   "metadata": {},
   "source": [
    "#### 构建ResNet50网络\n",
    "\n",
    "ResNet网络层结构如下图所示，以输入彩色图像$224\\times224$为例，首先通过数量64，卷积核大小为$7\\times7$，stride为2的卷积层conv1，该层输出图片大小为$112\\times112$，输出channel为64；然后通过一个$3\\times3$的最大下采样池化层，该层输出图片大小为$56\\times56$，输出channel为64；再堆叠4个残差网络块（conv2_x、conv3_x、conv4_x和conv5_x），此时输出图片大小为$7\\times7$，输出channel为2048；最后通过一个平均池化层、全连接层和softmax，得到分类概率。\n",
    "\n",
    "![resnet-layer](https://mindspore-website.obs.cn-north-4.myhuaweicloud.com/website-images/r1.7/tutorials/application/source_zh_cn/cv/images/resnet_2.png)\n",
    "\n",
    "对于每个残差网络块，以ResNet50网络中的conv2_x为例，其由3个Bottleneck结构堆叠而成，每个Bottleneck输入的channel为64，输出channel为256。\n",
    "\n",
    "如下示例定义`make_layer`实现残差块的构建，其参数如下所示:\n",
    "\n",
    "+ `last_out_channel`：上一个残差网络输出的通道数。\n",
    "+ `block`：残差网络的类别，分别为`ResidualBlockBase`和`ResidualBlock`。\n",
    "+ `channel`：残差网络输入的通道数。\n",
    "+ `block_nums`：残差网络块堆叠的个数。\n",
    "+ `stride`：卷积移动的步幅。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "3dfa40a1",
   "metadata": {},
   "outputs": [],
   "source": [
    "def make_layer(last_out_channel, block: Type[Union[ResidualBlockBase, ResidualBlock]],\n",
    "               channel: int, block_nums: int, stride: int = 1):\n",
    "    down_sample = None  # shortcuts分支\n",
    "\n",
    "    if stride != 1 or last_out_channel != channel * block.expansion:\n",
    "        down_sample = ConvNormActivation(last_out_channel, channel * block.expansion,\n",
    "                                         kernel_size=1, stride=stride, norm=nn.BatchNorm2d, activation=None)\n",
    "\n",
    "    layers = []\n",
    "    layers.append(block(last_out_channel, channel, stride=stride, down_sample=down_sample, norm=nn.BatchNorm2d))\n",
    "\n",
    "    in_channel = channel * block.expansion\n",
    "    # 堆叠残差网络\n",
    "    for _ in range(1, block_nums):\n",
    "        layers.append(block(in_channel, channel, norm=nn.BatchNorm2d))\n",
    "\n",
    "    return nn.SequentialCell(layers)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "67dae353",
   "metadata": {},
   "source": [
    "ResNet50网络共有5个卷积结构，一个平均池化层，一个全连接层，以CIFAR-10数据集为例：\n",
    "\n",
    "+ **conv1**：输入图片大小为$32\\times32$，输入channel为3。首先经过一个卷积核数量为64，卷积核大小为$7\\times7$，stride为2的卷积层；然后通过一个Batch Normalization层；最后通过Reul激活函数。该层输出feature map大小为$16\\times16$，输出channel为64。\n",
    "+ **conv2_x**：输入feature map大小为$16\\times16$，输入channel为64。首先经过一个卷积核大小为$3\\times3$，stride为2的最大下采样池化操作；然后堆叠3个$[1\\times1，64；3\\times3，64；1\\times1，256]$结构的Bottleneck。该层输出feature map大小为$8\\times8$，输出channel为256。\n",
    "+ **conv3_x**：输入feature map大小为$8\\times8$，输入channel为256。该层堆叠4个[1×1，128；3×3，128；1×1，512]结构的Bottleneck。该层输出feature map大小为$4\\times4$，输出channel为512。\n",
    "+ **conv4_x**：输入feature map大小为$4\\times4$，输入channel为512。该层堆叠6个[1×1，256；3×3，256；1×1，1024]结构的Bottleneck。该层输出feature map大小为$2\\times2$，输出channel为1024。\n",
    "+ **conv5_x**：输入feature map大小为$2\\times2$，输入channel为1024。该层堆叠3个[1×1，512；3×3，512；1×1，2048]结构的Bottleneck。该层输出feature map大小为$1\\times1$，输出channel为2048。\n",
    "+ **average pool & fc**：输入channel为2048，输出channel为分类的类别数。\n",
    "\n",
    "如下示例代码实现ResNet50模型的构建，通过用调函数`resnet50`即可构建ResNet50模型，函数`resnet50`参数如下：\n",
    "\n",
    "+ `num_classes`：分类的类别数，默认类别数为1000。\n",
    "+ `pretrained`：下载对应的训练模型，并加载预训练模型中的参数到网络中。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "1ebef3d0",
   "metadata": {},
   "outputs": [],
   "source": [
    "from mindvision.classification.models.classifiers import BaseClassifier\n",
    "from mindvision.classification.models.head import DenseHead\n",
    "from mindvision.classification.models.neck import GlobalAvgPooling\n",
    "from mindvision.classification.utils.model_urls import model_urls\n",
    "from mindvision.utils.load_pretrained_model import LoadPretrainedModel\n",
    "\n",
    "\n",
    "class ResNet(nn.Cell):\n",
    "    def __init__(self, block: Type[Union[ResidualBlockBase, ResidualBlock]],\n",
    "                 layer_nums: List[int], norm: Optional[nn.Cell] = None) -> None:\n",
    "        super(ResNet, self).__init__()\n",
    "        if not norm:\n",
    "            norm = nn.BatchNorm2d\n",
    "        # 第一个卷积层，输入channel为3（彩色图像），输出channel为64\n",
    "        self.conv1 = ConvNormActivation(3, 64, kernel_size=7, stride=2, norm=norm)\n",
    "        # 最大池化层，缩小图片的尺寸\n",
    "        self.max_pool = nn.MaxPool2d(kernel_size=3, stride=2, pad_mode='same')\n",
    "        # 各个残差网络结构块定义，\n",
    "        self.layer1 = make_layer(64, block, 64, layer_nums[0])\n",
    "        self.layer2 = make_layer(64 * block.expansion, block, 128, layer_nums[1], stride=2)\n",
    "        self.layer3 = make_layer(128 * block.expansion, block, 256, layer_nums[2], stride=2)\n",
    "        self.layer4 = make_layer(256 * block.expansion, block, 512, layer_nums[3], stride=2)\n",
    "\n",
    "    def construct(self, x):\n",
    "        x = self.conv1(x)\n",
    "        x = self.max_pool(x)\n",
    "\n",
    "        x = self.layer1(x)\n",
    "        x = self.layer2(x)\n",
    "        x = self.layer3(x)\n",
    "        x = self.layer4(x)\n",
    "\n",
    "        return x\n",
    "\n",
    "\n",
    "def _resnet(arch: str, block: Type[Union[ResidualBlockBase, ResidualBlock]],\n",
    "            layers: List[int], num_classes: int, pretrained: bool, input_channel: int):\n",
    "    backbone = ResNet(block, layers)\n",
    "    neck = GlobalAvgPooling()  # 平均池化层\n",
    "    head = DenseHead(input_channel=input_channel, num_classes=num_classes)  # 全连接层\n",
    "    model = BaseClassifier(backbone, neck, head)  # 将backbone层、neck层和head层连接起来\n",
    "\n",
    "    if pretrained:\n",
    "        # 下载并加载预训练模型\n",
    "        LoadPretrainedModel(model, model_urls[arch]).run()\n",
    "\n",
    "    return model\n",
    "\n",
    "\n",
    "def resnet50(num_classes: int = 1000, pretrained: bool = False):\n",
    "    \"ResNet50模型\"\n",
    "    return _resnet(\"resnet50\", ResidualBlock, [3, 4, 6, 3], num_classes, pretrained, 2048)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d40bd05a",
   "metadata": {},
   "source": [
    "## 模型训练与评估\n",
    "\n",
    "本节使用[ResNet50预训练模型](https://download.mindspore.cn/vision/classification/resnet50_224.ckpt)进行微调。调用`resnet50`构造ResNet50模型，并设置`pretrained`参数为True，将会自动下载ResNet50预训练模型，并加载预训练模型中的参数到网络中。然后定义优化器和损失函数，通过`model.train`接口对网络进行训练，将MindSpore Vision中的`mindvision.engine.callback.ValAccMonitor`接口传入回调函数中，将会打印训练的损失值和评估精度，并保存评估精度最高的ckpt文件（best.ckpt）到当前目录下。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "9cf10c03",
   "metadata": {},
   "outputs": [],
   "source": [
    "from mindspore.train import Model\n",
    "from mindvision.engine.callback import ValAccMonitor\n",
    "\n",
    "# 定义ResNet50网络\n",
    "network = resnet50(pretrained=True)\n",
    "\n",
    "# 全连接层输入层的大小\n",
    "in_channel = network.head.dense.in_channels\n",
    "head = DenseHead(input_channel=in_channel, num_classes=10)\n",
    "# 重置全连接层\n",
    "network.head = head\n",
    "# 设置学习率\n",
    "num_epochs = 40\n",
    "lr = nn.cosine_decay_lr(min_lr=0.00001, max_lr=0.001, total_step=step_size * num_epochs,\n",
    "                        step_per_epoch=step_size, decay_epoch=num_epochs)\n",
    "# 定义优化器和损失函数\n",
    "opt = nn.Momentum(params=network.trainable_params(), learning_rate=lr, momentum=0.9)\n",
    "loss = nn.SoftmaxCrossEntropyWithLogits(sparse=True, reduction='mean')\n",
    "# 实例化模型\n",
    "model = Model(network, loss, opt, metrics={\"Accuracy\": nn.Accuracy()})\n",
    "# 模型训练\n",
    "model.train(num_epochs, ds_train, callbacks=[ValAccMonitor(model, ds_val, num_epochs)])"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6ca392ab",
   "metadata": {},
   "source": [
    "```Text\n",
    "--------------------\n",
    "Epoch: [  0 /  40], Train Loss: [2.733], Accuracy:  0.274\n",
    "--------------------\n",
    "Epoch: [  1 /  40], Train Loss: [2.877], Accuracy:  0.319\n",
    "--------------------\n",
    "Epoch: [  2 /  40], Train Loss: [2.438], Accuracy:  0.249\n",
    "--------------------\n",
    "Epoch: [  3 /  40], Train Loss: [1.532], Accuracy:  0.386\n",
    "\n",
    "······\n",
    "\n",
    "Epoch: [ 37 /  40], Train Loss: [1.142], Accuracy:  0.738\n",
    "--------------------\n",
    "Epoch: [ 38 /  40], Train Loss: [0.402], Accuracy:  0.727\n",
    "--------------------\n",
    "Epoch: [ 39 /  40], Train Loss: [2.031], Accuracy:  0.735\n",
    "--------------------\n",
    "Epoch: [ 40 /  40], Train Loss: [0.582], Accuracy:  0.745\n",
    "================================================================================\n",
    "End of validation the best Accuracy is:  0.754, save the best ckpt file in ./best.ckpt\n",
    "\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "46e28f6f",
   "metadata": {},
   "source": [
    "## 可视化模型预测\n",
    "\n",
    "定义`visualize_model`函数，使用上述验证精度最高的模型对CIFAR-10测试数据集进行预测，并将预测结果可视化。若预测字体颜色为蓝色表示为预测正确，预测字体颜色为红色则表示预测错误。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "6ba2fa94",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 6 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "import matplotlib.pyplot as plt\n",
    "from mindspore import Tensor\n",
    "from mindspore import load_checkpoint, load_param_into_net\n",
    "\n",
    "\n",
    "def visualize_model(best_ckpt_path, val_ds):\n",
    "    num_class = 10  # 对狼和狗图像进行二分类\n",
    "    net = resnet50(num_class)\n",
    "    # 加载模型参数\n",
    "    param_dict = load_checkpoint(best_ckpt_path)\n",
    "    load_param_into_net(net, param_dict)\n",
    "    model = Model(net)\n",
    "    # 加载验证集的数据进行验证\n",
    "    data = next(val_ds.create_dict_iterator())\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",
    "\n",
    "    # 显示图像及图像的预测值\n",
    "    plt.figure()\n",
    "    for i in range(1, 7):\n",
    "        plt.subplot(2, 3, i)\n",
    "        # 若预测正确，显示为蓝色；若预测错误，显示为红色\n",
    "        color = 'blue' if pred[i - 1] == labels[i - 1] else 'red'\n",
    "        plt.title('predict:{}'.format(dataset_val.index2label[pred[i - 1]]), color=color)\n",
    "        picture_show = np.transpose(images[i - 1], (1, 2, 0))\n",
    "        mean = np.array([0.4914, 0.4822, 0.4465])\n",
    "        std = np.array([0.2023, 0.1994, 0.2010])\n",
    "        picture_show = std * picture_show + mean\n",
    "        picture_show = np.clip(picture_show, 0, 1)\n",
    "        plt.imshow(picture_show)\n",
    "        plt.axis('off')\n",
    "\n",
    "    plt.show()\n",
    "\n",
    "# 使用测试数据集进行验证\n",
    "visualize_model('best.ckpt', ds_val)"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "MindSpore",
   "language": "python",
   "name": "mindspore"
  },
  "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.9.0"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}