diff --git a/application_example/maskrcnn/src/dataset/__init__.py b/application_example/maskrcnn/src/dataset/__init__.py deleted file mode 100644 index e69de29bb2d1d6434b8b29ae775ad8c2e48c5391..0000000000000000000000000000000000000000 diff --git a/application_example/maskrcnn/src/datasets.md b/application_example/maskrcnn/src/datasets.md new file mode 100644 index 0000000000000000000000000000000000000000..bc300a2a659d274da454f15fa4f1f365f49eb2cf --- /dev/null +++ b/application_example/maskrcnn/src/datasets.md @@ -0,0 +1,7 @@ +. +└─cocodataset + ├─annotations + ├─instance_train2017.json + └─instance_val2017.json + ├─val2017 + └─train2017 diff --git a/application_example/maskrcnn/src/eval.py b/application_example/maskrcnn/src/eval.py index e5a7f9a7b0e53e8f28c53e5f3fe4d9b013de0b07..8afaead1229b35d4ce39345fa9780e6a4551e635 100644 --- a/application_example/maskrcnn/src/eval.py +++ b/application_example/maskrcnn/src/eval.py @@ -23,10 +23,10 @@ from mindspore import context, Tensor from mindspore.train.serialization import load_checkpoint, load_param_into_net from mindspore.common import set_seed +from utils.config import config from model.mask_rcnn_r50 import MaskRcnnResnet50 # when use maskrcnn mobilenetv1, just change the following backbone # from mask_rcnn_mobilenetv1 -from utils.config import config from utils.util import coco_eval, bbox2result_1image, results2json, get_seg_masks from dataset.dataset import data_to_mindrecord_byte_image, create_coco_dataset diff --git a/application_example/maskrcnn/src/images/framework.png b/application_example/maskrcnn/src/images/framework.png new file mode 100644 index 0000000000000000000000000000000000000000..c3cd10ba7b68be5a85d6fe16059c4df733ecb204 Binary files /dev/null and b/application_example/maskrcnn/src/images/framework.png differ diff --git a/application_example/maskrcnn/src/images/infer.png b/application_example/maskrcnn/src/images/infer.png new file mode 100644 index 0000000000000000000000000000000000000000..6d4a7e758ca9e84366f1e68eca8730c9d70d5e0d Binary files /dev/null and b/application_example/maskrcnn/src/images/infer.png differ diff --git a/application_example/maskrcnn/src/images/mobilenetv1.png b/application_example/maskrcnn/src/images/mobilenetv1.png new file mode 100644 index 0000000000000000000000000000000000000000..dccdafac99d892149bcf481f1d204f0e9daafefa Binary files /dev/null and b/application_example/maskrcnn/src/images/mobilenetv1.png differ diff --git a/application_example/maskrcnn/src/images/resnet_block.png b/application_example/maskrcnn/src/images/resnet_block.png new file mode 100644 index 0000000000000000000000000000000000000000..35d8ba8bdac9431e7f78e252979c6e822eea4522 Binary files /dev/null and b/application_example/maskrcnn/src/images/resnet_block.png differ diff --git a/application_example/maskrcnn/src/images/roi_align.png b/application_example/maskrcnn/src/images/roi_align.png new file mode 100644 index 0000000000000000000000000000000000000000..9a1ae73bb2feac22c9dc5c43c9392f4a8e4492ff Binary files /dev/null and b/application_example/maskrcnn/src/images/roi_align.png differ diff --git a/application_example/maskrcnn/src/infer.py b/application_example/maskrcnn/src/infer.py index 3f4fc70660e8edadf5f099a83b70512636b02294..e916f62bb528aece3b57787174de6a8cd2b8dbc8 100644 --- a/application_example/maskrcnn/src/infer.py +++ b/application_example/maskrcnn/src/infer.py @@ -27,10 +27,10 @@ from mindspore import context, Tensor from mindspore.train.serialization import load_checkpoint, load_param_into_net from mindspore.common import set_seed +from utils.config import config # when use maskrcnn mobilenetv1, just change the following backbone # from mask_rcnn_mobilenetv1 from model.mask_rcnn_r50 import MaskRcnnResnet50 -from utils.config import config from dataset.dataset import create_coco_dataset set_seed(1) diff --git a/application_example/maskrcnn/src/maskrcnn.ipynb b/application_example/maskrcnn/src/maskrcnn.ipynb new file mode 100644 index 0000000000000000000000000000000000000000..cceabf2cb109d9c2326e3619492c3df5699dbad5 --- /dev/null +++ b/application_example/maskrcnn/src/maskrcnn.ipynb @@ -0,0 +1,3788 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Mask R-CNN\n", + "\n", + "MaskRCNN是一种概念简单、灵活、通用的目标实例分割框架，在检测出图像中目标的同时，还为每一个实例生成高质量掩码。这种称为Mask R-CNN的方法，通过添加与现有边框检测分支平行的预测目标掩码分支，达到扩展Faster R-CNN的目的。Mask R-CNN训练简单，运行速度达5fps，与Faster R-CNN相比，开销只有小幅上涨。此外，Mask R-CNN易于推广到其他任务。例如，允许在同一框架中预测人体姿势。 Mask R-CNN在COCO挑战赛的三个关键难点上都表现不俗，包括实例分割、边框目标检测和人物关键点检测。Mask R-CNN没有什么华而不实的附加功能，各任务的表现都优于现存所有单模型，包括COCO 2016挑战赛的胜出模型。\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 模型简介\n", + "\n", + "MaskRCNN是一个两级目标检测网络，作为FasterRCNN的扩展模型，在现有的边框检测分支的基础上增加了一个预测目标掩码的分支。该网络采用区域候选网络（RPN），可与检测网络共享整个图像\n", + "的卷积特征，无需任何代价就可轻松计算候选区域。整个网络通过共享卷积特征，将RPN和掩码分支合并为一个网络。其模型骨干还可以选择轻量级网络Mobilenet。\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 官方库和第三方库的导入\n", + "\n", + "我们首先导入案例依赖的官方库和第三方库。" + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "metadata": {}, + "outputs": [], + "source": [ + "import time\n", + "import os\n", + "\n", + "import numpy as np\n", + "import mindspore.nn as nn\n", + "import mindspore.common.dtype as mstype\n", + "from mindspore.ops import operations as P\n", + "from mindspore.ops import functional as F\n", + "from mindspore.ops import composite as C\n", + "from mindspore.nn import layer as L\n", + "from mindspore.common.initializer import initializer\n", + "from mindspore import context, Tensor, Parameter\n", + "from mindspore import ParameterTuple\n", + "from mindspore.train.callback import Callback\n", + "from mindspore.nn.wrap.grad_reducer import DistributedGradReducer\n", + "from mindspore.train.callback import CheckpointConfig, ModelCheckpoint, TimeMonitor\n", + "from mindspore.train import Model\n", + "from mindspore.train.serialization import load_checkpoint, load_param_into_net\n", + "from mindspore.nn import Momentum\n", + "from mindspore.common import set_seed\n", + "\n", + "from utils.config import config" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 数据处理\n", + "\n", + "开始实验之前，请确保本地已经安装了Python环境并安装了MindSpore Vision套件。\n", + "\n", + "### 数据准备\n", + "\n", + "COCO2017是一个广泛应用的数据集，带有边框和像素级背景注释。这些注释可用于场景理解任务，如语义分割，目标检测和图像字幕制作。训练和评估的图像大小为118K和5K。\n", + "\n", + "数据集大小：19G\n", + "\n", + "训练：18G，118,000个图像\n", + "\n", + "评估：1G，5000个图像\n", + "\n", + "注释：241M；包括实例、字幕、人物关键点等\n", + "\n", + "数据格式：图像及JSON文件\n", + "\n", + "注：数据在dataset.py中处理。\n", + "\n", + "首先，你需要下载 coco2017 数据集。\n", + "\n", + "下载完成后，确保你的数据集存放符合如下路径。" + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + ".\n", + "└─cocodataset\n", + " ├─annotations\n", + " ├─instance_train2017.json\n", + " └─instance_val2017.json\n", + " ├─val2017\n", + " └─train2017" + ] + } + ], + "source": [ + "!cat datasets.md" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### 数据预处理\n", + "\n", + "原始数据集中图像大小不一致，不方便统一读取和检测。我们首先统一图像大小。数据的注释信息保存在json文件中，我们需要读取出来给图像数据加label。" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### 数据增强\n", + "\n", + "在你开始训练模型之前。数据增强对于您的数据集以及创建训练数据和测试数据是必要的。对于coco数据集，你可以使用dataset.py为图像添加label，并将它们转换到MindRecord。MindRecord是一种MindSpore指定的数据格式，可以在某些场景下优化MindSpore的性能。" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "首先，我们创建MindRecord数据集保存和读取的地址。" + ] + }, + { + "cell_type": "code", + "execution_count": 20, + "metadata": {}, + "outputs": [], + "source": [ + "from dataset.dataset import create_coco_dataset, data_to_mindrecord_byte_image\n", + "\n", + "def create_mindrecord_dir(prefix, mindrecord_dir):\n", + " \"\"\"Create MindRecord Direction.\"\"\"\n", + " if not os.path.isdir(mindrecord_dir):\n", + " os.makedirs(mindrecord_dir)\n", + " if config.dataset == \"coco\":\n", + " if os.path.isdir(config.data_root):\n", + " print(\"Create Mindrecord.\")\n", + " data_to_mindrecord_byte_image(\"coco\", True, prefix)\n", + " print(\"Create Mindrecord Done, at {}\".format(mindrecord_dir))\n", + " else:\n", + " raise Exception(\"coco_root not exits.\")\n", + " else:\n", + " if os.path.isdir(config.IMAGE_DIR) and os.path.exists(config.ANNO_PATH):\n", + " print(\"Create Mindrecord.\")\n", + " data_to_mindrecord_byte_image(\"other\", True, prefix)\n", + " print(\"Create Mindrecord Done, at {}\".format(mindrecord_dir))\n", + " else:\n", + " raise Exception(\"IMAGE_DIR or ANNO_PATH not exits.\")\n", + " while not os.path.exists(mindrecord_file+\".db\"):\n", + " time.sleep(5)\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "然后，加载数据集，调用dataset.py中的create_coco_dataset函数完成数据预处理和数据增强。" + ] + }, + { + "cell_type": "code", + "execution_count": 21, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Start create dataset!\n", + "total images num: 51790\n", + "Create dataset done!\n" + ] + } + ], + "source": [ + "# Allocating memory Environment\n", + "device_target = config.device_target\n", + "rank = 0\n", + "device_num = 1\n", + "context.set_context(mode=context.GRAPH_MODE, device_target=device_target)\n", + "\n", + "print(\"Start create dataset!\")\n", + "# Call the interface for data processing\n", + "# It will generate mindrecord file in config.mindrecord_dir,\n", + "# and the file name is MaskRcnn.mindrecord0, 1, ... file_num.\n", + "prefix = \"MaskRcnn.mindrecord\"\n", + "mindrecord_dir = config.mindrecord_dir\n", + "mindrecord_file = os.path.join(mindrecord_dir, prefix + \"0\")\n", + "if rank == 0 and not os.path.exists(mindrecord_file):\n", + " create_mindrecord_dir(prefix, mindrecord_dir)\n", + "# When create MindDataset, using the fitst mindrecord file,\n", + "# such as MaskRcnn.mindrecord0.\n", + "dataset = create_coco_dataset(mindrecord_file, batch_size=config.batch_size, device_num=device_num, rank_id=rank)\n", + "dataset_size = dataset.get_dataset_size()\n", + "print(\"total images num: \", dataset_size)\n", + "print(\"Create dataset done!\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### 数据集可视化\n", + "\n", + "运行以下代码观察数据增强后的图片。可以发现图片经过了旋转处理，并且图片的shape也已经转换为待输入网络的（N，C，H，W）格式，其中N代表样本数量，C代表图片通道，H和W代表图片的高和宽。" + ] + }, + { + "cell_type": "code", + "execution_count": 22, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Image shape: (2, 3, 768, 1280)\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "import numpy as np\n", + "import matplotlib.pyplot as plt\n", + "\n", + "show_data = next(dataset.create_dict_iterator())\n", + "\n", + "show_images = show_data[\"image\"].asnumpy()\n", + "print(f'Image shape: {show_images.shape}')\n", + "\n", + "plt.figure()\n", + "\n", + "# 展示2张图片供参考\n", + "for i in range(1, 3):\n", + " plt.subplot(1, 2, i)\n", + "\n", + " # 将图片转换HWC格式\n", + " image_trans = np.transpose(show_images[i - 1], (1, 2, 0))\n", + " image_trans = np.clip(image_trans, 0, 1)\n", + "\n", + " plt.imshow(image_trans[:, :], cmap=None)\n", + " plt.xticks(rotation=180)\n", + " plt.axis(\"off\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 构建网络\n", + "\n", + "![image1](images/framework.png)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "前文提到Mask RCNN的模型骨干采用ResNet50（原文），通过添加与现有边框检测分支平行的预测目标掩模分支实现扩展Faster R-CNN，完成目标检测。" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### 骨干网络\n", + "\n", + "Mask R-CNN骨干网络的选择：ResNet, VGG, Mobilenet等。本项目中，使用了对ResNet为骨干的Mask RCNN进行了框架迁移。以及扩展了Mobilenet这种轻量级网络。\n", + "\n", + "骨干网络：" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "1. Resnet（Deep residual network, ResNet），深度残差神经网络，卷积神经网络历史在具有划时代意义的神经网络。与Alexnet和VGG不同的是，网络结构上就有很大的改变，在大家为了提升卷积神经网络的性能在不断提升网络深度的时候，大家发现随着网络深度的提升，网络的效果变得越来越差，甚至出现了网络的退化问题，80层的网络比30层的效果还差，深度网络存在的梯度消失和爆炸问题越来越严重，这使得训练一个优异的深度学习模型变得更加艰难，在这种情况下，网络残差模块可以有效消除梯度消失和梯度爆炸问题。\n", + "\n", + "![image2](images/resnet_block.png)\n", + "\n", + "2. Mobilenetv1是一种轻量级的深度卷积网络，MobileNet的基本单元是深度级可分离卷积（depthwise separable convolution），将标准卷积分成两步。第一步 Depthwise convolution（DW）,也即逐通道的卷积，一个卷积核负责一个通道，一个通道只被一个卷积核“滤波”，则卷积核个数和通道数个数相同；第二步，Pointwise convolution（PW），将depthwise convolution得到的结果通过1x1卷积，再“串”起来。这样其实整体效果和一个标准卷积是差不多的，但是会大大减少计算量和模型参数量。其网络结构如下。\n", + "\n", + "![image3](images/mobilenetv1.png)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "原文中，使用Resnet为骨干网络。这里，我们也选择Resnet50作为骨干网络执行案例。" + ] + }, + { + "cell_type": "code", + "execution_count": 23, + "metadata": {}, + "outputs": [], + "source": [ + "import numpy as np\n", + "import mindspore.nn as nn\n", + "import mindspore.common.dtype as mstype\n", + "from mindspore.ops import operations as P\n", + "from mindspore.common.tensor import Tensor\n", + "from mindspore.ops import functional as F\n", + "\n", + "\n", + "ms_cast_type = mstype.float32\n", + "\n", + "\n", + "def weight_init_ones(shape):\n", + " \"\"\"\n", + " Weight init.\n", + "\n", + " Args:\n", + " shape(List): weights shape.\n", + "\n", + " Returns:\n", + " Tensor, weights, default float32.\n", + " \"\"\"\n", + " return Tensor(np.array(np.ones(shape).astype(np.float32) * 0.01).astype(np.float32))\n", + "\n", + "\n", + "def _conv(in_channels, out_channels, kernel_size=3, stride=1, padding=0, pad_mode='pad'):\n", + " \"\"\"\n", + " Conv2D wrapper.\n", + "\n", + " Args:\n", + " in_channels (int): The channel number of the input tensor of the Conv2d layer.\n", + " out_channels (int): The channel number of the output tensor of the Conv2d layer.\n", + " kernel_size (Union[int, tuple[int]]): Specifies the height and width of the 2D convolution kernel.\n", + " The data type is an integer or a tuple of two integers. An integer represents the height\n", + " and width of the convolution kernel. A tuple of two integers represents the height\n", + " and width of the convolution kernel respectively. Default: 3.\n", + " stride (Union[int, tuple[int]]): The movement stride of the 2D convolution kernel.\n", + " The data type is an integer or a tuple of two integers. An integer represents the movement step size\n", + " in both height and width directions. A tuple of two integers represents the movement step size in the height\n", + " and width directions respectively. Default: 1.\n", + " padding (Union[int, tuple[int]]): The number of padding on the height and width directions of the input.\n", + " The data type is an integer or a tuple of four integers. If `padding` is an integer,\n", + " then the top, bottom, left, and right padding are all equal to `padding`.\n", + " If `padding` is a tuple of 4 integers, then the top, bottom, left, and right padding\n", + " is equal to `padding[0]`, `padding[1]`, `padding[2]`, and `padding[3]` respectively.\n", + " The value should be greater than or equal to 0. Default: 0.\n", + " pad_mode (str): Specifies padding mode. The optional values are\n", + " \"same\", \"valid\", \"pad\". Default: \"pad\".\n", + "\n", + " Outputs:\n", + " Tensor, math '(N, C_{out}, H_{out}, W_{out})' or math '(N, H_{out}, W_{out}, C_{out})'.\n", + " \"\"\"\n", + " shape = (out_channels, in_channels, kernel_size, kernel_size)\n", + " weights = weight_init_ones(shape)\n", + " return nn.Conv2d(in_channels, out_channels,\n", + " kernel_size=kernel_size, stride=stride, padding=padding,\n", + " pad_mode=pad_mode, weight_init=weights, has_bias=False).to_float(ms_cast_type)\n", + "\n", + "\n", + "def _batch_norm2d_init(out_chls, momentum=0.1, affine=True, use_batch_statistics=True):\n", + " \"\"\"\n", + " Batchnorm2D wrapper.\n", + "\n", + " Args:\n", + " out_cls (int): The number of channels of the input tensor. Expected input size is (N, C, H, W),\n", + " `C` represents the number of channels\n", + " momentum (float): A floating hyperparameter of the momentum for the\n", + " running_mean and running_var computation. Default: 0.1.\n", + " affine (bool): A bool value. When set to True, gamma and beta can be learned. Default: True.\n", + " use_batch_statistics (bool):\n", + "\n", + " - If true, use the mean value and variance value of current batch data and track running mean\n", + " and running variance. Default: True.\n", + " - If false, use the mean value and variance value of specified value, and not track statistical value.\n", + " - If None, the use_batch_statistics is automatically set to true or false according to the training\n", + " and evaluation mode. During training, the parameter is set to true, and during evaluation, the\n", + " parameter is set to false.\n", + " Outputs:\n", + " Tensor, the normalized, scaled, offset tensor, of shape :math:'(N, C_{out}, H_{out}, W_{out})'.\n", + " \"\"\"\n", + " gamma_init = Tensor(np.array(np.ones(out_chls)).astype(np.float32))\n", + " beta_init = Tensor(np.array(np.ones(out_chls) * 0).astype(np.float32))\n", + " moving_mean_init = Tensor(np.array(np.ones(out_chls) * 0).astype(np.float32))\n", + " moving_var_init = Tensor(np.array(np.ones(out_chls)).astype(np.float32))\n", + "\n", + " return nn.BatchNorm2d(out_chls, momentum=momentum, affine=affine, gamma_init=gamma_init,\n", + " beta_init=beta_init, moving_mean_init=moving_mean_init,\n", + " moving_var_init=moving_var_init,\n", + " use_batch_statistics=use_batch_statistics)\n", + "\n", + "\n", + "class ResNetFea(nn.Cell):\n", + " \"\"\"\n", + " ResNet architecture.\n", + "\n", + " Args:\n", + " block (Cell): Block for network.\n", + " layer_nums (list): Numbers of block in different layers.\n", + " in_channels (list): Input channel in each layer.\n", + " out_channels (list): Output channel in each layer.\n", + " weights_update (bool): Weight update flag.\n", + "\n", + " Inputs:\n", + " - **x** (Cell) - Input block.\n", + "\n", + " Outputs:\n", + " Cell, output block.\n", + "\n", + " Support Plarforms:\n", + " ``Ascend`` ``CPU`` ``GPU``\n", + "\n", + " Examples:\n", + " >>> ResNetFea(ResidualBlockUsing, [3, 4, 6, 3], [64, 256, 512, 1024], [256, 512, 1024, 2048], False)\n", + " \"\"\"\n", + " def __init__(self, block, layer_nums, in_channels, out_channels, weights_update=False):\n", + " super(ResNetFea, self).__init__()\n", + "\n", + " if not len(layer_nums) == len(in_channels) == len(out_channels) == 4:\n", + " raise ValueError(\"the length of \"\n", + " \"layer_num, inchannel, outchannel list must be 4!\")\n", + "\n", + " bn_training = False\n", + " self.conv1 = _conv(3, 64, kernel_size=7, stride=2, padding=3, pad_mode='pad')\n", + " self.bn1 = _batch_norm2d_init(64, affine=bn_training, use_batch_statistics=bn_training)\n", + " self.relu = P.ReLU()\n", + " self.maxpool = P.MaxPool(kernel_size=3, strides=2, pad_mode=\"SAME\")\n", + " self.weights_update = weights_update\n", + "\n", + " if not self.weights_update:\n", + " self.conv1.weight.requires_grad = False\n", + "\n", + " self.layer1 = self._make_layer(block, layer_nums[0], in_channel=in_channels[0],\n", + " out_channel=out_channels[0], stride=1, training=bn_training,\n", + " weights_update=self.weights_update)\n", + " self.layer2 = self._make_layer(block, layer_nums[1], in_channel=in_channels[1],\n", + " out_channel=out_channels[1], stride=2,\n", + " training=bn_training, weights_update=True)\n", + " self.layer3 = self._make_layer(block, layer_nums[2], in_channel=in_channels[2],\n", + " out_channel=out_channels[2], stride=2,\n", + " training=bn_training, weights_update=True)\n", + " self.layer4 = self._make_layer(block, layer_nums[3], in_channel=in_channels[3],\n", + " out_channel=out_channels[3], stride=2,\n", + " training=bn_training, weights_update=True)\n", + "\n", + " def _make_layer(self, block, layer_num, in_channel, out_channel, stride, training=False, weights_update=False):\n", + " \"\"\"\n", + " Make layer for resnet backbone.\n", + "\n", + " Args:\n", + " block (Cell): ResNet block.\n", + " layer_num (int): Layer number.\n", + " in_channel (int): Input channel.\n", + " out_channel (int): Output channel.\n", + " stride (int): Stride size for convolutional layer.\n", + " training(bool): Whether to do training. Default: False.\n", + " weights_update(bool): Whether to update weights. Default: False.\n", + "\n", + " Returns:\n", + " SequentialCell, Combine several layers toghter.\n", + "\n", + " Examples:\n", + " >>> _make_layer(InvertedResidual, 4, 64, 64, 1)\n", + " \"\"\"\n", + " layers = []\n", + " down_sample = False\n", + " if stride != 1 or in_channel != out_channel:\n", + " down_sample = True\n", + " resblk = block(in_channel, out_channel, stride=stride, down_sample=down_sample,\n", + " training=training, weights_update=weights_update)\n", + " layers.append(resblk)\n", + "\n", + " for _ in range(1, layer_num):\n", + " resblk = block(out_channel, out_channel, stride=1, training=training, weights_update=weights_update)\n", + " layers.append(resblk)\n", + "\n", + " return nn.SequentialCell(layers)\n", + "\n", + " def construct(self, x):\n", + " \"\"\"Construct ResNet architecture.\"\"\"\n", + " x = self.conv1(x)\n", + " x = self.bn1(x)\n", + " x = self.relu(x)\n", + " c1 = self.maxpool(x)\n", + "\n", + " c2 = self.layer1(c1)\n", + " identity = c2\n", + " if not self.weights_update:\n", + " identity = F.stop_gradient(c2)\n", + " c3 = self.layer2(identity)\n", + " c4 = self.layer3(c3)\n", + " c5 = self.layer4(c4)\n", + "\n", + " return identity, c3, c4, c5\n", + "\n", + "\n", + "class ResidualBlockUsing(nn.Cell):\n", + " \"\"\"\n", + " ResNet V1 residual block definition.\n", + "\n", + " Args:\n", + " in_channels (int): Input channel.\n", + " out_channels (int): Output channel.\n", + " stride (int): Stride size for the initial convolutional layer. Default: 1.\n", + " down_sample (bool): If to do the downsample in block. Default: False.\n", + " momentum (float): Momentum for batchnorm layer. Default: 0.1.\n", + " training (bool): Training flag. Default: False.\n", + " weights_updata (bool): Weights update flag. Default: False.\n", + "\n", + " Inputs:\n", + " - **x** (Cell) - Input block.\n", + "\n", + " Outputs:\n", + " Cell, output block.\n", + "\n", + " Support Plarforms:\n", + " ``Ascend`` ``CPU`` ``GPU``\n", + "\n", + " Examples:\n", + " ResidualBlockUsing(3, 256, stride=2, down_sample=True)\n", + " \"\"\"\n", + " expansion = 4\n", + "\n", + " def __init__(self, in_channels, out_channels, stride=1, down_sample=False,\n", + " momentum=0.1, training=False, weights_update=False):\n", + " super(ResidualBlockUsing, self).__init__()\n", + "\n", + " self.affine = weights_update\n", + "\n", + " out_chls = out_channels // self.expansion\n", + " self.conv1 = _conv(in_channels, out_chls, kernel_size=1, stride=1, padding=0)\n", + " self.bn1 = _batch_norm2d_init(out_chls, momentum=momentum, affine=self.affine, use_batch_statistics=training)\n", + "\n", + " self.conv2 = _conv(out_chls, out_chls, kernel_size=3, stride=stride, padding=1)\n", + " self.bn2 = _batch_norm2d_init(out_chls, momentum=momentum, affine=self.affine, use_batch_statistics=training)\n", + "\n", + " self.conv3 = _conv(out_chls, out_channels, kernel_size=1, stride=1, padding=0)\n", + " self.bn3 = _batch_norm2d_init(out_channels, momentum=momentum, affine=self.affine,\n", + " use_batch_statistics=training)\n", + "\n", + " if training:\n", + " self.bn1 = self.bn1.set_train()\n", + " self.bn2 = self.bn2.set_train()\n", + " self.bn3 = self.bn3.set_train()\n", + "\n", + " if not weights_update:\n", + " self.conv1.weight.requires_grad = False\n", + " self.conv2.weight.requires_grad = False\n", + " self.conv3.weight.requires_grad = False\n", + "\n", + " self.relu = P.ReLU()\n", + " self.downsample = down_sample\n", + " if self.downsample:\n", + " self.conv_down_sample = _conv(in_channels, out_channels, kernel_size=1, stride=stride, padding=0)\n", + " self.bn_down_sample = _batch_norm2d_init(out_channels, momentum=momentum, affine=self.affine,\n", + " use_batch_statistics=training)\n", + " if training:\n", + " self.bn_down_sample = self.bn_down_sample.set_train()\n", + " if not weights_update:\n", + " self.conv_down_sample.weight.requires_grad = False\n", + " self.add = P.Add()\n", + "\n", + " def construct(self, x):\n", + " \"\"\"Construct ResNet V1 residual block.\"\"\"\n", + " identity = x\n", + "\n", + " out = self.conv1(x)\n", + " out = self.bn1(out)\n", + " out = self.relu(out)\n", + "\n", + " out = self.conv2(out)\n", + " out = self.bn2(out)\n", + " out = self.relu(out)\n", + "\n", + " out = self.conv3(out)\n", + " out = self.bn3(out)\n", + "\n", + " if self.downsample:\n", + " identity = self.conv_down_sample(identity)\n", + " identity = self.bn_down_sample(identity)\n", + "\n", + " out = self.add(out, identity)\n", + " out = self.relu(out)\n", + "\n", + " return out" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### FPN网络\n", + "\n", + "FPN网络（Feature Pyramid Network）同时利用低层特征高分辨率和高层特征的高语义信息，通过融合这些不同层的特征达到预测的效果。并且预测是在每个融合后的特征层上单独进行的，这和常规的特征融合方式不同。\n", + "\n", + "骨干网络和FPN网络结合构成了Mask RCNN网络的卷积层。" + ] + }, + { + "cell_type": "code", + "execution_count": 24, + "metadata": {}, + "outputs": [], + "source": [ + "def bias_init_zeros(shape):\n", + " \"\"\"Bias init method.\"\"\"\n", + " result = Tensor(np.array(np.zeros(shape).astype(np.float32)), dtype=mstype.float32)\n", + " return result\n", + "\n", + "\n", + "def _conv(in_channels, out_channels, kernel_size=3, stride=1, padding=0, pad_mode='pad'):\n", + " \"\"\"\n", + " Conv2D wrapper.\n", + "\n", + " Args:\n", + " in_channels(int): Input channel num.\n", + " out_channels(int): Output channel num.\n", + " kernel_size(int): Kernel size. Default: 1.\n", + " stride(int): Stride. Default: 1.\n", + " padding(int): Padding range. Default: 0.\n", + " pad_mode(bool): Padding model. Default: 'pad'.\n", + " gain(int): Gain. Default: 1.\n", + "\n", + " Returns:\n", + " Tensor, Convoluted result.\n", + " \"\"\"\n", + " shape = (out_channels, in_channels, kernel_size, kernel_size)\n", + " weights = initializer(\"XavierUniform\", shape=shape, dtype=mstype.float32)\n", + " shape_bias = (out_channels,)\n", + " biass = bias_init_zeros(shape_bias)\n", + " return nn.Conv2d(in_channels, out_channels, kernel_size=kernel_size, stride=stride, padding=padding,\n", + " pad_mode=pad_mode, weight_init=weights, has_bias=True, bias_init=biass)\n", + "\n", + "\n", + "class FeatPyramidNeck(nn.Cell):\n", + " \"\"\"\n", + " Feature pyramid network cell, usually uses as network neck.\n", + "\n", + " Applies the convolution on multiple, input feature maps\n", + " and output feature map with same channel size. if required num of\n", + " output larger then num of inputs, add extra maxpooling for further\n", + " downsampling;\n", + "\n", + " Args:\n", + " in_channels (tuple): Channel size of input feature maps.\n", + " out_channels (int): Channel size output.\n", + " num_outs (int): Num of output features.\n", + " Inputs:\n", + " - **x** (Tensor) - Input variant\n", + "\n", + " Outputs:\n", + " Tuple, with tensors of same channel size.\n", + "\n", + " Support Platform:\n", + " ``Ascend`` ``CPU`` ``GPU``\n", + "\n", + " Examples:\n", + " >>> neck = FeatPyramidNeck([100,200,300], 50, 4)\n", + " >>> input_data = (normal(0,0.1,(1,c,1280//(4*2**i), 768//(4*2**i)),\n", + " ... dtype=np.float32) for i, c in enumerate(config.fpn_in_channels))\n", + " >>> out = neck(input_data)\n", + " \"\"\"\n", + "\n", + " def __init__(self,\n", + " in_channels,\n", + " out_channels,\n", + " num_outs):\n", + " super(FeatPyramidNeck, self).__init__()\n", + "\n", + " self.cast_type = mstype.float32\n", + "\n", + " self.num_outs = num_outs\n", + " self.in_channels = in_channels\n", + " self.fpn_layer = len(self.in_channels)\n", + "\n", + " assert not self.num_outs < len(in_channels)\n", + "\n", + " self.lateral_convs_list_ = []\n", + " self.fpn_convs_ = []\n", + "\n", + " for _, channel in enumerate(in_channels):\n", + " l_conv = _conv(channel, out_channels, kernel_size=1, stride=1, padding=0,\n", + " pad_mode='valid').to_float(self.cast_type)\n", + " fpn_conv = _conv(out_channels, out_channels, kernel_size=3, stride=1, padding=0,\n", + " pad_mode='same').to_float(self.cast_type)\n", + " self.lateral_convs_list_.append(l_conv)\n", + " self.fpn_convs_.append(fpn_conv)\n", + " self.lateral_convs_list = nn.layer.CellList(self.lateral_convs_list_)\n", + " self.fpn_convs_list = nn.layer.CellList(self.fpn_convs_)\n", + " self.interpolate1 = P.ResizeBilinear((48, 80))\n", + " self.interpolate2 = P.ResizeBilinear((96, 160))\n", + " self.interpolate3 = P.ResizeBilinear((192, 320))\n", + " self.cast = P.Cast()\n", + " self.maxpool = P.MaxPool(kernel_size=1, strides=2, pad_mode=\"same\")\n", + "\n", + " def construct(self, inputs):\n", + " \"\"\"construction of Feature Pyramid Neck.\"\"\"\n", + " layers = ()\n", + " for i in range(self.fpn_layer):\n", + " layers += (self.lateral_convs_list[i](inputs[i]),)\n", + "\n", + " cast_layers = (layers[3],)\n", + " cast_layers = \\\n", + " cast_layers + (layers[2] + self.cast(self.interpolate1(cast_layers[self.fpn_layer - 4]), self.cast_type),)\n", + " cast_layers = \\\n", + " cast_layers + (layers[1] + self.cast(self.interpolate2(cast_layers[self.fpn_layer - 3]), self.cast_type),)\n", + " cast_layers = \\\n", + " cast_layers + (layers[0] + self.cast(self.interpolate3(cast_layers[self.fpn_layer - 2]), self.cast_type),)\n", + "\n", + " layers_arranged = ()\n", + " for i in range(self.fpn_layer - 1, -1, -1):\n", + " layers_arranged = layers_arranged + (cast_layers[i],)\n", + "\n", + " outs = ()\n", + " for i in range(self.fpn_layer):\n", + " outs = outs + (self.fpn_convs_list[i](layers_arranged[i]),)\n", + "\n", + " for i in range(self.num_outs - self.fpn_layer):\n", + " outs = outs + (self.maxpool(outs[3]),)\n", + " return outs\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### RPN网络\n", + "\n", + "RPN第一次出现在世人眼中是在Faster RCNN这个结构中，专门用来提取候选框，在RCNN和Fast RCNN等物体检测架构中，用来提取候选框的方法通常是Selective Search，是比较传统的方法，而且比较耗时，在CPU上要2s一张图。所以作者提出RPN，专门用来提取候选框，一方面RPN耗时少，另一方面RPN可以很容易结合到Fast RCNN中，称为一个整体。\n", + "\n", + "RPN网络主要输出项：\n", + "\n", + "1. ROI：对应在特征层每个特征点产生4k个变量，其中4表示[dy, dx, dh, dw]四个边框平移缩放量。其中k表示4个边框，k=4。\n", + "\n", + "2. scores：对应在特征层每个特征点产生2k个变量，其中2表示前景和北京概率。其中k表示3个边框，k=3。" + ] + }, + { + "cell_type": "code", + "execution_count": 25, + "metadata": {}, + "outputs": [], + "source": [ + "from model.bbox_assign_sample import BboxAssignSample\n", + "\n", + "\n", + "class RpnRegClsBlock(nn.Cell):\n", + " \"\"\"\n", + " Rpn reg cls block for rpn layer\n", + "\n", + " Args:\n", + " in_channels (int): Input channels of shared convolution.\n", + " feat_channels (int): Output channels of shared convolution.\n", + " num_anchors (int): The anchor number.\n", + " cls_out_channels (int): Output channels of classification convolution.\n", + " weight_conv (Tensor): Weight init for rpn conv.\n", + " bias_conv (Tensor): Bias init for rpn conv.\n", + " weight_cls (Tensor): Weight init for rpn cls conv.\n", + " bias_cls (Tensor): Bias init for rpn cls conv.\n", + " weight_reg (Tensor): Weight init for rpn reg conv.\n", + " bias_reg (Tensor): Bias init for rpn reg conv.\n", + "\n", + " Inputs:\n", + " - **x** (Tensor) - input variant\n", + "\n", + " Outputs:\n", + " Tensor, output tensor.\n", + "\n", + " Support Platform:\n", + " ``Ascend`` ``CPU`` ``GPU``\n", + "\n", + " Examples:\n", + " >>> x = Tensor(np.array([[[[1., 2.], [3., 4.]]]]), mindspore.float32)\n", + " >>> weight_conv = Tensor(np.array([[[[0.2, 0.3], [0.4, 0.1]]]]), mindspore.float32)\n", + " >>> bias_conv = Tensor(np.array([[[[0., 0.], [0., 0.]]]]), mindspore.float32)\n", + " >>> weight_cls = Tensor(np.array([[[[0.2, 0.3], [0.4, 0.1]]]]), mindspore.float32)\n", + " >>> bias_cls = Tensor(np.array([[[[0., 0.], [0., 0.]]]]), mindspore.float32)\n", + " >>> weight_reg = Tensor(np.array([[[[0.2, 0.3], [0.4, 0.1]]]]), mindspore.float32)\n", + " >>> bias_reg = Tensor(np.array([[[[0., 0.], [0., 0.]]]]), mindspore.float32)\n", + " >>> rpn = RpnRegClsBlock(2, 2, 4, 4, )\n", + " >>> rpn = ops.SingleRoIExtractor(2, 2, 0.5, 2, weight_conv, bias_conv,\n", + " ... weight_cls, bias_cls, weight_reg, bias_reg)\n", + " >>> output = rpn(x)\n", + " \"\"\"\n", + " def __init__(self, in_channels, feat_channels, num_anchors, cls_out_channels, weight_conv,\n", + " bias_conv, weight_cls, bias_cls, weight_reg, bias_reg):\n", + " super(RpnRegClsBlock, self).__init__()\n", + " self.rpn_conv = nn.Conv2d(in_channels, feat_channels, kernel_size=3,\n", + " stride=1, pad_mode='same',\n", + " has_bias=True, weight_init=weight_conv,\n", + " bias_init=bias_conv)\n", + " self.relu = nn.ReLU()\n", + "\n", + " self.rpn_cls = nn.Conv2d(feat_channels, num_anchors * cls_out_channels,\n", + " kernel_size=1, pad_mode='valid',\n", + " has_bias=True, weight_init=weight_cls,\n", + " bias_init=bias_cls)\n", + " self.rpn_reg = nn.Conv2d(feat_channels, num_anchors * 4,\n", + " kernel_size=1, pad_mode='valid',\n", + " has_bias=True, weight_init=weight_reg,\n", + " bias_init=bias_reg)\n", + "\n", + " def construct(self, x):\n", + " \"\"\"Construct Rpn reg cls block for rpn layer.\"\"\"\n", + " x = self.relu(self.rpn_conv(x))\n", + "\n", + " x1 = self.rpn_cls(x)\n", + " x2 = self.rpn_reg(x)\n", + "\n", + " return x1, x2\n", + "\n", + "\n", + "class RPN(nn.Cell):\n", + " \"\"\"\n", + " ROI proposal network..\n", + "\n", + " Args:\n", + " config (dict): Config.\n", + " batch_size (int): Batchsize.\n", + " in_channels (int): Input channels of shared convolution.\n", + " feat_channels (int): Output channels of shared convolution.\n", + " num_anchors (int): The anchor number.\n", + " cls_out_channels (int): Output channels of classification convolution.\n", + "\n", + " Inputs:\n", + " - **inputs** (Tensor) - Input variant.\n", + " - **img_metas** (Tensor) - Img shape.\n", + " - **anchor_list** (Tensor) - A list of anchors.\n", + " - **gt_bboxes** (Tensor) - Ground truth bounding boxes.\n", + " - **gt_labels** (Tensor) - Ground truth labels.\n", + " - **gt_valids** (Tensor) - Ground truth validations.\n", + "\n", + " Outputs:\n", + " Tuple, tuple of output tensor.\n", + "\n", + " Support Platform:\n", + " ``Ascend`` ``CPU`` ``GPU``\n", + "\n", + " Examples:\n", + " >>> RPN(config=config, batch_size=2, in_channels=256, feat_channels=1024,\n", + " ... num_anchors=3, cls_out_channels=512)\n", + " \"\"\"\n", + " def __init__(self, config, batch_size, in_channels, feat_channels, num_anchors, cls_out_channels):\n", + " super(RPN, self).__init__()\n", + " cfg_rpn = config\n", + "\n", + " self.cast_type = mstype.float32\n", + " self.np_cast_type = np.float32\n", + "\n", + " self.num_bboxes = cfg_rpn.num_bboxes\n", + " self.slice_index = ()\n", + " self.feature_anchor_shape = ()\n", + " self.slice_index += (0,)\n", + " index = 0\n", + " for shape in cfg_rpn.feature_shapes:\n", + " self.slice_index += (self.slice_index[index] + shape[0] * shape[1] * num_anchors,)\n", + " self.feature_anchor_shape += (shape[0] * shape[1] * num_anchors * batch_size,)\n", + " index += 1\n", + "\n", + " self.num_anchors = num_anchors\n", + " self.batch_size = batch_size\n", + " self.test_batch_size = cfg_rpn.test_batch_size\n", + " self.num_layers = 5\n", + " self.real_ratio = Tensor(np.ones((1, 1)).astype(self.np_cast_type))\n", + "\n", + " self.rpn_convs_list = nn.layer.CellList(self._make_rpn_layer(self.num_layers, in_channels, feat_channels,\n", + " num_anchors, cls_out_channels))\n", + "\n", + " self.transpose = P.Transpose()\n", + " self.reshape = P.Reshape()\n", + " self.concat = P.Concat(axis=0)\n", + " self.fill = P.Fill()\n", + " self.placeh1 = Tensor(np.ones((1,)).astype(self.np_cast_type))\n", + "\n", + " self.trans_shape = (0, 2, 3, 1)\n", + "\n", + " self.reshape_shape_reg = (-1, 4)\n", + " self.reshape_shape_cls = (-1,)\n", + " self.rpn_loss_reg_weight = Tensor(np.array(cfg_rpn.rpn_loss_reg_weight).astype(self.np_cast_type))\n", + " self.rpn_loss_cls_weight = Tensor(np.array(cfg_rpn.rpn_loss_cls_weight).astype(self.np_cast_type))\n", + " expected_total_size = cfg_rpn.num_expected_neg * self.batch_size\n", + " self.num_expected_total = Tensor(np.array(expected_total_size).astype(self.np_cast_type))\n", + " self.num_bboxes = cfg_rpn.num_bboxes\n", + " self.get_targets = BboxAssignSample(cfg_rpn, self.batch_size, self.num_bboxes, False)\n", + " self.check_valid = P.CheckValid()\n", + " self.sum_loss = P.ReduceSum()\n", + " self.loss_cls = P.SigmoidCrossEntropyWithLogits()\n", + " self.loss_bbox = P.SmoothL1Loss(beta=1.0/9.0)\n", + " self.squeeze = P.Squeeze()\n", + " self.cast = P.Cast()\n", + " self.tile = P.Tile()\n", + " self.zeros_like = P.ZerosLike()\n", + " self.loss = Tensor(np.zeros((1,)).astype(self.np_cast_type))\n", + " self.clsloss = Tensor(np.zeros((1,)).astype(self.np_cast_type))\n", + " self.regloss = Tensor(np.zeros((1,)).astype(self.np_cast_type))\n", + "\n", + " def _make_rpn_layer(self, num_layers, in_channels,\n", + " feat_channels, num_anchors, cls_out_channels):\n", + " \"\"\"\n", + " Make rpn layer for rpn proposal network\n", + "\n", + " Args:\n", + " num_layers (int): layer num.\n", + " in_channels (int): Input channels of shared convolution.\n", + " feat_channels (int): Output channels of shared convolution.\n", + " num_anchors (int): The anchor number.\n", + " cls_out_channels (int): Output channels of classification convolution.\n", + "\n", + " Returns:\n", + " List, list of RpnRegClsBlock cells.\n", + " \"\"\"\n", + " rpn_layer = []\n", + "\n", + " shp_weight_conv = (feat_channels, in_channels, 3, 3)\n", + " shp_bias_conv = (feat_channels,)\n", + " weight_conv = initializer('Normal', shape=shp_weight_conv, dtype=mstype.float32)\n", + " bias_conv = initializer(0, shape=shp_bias_conv, dtype=mstype.float32)\n", + "\n", + " shp_weight_cls = (num_anchors * cls_out_channels, feat_channels, 1, 1)\n", + " shp_bias_cls = (num_anchors * cls_out_channels,)\n", + " weight_cls = initializer('Normal', shape=shp_weight_cls, dtype=mstype.float32)\n", + " bias_cls = initializer(0, shape=shp_bias_cls, dtype=mstype.float32)\n", + "\n", + " shp_weight_reg = (num_anchors * 4, feat_channels, 1, 1)\n", + " shp_bias_reg = (num_anchors * 4,)\n", + " weight_reg = initializer('Normal', shape=shp_weight_reg, dtype=mstype.float32)\n", + " bias_reg = initializer(0, shape=shp_bias_reg, dtype=mstype.float32)\n", + "\n", + " for i in range(num_layers):\n", + " rpn_layer.append(RpnRegClsBlock(in_channels, feat_channels, num_anchors, cls_out_channels, weight_conv,\n", + " bias_conv, weight_cls, bias_cls, weight_reg,\n", + " bias_reg).to_float(self.cast_type))\n", + "\n", + " for i in range(1, num_layers):\n", + " rpn_layer[i].rpn_conv.weight = rpn_layer[0].rpn_conv.weight\n", + " rpn_layer[i].rpn_cls.weight = rpn_layer[0].rpn_cls.weight\n", + " rpn_layer[i].rpn_reg.weight = rpn_layer[0].rpn_reg.weight\n", + "\n", + " rpn_layer[i].rpn_conv.bias = rpn_layer[0].rpn_conv.bias\n", + " rpn_layer[i].rpn_cls.bias = rpn_layer[0].rpn_cls.bias\n", + " rpn_layer[i].rpn_reg.bias = rpn_layer[0].rpn_reg.bias\n", + "\n", + " return rpn_layer\n", + "\n", + " def construct(self, inputs, img_metas, anchor_list, gt_bboxes, gt_labels, gt_valids):\n", + " \"\"\"Construct ROI Proposal Network.\"\"\"\n", + " loss_print = ()\n", + " rpn_cls_score = ()\n", + " rpn_bbox_pred = ()\n", + " rpn_cls_score_total = ()\n", + " rpn_bbox_pred_total = ()\n", + "\n", + " for i in range(self.num_layers):\n", + " x1, x2 = self.rpn_convs_list[i](inputs[i])\n", + "\n", + " rpn_cls_score_total = rpn_cls_score_total + (x1,)\n", + " rpn_bbox_pred_total = rpn_bbox_pred_total + (x2,)\n", + "\n", + " x1 = self.transpose(x1, self.trans_shape)\n", + " x1 = self.reshape(x1, self.reshape_shape_cls)\n", + "\n", + " x2 = self.transpose(x2, self.trans_shape)\n", + " x2 = self.reshape(x2, self.reshape_shape_reg)\n", + "\n", + " rpn_cls_score = rpn_cls_score + (x1,)\n", + " rpn_bbox_pred = rpn_bbox_pred + (x2,)\n", + "\n", + " loss = self.loss\n", + " clsloss = self.clsloss\n", + " regloss = self.regloss\n", + " bbox_targets = ()\n", + " bbox_weights = ()\n", + " labels = ()\n", + " label_weights = ()\n", + "\n", + " output = ()\n", + " if self.training:\n", + " for i in range(self.batch_size):\n", + " multi_level_flags = ()\n", + " anchor_list_tuple = ()\n", + "\n", + " for j in range(self.num_layers):\n", + " res = self.cast(self.check_valid(anchor_list[j], self.squeeze(img_metas[i:i + 1:1, ::])),\n", + " mstype.int32)\n", + " multi_level_flags = multi_level_flags + (res,)\n", + " anchor_list_tuple = anchor_list_tuple + (anchor_list[j],)\n", + "\n", + " valid_flag_list = self.concat(multi_level_flags)\n", + " anchor_using_list = self.concat(anchor_list_tuple)\n", + "\n", + " gt_bboxes_i = self.squeeze(gt_bboxes[i:i + 1:1, ::])\n", + " gt_labels_i = self.squeeze(gt_labels[i:i + 1:1, ::])\n", + " gt_valids_i = self.squeeze(gt_valids[i:i + 1:1, ::])\n", + "\n", + " bbox_target, bbox_weight, label, label_weight = \\\n", + " self.get_targets(gt_bboxes_i, gt_labels_i, self.cast(valid_flag_list, mstype.bool_),\n", + " anchor_using_list, gt_valids_i)\n", + "\n", + " bbox_weight = self.cast(bbox_weight, self.cast_type)\n", + " label = self.cast(label, self.cast_type)\n", + " label_weight = self.cast(label_weight, self.cast_type)\n", + "\n", + " for j in range(self.num_layers):\n", + " begin = self.slice_index[j]\n", + " end = self.slice_index[j + 1]\n", + " stride = 1\n", + " bbox_targets += (bbox_target[begin:end:stride, ::],)\n", + " bbox_weights += (bbox_weight[begin:end:stride],)\n", + " labels += (label[begin:end:stride],)\n", + " label_weights += (label_weight[begin:end:stride],)\n", + "\n", + " for i in range(self.num_layers):\n", + " bbox_target_using = ()\n", + " bbox_weight_using = ()\n", + " label_using = ()\n", + " label_weight_using = ()\n", + "\n", + " for j in range(self.batch_size):\n", + " bbox_target_using += (bbox_targets[i + (self.num_layers * j)],)\n", + " bbox_weight_using += (bbox_weights[i + (self.num_layers * j)],)\n", + " label_using += (labels[i + (self.num_layers * j)],)\n", + " label_weight_using += (label_weights[i + (self.num_layers * j)],)\n", + "\n", + " bbox_target_with_batchsize = self.concat(bbox_target_using)\n", + " bbox_weight_with_batchsize = self.concat(bbox_weight_using)\n", + " label_with_batchsize = self.concat(label_using)\n", + " label_weight_with_batchsize = self.concat(label_weight_using)\n", + "\n", + " # stop\n", + " bbox_target_ = F.stop_gradient(bbox_target_with_batchsize)\n", + " bbox_weight_ = F.stop_gradient(bbox_weight_with_batchsize)\n", + " label_ = F.stop_gradient(label_with_batchsize)\n", + " label_weight_ = F.stop_gradient(label_weight_with_batchsize)\n", + "\n", + " cls_score_i = rpn_cls_score[i]\n", + " reg_score_i = rpn_bbox_pred[i]\n", + "\n", + " loss_cls = self.loss_cls(cls_score_i, label_)\n", + " loss_cls_item = loss_cls * label_weight_\n", + " loss_cls_item = self.sum_loss(loss_cls_item, (0,)) / self.num_expected_total\n", + "\n", + " loss_reg = self.loss_bbox(reg_score_i, bbox_target_)\n", + " bbox_weight_ = self.tile(self.reshape(bbox_weight_, (self.feature_anchor_shape[i], 1)), (1, 4))\n", + " loss_reg = loss_reg * bbox_weight_\n", + " loss_reg_item = self.sum_loss(loss_reg, (1,))\n", + " loss_reg_item = self.sum_loss(loss_reg_item, (0,)) / self.num_expected_total\n", + "\n", + " loss_total = self.rpn_loss_cls_weight * loss_cls_item + self.rpn_loss_reg_weight * loss_reg_item\n", + "\n", + " loss += loss_total\n", + " loss_print += (loss_total, loss_cls_item, loss_reg_item)\n", + " clsloss += loss_cls_item\n", + " regloss += loss_reg_item\n", + "\n", + " output = (loss, rpn_cls_score_total, rpn_bbox_pred_total,\n", + " clsloss, regloss, loss_print)\n", + " else:\n", + " output = (self.placeh1, rpn_cls_score_total, rpn_bbox_pred_total,\n", + " self.placeh1, self.placeh1, self.placeh1)\n", + " return output\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### ROI Align\n", + "\n", + "ROI Align可以计算不同proposal对应到不同尺度下的特征，利用proposal对该特征进行剪裁、resize、pooling提取特征。\n", + "\n", + "Mask-RCNN中使用的ROI Level校准:\n", + "\n", + "$$\n", + "k=[k_0+\\log_2{(\\frac{\\sqrt{wh}}{224/\\sqrt{image\\; area}})}]\n", + "$$\n", + "\n", + "#### 解释\n", + "\n", + "1. 由于Mask R-CNN训练数据的box和anchor都做了调整，所以ROI Level的计算部分也需要 $224/\\sqrt{image\\; area}$。其中，224应为输入图像尺寸的一半。\n", + "\n", + "2. 计算得到的k即为ROI对应的level，level一共4个:\n", + "\n", + " 1. $level=2$表示映射回特征 $P_{2}$，大小为原输入图像的 $1/4$。\n", + "\n", + " 2. $level=3$表示映射回特征 $P_{3}$，大小为原输入图像的 $1/8$。\n", + "\n", + " 3. $level=4$表示映射回特征 $P_{4}$，大小为原输入图像的 $1/16$。\n", + "\n", + " 4. $level=5$表示映射回特征 $P_{5}$，大小为原输入图像的 $1/32$。\n", + "\n", + "![image4](images/roi_align.png)\n", + "\n", + "虚线网格表示特征图，实线表示RoI(在本例中为2×2个bin)，点表示每个容器中的4个采样点。RoIAlign通过双线性插值从特征图上附近的网格点(最近的4个)计算每个采样点的值。在ROI、4个bin或采样点中涉及的任何坐标上都不进行量化。" + ] + }, + { + "cell_type": "code", + "execution_count": 26, + "metadata": {}, + "outputs": [], + "source": [ + "class ROIAlign(nn.Cell):\n", + " \"\"\"\n", + " Extract RoI features from mulitiple feature map.\n", + "\n", + " Args:\n", + " out_size_h (int): RoI height.\n", + " out_size_w (int): RoI width.\n", + " spatial_scale (int): RoI spatial scale.\n", + " sample_num (int): RoI sample number. Default: 0.\n", + " roi_align_mode (int): RoI align mode. Default: 1.\n", + "\n", + " Inputs:\n", + " - **features** (Tensor) - The input features, whose shape must be :math:'(N, C, H, W)'.\n", + " - **rois** (Tensor) - The shape is :math:'(rois_n, 5)'. With data type of float16 or float32.\n", + "\n", + " Outputs:\n", + " Tensor, the shape is :math: '(rois_n, C, pooled_height, pooled_width)'.\n", + "\n", + " Support Platform:\n", + " ``Ascend`` ``CPU`` ``GPU``\n", + "\n", + " Examples:\n", + " >>> features = Tensor(np.array([[[[1., 2.], [3., 4.]]]]), mindspore.float32)\n", + " >>> rois = Tensor(np.array([[0, 0.2, 0.3, 0.2, 0.3]]), mindspore.float32)\n", + " >>> roi_align = ops.ROIAlign(2, 2, 0.5, 2)\n", + " >>> output = roi_align(features, rois)\n", + " >>> print(output)\n", + " [[[[1.775 2.025]\n", + " [2.275 2.525]]]]\n", + " \"\"\"\n", + " def __init__(self, out_size_h, out_size_w, spatial_scale, sample_num=0, roi_align_mode=1):\n", + " super(ROIAlign, self).__init__()\n", + "\n", + " self.out_size = (out_size_h, out_size_w)\n", + " self.spatial_scale = float(spatial_scale)\n", + " self.sample_num = int(sample_num)\n", + " self.align_op = P.ROIAlign(self.out_size[0], self.out_size[1],\n", + " self.spatial_scale, self.sample_num,\n", + " roi_align_mode)\n", + "\n", + " def construct(self, features, rois):\n", + " \"\"\"Construct ROI Align\"\"\"\n", + " return self.align_op(features, rois)\n", + "\n", + " def __repr__(self):\n", + " format_str = self.__class__.__name__\n", + " format_str += \\\n", + " '(out_size={}, spatial_scale={}, sample_num={}'.format(self.out_size, self.spatial_scale, self.sample_num)\n", + " return format_str\n", + "\n", + "\n", + "class SingleRoIExtractor(nn.Cell):\n", + " \"\"\"\n", + " Extract RoI features from a single level feature map.\n", + "\n", + " If there are multiple input feature levels, each RoI is mapped to a level according to its scale.\n", + "\n", + " Args:\n", + " config (dict): Config\n", + " out_channels (int): Output channels of RoI layers.\n", + " featmap_strides (int): Strides of input feature maps.\n", + " batch_size (int): Batchsize. Default: 1.\n", + " finest_scale (int): Scale threshold of mapping to level 0. Default: 56.\n", + " mask (bool): Specify ROIAlign for cls or mask branch. Default: False.\n", + "\n", + " Inputs:\n", + " - **rois** (Tensor) - The shape is :math:'(rois_n, 5)'. With data type of float16 or float32.\n", + " - **feat1** (Tensor) - The input features, whose shape must be :math:'(N, C, H, W)'.\n", + " - **feat2** (Tensor) - The input features, whose shape must be :math:'(N, C, H, W)'.\n", + " - **feat3** (Tensor) - The input features, whose shape must be :math:'(N, C, H, W)'.\n", + " - **feat4** (Tensor) - The input features, whose shape must be :math:'(N, C, H, W)'.\n", + "\n", + " Outputs:\n", + " Tensor, the shape is :math:'(rois_n, C, pooled_height, pooled_width)'.\n", + "\n", + " Support Platform:\n", + " ``Ascend`` ``CPU`` ``GPU``\n", + "\n", + " Examples:\n", + " >>> fea1 = Tensor(np.array([[[[1., 2.], [3., 4.]]]]), mindspore.float32)\n", + " >>> fea2 = Tensor(np.array([[[[1., 2.], [3., 4.]]]]), mindspore.float32)\n", + " >>> fea3 = Tensor(np.array([[[[1., 2.], [3., 4.]]]]), mindspore.float32)\n", + " >>> fea4 = Tensor(np.array([[[[1., 2.], [3., 4.]]]]), mindspore.float32)\n", + " >>> rois = Tensor(np.array([[0, 0.2, 0.3, 0.2, 0.3]]), mindspore.float32)\n", + " >>> single_roi = ops.SingleRoIExtractor(conifg, 2, 1, 2, 2, mask)\n", + " >>> output = single_roi(rois, fea1, fea2, fea3, fea4)\n", + " \"\"\"\n", + "\n", + " def __init__(self, config, roi_layer, out_channels, featmap_strides, batch_size=1, finest_scale=56, mask=False):\n", + " super(SingleRoIExtractor, self).__init__()\n", + " cfg = config\n", + " self.train_batch_size = batch_size\n", + " self.out_channels = out_channels\n", + " self.featmap_strides = featmap_strides\n", + " self.num_levels = len(self.featmap_strides)\n", + " self.out_size = roi_layer.mask_out_size if mask else roi_layer.out_size\n", + " self.mask = mask\n", + " self.sample_num = roi_layer.sample_num\n", + " self.roi_layers = self.build_roi_layers(self.featmap_strides)\n", + " self.roi_layers = L.CellList(self.roi_layers)\n", + "\n", + " self.sqrt = P.Sqrt()\n", + " self.log = P.Log()\n", + " self.finest_scale_ = finest_scale\n", + " self.clamp = C.clip_by_value\n", + "\n", + " self.cast = P.Cast()\n", + " self.equal = P.Equal()\n", + " self.select = P.Select()\n", + "\n", + " in_mode_16 = False\n", + " self.dtype = np.float16 if in_mode_16 else np.float32\n", + " self.ms_dtype = mstype.float16 if in_mode_16 else mstype.float32\n", + " self.set_train_local(cfg, training=True)\n", + "\n", + " def set_train_local(self, config, training=True):\n", + " \"\"\"Set training flag.\"\"\"\n", + " self.training_local = training\n", + "\n", + " cfg = config\n", + " # Init tensor\n", + " roi_sample_num = cfg.num_expected_pos_stage2 if self.mask else cfg.roi_sample_num\n", + " self.batch_size = roi_sample_num if self.training_local else cfg.rpn_max_num\n", + " self.batch_size = self.train_batch_size*self.batch_size \\\n", + " if self.training_local else cfg.test_batch_size*self.batch_size\n", + " self.ones = Tensor(np.array(np.ones((self.batch_size, 1)), dtype=self.dtype))\n", + " finest_scale = np.array(np.ones((self.batch_size, 1)), dtype=self.dtype) * self.finest_scale_\n", + " self.finest_scale = Tensor(finest_scale)\n", + " self.epslion = Tensor(np.array(np.ones((self.batch_size, 1)), dtype=self.dtype)*self.dtype(1e-6))\n", + " self.zeros = Tensor(np.array(np.zeros((self.batch_size, 1)), dtype=np.int32))\n", + " self.max_levels = Tensor(np.array(np.ones((self.batch_size, 1)), dtype=np.int32)*(self.num_levels-1))\n", + " self.twos = Tensor(np.array(np.ones((self.batch_size, 1)), dtype=self.dtype) * 2)\n", + " self.res_ = Tensor(np.array(np.zeros((self.batch_size, self.out_channels, self.out_size, self.out_size)),\n", + " dtype=self.dtype))\n", + "\n", + " def num_inputs(self):\n", + " \"\"\"input number.\"\"\"\n", + " return len(self.featmap_strides)\n", + "\n", + " def log2(self, value):\n", + " \"\"\"calculate log2.\"\"\"\n", + " return self.log(value) / self.log(self.twos)\n", + "\n", + " def build_roi_layers(self, featmap_strides):\n", + " \"\"\"build ROI layers.\"\"\"\n", + " roi_layers = []\n", + " for s in featmap_strides:\n", + " layer_cls = ROIAlign(self.out_size, self.out_size, spatial_scale=1 / s,\n", + " sample_num=self.sample_num, roi_align_mode=0)\n", + " roi_layers.append(layer_cls)\n", + " return roi_layers\n", + "\n", + " def _c_map_roi_levels(self, rois):\n", + " \"\"\"Map rois to corresponding feature levels by scales.\n", + "\n", + " - scale < finest_scale * 2: level 0\n", + " - finest_scale * 2 <= scale < finest_scale * 4: level 1\n", + " - finest_scale * 4 <= scale < finest_scale * 8: level 2\n", + " - scale >= finest_scale * 8: level 3\n", + "\n", + " Args:\n", + " rois (Tensor): Input RoIs, shape (k, 5).\n", + " num_levels (int): Total level number.\n", + "\n", + " Returns:\n", + " Tensor, Level index (0-based) of each RoI, shape (k, )\n", + " \"\"\"\n", + " scale = self.sqrt(rois[::, 3:4:1] - rois[::, 1:2:1] + self.ones) * \\\n", + " self.sqrt(rois[::, 4:5:1] - rois[::, 2:3:1] + self.ones)\n", + "\n", + " target_lvls = self.log2(scale / self.finest_scale + self.epslion)\n", + " target_lvls = P.Floor()(target_lvls)\n", + " target_lvls = self.cast(target_lvls, mstype.int32)\n", + " target_lvls = self.clamp(target_lvls, self.zeros, self.max_levels)\n", + "\n", + " return target_lvls\n", + "\n", + " def construct(self, rois, feat1, feat2, feat3, feat4):\n", + " \"\"\"Construct Single RoI Extractor\"\"\"\n", + " feats = (feat1, feat2, feat3, feat4)\n", + " res = self.res_\n", + " target_lvls = self._c_map_roi_levels(rois)\n", + " for i in range(self.num_levels):\n", + " mask = self.equal(target_lvls, P.ScalarToArray()(i))\n", + " mask = P.Reshape()(mask, (-1, 1, 1, 1))\n", + " roi_feats_t = self.roi_layers[i](feats[i], rois)\n", + " mask = \\\n", + " self.cast(P.Tile()(self.cast(mask, mstype.int32), (1, 256, self.out_size, self.out_size)), mstype.bool_)\n", + " res = self.select(mask, roi_feats_t, res)\n", + " return res\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Class/Bounding Box预测\n", + "\n", + "Class/bounding box预测时，RPN输出一系列ROI，RoIAlign将ROI逐个对应会Resnet输出的5个特征层中的一个。再对该特征做相应的裁剪，resize操作得到对应的特征。再对该特征做进一步卷积，全连接最终输出预测。" + ] + }, + { + "cell_type": "code", + "execution_count": 27, + "metadata": {}, + "outputs": [], + "source": [ + "class DenseNoTranpose(nn.Cell):\n", + " \"\"\"\n", + " Dense method\n", + "\n", + " Args:\n", + " input_channels (int): Channel size of input feature maps.\n", + " output_channels (int): Channel size output.\n", + " weight_init (tuple): Initialized values of weights.\n", + "\n", + " Inputs:\n", + " - **x** (Tensor) - Input from the upper layer.\n", + "\n", + " Outputs:\n", + " Tensor, dense result.\n", + "\n", + " Support Platforms:\n", + " ``Ascend`` ``CPU`` ``GPU``\n", + "\n", + " Examples:\n", + " >>> out_channels = 128\n", + " >>> dense_notranspose = DenseNoTranpose(input_channels, output_channels, weights)\n", + " \"\"\"\n", + " def __init__(self, input_channels, output_channels, weight_init):\n", + " super(DenseNoTranpose, self).__init__()\n", + " self.weight = Parameter(initializer(weight_init, [input_channels, output_channels], mstype.float32))\n", + " self.bias = Parameter(initializer(\"zeros\", [output_channels], mstype.float32))\n", + " self.matmul = P.MatMul(transpose_b=False)\n", + " self.bias_add = P.BiasAdd()\n", + "\n", + " def construct(self, x):\n", + " \"\"\"Construct Dense No Transpose.\"\"\"\n", + " output = self.bias_add(self.matmul(x, self.weight), self.bias)\n", + " return output\n", + "\n", + "\n", + "class FpnCls(nn.Cell):\n", + " \"\"\"\n", + " Dense layer of classification and box head\n", + "\n", + " Args:\n", + " input_channels (int): Channel size of input feature maps.\n", + " output_channels (int): Channel size output\n", + " num_classes (int): Number of classes.\n", + " pool_size (int): Pooling size.\n", + "\n", + " Inputs:\n", + " - **x** (Tensor) - Input from the upper layer.\n", + "\n", + " Outputs:\n", + " Tensor, dense result.\n", + "\n", + " Support Platforms:\n", + " ``Ascend`` ``CPU`` ``GPU``\n", + "\n", + " Examples:\n", + " >>> fpn_cls = FpnCls(256,128,81,2)\n", + " \"\"\"\n", + " def __init__(self, input_channels, output_channels, num_classes, pool_size):\n", + " super(FpnCls, self).__init__()\n", + "\n", + " self.cast_type = mstype.float32\n", + "\n", + " representation_size = input_channels * pool_size * pool_size\n", + " shape_0 = (output_channels, representation_size)\n", + " weights_0 = initializer(\"XavierUniform\", shape=shape_0[::-1], dtype=mstype.float32)\n", + " shape_1 = (output_channels, output_channels)\n", + " weights_1 = initializer(\"XavierUniform\", shape=shape_1[::-1], dtype=mstype.float32)\n", + " self.shared_fc_0 = DenseNoTranpose(representation_size, output_channels, weights_0).to_float(self.cast_type)\n", + " self.shared_fc_1 = DenseNoTranpose(output_channels, output_channels, weights_1).to_float(self.cast_type)\n", + "\n", + " cls_weight = initializer('Normal', shape=[num_classes, output_channels][::-1], dtype=mstype.float32)\n", + " reg_weight = initializer('Normal', shape=[num_classes * 4, output_channels][::-1], dtype=mstype.float32)\n", + " self.cls_scores = DenseNoTranpose(output_channels, num_classes, cls_weight).to_float(self.cast_type)\n", + " self.reg_scores = DenseNoTranpose(output_channels, num_classes * 4, reg_weight).to_float(self.cast_type)\n", + "\n", + " self.relu = P.ReLU()\n", + " self.flatten = P.Flatten()\n", + "\n", + " def construct(self, x):\n", + " \"\"\"Construct FPNCls\"\"\"\n", + " # two share fc layer\n", + " x = self.flatten(x)\n", + "\n", + " x = self.relu(self.shared_fc_0(x))\n", + " x = self.relu(self.shared_fc_1(x))\n", + "\n", + " # classifier head\n", + " cls_scores = self.cls_scores(x)\n", + " # bbox head\n", + " reg_scores = self.reg_scores(x)\n", + "\n", + " return cls_scores, reg_scores\n", + "\n", + "\n", + "class RcnnCls(nn.Cell):\n", + " \"\"\"\n", + " Rcnn for classification and box regression subnet.\n", + "\n", + " Args:\n", + " config (dict): Config.\n", + " batch_size (int): Batchsize.\n", + " num_classes (int): Class number.\n", + " target_means (list): Means for encode function. Default: (.0, .0, .0, .0]).\n", + " target_stds (list): Stds for encode function. Default: (0.1, 0.1, 0.2, 0.2).\n", + "\n", + " Inputs:\n", + " - **featuremap** (tuple) - Feature map.\n", + " - **bbox_targets** (tuple) - A set of bounding box targets.\n", + " - **labels** (tuple) - Ground truth labels.\n", + " - **mask** (tuple) - Mask array.\n", + "\n", + " Outputs:\n", + " Tuple, tuple of output tensor.\n", + "\n", + " Support Platforms:\n", + " ``Ascend`` ``CPU`` ``GPU``\n", + "\n", + " Examples:\n", + " >>> RcnnCls(config=config, representation_size = 1024,\n", + " ... batch_size=2, num_classes = 81,\n", + " ... target_means=(0., 0., 0., 0.),\n", + " ... target_stds=(0.1, 0.1, 0.2, 0.2))\n", + " \"\"\"\n", + "\n", + " def __init__(self, config, batch_size, num_classes, target_means=(0., 0., 0., 0.),\n", + " target_stds=(0.1, 0.1, 0.2, 0.2)):\n", + " super(RcnnCls, self).__init__()\n", + " cfg = config\n", + "\n", + " self.cast_type = mstype.float32\n", + " self.np_cast_type = np.float32\n", + "\n", + " self.rcnn_loss_cls_weight = Tensor(np.array(cfg.rcnn_loss_cls_weight).astype(self.np_cast_type))\n", + " self.rcnn_loss_reg_weight = Tensor(np.array(cfg.rcnn_loss_reg_weight).astype(self.np_cast_type))\n", + " self.rcnn_fc_out_channels = cfg.rcnn_fc_out_channels\n", + " self.target_means = target_means\n", + " self.target_stds = target_stds\n", + " self.num_classes = num_classes\n", + " self.in_channels = cfg.rcnn_in_channels\n", + " self.train_batch_size = batch_size\n", + " self.test_batch_size = cfg.test_batch_size\n", + "\n", + " self.fpn_cls = FpnCls(self.in_channels, self.rcnn_fc_out_channels, self.num_classes, cfg.roi_layer.out_size)\n", + " self.relu = P.ReLU()\n", + " self.logicaland = P.LogicalAnd()\n", + " self.loss_cls = P.SoftmaxCrossEntropyWithLogits()\n", + " self.loss_bbox = P.SmoothL1Loss(beta=1.0)\n", + " self.loss_mask = P.SigmoidCrossEntropyWithLogits()\n", + " self.reshape = P.Reshape()\n", + " self.onehot = P.OneHot()\n", + " self.greater = P.Greater()\n", + " self.cast = P.Cast()\n", + " self.sum_loss = P.ReduceSum()\n", + " self.tile = P.Tile()\n", + " self.expandims = P.ExpandDims()\n", + "\n", + " self.gather = P.GatherNd()\n", + " self.argmax = P.ArgMaxWithValue(axis=1)\n", + "\n", + " self.on_value = Tensor(1.0, mstype.float32)\n", + " self.off_value = Tensor(0.0, mstype.float32)\n", + " self.value = Tensor(1.0, self.cast_type)\n", + "\n", + " self.num_bboxes = (cfg.num_expected_pos_stage2 + cfg.num_expected_neg_stage2) * batch_size\n", + "\n", + " rmv_first = np.ones((self.num_bboxes, self.num_classes))\n", + " rmv_first[:, 0] = np.zeros((self.num_bboxes,))\n", + " self.rmv_first_tensor = Tensor(rmv_first.astype(self.np_cast_type))\n", + "\n", + " self.num_bboxes_test = cfg.rpn_max_num * cfg.test_batch_size\n", + "\n", + " def construct(self, featuremap, bbox_targets, labels, mask):\n", + " \"\"\"Construct Rcnn for classification\"\"\"\n", + " x_cls, x_reg = self.fpn_cls(featuremap)\n", + "\n", + " if self.training:\n", + " bbox_weights = self.cast(self.logicaland(self.greater(labels, 0), mask), mstype.int32) * labels\n", + " labels = self.cast(self.onehot(labels, self.num_classes, self.on_value, self.off_value), self.cast_type)\n", + " bbox_targets = self.tile(self.expandims(bbox_targets, 1), (1, self.num_classes, 1))\n", + "\n", + " loss_cls, loss_reg = self.loss(x_cls, x_reg, bbox_targets, bbox_weights, labels, mask)\n", + " out = (loss_cls, loss_reg)\n", + " else:\n", + " out = (x_cls, x_reg)\n", + "\n", + " return out\n", + "\n", + " def loss(self, cls_score, bbox_pred, bbox_targets, bbox_weights, labels, weights):\n", + " \"\"\"\n", + " Loss method.\n", + " Args:\n", + " cls_score(Array): Classificaiton scores.\n", + " bbox_pred(Array): Bounding box prediction.\n", + " bbox_targets(Array): Bounding box GT target.\n", + " bbox_weights(Array): Bounding box weights.\n", + " labels(Array): GT labels.\n", + " weights(Array): GT wieghts.\n", + "\n", + " Returns:\n", + " loss_cls, float, classification loss.\n", + " loss_reg, float, regression loss.\n", + " \"\"\"\n", + " # loss_cls\n", + " loss_cls, _ = self.loss_cls(cls_score, labels)\n", + " weights = self.cast(weights, self.cast_type)\n", + " loss_cls = loss_cls * weights\n", + " loss_cls = self.sum_loss(loss_cls, (0,)) / (self.sum_loss(weights, (0,)) + 1e-5)\n", + "\n", + " # loss_reg\n", + " bbox_weights = self.cast(self.onehot(bbox_weights, self.num_classes, self.on_value, self.off_value),\n", + " self.cast_type)\n", + " bbox_weights = bbox_weights * self.rmv_first_tensor\n", + " pos_bbox_pred = self.reshape(bbox_pred, (self.num_bboxes, -1, 4))\n", + " loss_reg = self.loss_bbox(pos_bbox_pred, bbox_targets)\n", + " loss_reg = self.sum_loss(loss_reg, (2,))\n", + " loss_reg = loss_reg * bbox_weights\n", + " loss_reg = loss_reg / (self.sum_loss(weights, (0,)) + 1e-5)\n", + " loss_reg = self.sum_loss(loss_reg, (0, 1))\n", + "\n", + " return loss_cls, loss_reg\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Mask预测\n", + "\n", + "对RoIAlign输出的特征进行一系列的卷积，转置卷积，最后输出mask的预测结果。" + ] + }, + { + "cell_type": "code", + "execution_count": 28, + "metadata": {}, + "outputs": [], + "source": [ + "def _conv(in_channels, out_channels, kernel_size=1, stride=1, padding=0, pad_mode='pad', gain=1):\n", + " \"\"\"\n", + " Conv2D wrapper.\n", + "\n", + " Args:\n", + " in_channels(int): Input channel num.\n", + " out_channels(int): Output channel num.\n", + " kernel_size(int): Kernel size. Default: 1\n", + " stride(int): Stride. Default: 1\n", + " padding(int): Padding range. Default: 0\n", + " pad_mode(bool): Padding model. Default: 'pad'\n", + " gain(int): Gain. Default: 1\n", + "\n", + " Returns:\n", + " Tensor, Convoluted result.\n", + " \"\"\"\n", + " shape = (out_channels, in_channels, kernel_size, kernel_size)\n", + " # xavier_normal\n", + " fan_in = in_channels * kernel_size * kernel_size\n", + " fan_out = out_channels * kernel_size * kernel_size\n", + " std = gain * (2 / (fan_in + fan_out)) ** 0.5\n", + " weights = Tensor(np.random.normal(loc=0.0, scale=std, size=shape).astype(np.float32))\n", + " shape_bias = (out_channels,)\n", + " bias = Tensor(np.array(np.zeros(shape_bias)).astype(np.float32))\n", + " return nn.Conv2d(in_channels, out_channels, kernel_size=kernel_size, stride=stride, padding=padding,\n", + " pad_mode=pad_mode, weight_init=weights, has_bias=True, bias_init=bias)\n", + "\n", + "\n", + "def _conv_transpose(in_channels, out_channels, kernel_size=1, stride=1, padding=0, pad_mode='pad', gain=1):\n", + " \"\"\"\n", + " ConvTranspose wrapper.\n", + "\n", + " Args:\n", + " in_channels(int): Input channel num.\n", + " out_channels(int): Output channel num.\n", + " kernel_size(int): Kernel size. Default: 1\n", + " stride(int): Stride. Default: 1\n", + " padding(int): Padding range. Default: 0\n", + " pad_mode(bool): Padding model. Default: 'pad'\n", + " gain(int): Gain. Default: 1\n", + "\n", + " Returns:\n", + " Tensor, Convoluted Transposed result.\n", + " \"\"\"\n", + " shape = (out_channels, in_channels, kernel_size, kernel_size)\n", + " # xavier_normal\n", + " fan_in = in_channels * kernel_size * kernel_size\n", + " fan_out = out_channels * kernel_size * kernel_size\n", + " std = gain * (2 / (fan_in + fan_out)) ** 0.5\n", + " weights = Tensor(np.random.normal(loc=0.0, scale=std, size=shape).astype(np.float32))\n", + " shape_bias = (out_channels,)\n", + " bias = Tensor(np.array(np.zeros(shape_bias)).astype(np.float32))\n", + " return nn.Conv2dTranspose(in_channels, out_channels, kernel_size=kernel_size, stride=stride, padding=padding,\n", + " pad_mode=pad_mode, weight_init=weights, has_bias=True, bias_init=bias)\n", + "\n", + "\n", + "class FpnMask(nn.Cell):\n", + " \"\"\"\n", + " Conv layers of mask head\n", + "\n", + " Args:\n", + " input_channels (int): Channel size of input feature maps.\n", + " output_channels (int): Channel size output\n", + " num_classes (int): Number of classes.\n", + "\n", + " Inputs:\n", + " - **x** (Tensor) - Input from the upper layer.\n", + "\n", + " Outputs:\n", + " Tuple, tuple of output tensor.\n", + "\n", + " Support Platforms:\n", + " ``Ascend`` ``CPU`` ``GPU``\n", + "\n", + " Examples:\n", + " >>> FpnMask(input_channels=256, output_channels=256, num_classes=81)\n", + " \"\"\"\n", + " def __init__(self, input_channels, output_channels, num_classes):\n", + " super(FpnMask, self).__init__()\n", + "\n", + " self.cast_type = mstype.float32\n", + "\n", + " self.mask_conv1 = _conv(input_channels, output_channels,\n", + " kernel_size=3, gain=2 ** 0.5,\n", + " pad_mode=\"same\").to_float(self.cast_type)\n", + " self.mask_relu1 = P.ReLU()\n", + "\n", + " self.mask_conv2 = _conv(output_channels, output_channels,\n", + " kernel_size=3, gain=2 ** 0.5,\n", + " pad_mode=\"same\").to_float(self.cast_type)\n", + " self.mask_relu2 = P.ReLU()\n", + "\n", + " self.mask_conv3 = _conv(output_channels, output_channels,\n", + " kernel_size=3, gain=2 ** 0.5,\n", + " pad_mode=\"same\").to_float(self.cast_type)\n", + " self.mask_relu3 = P.ReLU()\n", + "\n", + " self.mask_conv4 = _conv(output_channels, output_channels,\n", + " kernel_size=3, gain=2 ** 0.5,\n", + " pad_mode=\"same\").to_float(self.cast_type)\n", + " self.mask_relu4 = P.ReLU()\n", + "\n", + " self.mask_deconv5 = _conv_transpose(output_channels, output_channels, kernel_size=2, gain=2 ** 0.5,\n", + " stride=2, pad_mode=\"valid\").to_float(self.cast_type)\n", + " self.mask_relu5 = P.ReLU()\n", + " self.mask_conv6 = _conv(output_channels, num_classes, kernel_size=1, stride=1, gain=2,\n", + " pad_mode=\"valid\").to_float(self.cast_type)\n", + "\n", + " def construct(self, x):\n", + " \"\"\"Construct convolutional layers of mask heads. \"\"\"\n", + " x = self.mask_conv1(x)\n", + " x = self.mask_relu1(x)\n", + "\n", + " x = self.mask_conv2(x)\n", + " x = self.mask_relu2(x)\n", + "\n", + " x = self.mask_conv3(x)\n", + " x = self.mask_relu3(x)\n", + "\n", + " x = self.mask_conv4(x)\n", + " x = self.mask_relu4(x)\n", + "\n", + " x = self.mask_deconv5(x)\n", + " x = self.mask_relu5(x)\n", + "\n", + " x = self.mask_conv6(x)\n", + "\n", + " return x\n", + "\n", + "\n", + "class RcnnMask(nn.Cell):\n", + " \"\"\"\n", + " Rcnn for mask subnet.\n", + "\n", + " Args:\n", + " config (dict): Config.\n", + " batch_size (int): Batchsize.\n", + " num_classes (int): Class number.\n", + " target_means (list): Means for encode function. Default: (.0, .0, .0, .0]).\n", + " target_stds (list): Stds for encode function. Default: (0.1, 0.1, 0.2, 0.2).\n", + "\n", + " Inputs:\n", + " - **mask_featuremap** (tuple) - Masked feature map\n", + " - **labels** (tuple) - Ground truth labels. Default: None\n", + " - **mask** (tuple) - Mask map. Default: None\n", + " - **mask_fb_targets** (tuple) - Masked targets. Default: None\n", + "\n", + " Outputs:\n", + " Tuple, tuple of output tensor.\n", + "\n", + " Examples:\n", + " >>> RcnnMask(config=config, representation_size = 1024,\n", + " ... batch_size=2, num_classes = 81,\n", + " ... target_means=(0., 0., 0., 0.),\n", + " ... target_stds=(0.1, 0.1, 0.2, 0.2))\n", + " \"\"\"\n", + "\n", + " def __init__(self, config, batch_size, num_classes, target_means=(0., 0., 0., 0.),\n", + " target_stds=(0.1, 0.1, 0.2, 0.2)):\n", + " super(RcnnMask, self).__init__()\n", + " cfg = config\n", + "\n", + " self.cast_type = mstype.float32\n", + " self.np_cast_type = np.float32\n", + "\n", + " self.rcnn_loss_mask_fb_weight = Tensor(np.array(cfg.rcnn_loss_mask_fb_weight).astype(self.np_cast_type))\n", + " self.rcnn_mask_out_channels = cfg.rcnn_mask_out_channels\n", + " self.target_means = target_means\n", + " self.target_stds = target_stds\n", + " self.num_classes = num_classes\n", + " self.in_channels = cfg.rcnn_in_channels\n", + "\n", + " self.fpn_mask = FpnMask(self.in_channels, self.rcnn_mask_out_channels, self.num_classes)\n", + "\n", + " self.logicaland = P.LogicalAnd()\n", + " self.loss_mask = P.SigmoidCrossEntropyWithLogits()\n", + " self.onehot = P.OneHot()\n", + " self.greater = P.Greater()\n", + " self.cast = P.Cast()\n", + " self.sum_loss = P.ReduceSum()\n", + " self.tile = P.Tile()\n", + " self.expandims = P.ExpandDims()\n", + "\n", + " self.on_value = Tensor(1.0, mstype.float32)\n", + " self.off_value = Tensor(0.0, mstype.float32)\n", + "\n", + " self.num_bboxes = cfg.num_expected_pos_stage2 * batch_size\n", + " rmv_first = np.ones((self.num_bboxes, self.num_classes))\n", + " rmv_first[:, 0] = np.zeros((self.num_bboxes,))\n", + " self.rmv_first_tensor = Tensor(rmv_first.astype(self.np_cast_type))\n", + " self.mean_loss = P.ReduceMean()\n", + "\n", + " def construct(self, mask_featuremap, labels=None, mask=None, mask_fb_targets=None):\n", + " \"\"\"Construct Rcnn Mask.\"\"\"\n", + " x_mask_fb = self.fpn_mask(mask_featuremap)\n", + "\n", + " if self.training:\n", + " bbox_weights = self.cast(self.logicaland(self.greater(labels, 0), mask), mstype.int32) * labels\n", + " mask_fb_targets = self.tile(self.expandims(mask_fb_targets, 1), (1, self.num_classes, 1, 1))\n", + "\n", + " loss_mask_fb = self.loss(x_mask_fb, bbox_weights, mask, mask_fb_targets)\n", + " out = loss_mask_fb\n", + " else:\n", + " out = x_mask_fb\n", + "\n", + " return out\n", + "\n", + " def loss(self, masks_fb_pred, bbox_weights, weights, masks_fb_targets):\n", + " \"\"\"\n", + " Loss method.\n", + "\n", + " Args:\n", + " mask_fb_pred (Tensor): Mask feedback prediction.\n", + " bbox_weights (Tensor): Bounding box weights.\n", + " weights (Tensor): GT weights.\n", + " masks_fb_targets (Tensor): Mask feedback targets.\n", + "\n", + " Returns:\n", + " Tensor, loss mask feedback result.\n", + " \"\"\"\n", + " weights = self.cast(weights, self.cast_type)\n", + " bbox_weights = \\\n", + " self.cast(self.onehot(bbox_weights, self.num_classes, self.on_value, self.off_value), self.cast_type)\n", + " bbox_weights = bbox_weights * self.rmv_first_tensor\n", + "\n", + " # loss_mask_fb\n", + " masks_fb_targets = self.cast(masks_fb_targets, self.cast_type)\n", + " loss_mask_fb = self.loss_mask(masks_fb_pred, masks_fb_targets)\n", + " loss_mask_fb = self.mean_loss(loss_mask_fb, (2, 3))\n", + " loss_mask_fb = loss_mask_fb * bbox_weights\n", + " loss_mask_fb = loss_mask_fb / (self.sum_loss(weights, (0,)) + 1e-5)\n", + " loss_mask_fb = self.sum_loss(loss_mask_fb, (0, 1))\n", + "\n", + " return loss_mask_fb\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Mask RCNN模型\n", + "\n", + "我们将卷积层，RPN层，RoIAlign层，Bbox预测层和Mask预测层连接起来，构建Mask RCNN网络。" + ] + }, + { + "cell_type": "code", + "execution_count": 29, + "metadata": {}, + "outputs": [], + "source": [ + "from model.bbox_assign_sample_stage2 import BboxAssignSampleForRcnn\n", + "from model.proposal_generator import Proposal\n", + "from model.anchor_generator import AnchorGenerator\n", + "\n", + "\n", + "class MaskRcnnResnet50(nn.Cell):\n", + " \"\"\"\n", + " MaskRcnn Network.\n", + "\n", + " Note:\n", + " backbone = resnet50\n", + "\n", + " Args:\n", + " config (dict): Config.\n", + "\n", + " Inputs:\n", + " - **img_data** (Tensor) - Image data.\n", + " - **img_metas** (List) - Image shapes.\n", + " - **gt_bboxes** (List) - GT boudning boxes.\n", + " - **gt_labels** (List) - GT labels.\n", + " - **gt_valids** (List) - GT validations.\n", + " - **gt_masks** (List) - GT masks.\n", + "\n", + " Outputs:\n", + " Function, return a tuple of output tensor.\n", + "\n", + " Support Plarforms:\n", + " ``Ascend`` ``CPU`` ``GPU``\n", + "\n", + " Examples:\n", + " >>> net = MaskRcnnResnet50(config)\n", + " \"\"\"\n", + " def __init__(self, config):\n", + " super(MaskRcnnResnet50, self).__init__()\n", + "\n", + " self.cast_type = mstype.float32\n", + " self.np_cast_type = np.float32\n", + "\n", + " self.train_batch_size = config.batch_size\n", + " self.num_classes = config.num_classes\n", + " self.anchor_scales = config.anchor_scales\n", + " self.anchor_ratios = config.anchor_ratios\n", + " self.anchor_strides = config.anchor_strides\n", + " self.target_means = tuple(config.rcnn_target_means)\n", + " self.target_stds = tuple(config.rcnn_target_stds)\n", + "\n", + " # Anchor generator\n", + " anchor_base_sizes = None\n", + " self.anchor_base_sizes = list(\n", + " self.anchor_strides) if anchor_base_sizes is None else anchor_base_sizes\n", + "\n", + " self.anchor_generators = []\n", + " for anchor_base in self.anchor_base_sizes:\n", + " self.anchor_generators.append(AnchorGenerator(anchor_base, self.anchor_scales, self.anchor_ratios))\n", + "\n", + " self.num_anchors = len(self.anchor_ratios) * len(self.anchor_scales)\n", + "\n", + " featmap_sizes = config.feature_shapes\n", + " assert len(featmap_sizes) == len(self.anchor_generators)\n", + "\n", + " self.anchor_list = self.get_anchors(featmap_sizes)\n", + "\n", + " # Backbone resnet50\n", + " self.backbone = ResNetFea(ResidualBlockUsing, config.resnet_block, config.resnet_in_channels,\n", + " config.resnet_out_channels, False)\n", + " # Fpn\n", + " self.fpn_ncek = FeatPyramidNeck(config.fpn_in_channels, config.fpn_out_channels, config.fpn_num_outs)\n", + "\n", + " # Rpn and rpn loss\n", + " self.gt_labels_stage1 = Tensor(np.ones((self.train_batch_size, config.num_gts)).astype(np.int32))\n", + " self.rpn_with_loss = RPN(config, self.train_batch_size, config.rpn_in_channels,\n", + " config.rpn_feat_channels, config.num_anchors, config.rpn_cls_out_channels)\n", + "\n", + " # Proposal\n", + " self.proposal_generator = Proposal(config, self.train_batch_size,\n", + " config.activate_num_classes,\n", + " config.use_sigmoid_cls)\n", + " self.proposal_generator.set_train_local(config, True)\n", + " self.proposal_generator_test = Proposal(config, config.test_batch_size,\n", + " config.activate_num_classes,\n", + " config.use_sigmoid_cls)\n", + " self.proposal_generator_test.set_train_local(config, False)\n", + "\n", + " # Assign and sampler stage two\n", + " self.bbox_assigner_sampler_for_rcnn = \\\n", + " BboxAssignSampleForRcnn(config, self.train_batch_size, config.num_bboxes_stage2, True)\n", + " self.decode = P.BoundingBoxDecode(max_shape=(768, 1280), means=self.target_means, stds=self.target_stds)\n", + "\n", + " # Roi\n", + " self.init_roi(config)\n", + "\n", + " # Rcnn\n", + " self.rcnn_cls = RcnnCls(config, self.train_batch_size, self.num_classes)\n", + " self.rcnn_mask = RcnnMask(config, self.train_batch_size, self.num_classes)\n", + "\n", + " # Op declare\n", + " self.squeeze = P.Squeeze()\n", + " self.cast = P.Cast()\n", + "\n", + " self.concat = P.Concat(axis=0)\n", + " self.concat_1 = P.Concat(axis=1)\n", + " self.concat_2 = P.Concat(axis=2)\n", + " self.reshape = P.Reshape()\n", + " self.select = P.Select()\n", + " self.greater = P.Greater()\n", + " self.transpose = P.Transpose()\n", + "\n", + " # Test mode\n", + " self.init_test_mode(config)\n", + "\n", + " # Improve speed\n", + " self.concat_start = min(self.num_classes - 2, 55)\n", + " self.concat_end = (self.num_classes - 1)\n", + "\n", + " # Init tensor\n", + " self.init_tensor(config)\n", + "\n", + " def init_roi(self, config):\n", + " \"\"\"initialize roi aligners.\"\"\"\n", + " self.roi_align = SingleRoIExtractor(config, config.roi_layer, config.roi_align_out_channels,\n", + " config.roi_align_featmap_strides, self.train_batch_size,\n", + " config.roi_align_finest_scale, mask=False)\n", + " self.roi_align.set_train_local(config, True)\n", + "\n", + " self.roi_align_mask = SingleRoIExtractor(config, config.roi_layer, config.roi_align_out_channels,\n", + " config.roi_align_featmap_strides, self.train_batch_size,\n", + " config.roi_align_finest_scale, mask=True)\n", + " self.roi_align_mask.set_train_local(config, True)\n", + "\n", + " self.roi_align_test = SingleRoIExtractor(config, config.roi_layer, config.roi_align_out_channels,\n", + " config.roi_align_featmap_strides, 1,\n", + " config.roi_align_finest_scale, mask=False)\n", + " self.roi_align_test.set_train_local(config, False)\n", + "\n", + " self.roi_align_mask_test = SingleRoIExtractor(config, config.roi_layer, config.roi_align_out_channels,\n", + " config.roi_align_featmap_strides, 1,\n", + " config.roi_align_finest_scale, mask=True)\n", + " self.roi_align_mask_test.set_train_local(config, False)\n", + "\n", + " def init_test_mode(self, config):\n", + " \"\"\"\"initialize the test mode.\"\"\"\n", + " self.test_batch_size = config.test_batch_size\n", + " self.split = P.Split(axis=0, output_num=self.test_batch_size)\n", + " self.split_shape = P.Split(axis=0, output_num=4)\n", + " self.split_scores = P.Split(axis=1, output_num=self.num_classes)\n", + " self.split_fb_mask = P.Split(axis=1, output_num=self.num_classes)\n", + " self.split_cls = P.Split(axis=0, output_num=self.num_classes-1)\n", + " self.tile = P.Tile()\n", + " self.gather = P.GatherNd()\n", + "\n", + " self.rpn_max_num = config.rpn_max_num\n", + "\n", + " self.zeros_for_nms = Tensor(np.zeros((self.rpn_max_num, 3)).astype(self.np_cast_type))\n", + " self.ones_mask = np.ones((self.rpn_max_num, 1)).astype(np.bool)\n", + " self.zeros_mask = np.zeros((self.rpn_max_num, 1)).astype(np.bool)\n", + " self.bbox_mask = Tensor(np.concatenate((self.ones_mask, self.zeros_mask,\n", + " self.ones_mask, self.zeros_mask), axis=1))\n", + " self.nms_pad_mask = Tensor(np.concatenate((self.ones_mask, self.ones_mask,\n", + " self.ones_mask, self.ones_mask,\n", + " self.zeros_mask), axis=1))\n", + "\n", + " self.test_score_thresh = Tensor(np.ones((self.rpn_max_num, 1)).astype(self.np_cast_type) * \\\n", + " config.test_score_thr)\n", + " self.test_score_zeros = Tensor(np.ones((self.rpn_max_num, 1)).astype(self.np_cast_type) * 0)\n", + " self.test_box_zeros = Tensor(np.ones((self.rpn_max_num, 4)).astype(self.np_cast_type) * -1)\n", + " self.test_iou_thr = Tensor(np.ones((self.rpn_max_num, 1)).astype(self.np_cast_type) * config.test_iou_thr)\n", + " self.test_max_per_img = config.test_max_per_img\n", + " self.nms_test = P.NMSWithMask(config.test_iou_thr)\n", + " self.softmax = P.Softmax(axis=1)\n", + " self.logicand = P.LogicalAnd()\n", + " self.oneslike = P.OnesLike()\n", + " self.test_topk = P.TopK(sorted=True)\n", + " self.test_num_proposal = self.test_batch_size * self.rpn_max_num\n", + "\n", + " def init_tensor(self, config):\n", + " \"\"\"initialize the tensors.\"\"\"\n", + " roi_align_index = [np.array(np.ones((config.num_expected_pos_stage2 + \\\n", + " config.num_expected_neg_stage2, 1)) * i,\n", + " dtype=self.np_cast_type) for i in range(self.train_batch_size)]\n", + "\n", + " roi_align_index_test = [np.array(np.ones((config.rpn_max_num, 1)) * i,\n", + " dtype=self.np_cast_type) for i in range(self.test_batch_size)]\n", + "\n", + " self.roi_align_index_tensor = Tensor(np.concatenate(roi_align_index))\n", + " self.roi_align_index_test_tensor = Tensor(np.concatenate(roi_align_index_test))\n", + "\n", + " roi_align_index_pos = [np.array(np.ones((config.num_expected_pos_stage2, 1)) * i,\n", + " dtype=self.np_cast_type) for i in range(self.train_batch_size)]\n", + " self.roi_align_index_tensor_pos = Tensor(np.concatenate(roi_align_index_pos))\n", + "\n", + " self.rcnn_loss_cls_weight = Tensor(np.array(config.rcnn_loss_cls_weight).astype(self.np_cast_type))\n", + " self.rcnn_loss_reg_weight = Tensor(np.array(config.rcnn_loss_reg_weight).astype(self.np_cast_type))\n", + " self.rcnn_loss_mask_fb_weight = Tensor(np.array(config.rcnn_loss_mask_fb_weight).astype(self.np_cast_type))\n", + "\n", + " self.argmax_with_value = P.ArgMaxWithValue(axis=1)\n", + " self.on_value = Tensor(1.0, mstype.float32)\n", + " self.off_value = Tensor(0.0, mstype.float32)\n", + " self.onehot = P.OneHot()\n", + " self.reducesum = P.ReduceSum()\n", + " self.sigmoid = P.Sigmoid()\n", + " self.expand_dims = P.ExpandDims()\n", + " self.test_mask_fb_zeros = Tensor(np.zeros((self.rpn_max_num, 28, 28)).astype(self.np_cast_type))\n", + " self.value = Tensor(1.0, self.cast_type)\n", + "\n", + " def construct(self, img_data, img_metas, gt_bboxes, gt_labels, gt_valids, gt_masks):\n", + " \"\"\"Construct for Mask R-CNN net.\"\"\"\n", + " x = self.backbone(img_data)\n", + " x = self.fpn_ncek(x)\n", + "\n", + " rpn_loss, cls_score, bbox_pred, rpn_cls_loss, rpn_reg_loss, _ = self.rpn_with_loss(x, img_metas,\n", + " self.anchor_list,\n", + " gt_bboxes,\n", + " self.gt_labels_stage1,\n", + " gt_valids)\n", + "\n", + " if self.training:\n", + " proposal, proposal_mask = self.proposal_generator(cls_score, bbox_pred, self.anchor_list)\n", + " else:\n", + " proposal, proposal_mask = self.proposal_generator_test(cls_score, bbox_pred, self.anchor_list)\n", + "\n", + " gt_labels = self.cast(gt_labels, mstype.int32)\n", + " gt_valids = self.cast(gt_valids, mstype.int32)\n", + " bboxes_tuple = ()\n", + " deltas_tuple = ()\n", + " labels_tuple = ()\n", + " mask_tuple = ()\n", + "\n", + " pos_bboxes_tuple = ()\n", + " pos_mask_fb_tuple = ()\n", + " pos_labels_tuple = ()\n", + " pos_mask_tuple = ()\n", + "\n", + " if self.training:\n", + " for i in range(self.train_batch_size):\n", + " gt_bboxes_i = self.squeeze(gt_bboxes[i:i + 1:1, ::])\n", + "\n", + " gt_labels_i = self.squeeze(gt_labels[i:i + 1:1, ::])\n", + " gt_labels_i = self.cast(gt_labels_i, mstype.int32)\n", + "\n", + " gt_valids_i = self.squeeze(gt_valids[i:i + 1:1, ::])\n", + " gt_valids_i = self.cast(gt_valids_i, mstype.bool_)\n", + "\n", + " gt_masks_i = self.squeeze(gt_masks[i:i + 1:1, ::])\n", + " gt_masks_i = self.cast(gt_masks_i, mstype.bool_)\n", + "\n", + " bboxes, deltas, labels, mask, pos_bboxes, pos_mask_fb, pos_labels, pos_mask = \\\n", + " self.bbox_assigner_sampler_for_rcnn(gt_bboxes_i, gt_labels_i, proposal_mask[i],\n", + " proposal[i][::, 0:4:1], gt_valids_i, gt_masks_i)\n", + " bboxes_tuple += (bboxes,)\n", + " deltas_tuple += (deltas,)\n", + " labels_tuple += (labels,)\n", + " mask_tuple += (mask,)\n", + "\n", + " pos_bboxes_tuple += (pos_bboxes,)\n", + " pos_mask_fb_tuple += (pos_mask_fb,)\n", + " pos_labels_tuple += (pos_labels,)\n", + " pos_mask_tuple += (pos_mask,)\n", + "\n", + " bbox_targets = self.concat(deltas_tuple)\n", + " rcnn_labels = self.concat(labels_tuple)\n", + " bbox_targets = F.stop_gradient(bbox_targets)\n", + " rcnn_labels = F.stop_gradient(rcnn_labels)\n", + " rcnn_labels = self.cast(rcnn_labels, mstype.int32)\n", + "\n", + " rcnn_pos_masks_fb = self.concat(pos_mask_fb_tuple)\n", + " rcnn_pos_masks_fb = F.stop_gradient(rcnn_pos_masks_fb)\n", + " rcnn_pos_labels = self.concat(pos_labels_tuple)\n", + " rcnn_pos_labels = F.stop_gradient(rcnn_pos_labels)\n", + " rcnn_pos_labels = self.cast(rcnn_pos_labels, mstype.int32)\n", + " else:\n", + " mask_tuple += proposal_mask\n", + " bbox_targets = proposal_mask\n", + " rcnn_labels = proposal_mask\n", + "\n", + " rcnn_pos_masks_fb = proposal_mask\n", + " rcnn_pos_labels = proposal_mask\n", + " for p_i in proposal:\n", + " bboxes_tuple += (p_i[::, 0:4:1],)\n", + "\n", + " bboxes_all, rois, pos_rois = self.rois(bboxes_tuple, pos_bboxes_tuple)\n", + "\n", + " if self.training:\n", + " roi_feats = self.roi_align(rois,\n", + " self.cast(x[0], mstype.float32),\n", + " self.cast(x[1], mstype.float32),\n", + " self.cast(x[2], mstype.float32),\n", + " self.cast(x[3], mstype.float32))\n", + " else:\n", + " roi_feats = self.roi_align_test(rois,\n", + " self.cast(x[0], mstype.float32),\n", + " self.cast(x[1], mstype.float32),\n", + " self.cast(x[2], mstype.float32),\n", + " self.cast(x[3], mstype.float32))\n", + "\n", + "\n", + " roi_feats = self.cast(roi_feats, self.cast_type)\n", + " rcnn_masks = self.concat(mask_tuple)\n", + " rcnn_masks = F.stop_gradient(rcnn_masks)\n", + " rcnn_mask_squeeze = self.squeeze(self.cast(rcnn_masks, mstype.bool_))\n", + "\n", + " rcnn_pos_masks = self.concat(pos_mask_tuple)\n", + " rcnn_pos_masks = F.stop_gradient(rcnn_pos_masks)\n", + " rcnn_pos_mask_squeeze = self.squeeze(self.cast(rcnn_pos_masks, mstype.bool_))\n", + "\n", + " rcnn_cls_loss, rcnn_reg_loss = self.rcnn_cls(roi_feats, bbox_targets, rcnn_labels, rcnn_mask_squeeze)\n", + "\n", + " if self.training:\n", + " return self.get_output_train(pos_rois, x, rcnn_pos_labels, rcnn_pos_mask_squeeze, rcnn_pos_masks_fb,\n", + " rpn_loss, rpn_cls_loss, rpn_reg_loss, rcnn_cls_loss, rcnn_reg_loss)\n", + "\n", + " return self.get_output_eval(x, bboxes_all, rcnn_cls_loss, rcnn_reg_loss, rcnn_masks, img_metas)\n", + "\n", + " def rois(self, bboxes_tuple, pos_bboxes_tuple):\n", + " \"\"\"\"initialize the rois.\"\"\"\n", + " pos_rois = None\n", + " if self.training:\n", + " if self.train_batch_size > 1:\n", + " bboxes_all = self.concat(bboxes_tuple)\n", + " pos_bboxes_all = self.concat(pos_bboxes_tuple)\n", + " else:\n", + " bboxes_all = bboxes_tuple[0]\n", + " pos_bboxes_all = pos_bboxes_tuple[0]\n", + " rois = self.concat_1((self.roi_align_index_tensor, bboxes_all))\n", + " pos_rois = self.concat_1((self.roi_align_index_tensor_pos, pos_bboxes_all))\n", + " pos_rois = self.cast(pos_rois, mstype.float32)\n", + " pos_rois = F.stop_gradient(pos_rois)\n", + " else:\n", + " if self.test_batch_size > 1:\n", + " bboxes_all = self.concat(bboxes_tuple)\n", + " else:\n", + " bboxes_all = bboxes_tuple[0]\n", + " rois = self.concat_1((self.roi_align_index_test_tensor, bboxes_all))\n", + "\n", + " rois = self.cast(rois, mstype.float32)\n", + " rois = F.stop_gradient(rois)\n", + "\n", + " return bboxes_all, rois, pos_rois\n", + "\n", + " def get_output_train(self, pos_rois, x, rcnn_pos_labels, rcnn_pos_mask_squeeze, rcnn_pos_masks_fb,\n", + " rpn_loss, rpn_cls_loss, rpn_reg_loss, rcnn_cls_loss, rcnn_reg_loss):\n", + " \"\"\"get the training outputs.\"\"\"\n", + " output = ()\n", + " roi_feats_mask = self.roi_align_mask(pos_rois,\n", + " self.cast(x[0], mstype.float32),\n", + " self.cast(x[1], mstype.float32),\n", + " self.cast(x[2], mstype.float32),\n", + " self.cast(x[3], mstype.float32))\n", + " roi_feats_mask = self.cast(roi_feats_mask, self.cast_type)\n", + " rcnn_mask_fb_loss = self.rcnn_mask(roi_feats_mask, rcnn_pos_labels, rcnn_pos_mask_squeeze, rcnn_pos_masks_fb)\n", + "\n", + " rcnn_loss = self.rcnn_loss_cls_weight * rcnn_cls_loss + self.rcnn_loss_reg_weight * rcnn_reg_loss + \\\n", + " self.rcnn_loss_mask_fb_weight * rcnn_mask_fb_loss\n", + " output += (rpn_loss, rcnn_loss, rpn_cls_loss, rpn_reg_loss, rcnn_cls_loss, rcnn_reg_loss, rcnn_mask_fb_loss)\n", + " return output\n", + "\n", + " def get_output_eval(self, x, bboxes_all, rcnn_cls_loss, rcnn_reg_loss, rcnn_masks, img_metas):\n", + " \"\"\"get the evaluation results.\"\"\"\n", + " mask_fb_pred_all = self.rcnn_mask_test(x, bboxes_all, rcnn_cls_loss, rcnn_reg_loss)\n", + " output = self.get_det_bboxes(rcnn_cls_loss, rcnn_reg_loss, rcnn_masks, bboxes_all, img_metas, mask_fb_pred_all)\n", + " return output\n", + "\n", + " def get_det_bboxes(self, cls_logits, reg_logits, mask_logits, rois, img_metas, mask_fb_pred_all):\n", + " \"\"\"Get the actual detection box.\"\"\"\n", + " scores = self.softmax(cls_logits / self.value)\n", + " mask_fb_logits = self.sigmoid(mask_fb_pred_all)\n", + "\n", + " boxes_all = ()\n", + " for i in range(self.num_classes):\n", + " k = i * 4\n", + " reg_logits_i = self.squeeze(reg_logits[::, k:k+4:1])\n", + " out_boxes_i = self.decode(rois, reg_logits_i)\n", + " boxes_all += (out_boxes_i,)\n", + "\n", + " img_metas_all = self.split(img_metas)\n", + " scores_all = self.split(scores)\n", + " mask_all = self.split(self.cast(mask_logits, mstype.int32))\n", + " mask_fb_all = self.split(mask_fb_logits)\n", + "\n", + " boxes_all_with_batchsize = ()\n", + " for i in range(self.test_batch_size):\n", + " scale = self.split_shape(self.squeeze(img_metas_all[i]))\n", + " scale_h = scale[2]\n", + " scale_w = scale[3]\n", + " boxes_tuple = ()\n", + " for j in range(self.num_classes):\n", + " boxes_tmp = self.split(boxes_all[j])\n", + " out_boxes_h = boxes_tmp[i] / scale_h\n", + " out_boxes_w = boxes_tmp[i] / scale_w\n", + " boxes_tuple += (self.select(self.bbox_mask, out_boxes_w, out_boxes_h),)\n", + " boxes_all_with_batchsize += (boxes_tuple,)\n", + "\n", + " output = self.multiclass_nms(boxes_all_with_batchsize, scores_all, mask_all, mask_fb_all)\n", + "\n", + " return output\n", + "\n", + " def multiclass_nms(self, boxes_all, scores_all, mask_all, mask_fb_all):\n", + " \"\"\"\n", + " Multiscale postprocessing.\n", + "\n", + " Args:\n", + " boxes_all (tuple): All bounding boxes.\n", + " scores_all (tuple): All scores.\n", + " mask_all (tuple): All masks.\n", + " mask_fb_all (tuple): All feedback masks.\n", + "\n", + " Returns:\n", + " - all_bboxes, tuple, output bounding boxes with the same shape of boxes_all.\n", + " - all_labels, tuple, output labels with the same shape of scores_all.\n", + " - all_masks, tuple, output masks with the same shape of mask_all.\n", + " - all_masks_fb, tuple, output feedback masks with the same shape of mask_fb_all.\n", + " \"\"\"\n", + " all_bboxes = ()\n", + " all_labels = ()\n", + " all_masks = ()\n", + " all_masks_fb = ()\n", + "\n", + " for i in range(self.test_batch_size):\n", + " bboxes = boxes_all[i]\n", + " scores = scores_all[i]\n", + " masks = self.cast(mask_all[i], mstype.bool_)\n", + " masks_fb = mask_fb_all[i]\n", + " mask_fb_all_x = self.split_fb_mask(masks_fb)\n", + "\n", + " res_boxes_tuple = ()\n", + " res_labels_tuple = ()\n", + " res_masks_tuple = ()\n", + " res_masks_fb_tuple = ()\n", + "\n", + " for j in range(self.num_classes - 1):\n", + " k = j + 1\n", + " cls_scores_x = scores[::, k:k + 1:1]\n", + " bboxes_x = self.squeeze(bboxes[k])\n", + " mask_ox = self.reshape(masks, (self.rpn_max_num, 1))\n", + " masks_fb_x = self.squeeze(mask_fb_all_x[k])\n", + "\n", + " cls_mask = self.greater(cls_scores_x, self.test_score_thresh)\n", + " mask_x = self.logicand(mask_ox, cls_mask)\n", + "\n", + " reg_mask_x = self.cast(self.tile(self.cast(mask_x, mstype.int32), (1, 4)), mstype.bool_)\n", + "\n", + " bboxes_x = self.select(reg_mask_x, bboxes_x, self.test_box_zeros)\n", + " fb_mask_x = self.expand_dims(mask_x, -1)\n", + " mask_fb_mask_x = self.cast(self.tile(self.cast(fb_mask_x, mstype.int32), (1, 28, 28)), mstype.bool_)\n", + " masks_fb_x = self.select(mask_fb_mask_x, masks_fb_x, self.test_mask_fb_zeros)\n", + " cls_scores_x = self.select(mask_x, cls_scores_x, self.test_score_zeros)\n", + " cls_scores_x_next = self.squeeze(cls_scores_x)\n", + " scores_sorted, topk_inds = self.test_topk(cls_scores_x_next, self.rpn_max_num)\n", + " topk_inds = self.reshape(topk_inds, (self.rpn_max_num, 1))\n", + " scores_sorted = self.reshape(scores_sorted, (self.rpn_max_num, 1))\n", + " bboxes_x_sorted = self.gather(bboxes_x, topk_inds)\n", + " mask_fb_sorted_x = self.gather(masks_fb_x, topk_inds)\n", + " mask_sorted_x = self.gather(mask_x, topk_inds)\n", + "\n", + " scores_sorted = self.tile(scores_sorted, (1, 4))\n", + " cls_dets = self.concat_1((bboxes_x_sorted, scores_sorted))\n", + " cls_dets = P.Slice()(cls_dets, (0, 0), (self.rpn_max_num, 5))\n", + "\n", + " cls_dets, index_x, mask_nms_x = self.nms_test(cls_dets)\n", + " index_x = self.reshape(index_x, (self.rpn_max_num, 1))\n", + " mask_nms_x = self.reshape(mask_nms_x, (self.rpn_max_num, 1))\n", + "\n", + " mask_n_x = self.gather(mask_sorted_x, index_x)\n", + " mask_n_x = self.logicand(mask_n_x, mask_nms_x)\n", + "\n", + " mask_fb_x = self.gather(mask_fb_sorted_x, index_x)\n", + "\n", + " cls_labels = self.oneslike(index_x) * j\n", + " res_boxes_tuple += (cls_dets,)\n", + " res_labels_tuple += (cls_labels,)\n", + " res_masks_tuple += (mask_n_x,)\n", + " res_masks_fb_tuple += (mask_fb_x,)\n", + "\n", + " res_boxes_start = self.concat(res_boxes_tuple[:self.concat_start])\n", + " res_labels_start = self.concat(res_labels_tuple[:self.concat_start])\n", + " res_masks_start = self.concat(res_masks_tuple[:self.concat_start])\n", + " res_masks_fb_start = self.concat(res_masks_fb_tuple[:self.concat_start])\n", + "\n", + " res_boxes_end = self.concat(res_boxes_tuple[self.concat_start:self.concat_end])\n", + " res_labels_end = self.concat(res_labels_tuple[self.concat_start:self.concat_end])\n", + " res_masks_end = self.concat(res_masks_tuple[self.concat_start:self.concat_end])\n", + " res_masks_fb_end = self.concat(res_masks_fb_tuple[self.concat_start:self.concat_end])\n", + "\n", + " res_boxes = self.concat((res_boxes_start, res_boxes_end))\n", + " res_labels = self.concat((res_labels_start, res_labels_end))\n", + " res_masks = self.concat((res_masks_start, res_masks_end))\n", + " res_masks_fb = self.concat((res_masks_fb_start, res_masks_fb_end))\n", + "\n", + " reshape_size = (self.num_classes - 1) * self.rpn_max_num\n", + " res_boxes = self.reshape(res_boxes, (1, reshape_size, 5))\n", + " res_labels = self.reshape(res_labels, (1, reshape_size, 1))\n", + " res_masks = self.reshape(res_masks, (1, reshape_size, 1))\n", + " res_masks_fb = self.reshape(res_masks_fb, (1, reshape_size, 28, 28))\n", + "\n", + " all_bboxes += (res_boxes,)\n", + " all_labels += (res_labels,)\n", + " all_masks += (res_masks,)\n", + " all_masks_fb += (res_masks_fb,)\n", + "\n", + " all_bboxes = self.concat(all_bboxes)\n", + " all_labels = self.concat(all_labels)\n", + " all_masks = self.concat(all_masks)\n", + " all_masks_fb = self.concat(all_masks_fb)\n", + " return all_bboxes, all_labels, all_masks, all_masks_fb\n", + "\n", + " def get_anchors(self, featmap_sizes):\n", + " \"\"\"Get anchors according to feature map sizes.\n", + "\n", + " Args:\n", + " featmap_sizes (list[tuple]): Multi-level feature map sizes.\n", + " img_metas (list[dict]): Image meta info.\n", + "\n", + " Returns:\n", + " Tuple, anchors of each image, valid flags of each image\n", + " \"\"\"\n", + " num_levels = len(featmap_sizes)\n", + "\n", + " # since feature map sizes of all images are the same, we only compute\n", + " # anchors for one time\n", + " multi_level_anchors = ()\n", + " for i in range(num_levels):\n", + " anchors = self.anchor_generators[i].grid_anchors(featmap_sizes[i], self.anchor_strides[i])\n", + " multi_level_anchors += (Tensor(anchors.astype(self.np_cast_type)),)\n", + "\n", + " return multi_level_anchors\n", + "\n", + " def rcnn_mask_test(self, x, rois, cls_pred, reg_pred):\n", + " \"\"\"\n", + " Prediction masks in an images by the bounding boxes.\n", + "\n", + " Args:\n", + " x (Cell): Input layer.\n", + " rois (List): Region of Interest.\n", + " cls_pred (float): Classification prediction.\n", + " reg_pred (float): Regression prediction.\n", + "\n", + " Returns:\n", + " Cell, masked rcnn layer.\n", + " \"\"\"\n", + " cls_scores = self.softmax(cls_pred / self.value)\n", + "\n", + " cls_scores_all = self.split(cls_scores)\n", + " reg_pred = self.reshape(reg_pred, (-1, self.num_classes, 4))\n", + " reg_pred_all = self.split(reg_pred)\n", + " rois_all = self.split(rois)\n", + " boxes_tuple = ()\n", + " for i in range(self.test_batch_size):\n", + " cls_score_max_index, _ = self.argmax_with_value(cls_scores_all[i])\n", + " cls_score_max_index = self.cast(self.onehot(cls_score_max_index, self.num_classes,\n", + " self.on_value, self.off_value), self.cast_type)\n", + " cls_score_max_index = self.expand_dims(cls_score_max_index, -1)\n", + " cls_score_max_index = self.tile(cls_score_max_index, (1, 1, 4))\n", + " reg_pred_max = reg_pred_all[i] * cls_score_max_index\n", + " reg_pred_max = self.reducesum(reg_pred_max, 1)\n", + " out_boxes_i = self.decode(rois_all[i], reg_pred_max)\n", + " boxes_tuple += (out_boxes_i,)\n", + "\n", + " boxes_all = self.concat(boxes_tuple)\n", + " boxes_rois = self.concat_1((self.roi_align_index_test_tensor, boxes_all))\n", + " boxes_rois = self.cast(boxes_rois, self.cast_type)\n", + " roi_feats_mask_test = self.roi_align_mask_test(boxes_rois,\n", + " self.cast(x[0], mstype.float32),\n", + " self.cast(x[1], mstype.float32),\n", + " self.cast(x[2], mstype.float32),\n", + " self.cast(x[3], mstype.float32))\n", + " roi_feats_mask_test = self.cast(roi_feats_mask_test, self.cast_type)\n", + " mask_fb_pred_all = self.rcnn_mask(roi_feats_mask_test)\n", + " return mask_fb_pred_all\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### 连接网络和损失函数\n", + "\n", + "MindSpore将损失函数、优化器等操作都封装到了Cell中，我们需要自定义WithLossCell类，将网络和Loss连接起来。\n", + "\n", + "Mask RCNN的损失函数被定义为：\n", + "\n", + "$$\n", + "L=L_{c l s}+L_{b o x}+L_{\\text {mask }}\n", + "$$\n", + "\n", + "$L_{c l s}$类别损失：rpn class和rcnn_cls的类别损失都是交叉熵损失。\n", + "\n", + "$L_{b o x}$边框损失：\n", + "\n", + "$$\n", + "\\operatorname{smooth}_{L_{1}}(x)= \\begin{cases}0.5 x^{2} & \\text { if }|x|<1 \\\\ |x|-0.5 & \\text { otherwise }\\end{cases}\n", + "$$\n", + "\n", + "$L_{mask}$掩膜损失：\n", + "\n", + "只对rcnn_mask计算1/0交叉熵损失。" + ] + }, + { + "cell_type": "code", + "execution_count": 30, + "metadata": {}, + "outputs": [], + "source": [ + "TIME_STAMP_INIT = False\n", + "TIME_STAMP_FIRST = 0\n", + "\n", + "GRADIENT_CLIP_TYPE = 1\n", + "GRADIENT_CLIP_VALUE = 1.0\n", + "\n", + "clip_grad = C.MultitypeFuncGraph(\"clip_grad\")\n", + "\n", + "@clip_grad.register(\"Number\", \"Number\", \"Tensor\")\n", + "def _clip_grad(clip_type, clip_value, grad):\n", + " \"\"\"\n", + " Clip gradients.\n", + "\n", + " Args:\n", + " clip_type (int): The way to clip, 0 for 'value', 1 for 'norm'.\n", + " clip_value (float): Specifies how much to clip.\n", + " grad (tuple[Tensor]): Gradients.\n", + "\n", + " Returns:\n", + " tuple[Tensor], clipped gradients.\n", + " \"\"\"\n", + " if clip_type not in (0, 1):\n", + " return grad\n", + " dt = F.dtype(grad)\n", + " mf_cast = F.cast(F.tuple_to_array((-clip_value,)), dt)\n", + " pf_cast = F.cast(F.tuple_to_array((clip_value,)), dt)\n", + " if clip_type == 0:\n", + " new_grad = C.clip_by_value(grad, mf_cast, pf_cast)\n", + " else:\n", + " new_grad = nn.ClipByNorm()(grad, pf_cast)\n", + " return F.cast(new_grad, dt)\n", + "\n", + "class LossCallBack(Callback):\n", + " \"\"\"\n", + " Monitor the loss in training.\n", + "\n", + " If the loss is NAN or INF terminating training.\n", + "\n", + " Note:\n", + " If per_print_times is 0 do not print loss.\n", + "\n", + " Args:\n", + " per_print_times (int): Print loss every times. Default: 1.\n", + " \"\"\"\n", + "\n", + " def __init__(self, per_print_times=1, rank_id=0):\n", + " super(LossCallBack, self).__init__()\n", + " if not isinstance(per_print_times, int) or per_print_times < 0:\n", + " raise ValueError(\"print_step must be int and >= 0.\")\n", + " self._per_print_times = per_print_times\n", + " self.count = 0\n", + " self.loss_sum = 0\n", + " self.rank_id = rank_id\n", + "\n", + " global TIME_STAMP_INIT, TIME_STAMP_FIRST\n", + " if not TIME_STAMP_INIT:\n", + " TIME_STAMP_FIRST = time.time()\n", + " TIME_STAMP_INIT = True\n", + "\n", + " def step_end(self, run_context):\n", + " \"\"\"set the end of step\"\"\"\n", + " cb_params = run_context.original_args()\n", + " loss = cb_params.net_outputs.asnumpy()\n", + " cur_step_in_epoch = (cb_params.cur_step_num - 1) % cb_params.batch_num + 1\n", + " cur_time = time.time()\n", + " self.count += 1\n", + " self.loss_sum += float(loss)\n", + "\n", + " if self.count >= 1:\n", + " global TIME_STAMP_FIRST\n", + " time_stamp_current = time.time()\n", + " total_loss = self.loss_sum/self.count\n", + "\n", + " print(\"%lu epoch: %s step: %s total_loss: %.5f\" %\n", + " (time_stamp_current - TIME_STAMP_FIRST,\n", + " cb_params.cur_epoch_num, cur_step_in_epoch, total_loss))\n", + " loss_file = open(\"./loss_{}.log\".format(self.rank_id), \"a+\")\n", + " loss_file.write(\"%lu epoch: %s step: %s total_loss: %.5f\" %\n", + " (time_stamp_current - TIME_STAMP_FIRST,\n", + " cb_params.cur_epoch_num, cur_step_in_epoch,\n", + " total_loss))\n", + " loss_file.write(\"\\n\")\n", + " loss_file.close()\n", + "\n", + " self.count = 0\n", + " self.loss_sum = 0\n", + "\n", + " if cur_step_in_epoch > 100 and total_loss < 1:\n", + " print(\"End training, time:\", cur_time, \",epoch:\", cb_params.cur_epoch_num,\n", + " \",step:\", cur_step_in_epoch, \",loss:\", total_loss)\n", + " run_context.request_stop()\n", + "\n", + "\n", + "class LossNet(nn.Cell):\n", + " \"\"\"MaskRcnn loss sum\"\"\"\n", + " def construct(self, x1, x2, x3, x4, x5, x6, x7):\n", + " return x1 + x2\n", + "\n", + "\n", + "class WithLossCell(nn.Cell):\n", + " \"\"\"\n", + " Wrap the network with loss function to compute loss.\n", + "\n", + " Args:\n", + " backbone (Cell): The target network to wrap.\n", + " loss_fn (Cell): The loss function used to compute loss.\n", + "\n", + " Inputs:\n", + " - **x** (Tensor) - Input variant.\n", + " - **img_shape** (Tensor) - Img shape.\n", + " - **gt_bboxe** (Tensor) - Ground truth bounding boxes.\n", + " - **gt_label** (Tensor) - Ground truth labels.\n", + " - **gt_num** (int) - The number of ground truth.\n", + " - **gt_mask** (Tensor) - Ground truth mask.\n", + "\n", + " Outputs:\n", + " Loss network, Cell\n", + "\n", + " Support Platform:\n", + " \"Ascend\" \"CPU\" \"GPU\"\n", + "\n", + " Examples:\n", + " >>> net = MaskRcnnMobilenetV1(config=config)\n", + " >>> loss = LossNet()\n", + " >>> net_with_loss = WithLossCell(network, loss)\n", + " \"\"\"\n", + " def __init__(self, backbone, loss_fn):\n", + " super(WithLossCell, self).__init__(auto_prefix=False)\n", + " self._backbone = backbone\n", + " self._loss_fn = loss_fn\n", + "\n", + " def construct(self, x, img_shape, gt_bboxe, gt_label, gt_num, gt_mask):\n", + " loss1, loss2, loss3, loss4, loss5, loss6, loss7 = \\\n", + " self._backbone(x, img_shape, gt_bboxe, gt_label, gt_num, gt_mask)\n", + " return self._loss_fn(loss1, loss2, loss3, loss4, loss5, loss6, loss7)\n", + "\n", + " @property\n", + " def backbone_network(self):\n", + " \"\"\"\n", + " Get the backbone network.\n", + "\n", + " Returns:\n", + " Cell, return backbone network.\n", + " \"\"\"\n", + " return self._backbone\n", + "\n", + "class TrainOneStepCell(nn.Cell):\n", + " \"\"\"\n", + " Network training package class.\n", + "\n", + " Append an optimizer to the training network\n", + " after that the construct function.\n", + " can be called to create the backward graph.\n", + "\n", + " Args:\n", + " network (Cell): The training network.\n", + " optimizer (Cell): Optimizer for updating the weights.\n", + " sens (Number): The adjust parameter. Default: 1.0.\n", + " reduce_flag (bool): The reduce flag. Default: False.\n", + " mean (bool): Allreduce method. Default: False.\n", + " degree (int): Device number. Default: None.\n", + "\n", + " Inputs:\n", + " - **x** (Tensor) - Input variant.\n", + " - **img_shape** (Tensor) - Img shape.\n", + " - **gt_bboxe** (Tensor) - Ground truth bounding boxes.\n", + " - **gt_label** (Tensor) - Ground truth labels.\n", + " - **gt_num** (int) - The number of ground truth.\n", + " - **gt_mask** (Tensor) - Ground truth mask.\n", + "\n", + " Outputs:\n", + " Float, loss result.\n", + "\n", + " Support Platform:\n", + " ``Ascend`` ``CPU`` ``GPU``\n", + "\n", + " Examples:\n", + " >>> from utils.config import config\n", + " >>> from model.mask_rcnn_r50 import MaskRcnnResnet50\n", + " >>> net = MaskRcnnResnet50(config=config)\n", + " >>> loss = LossNet()\n", + " >>> net_with_loss = WithLossCell(net, loss)\n", + " >>> lr = Tensor(dynamic_lr(config, rank_size=1, start_steps=0), mstype.float32)\n", + " >>> opt = Momentum(params=net.trainable_params(), learning_rate=lr, momentum=0.91,\n", + " ... weight_decay=1e-4, loss_scale=1)\n", + " >>> net = TrainOneStepCell(net_with_loss, opt, sens=config.loss_scale)\n", + " \"\"\"\n", + " def __init__(self, network, optimizer, sens=1.0, reduce_flag=False, mean=True, degree=None):\n", + " super(TrainOneStepCell, self).__init__(auto_prefix=False)\n", + " self.network = network\n", + " self.network.set_grad()\n", + " self.weights = ParameterTuple(network.trainable_params())\n", + " self.optimizer = optimizer\n", + " self.grad = C.GradOperation(get_by_list=True, sens_param=True)\n", + "\n", + " self.sens = Tensor((np.ones((1,)) * sens).astype(np.float32))\n", + " self.reduce_flag = reduce_flag\n", + " self.hyper_map = C.HyperMap()\n", + " if reduce_flag:\n", + " self.grad_reducer = DistributedGradReducer(optimizer.parameters, mean, degree)\n", + "\n", + " def construct(self, x, img_shape, gt_bboxe, gt_label, gt_num, gt_mask):\n", + " \"\"\"Construct Network training package class.\"\"\"\n", + " weights = self.weights\n", + " loss = self.network(x, img_shape, gt_bboxe, gt_label, gt_num, gt_mask)\n", + " grads = self.grad(self.network, weights)(x, img_shape, gt_bboxe, gt_label, gt_num, gt_mask, self.sens)\n", + " if self.reduce_flag:\n", + " grads = self.grad_reducer(grads)\n", + " grads = self.hyper_map(F.partial(clip_grad, GRADIENT_CLIP_TYPE, GRADIENT_CLIP_VALUE), grads)\n", + " self.optimizer(grads)\n", + " return loss\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 训练\n", + "\n", + "### 模型训练参数\n", + "\n", + "在这里，我们列出了一些重要的训练参数。此外，您可以查看配置文件config.py的详细信息。\n", + "\n", + "| Parameter | Default | Description |\n", + "| ---- | ---- | ---- |\n", + "| workers | 1 | Number of parallel workers |\n", + "| device_target | GPU | Device type |\n", + "| learning_rate | 0.002 | learning rate |\n", + "| weight_decay | 1e-4 | Control weight decay speed |\n", + "| total_epoch | 13 | Number of epoch |\n", + "| batch_size | 2 | Batch size |\n", + "| dataset | coco | Dataset name |\n", + "| pre_trained | ./checkpoint | The path of pretrained model |\n", + "| checkpoint_path | ./ckpt_0 | The path to save |" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### 训练模型\n", + "\n", + "模型训练需要定义好优化器、损失函数等。同时，可以加载预训练模型以加快模型训练。\n", + "\n", + "因此，我们定义权重文件加载函数。" + ] + }, + { + "cell_type": "code", + "execution_count": 31, + "metadata": {}, + "outputs": [], + "source": [ + "def load_pretrained_ckpt(net, load_path, device_target):\n", + " \"\"\"\n", + " Load pretrained checkpoint.\n", + "\n", + " Args:\n", + " net(Cell): Used Network\n", + " load_path(string): The path of checkpoint.\n", + " device_target(string): device target.\n", + "\n", + " Returns:\n", + " Cell, the network with pretrained weights.\n", + " \"\"\"\n", + " param_dict = load_checkpoint(load_path)\n", + " if config.pretrain_epoch_size == 0:\n", + " for item in list(param_dict.keys()):\n", + " if not (item.startswith('backbone') or item.startswith('rcnn_mask')):\n", + " param_dict.pop(item)\n", + "\n", + " if device_target == 'GPU':\n", + " for key, value in param_dict.items():\n", + " tensor = Tensor(value, mstype.float32)\n", + " param_dict[key] = Parameter(tensor, key)\n", + "\n", + " load_param_into_net(net, param_dict)\n", + " return net" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "本案例中，为了方便展示效果，选取了数据集中的部分数据进行了1个epoch的训练，由于加载了预训练模型，所以loss值快速趋于稳定，在1附近间波动，这可以作为判断模型收敛的一个标准。\n", + "\n", + "训练得到的ckpt文件被保存在checkpoint文件夹内，可以作为后续fine-tune以及推理的加载模型使用。" + ] + }, + { + "cell_type": "code", + "execution_count": 32, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Start create dataset!\n", + "total images num: 51790\n", + "Create dataset done!\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/maskrcnn/miniconda3/envs/mrcnn17/lib/python3.7/site-packages/ipykernel_launcher.py:155: DeprecationWarning: `np.bool` is a deprecated alias for the builtin `bool`. To silence this warning, use `bool` by itself. Doing this will not modify any behavior and is safe. If you specifically wanted the numpy scalar type, use `np.bool_` here.\n", + "Deprecated in NumPy 1.20; for more details and guidance: https://numpy.org/devdocs/release/1.20.0-notes.html#deprecations\n", + "/home/maskrcnn/miniconda3/envs/mrcnn17/lib/python3.7/site-packages/ipykernel_launcher.py:156: DeprecationWarning: `np.bool` is a deprecated alias for the builtin `bool`. To silence this warning, use `bool` by itself. Doing this will not modify any behavior and is safe. If you specifically wanted the numpy scalar type, use `np.bool_` here.\n", + "Deprecated in NumPy 1.20; for more details and guidance: https://numpy.org/devdocs/release/1.20.0-notes.html#deprecations\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Loading pretrained resnet50 checkpoint\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "[WARNING] ME(1289646:140507235451840,MainProcess):2022-07-27-23:30:32.385.002 [mindspore/train/serialization.py:648] For 'load_param_into_net', 83 parameters in the 'net' are not loaded, because they are not in the 'parameter_dict', please check whether the network structure is consistent when training and loading checkpoint.\n", + "[WARNING] ME(1289646:140507235451840,MainProcess):2022-07-27-23:30:32.386.026 [mindspore/train/serialization.py:650] backbone.conv1.bias is not loaded.\n", + "[WARNING] ME(1289646:140507235451840,MainProcess):2022-07-27-23:30:32.386.719 [mindspore/train/serialization.py:650] backbone.layer1.0.conv1.bias is not loaded.\n", + "[WARNING] ME(1289646:140507235451840,MainProcess):2022-07-27-23:30:32.387.262 [mindspore/train/serialization.py:650] backbone.layer1.0.conv2.bias is not loaded.\n", + "[WARNING] ME(1289646:140507235451840,MainProcess):2022-07-27-23:30:32.387.842 [mindspore/train/serialization.py:650] backbone.layer1.0.conv3.bias is not loaded.\n", + "[WARNING] ME(1289646:140507235451840,MainProcess):2022-07-27-23:30:32.389.278 [mindspore/train/serialization.py:650] backbone.layer1.0.conv_down_sample.bias is not loaded.\n", + "[WARNING] ME(1289646:140507235451840,MainProcess):2022-07-27-23:30:32.389.868 [mindspore/train/serialization.py:650] backbone.layer1.1.conv1.bias is not loaded.\n", + "[WARNING] ME(1289646:140507235451840,MainProcess):2022-07-27-23:30:32.390.374 [mindspore/train/serialization.py:650] backbone.layer1.1.conv2.bias is not loaded.\n", + "[WARNING] ME(1289646:140507235451840,MainProcess):2022-07-27-23:30:32.390.927 [mindspore/train/serialization.py:650] backbone.layer1.1.conv3.bias is not loaded.\n", + "[WARNING] ME(1289646:140507235451840,MainProcess):2022-07-27-23:30:32.392.133 [mindspore/train/serialization.py:650] backbone.layer1.2.conv1.bias is not loaded.\n", + "[WARNING] ME(1289646:140507235451840,MainProcess):2022-07-27-23:30:32.392.697 [mindspore/train/serialization.py:650] backbone.layer1.2.conv2.bias is not loaded.\n", + "[WARNING] ME(1289646:140507235451840,MainProcess):2022-07-27-23:30:32.393.600 [mindspore/train/serialization.py:650] backbone.layer1.2.conv3.bias is not loaded.\n", + "[WARNING] ME(1289646:140507235451840,MainProcess):2022-07-27-23:30:32.394.189 [mindspore/train/serialization.py:650] backbone.layer2.0.conv1.bias is not loaded.\n", + "[WARNING] ME(1289646:140507235451840,MainProcess):2022-07-27-23:30:32.394.694 [mindspore/train/serialization.py:650] backbone.layer2.0.conv2.bias is not loaded.\n", + "[WARNING] ME(1289646:140507235451840,MainProcess):2022-07-27-23:30:32.395.240 [mindspore/train/serialization.py:650] backbone.layer2.0.conv3.bias is not loaded.\n", + "[WARNING] ME(1289646:140507235451840,MainProcess):2022-07-27-23:30:32.395.775 [mindspore/train/serialization.py:650] backbone.layer2.0.conv_down_sample.bias is not loaded.\n", + "[WARNING] ME(1289646:140507235451840,MainProcess):2022-07-27-23:30:32.396.353 [mindspore/train/serialization.py:650] backbone.layer2.1.conv1.bias is not loaded.\n", + "[WARNING] ME(1289646:140507235451840,MainProcess):2022-07-27-23:30:32.396.779 [mindspore/train/serialization.py:650] backbone.layer2.1.conv2.bias is not loaded.\n", + "[WARNING] ME(1289646:140507235451840,MainProcess):2022-07-27-23:30:32.397.027 [mindspore/train/serialization.py:650] backbone.layer2.1.conv3.bias is not loaded.\n", + "[WARNING] ME(1289646:140507235451840,MainProcess):2022-07-27-23:30:32.397.270 [mindspore/train/serialization.py:650] backbone.layer2.2.conv1.bias is not loaded.\n", + "[WARNING] ME(1289646:140507235451840,MainProcess):2022-07-27-23:30:32.397.534 [mindspore/train/serialization.py:650] backbone.layer2.2.conv2.bias is not loaded.\n", + "[WARNING] ME(1289646:140507235451840,MainProcess):2022-07-27-23:30:32.397.771 [mindspore/train/serialization.py:650] backbone.layer2.2.conv3.bias is not loaded.\n", + "[WARNING] ME(1289646:140507235451840,MainProcess):2022-07-27-23:30:32.398.016 [mindspore/train/serialization.py:650] backbone.layer2.3.conv1.bias is not loaded.\n", + "[WARNING] ME(1289646:140507235451840,MainProcess):2022-07-27-23:30:32.398.247 [mindspore/train/serialization.py:650] backbone.layer2.3.conv2.bias is not loaded.\n", + "[WARNING] ME(1289646:140507235451840,MainProcess):2022-07-27-23:30:32.398.476 [mindspore/train/serialization.py:650] backbone.layer2.3.conv3.bias is not loaded.\n", + "[WARNING] ME(1289646:140507235451840,MainProcess):2022-07-27-23:30:32.398.708 [mindspore/train/serialization.py:650] backbone.layer3.0.conv1.bias is not loaded.\n", + "[WARNING] ME(1289646:140507235451840,MainProcess):2022-07-27-23:30:32.398.942 [mindspore/train/serialization.py:650] backbone.layer3.0.conv2.bias is not loaded.\n", + "[WARNING] ME(1289646:140507235451840,MainProcess):2022-07-27-23:30:32.399.169 [mindspore/train/serialization.py:650] backbone.layer3.0.conv3.bias is not loaded.\n", + "[WARNING] ME(1289646:140507235451840,MainProcess):2022-07-27-23:30:32.399.406 [mindspore/train/serialization.py:650] backbone.layer3.0.conv_down_sample.bias is not loaded.\n", + "[WARNING] ME(1289646:140507235451840,MainProcess):2022-07-27-23:30:32.399.636 [mindspore/train/serialization.py:650] backbone.layer3.1.conv1.bias is not loaded.\n", + "[WARNING] ME(1289646:140507235451840,MainProcess):2022-07-27-23:30:32.399.865 [mindspore/train/serialization.py:650] backbone.layer3.1.conv2.bias is not loaded.\n", + "[WARNING] ME(1289646:140507235451840,MainProcess):2022-07-27-23:30:32.400.095 [mindspore/train/serialization.py:650] backbone.layer3.1.conv3.bias is not loaded.\n", + "[WARNING] ME(1289646:140507235451840,MainProcess):2022-07-27-23:30:32.400.335 [mindspore/train/serialization.py:650] backbone.layer3.2.conv1.bias is not loaded.\n", + "[WARNING] ME(1289646:140507235451840,MainProcess):2022-07-27-23:30:32.400.562 [mindspore/train/serialization.py:650] backbone.layer3.2.conv2.bias is not loaded.\n", + "[WARNING] ME(1289646:140507235451840,MainProcess):2022-07-27-23:30:32.400.793 [mindspore/train/serialization.py:650] backbone.layer3.2.conv3.bias is not loaded.\n", + "[WARNING] ME(1289646:140507235451840,MainProcess):2022-07-27-23:30:32.401.032 [mindspore/train/serialization.py:650] backbone.layer3.3.conv1.bias is not loaded.\n", + "[WARNING] ME(1289646:140507235451840,MainProcess):2022-07-27-23:30:32.401.276 [mindspore/train/serialization.py:650] backbone.layer3.3.conv2.bias is not loaded.\n", + "[WARNING] ME(1289646:140507235451840,MainProcess):2022-07-27-23:30:32.401.515 [mindspore/train/serialization.py:650] backbone.layer3.3.conv3.bias is not loaded.\n", + "[WARNING] ME(1289646:140507235451840,MainProcess):2022-07-27-23:30:32.401.741 [mindspore/train/serialization.py:650] backbone.layer3.4.conv1.bias is not loaded.\n", + "[WARNING] ME(1289646:140507235451840,MainProcess):2022-07-27-23:30:32.401.968 [mindspore/train/serialization.py:650] backbone.layer3.4.conv2.bias is not loaded.\n", + "[WARNING] ME(1289646:140507235451840,MainProcess):2022-07-27-23:30:32.402.211 [mindspore/train/serialization.py:650] backbone.layer3.4.conv3.bias is not loaded.\n", + "[WARNING] ME(1289646:140507235451840,MainProcess):2022-07-27-23:30:32.402.446 [mindspore/train/serialization.py:650] backbone.layer3.5.conv1.bias is not loaded.\n", + "[WARNING] ME(1289646:140507235451840,MainProcess):2022-07-27-23:30:32.402.673 [mindspore/train/serialization.py:650] backbone.layer3.5.conv2.bias is not loaded.\n", + "[WARNING] ME(1289646:140507235451840,MainProcess):2022-07-27-23:30:32.402.916 [mindspore/train/serialization.py:650] backbone.layer3.5.conv3.bias is not loaded.\n", + "[WARNING] ME(1289646:140507235451840,MainProcess):2022-07-27-23:30:32.405.019 [mindspore/train/serialization.py:650] backbone.layer4.0.conv1.bias is not loaded.\n", + "[WARNING] ME(1289646:140507235451840,MainProcess):2022-07-27-23:30:32.405.285 [mindspore/train/serialization.py:650] backbone.layer4.0.conv2.bias is not loaded.\n", + "[WARNING] ME(1289646:140507235451840,MainProcess):2022-07-27-23:30:32.405.528 [mindspore/train/serialization.py:650] backbone.layer4.0.conv3.bias is not loaded.\n", + "[WARNING] ME(1289646:140507235451840,MainProcess):2022-07-27-23:30:32.405.785 [mindspore/train/serialization.py:650] backbone.layer4.0.conv_down_sample.bias is not loaded.\n", + "[WARNING] ME(1289646:140507235451840,MainProcess):2022-07-27-23:30:32.406.027 [mindspore/train/serialization.py:650] backbone.layer4.1.conv1.bias is not loaded.\n", + "[WARNING] ME(1289646:140507235451840,MainProcess):2022-07-27-23:30:32.406.279 [mindspore/train/serialization.py:650] backbone.layer4.1.conv2.bias is not loaded.\n", + "[WARNING] ME(1289646:140507235451840,MainProcess):2022-07-27-23:30:32.406.533 [mindspore/train/serialization.py:650] backbone.layer4.1.conv3.bias is not loaded.\n", + "[WARNING] ME(1289646:140507235451840,MainProcess):2022-07-27-23:30:32.406.770 [mindspore/train/serialization.py:650] backbone.layer4.2.conv1.bias is not loaded.\n", + "[WARNING] ME(1289646:140507235451840,MainProcess):2022-07-27-23:30:32.407.016 [mindspore/train/serialization.py:650] backbone.layer4.2.conv2.bias is not loaded.\n", + "[WARNING] ME(1289646:140507235451840,MainProcess):2022-07-27-23:30:32.407.259 [mindspore/train/serialization.py:650] backbone.layer4.2.conv3.bias is not loaded.\n", + "[WARNING] ME(1289646:140507235451840,MainProcess):2022-07-27-23:30:32.407.502 [mindspore/train/serialization.py:650] fpn_ncek.lateral_convs_list.0.weight is not loaded.\n", + "[WARNING] ME(1289646:140507235451840,MainProcess):2022-07-27-23:30:32.407.749 [mindspore/train/serialization.py:650] fpn_ncek.lateral_convs_list.0.bias is not loaded.\n", + "[WARNING] ME(1289646:140507235451840,MainProcess):2022-07-27-23:30:32.407.994 [mindspore/train/serialization.py:650] fpn_ncek.lateral_convs_list.1.weight is not loaded.\n", + "[WARNING] ME(1289646:140507235451840,MainProcess):2022-07-27-23:30:32.408.244 [mindspore/train/serialization.py:650] fpn_ncek.lateral_convs_list.1.bias is not loaded.\n", + "[WARNING] ME(1289646:140507235451840,MainProcess):2022-07-27-23:30:32.408.494 [mindspore/train/serialization.py:650] fpn_ncek.lateral_convs_list.2.weight is not loaded.\n", + "[WARNING] ME(1289646:140507235451840,MainProcess):2022-07-27-23:30:32.408.787 [mindspore/train/serialization.py:650] fpn_ncek.lateral_convs_list.2.bias is not loaded.\n", + "[WARNING] ME(1289646:140507235451840,MainProcess):2022-07-27-23:30:32.409.080 [mindspore/train/serialization.py:650] fpn_ncek.lateral_convs_list.3.weight is not loaded.\n", + "[WARNING] ME(1289646:140507235451840,MainProcess):2022-07-27-23:30:32.409.370 [mindspore/train/serialization.py:650] fpn_ncek.lateral_convs_list.3.bias is not loaded.\n", + "[WARNING] ME(1289646:140507235451840,MainProcess):2022-07-27-23:30:32.409.689 [mindspore/train/serialization.py:650] fpn_ncek.fpn_convs_list.0.weight is not loaded.\n", + "[WARNING] ME(1289646:140507235451840,MainProcess):2022-07-27-23:30:32.409.987 [mindspore/train/serialization.py:650] fpn_ncek.fpn_convs_list.0.bias is not loaded.\n", + "[WARNING] ME(1289646:140507235451840,MainProcess):2022-07-27-23:30:32.410.280 [mindspore/train/serialization.py:650] fpn_ncek.fpn_convs_list.1.weight is not loaded.\n", + "[WARNING] ME(1289646:140507235451840,MainProcess):2022-07-27-23:30:32.410.584 [mindspore/train/serialization.py:650] fpn_ncek.fpn_convs_list.1.bias is not loaded.\n", + "[WARNING] ME(1289646:140507235451840,MainProcess):2022-07-27-23:30:32.412.125 [mindspore/train/serialization.py:650] fpn_ncek.fpn_convs_list.2.weight is not loaded.\n", + "[WARNING] ME(1289646:140507235451840,MainProcess):2022-07-27-23:30:32.412.393 [mindspore/train/serialization.py:650] fpn_ncek.fpn_convs_list.2.bias is not loaded.\n", + "[WARNING] ME(1289646:140507235451840,MainProcess):2022-07-27-23:30:32.412.655 [mindspore/train/serialization.py:650] fpn_ncek.fpn_convs_list.3.weight is not loaded.\n", + "[WARNING] ME(1289646:140507235451840,MainProcess):2022-07-27-23:30:32.412.897 [mindspore/train/serialization.py:650] fpn_ncek.fpn_convs_list.3.bias is not loaded.\n", + "[WARNING] ME(1289646:140507235451840,MainProcess):2022-07-27-23:30:32.413.181 [mindspore/train/serialization.py:650] rpn_with_loss.rpn_convs_list.0.rpn_conv.weight is not loaded.\n", + "[WARNING] ME(1289646:140507235451840,MainProcess):2022-07-27-23:30:32.413.429 [mindspore/train/serialization.py:650] rpn_with_loss.rpn_convs_list.0.rpn_conv.bias is not loaded.\n", + "[WARNING] ME(1289646:140507235451840,MainProcess):2022-07-27-23:30:32.413.698 [mindspore/train/serialization.py:650] rpn_with_loss.rpn_convs_list.0.rpn_cls.weight is not loaded.\n", + "[WARNING] ME(1289646:140507235451840,MainProcess):2022-07-27-23:30:32.413.936 [mindspore/train/serialization.py:650] rpn_with_loss.rpn_convs_list.0.rpn_cls.bias is not loaded.\n", + "[WARNING] ME(1289646:140507235451840,MainProcess):2022-07-27-23:30:32.414.199 [mindspore/train/serialization.py:650] rpn_with_loss.rpn_convs_list.0.rpn_reg.weight is not loaded.\n", + "[WARNING] ME(1289646:140507235451840,MainProcess):2022-07-27-23:30:32.414.440 [mindspore/train/serialization.py:650] rpn_with_loss.rpn_convs_list.0.rpn_reg.bias is not loaded.\n", + "[WARNING] ME(1289646:140507235451840,MainProcess):2022-07-27-23:30:32.414.693 [mindspore/train/serialization.py:650] rcnn_cls.fpn_cls.shared_fc_0.weight is not loaded.\n", + "[WARNING] ME(1289646:140507235451840,MainProcess):2022-07-27-23:30:32.414.942 [mindspore/train/serialization.py:650] rcnn_cls.fpn_cls.shared_fc_0.bias is not loaded.\n", + "[WARNING] ME(1289646:140507235451840,MainProcess):2022-07-27-23:30:32.415.197 [mindspore/train/serialization.py:650] rcnn_cls.fpn_cls.shared_fc_1.weight is not loaded.\n", + "[WARNING] ME(1289646:140507235451840,MainProcess):2022-07-27-23:30:32.415.458 [mindspore/train/serialization.py:650] rcnn_cls.fpn_cls.shared_fc_1.bias is not loaded.\n", + "[WARNING] ME(1289646:140507235451840,MainProcess):2022-07-27-23:30:32.415.708 [mindspore/train/serialization.py:650] rcnn_cls.fpn_cls.cls_scores.weight is not loaded.\n", + "[WARNING] ME(1289646:140507235451840,MainProcess):2022-07-27-23:30:32.415.969 [mindspore/train/serialization.py:650] rcnn_cls.fpn_cls.cls_scores.bias is not loaded.\n", + "[WARNING] ME(1289646:140507235451840,MainProcess):2022-07-27-23:30:32.416.216 [mindspore/train/serialization.py:650] rcnn_cls.fpn_cls.reg_scores.weight is not loaded.\n", + "[WARNING] ME(1289646:140507235451840,MainProcess):2022-07-27-23:30:32.416.476 [mindspore/train/serialization.py:650] rcnn_cls.fpn_cls.reg_scores.bias is not loaded.\n", + "[WARNING] PIPELINE(1289646,7fca63db83c0,python):2022-07-27-23:30:35.375.397 [mindspore/ccsrc/pipeline/jit/pipeline.cc:173] CheckArgValid] The data types of Tensor:[[ True True True False False False False False False False False False\n", + " False False False False False False False False False False False False\n", + " False False False False False False False False False False False False\n", + " False False False False False False False False False False False False\n", + " False False False False False False False False False False False False\n", + " False False False False False False False False False False False False\n", + " False False False False False False False False False False False False\n", + " False False False False False False False False False False False False\n", + " False False False False False False False False False False False False\n", + " False False False False False False False False False False False False\n", + " False False False False False False False False]\n", + " [ True True True True True True True True False False False False\n", + " False False False False False False False False False False False False\n", + " False False False False False False False False False False False False\n", + " False False False False False False False False False False False False\n", + " False False False False False False False False False False False False\n", + " False False False False False False False False False False False False\n", + " False False False False False False False False False False False False\n", + " False False False False False False False False False False False False\n", + " False False False False False False False False False False False False\n", + " False False False False False False False False False False False False\n", + " False False False False False False False False]] is bool, which may cause SelectKernelInfo failure for operator [AddN]. For more details, please refer to the FAQ at https://www.mindspore.cn.\n", + "[WARNING] PIPELINE(1289646,7fca63db83c0,python):2022-07-27-23:30:35.377.424 [mindspore/ccsrc/pipeline/jit/pipeline.cc:173] CheckArgValid] The data types of Tensor:[[[[False False False ... False False False]\n", + " [False False False ... False False False]\n", + " [False False False ... False False False]\n", + " ...\n", + " [False False False ... False False False]\n", + " [False False False ... False False False]\n", + " [False False False ... False False False]]\n", + "\n", + " [[False False False ... False False False]\n", + " [False False False ... False False False]\n", + " [False False False ... False False False]\n", + " ...\n", + " [False False False ... False False False]\n", + " [False False False ... False False False]\n", + " [False False False ... False False False]]\n", + "\n", + " [[False False False ... False False False]\n", + " [False False False ... False False False]\n", + " [False False False ... False False False]\n", + " ...\n", + " [False False False ... False False False]\n", + " [False False False ... False False False]\n", + " [False False False ... False False False]]\n", + "\n", + " ...\n", + "\n", + " [[False False False ... False False False]\n", + " [False False False ... False False False]\n", + " [False False False ... False False False]\n", + " ...\n", + " [False False False ... False False False]\n", + " [False False False ... False False False]\n", + " [False False False ... False False False]]\n", + "\n", + " [[False False False ... False False False]\n", + " [False False False ... False False False]\n", + " [False False False ... False False False]\n", + " ...\n", + " [False False False ... False False False]\n", + " [False False False ... False False False]\n", + " [False False False ... False False False]]\n", + "\n", + " [[False False False ... False False False]\n", + " [False False False ... False False False]\n", + " [False False False ... False False False]\n", + " ...\n", + " [False False False ... False False False]\n", + " [False False False ... False False False]\n", + " [False False False ... False False False]]]\n", + "\n", + "\n", + " [[[False False False ... False False False]\n", + " [False False False ... False False False]\n", + " [False False False ... False False False]\n", + " ...\n", + " [False False False ... False False False]\n", + " [False False False ... False False False]\n", + " [False False False ... False False False]]\n", + "\n", + " [[False False False ... False False False]\n", + " [False False False ... False False False]\n", + " [False False False ... False False False]\n", + " ...\n", + " [False False False ... False False False]\n", + " [False False False ... False False False]\n", + " [False False False ... False False False]]\n", + "\n", + " [[False False False ... False False False]\n", + " [False False False ... False False False]\n", + " [False False False ... False False False]\n", + " ...\n", + " [False False False ... False False False]\n", + " [False False False ... False False False]\n", + " [False False False ... False False False]]\n", + "\n", + " ...\n", + "\n", + " [[False False False ... False False False]\n", + " [False False False ... False False False]\n", + " [False False False ... False False False]\n", + " ...\n", + " [False False False ... False False False]\n", + " [False False False ... False False False]\n", + " [False False False ... False False False]]\n", + "\n", + " [[False False False ... False False False]\n", + " [False False False ... False False False]\n", + " [False False False ... False False False]\n", + " ...\n", + " [False False False ... False False False]\n", + " [False False False ... False False False]\n", + " [False False False ... False False False]]\n", + "\n", + " [[False False False ... False False False]\n", + " [False False False ... False False False]\n", + " [False False False ... False False False]\n", + " ...\n", + " [False False False ... False False False]\n", + " [False False False ... False False False]\n", + " [False False False ... False False False]]]] is bool, which may cause SelectKernelInfo failure for operator [AddN]. For more details, please refer to the FAQ at https://www.mindspore.cn.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "58 epoch: 1 step: 1 total_loss: 5.75554\n", + "59 epoch: 1 step: 2 total_loss: 5.62021\n", + "60 epoch: 1 step: 3 total_loss: 4.39285\n", + "60 epoch: 1 step: 4 total_loss: 3.12360\n", + "61 epoch: 1 step: 5 total_loss: 2.20772\n", + "62 epoch: 1 step: 6 total_loss: 2.08234\n", + "62 epoch: 1 step: 7 total_loss: 1.85937\n", + "63 epoch: 1 step: 8 total_loss: 1.48294\n", + "64 epoch: 1 step: 9 total_loss: 2.45977\n", + "64 epoch: 1 step: 10 total_loss: 4.78331\n", + "65 epoch: 1 step: 11 total_loss: 2.60320\n", + "66 epoch: 1 step: 12 total_loss: 2.66626\n", + "67 epoch: 1 step: 13 total_loss: 2.92546\n", + "68 epoch: 1 step: 14 total_loss: 1.05098\n", + "69 epoch: 1 step: 15 total_loss: 2.44125\n", + "70 epoch: 1 step: 16 total_loss: 1.25769\n", + "71 epoch: 1 step: 17 total_loss: 2.13439\n", + "72 epoch: 1 step: 18 total_loss: 1.85752\n", + "73 epoch: 1 step: 19 total_loss: 1.57048\n", + "73 epoch: 1 step: 20 total_loss: 1.16632\n", + "74 epoch: 1 step: 21 total_loss: 0.95452\n", + "75 epoch: 1 step: 22 total_loss: 1.38052\n", + "75 epoch: 1 step: 23 total_loss: 0.91722\n", + "76 epoch: 1 step: 24 total_loss: 0.92058\n", + "77 epoch: 1 step: 25 total_loss: 1.44209\n", + "78 epoch: 1 step: 26 total_loss: 1.62278\n", + "78 epoch: 1 step: 27 total_loss: 0.97781\n", + "79 epoch: 1 step: 28 total_loss: 1.98220\n", + "80 epoch: 1 step: 29 total_loss: 1.54636\n", + "80 epoch: 1 step: 30 total_loss: 1.13240\n", + "81 epoch: 1 step: 31 total_loss: 1.45014\n", + "82 epoch: 1 step: 32 total_loss: 0.87475\n", + "82 epoch: 1 step: 33 total_loss: 1.08100\n", + "83 epoch: 1 step: 34 total_loss: 1.36666\n", + "84 epoch: 1 step: 35 total_loss: 1.28859\n", + "84 epoch: 1 step: 36 total_loss: 1.48311\n", + "85 epoch: 1 step: 37 total_loss: 1.17995\n", + "86 epoch: 1 step: 38 total_loss: 1.42331\n", + "86 epoch: 1 step: 39 total_loss: 1.17482\n", + "87 epoch: 1 step: 40 total_loss: 1.84335\n", + "88 epoch: 1 step: 41 total_loss: 1.44425\n", + "89 epoch: 1 step: 42 total_loss: 1.15063\n", + "89 epoch: 1 step: 43 total_loss: 0.96332\n", + "90 epoch: 1 step: 44 total_loss: 1.46840\n", + "91 epoch: 1 step: 45 total_loss: 1.93449\n", + "91 epoch: 1 step: 46 total_loss: 1.37041\n", + "92 epoch: 1 step: 47 total_loss: 1.96878\n", + "93 epoch: 1 step: 48 total_loss: 1.11222\n", + "93 epoch: 1 step: 49 total_loss: 1.23973\n", + "94 epoch: 1 step: 50 total_loss: 1.93399\n", + "95 epoch: 1 step: 51 total_loss: 0.91994\n", + "95 epoch: 1 step: 52 total_loss: 1.58976\n", + "96 epoch: 1 step: 53 total_loss: 1.69277\n", + "97 epoch: 1 step: 54 total_loss: 1.47368\n", + "97 epoch: 1 step: 55 total_loss: 1.21262\n", + "98 epoch: 1 step: 56 total_loss: 1.52950\n", + "99 epoch: 1 step: 57 total_loss: 0.98201\n", + "99 epoch: 1 step: 58 total_loss: 1.20535\n", + "100 epoch: 1 step: 59 total_loss: 1.22178\n", + "101 epoch: 1 step: 60 total_loss: 1.29352\n", + "102 epoch: 1 step: 61 total_loss: 1.34618\n", + "102 epoch: 1 step: 62 total_loss: 2.33590\n", + "103 epoch: 1 step: 63 total_loss: 1.24699\n", + "104 epoch: 1 step: 64 total_loss: 1.82364\n", + "104 epoch: 1 step: 65 total_loss: 1.18940\n", + "105 epoch: 1 step: 66 total_loss: 1.08232\n", + "106 epoch: 1 step: 67 total_loss: 1.29253\n", + "106 epoch: 1 step: 68 total_loss: 1.34224\n", + "107 epoch: 1 step: 69 total_loss: 1.15712\n", + "108 epoch: 1 step: 70 total_loss: 1.37997\n", + "108 epoch: 1 step: 71 total_loss: 1.35490\n", + "109 epoch: 1 step: 72 total_loss: 1.45236\n", + "110 epoch: 1 step: 73 total_loss: 1.71247\n", + "110 epoch: 1 step: 74 total_loss: 1.17064\n", + "111 epoch: 1 step: 75 total_loss: 1.47019\n", + "112 epoch: 1 step: 76 total_loss: 2.02627\n", + "112 epoch: 1 step: 77 total_loss: 0.79998\n", + "113 epoch: 1 step: 78 total_loss: 0.98788\n", + "114 epoch: 1 step: 79 total_loss: 1.17783\n", + "114 epoch: 1 step: 80 total_loss: 0.96300\n", + "115 epoch: 1 step: 81 total_loss: 2.99116\n", + "116 epoch: 1 step: 82 total_loss: 1.02599\n", + "117 epoch: 1 step: 83 total_loss: 1.96789\n", + "117 epoch: 1 step: 84 total_loss: 1.10882\n", + "118 epoch: 1 step: 85 total_loss: 1.30341\n", + "119 epoch: 1 step: 86 total_loss: 1.18809\n", + "119 epoch: 1 step: 87 total_loss: 2.02210\n", + "120 epoch: 1 step: 88 total_loss: 0.93199\n", + "121 epoch: 1 step: 89 total_loss: 1.32749\n", + "121 epoch: 1 step: 90 total_loss: 1.17464\n", + "122 epoch: 1 step: 91 total_loss: 0.74877\n", + "123 epoch: 1 step: 92 total_loss: 1.13211\n", + "123 epoch: 1 step: 93 total_loss: 1.60181\n", + "124 epoch: 1 step: 94 total_loss: 1.62449\n", + "125 epoch: 1 step: 95 total_loss: 2.71518\n", + "125 epoch: 1 step: 96 total_loss: 1.31592\n", + "126 epoch: 1 step: 97 total_loss: 1.58154\n", + "127 epoch: 1 step: 98 total_loss: 0.87627\n", + "127 epoch: 1 step: 99 total_loss: 0.95769\n", + "128 epoch: 1 step: 100 total_loss: 1.19945\n", + "129 epoch: 1 step: 101 total_loss: 2.51535\n", + "129 epoch: 1 step: 102 total_loss: 0.93991\n", + "End training, time: 1658964762.9842348 ,epoch: 1 ,step: 102 ,loss: 0.9399106502532959\n", + "epoch time: 129033.264 ms, per step time: 2.491 ms\n" + ] + } + ], + "source": [ + "from utils.lr_schedule import dynamic_lr\n", + "\n", + "set_seed(1)\n", + "\n", + "def train_maskrcnn():\n", + " \"\"\"Construct the traning function\"\"\"\n", + " # Allocating memory Environment\n", + " device_target = config.device_target\n", + " rank = 0\n", + " device_num = 1\n", + " context.set_context(mode=context.GRAPH_MODE, device_target=device_target)\n", + "\n", + " print(\"Start create dataset!\")\n", + " # Call the interface for data processing\n", + " # It will generate mindrecord file in config.mindrecord_dir,\n", + " # and the file name is MaskRcnn.mindrecord0, 1, ... file_num.\n", + " prefix = \"MaskRcnn.mindrecord\"\n", + " mindrecord_dir = config.mindrecord_dir\n", + " mindrecord_file = os.path.join(mindrecord_dir, prefix + \"0\")\n", + " if rank == 0 and not os.path.exists(mindrecord_file):\n", + " create_mindrecord_dir(prefix, mindrecord_dir)\n", + " # When create MindDataset, using the fitst mindrecord file,\n", + " # such as MaskRcnn.mindrecord0.\n", + " dataset = create_coco_dataset(mindrecord_file, batch_size=config.batch_size, device_num=device_num, rank_id=rank)\n", + " dataset_size = dataset.get_dataset_size()\n", + " print(\"total images num: \", dataset_size)\n", + " print(\"Create dataset done!\")\n", + " # Net Instance\n", + " net = MaskRcnnResnet50(config=config)\n", + "\n", + " net = net.set_train()\n", + " # load pretrained model\n", + " load_path = config.pre_trained\n", + " if load_path != \"\":\n", + " print(\"Loading pretrained resnet50 checkpoint\")\n", + " net = load_pretrained_ckpt(net=net, load_path=load_path, device_target=device_target)\n", + "\n", + " loss = LossNet()\n", + " lr = Tensor(dynamic_lr(config, rank_size=device_num, start_steps=config.pretrain_epoch_size * dataset_size),\n", + " mstype.float32)\n", + " opt = Momentum(params=net.trainable_params(), learning_rate=lr, momentum=config.momentum,\n", + " weight_decay=config.weight_decay, loss_scale=config.loss_scale)\n", + " # wrap the loss function\n", + " net_with_loss = WithLossCell(net, loss)\n", + " # Use TrainOneStepCell set the training pipeline.\n", + " net = TrainOneStepCell(net_with_loss, opt, sens=config.loss_scale)\n", + " # Monitor the traning process.\n", + " time_cb = TimeMonitor(data_size=dataset_size)\n", + " loss_cb = LossCallBack(rank_id=rank)\n", + " cb = [time_cb, loss_cb]\n", + " # save the trained model\n", + " if config.save_checkpoint:\n", + " # set saved weights.\n", + " ckpt_step = config.save_checkpoint_epochs * dataset_size\n", + " ckptconfig = CheckpointConfig(save_checkpoint_steps=ckpt_step, keep_checkpoint_max=config.keep_checkpoint_max)\n", + " save_checkpoint_path = os.path.join(config.save_checkpoint_path, 'ckpt_' + str(rank) + '/')\n", + " # apply saved weights.\n", + " ckpoint_cb = ModelCheckpoint(prefix='mask_rcnn', directory=save_checkpoint_path, config=ckptconfig)\n", + " cb += [ckpoint_cb]\n", + " # start training.\n", + " model = Model(net)\n", + " model.train(config.epoch_size, dataset, callbacks=cb, dataset_sink_mode=False)\n", + "\n", + "if __name__ == '__main__':\n", + " train_maskrcnn()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 评估\n", + "\n", + "完成训练后，我们可以将我们训练的模型保存在checkpoint目录下。\n", + "\n", + "在COCO的validation数据集上，可以评估我们训练好的模型的准确性。" + ] + }, + { + "cell_type": "code", + "execution_count": 33, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Start Eval!\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/maskrcnn/miniconda3/envs/mrcnn17/lib/python3.7/site-packages/ipykernel_launcher.py:155: DeprecationWarning: `np.bool` is a deprecated alias for the builtin `bool`. To silence this warning, use `bool` by itself. Doing this will not modify any behavior and is safe. If you specifically wanted the numpy scalar type, use `np.bool_` here.\n", + "Deprecated in NumPy 1.20; for more details and guidance: https://numpy.org/devdocs/release/1.20.0-notes.html#deprecations\n", + "/home/maskrcnn/miniconda3/envs/mrcnn17/lib/python3.7/site-packages/ipykernel_launcher.py:156: DeprecationWarning: `np.bool` is a deprecated alias for the builtin `bool`. To silence this warning, use `bool` by itself. Doing this will not modify any behavior and is safe. If you specifically wanted the numpy scalar type, use `np.bool_` here.\n", + "Deprecated in NumPy 1.20; for more details and guidance: https://numpy.org/devdocs/release/1.20.0-notes.html#deprecations\n", + "[WARNING] ME(1289646:140507235451840,MainProcess):2022-07-27-23:32:48.595.02 [mindspore/train/serialization.py:648] For 'load_param_into_net', 53 parameters in the 'net' are not loaded, because they are not in the 'parameter_dict', please check whether the network structure is consistent when training and loading checkpoint.\n", + "[WARNING] ME(1289646:140507235451840,MainProcess):2022-07-27-23:32:48.601.40 [mindspore/train/serialization.py:650] backbone.conv1.bias is not loaded.\n", + "[WARNING] ME(1289646:140507235451840,MainProcess):2022-07-27-23:32:48.605.69 [mindspore/train/serialization.py:650] backbone.layer1.0.conv1.bias is not loaded.\n", + "[WARNING] ME(1289646:140507235451840,MainProcess):2022-07-27-23:32:48.608.74 [mindspore/train/serialization.py:650] backbone.layer1.0.conv2.bias is not loaded.\n", + "[WARNING] ME(1289646:140507235451840,MainProcess):2022-07-27-23:32:48.611.73 [mindspore/train/serialization.py:650] backbone.layer1.0.conv3.bias is not loaded.\n", + "[WARNING] ME(1289646:140507235451840,MainProcess):2022-07-27-23:32:48.614.65 [mindspore/train/serialization.py:650] backbone.layer1.0.conv_down_sample.bias is not loaded.\n", + "[WARNING] ME(1289646:140507235451840,MainProcess):2022-07-27-23:32:48.617.53 [mindspore/train/serialization.py:650] backbone.layer1.1.conv1.bias is not loaded.\n", + "[WARNING] ME(1289646:140507235451840,MainProcess):2022-07-27-23:32:48.620.48 [mindspore/train/serialization.py:650] backbone.layer1.1.conv2.bias is not loaded.\n", + "[WARNING] ME(1289646:140507235451840,MainProcess):2022-07-27-23:32:48.628.26 [mindspore/train/serialization.py:650] backbone.layer1.1.conv3.bias is not loaded.\n", + "[WARNING] ME(1289646:140507235451840,MainProcess):2022-07-27-23:32:48.631.16 [mindspore/train/serialization.py:650] backbone.layer1.2.conv1.bias is not loaded.\n", + "[WARNING] ME(1289646:140507235451840,MainProcess):2022-07-27-23:32:48.634.01 [mindspore/train/serialization.py:650] backbone.layer1.2.conv2.bias is not loaded.\n", + "[WARNING] ME(1289646:140507235451840,MainProcess):2022-07-27-23:32:48.636.95 [mindspore/train/serialization.py:650] backbone.layer1.2.conv3.bias is not loaded.\n", + "[WARNING] ME(1289646:140507235451840,MainProcess):2022-07-27-23:32:48.639.68 [mindspore/train/serialization.py:650] backbone.layer2.0.conv1.bias is not loaded.\n", + "[WARNING] ME(1289646:140507235451840,MainProcess):2022-07-27-23:32:48.642.69 [mindspore/train/serialization.py:650] backbone.layer2.0.conv2.bias is not loaded.\n", + "[WARNING] ME(1289646:140507235451840,MainProcess):2022-07-27-23:32:48.645.46 [mindspore/train/serialization.py:650] backbone.layer2.0.conv3.bias is not loaded.\n", + "[WARNING] ME(1289646:140507235451840,MainProcess):2022-07-27-23:32:48.648.30 [mindspore/train/serialization.py:650] backbone.layer2.0.conv_down_sample.bias is not loaded.\n", + "[WARNING] ME(1289646:140507235451840,MainProcess):2022-07-27-23:32:48.651.13 [mindspore/train/serialization.py:650] backbone.layer2.1.conv1.bias is not loaded.\n", + "[WARNING] ME(1289646:140507235451840,MainProcess):2022-07-27-23:32:48.654.17 [mindspore/train/serialization.py:650] backbone.layer2.1.conv2.bias is not loaded.\n", + "[WARNING] ME(1289646:140507235451840,MainProcess):2022-07-27-23:32:48.656.95 [mindspore/train/serialization.py:650] backbone.layer2.1.conv3.bias is not loaded.\n", + "[WARNING] ME(1289646:140507235451840,MainProcess):2022-07-27-23:32:48.659.91 [mindspore/train/serialization.py:650] backbone.layer2.2.conv1.bias is not loaded.\n", + "[WARNING] ME(1289646:140507235451840,MainProcess):2022-07-27-23:32:48.662.58 [mindspore/train/serialization.py:650] backbone.layer2.2.conv2.bias is not loaded.\n", + "[WARNING] ME(1289646:140507235451840,MainProcess):2022-07-27-23:32:48.665.53 [mindspore/train/serialization.py:650] backbone.layer2.2.conv3.bias is not loaded.\n", + "[WARNING] ME(1289646:140507235451840,MainProcess):2022-07-27-23:32:48.668.37 [mindspore/train/serialization.py:650] backbone.layer2.3.conv1.bias is not loaded.\n", + "[WARNING] ME(1289646:140507235451840,MainProcess):2022-07-27-23:32:48.671.12 [mindspore/train/serialization.py:650] backbone.layer2.3.conv2.bias is not loaded.\n", + "[WARNING] ME(1289646:140507235451840,MainProcess):2022-07-27-23:32:48.673.90 [mindspore/train/serialization.py:650] backbone.layer2.3.conv3.bias is not loaded.\n", + "[WARNING] ME(1289646:140507235451840,MainProcess):2022-07-27-23:32:48.676.95 [mindspore/train/serialization.py:650] backbone.layer3.0.conv1.bias is not loaded.\n", + "[WARNING] ME(1289646:140507235451840,MainProcess):2022-07-27-23:32:48.679.81 [mindspore/train/serialization.py:650] backbone.layer3.0.conv2.bias is not loaded.\n", + "[WARNING] ME(1289646:140507235451840,MainProcess):2022-07-27-23:32:48.682.63 [mindspore/train/serialization.py:650] backbone.layer3.0.conv3.bias is not loaded.\n", + "[WARNING] ME(1289646:140507235451840,MainProcess):2022-07-27-23:32:48.685.38 [mindspore/train/serialization.py:650] backbone.layer3.0.conv_down_sample.bias is not loaded.\n", + "[WARNING] ME(1289646:140507235451840,MainProcess):2022-07-27-23:32:48.688.34 [mindspore/train/serialization.py:650] backbone.layer3.1.conv1.bias is not loaded.\n", + "[WARNING] ME(1289646:140507235451840,MainProcess):2022-07-27-23:32:48.691.18 [mindspore/train/serialization.py:650] backbone.layer3.1.conv2.bias is not loaded.\n", + "[WARNING] ME(1289646:140507235451840,MainProcess):2022-07-27-23:32:48.694.14 [mindspore/train/serialization.py:650] backbone.layer3.1.conv3.bias is not loaded.\n", + "[WARNING] ME(1289646:140507235451840,MainProcess):2022-07-27-23:32:48.696.78 [mindspore/train/serialization.py:650] backbone.layer3.2.conv1.bias is not loaded.\n", + "[WARNING] ME(1289646:140507235451840,MainProcess):2022-07-27-23:32:48.699.74 [mindspore/train/serialization.py:650] backbone.layer3.2.conv2.bias is not loaded.\n", + "[WARNING] ME(1289646:140507235451840,MainProcess):2022-07-27-23:32:48.702.42 [mindspore/train/serialization.py:650] backbone.layer3.2.conv3.bias is not loaded.\n", + "[WARNING] ME(1289646:140507235451840,MainProcess):2022-07-27-23:32:48.705.18 [mindspore/train/serialization.py:650] backbone.layer3.3.conv1.bias is not loaded.\n", + "[WARNING] ME(1289646:140507235451840,MainProcess):2022-07-27-23:32:48.707.91 [mindspore/train/serialization.py:650] backbone.layer3.3.conv2.bias is not loaded.\n", + "[WARNING] ME(1289646:140507235451840,MainProcess):2022-07-27-23:32:48.710.83 [mindspore/train/serialization.py:650] backbone.layer3.3.conv3.bias is not loaded.\n", + "[WARNING] ME(1289646:140507235451840,MainProcess):2022-07-27-23:32:48.713.68 [mindspore/train/serialization.py:650] backbone.layer3.4.conv1.bias is not loaded.\n", + "[WARNING] ME(1289646:140507235451840,MainProcess):2022-07-27-23:32:48.716.59 [mindspore/train/serialization.py:650] backbone.layer3.4.conv2.bias is not loaded.\n", + "[WARNING] ME(1289646:140507235451840,MainProcess):2022-07-27-23:32:48.719.24 [mindspore/train/serialization.py:650] backbone.layer3.4.conv3.bias is not loaded.\n", + "[WARNING] ME(1289646:140507235451840,MainProcess):2022-07-27-23:32:48.722.19 [mindspore/train/serialization.py:650] backbone.layer3.5.conv1.bias is not loaded.\n", + "[WARNING] ME(1289646:140507235451840,MainProcess):2022-07-27-23:32:48.724.90 [mindspore/train/serialization.py:650] backbone.layer3.5.conv2.bias is not loaded.\n", + "[WARNING] ME(1289646:140507235451840,MainProcess):2022-07-27-23:32:48.727.85 [mindspore/train/serialization.py:650] backbone.layer3.5.conv3.bias is not loaded.\n", + "[WARNING] ME(1289646:140507235451840,MainProcess):2022-07-27-23:32:48.730.67 [mindspore/train/serialization.py:650] backbone.layer4.0.conv1.bias is not loaded.\n", + "[WARNING] ME(1289646:140507235451840,MainProcess):2022-07-27-23:32:48.733.62 [mindspore/train/serialization.py:650] backbone.layer4.0.conv2.bias is not loaded.\n", + "[WARNING] ME(1289646:140507235451840,MainProcess):2022-07-27-23:32:48.736.40 [mindspore/train/serialization.py:650] backbone.layer4.0.conv3.bias is not loaded.\n", + "[WARNING] ME(1289646:140507235451840,MainProcess):2022-07-27-23:32:48.739.31 [mindspore/train/serialization.py:650] backbone.layer4.0.conv_down_sample.bias is not loaded.\n", + "[WARNING] ME(1289646:140507235451840,MainProcess):2022-07-27-23:32:48.741.95 [mindspore/train/serialization.py:650] backbone.layer4.1.conv1.bias is not loaded.\n", + "[WARNING] ME(1289646:140507235451840,MainProcess):2022-07-27-23:32:48.744.82 [mindspore/train/serialization.py:650] backbone.layer4.1.conv2.bias is not loaded.\n", + "[WARNING] ME(1289646:140507235451840,MainProcess):2022-07-27-23:32:48.747.67 [mindspore/train/serialization.py:650] backbone.layer4.1.conv3.bias is not loaded.\n", + "[WARNING] ME(1289646:140507235451840,MainProcess):2022-07-27-23:32:48.750.58 [mindspore/train/serialization.py:650] backbone.layer4.2.conv1.bias is not loaded.\n", + "[WARNING] ME(1289646:140507235451840,MainProcess):2022-07-27-23:32:48.753.23 [mindspore/train/serialization.py:650] backbone.layer4.2.conv2.bias is not loaded.\n", + "[WARNING] ME(1289646:140507235451840,MainProcess):2022-07-27-23:32:48.756.11 [mindspore/train/serialization.py:650] backbone.layer4.2.conv3.bias is not loaded.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "loading annotations into memory...\n", + "Done (t=0.54s)\n", + "creating index...\n", + "index created!\n", + "total images num: 2500\n", + "Processing, please wait a moment.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "[WARNING] PIPELINE(1289646,7fca63db83c0,python):2022-07-27-23:32:49.023.161 [mindspore/ccsrc/pipeline/jit/pipeline.cc:173] CheckArgValid] The data types of Tensor:[[False False False False False False False False False False False False\n", + " False False False False False False False False False False False False\n", + " False False False False False False False False False False False False\n", + " False False False False False False False False False False False False\n", + " False False False False False False False False False False False False\n", + " False False False False False False False False False False False False\n", + " False False False False False False False False False False False False\n", + " False False False False False False False False False False False False\n", + " False False False False False False False False False False False False\n", + " False False False False False False False False False False False False\n", + " False False False False False False False False]\n", + " [False False False False False False False False False False False False\n", + " False False False False False False False False False False False False\n", + " False False False False False False False False False False False False\n", + " False False False False False False False False False False False False\n", + " False False False False False False False False False False False False\n", + " False False False False False False False False False False False False\n", + " False False False False False False False False False False False False\n", + " False False False False False False False False False False False False\n", + " False False False False False False False False False False False False\n", + " False False False False False False False False False False False False\n", + " False False False False False False False False]] is bool, which may cause SelectKernelInfo failure for operator [AddN]. For more details, please refer to the FAQ at https://www.mindspore.cn.\n", + "[WARNING] PIPELINE(1289646,7fca63db83c0,python):2022-07-27-23:32:49.023.271 [mindspore/ccsrc/pipeline/jit/pipeline.cc:173] CheckArgValid] The data types of Tensor:[[[[False]]]\n", + "\n", + "\n", + " [[[False]]]] is bool, which may cause SelectKernelInfo failure for operator [AddN]. For more details, please refer to the FAQ at https://www.mindspore.cn.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Evaluation cost time 1896.9504017829895\n", + "Loading and preparing results...\n", + "DONE (t=1.67s)\n", + "creating index...\n", + "index created!\n", + "Running per image evaluation...\n", + "Evaluate annotation type *bbox*\n", + "DONE (t=27.94s).\n", + "Accumulating evaluation results...\n", + "DONE (t=5.42s).\n", + " Average Precision (AP) @[ IoU=0.50:0.95 | area= all | maxDets=100 ] = 0.374\n", + " Average Precision (AP) @[ IoU=0.50 | area= all | maxDets=100 ] = 0.599\n", + " Average Precision (AP) @[ IoU=0.75 | area= all | maxDets=100 ] = 0.403\n", + " Average Precision (AP) @[ IoU=0.50:0.95 | area= small | maxDets=100 ] = 0.235\n", + " Average Precision (AP) @[ IoU=0.50:0.95 | area=medium | maxDets=100 ] = 0.415\n", + " Average Precision (AP) @[ IoU=0.50:0.95 | area= large | maxDets=100 ] = 0.474\n", + " Average Recall (AR) @[ IoU=0.50:0.95 | area= all | maxDets= 1 ] = 0.312\n", + " Average Recall (AR) @[ IoU=0.50:0.95 | area= all | maxDets= 10 ] = 0.501\n", + " Average Recall (AR) @[ IoU=0.50:0.95 | area= all | maxDets=100 ] = 0.530\n", + " Average Recall (AR) @[ IoU=0.50:0.95 | area= small | maxDets=100 ] = 0.363\n", + " Average Recall (AR) @[ IoU=0.50:0.95 | area=medium | maxDets=100 ] = 0.571\n", + " Average Recall (AR) @[ IoU=0.50:0.95 | area= large | maxDets=100 ] = 0.656\n", + "Loading and preparing results...\n", + "DONE (t=4.10s)\n", + "creating index...\n", + "index created!\n", + "Running per image evaluation...\n", + "Evaluate annotation type *segm*\n", + "DONE (t=32.34s).\n", + "Accumulating evaluation results...\n", + "DONE (t=5.36s).\n", + " Average Precision (AP) @[ IoU=0.50:0.95 | area= all | maxDets=100 ] = 0.329\n", + " Average Precision (AP) @[ IoU=0.50 | area= all | maxDets=100 ] = 0.555\n", + " Average Precision (AP) @[ IoU=0.75 | area= all | maxDets=100 ] = 0.344\n", + " Average Precision (AP) @[ IoU=0.50:0.95 | area= small | maxDets=100 ] = 0.165\n", + " Average Precision (AP) @[ IoU=0.50:0.95 | area=medium | maxDets=100 ] = 0.357\n", + " Average Precision (AP) @[ IoU=0.50:0.95 | area= large | maxDets=100 ] = 0.477\n", + " Average Recall (AR) @[ IoU=0.50:0.95 | area= all | maxDets= 1 ] = 0.284\n", + " Average Recall (AR) @[ IoU=0.50:0.95 | area= all | maxDets= 10 ] = 0.436\n", + " Average Recall (AR) @[ IoU=0.50:0.95 | area= all | maxDets=100 ] = 0.455\n", + " Average Recall (AR) @[ IoU=0.50:0.95 | area= small | maxDets=100 ] = 0.283\n", + " Average Recall (AR) @[ IoU=0.50:0.95 | area=medium | maxDets=100 ] = 0.490\n", + " Average Recall (AR) @[ IoU=0.50:0.95 | area= large | maxDets=100 ] = 0.592\n", + "ckpt_path= ./checkpoint/maskrcnn_coco2017_acc32.9.ckpt\n" + ] + } + ], + "source": [ + "from pycocotools.coco import COCO\n", + "\n", + "from utils.util import coco_eval, bbox2result_1image, results2json, get_seg_masks\n", + "\n", + "set_seed(1)\n", + "\n", + "\n", + "def maskrcnn_eval(dataset_path, ckpt_path, ann_file):\n", + " \"\"\"\n", + " MaskRcnn evaluation.\n", + "\n", + " Args:\n", + " dataset_path(str): Dataset file path.\n", + " ckpt_path(str): Checkpoint file path.\n", + " ann_file(str): Annotations file path.\n", + " \"\"\"\n", + " ds = create_coco_dataset(dataset_path, batch_size=config.test_batch_size, is_training=False)\n", + "\n", + " net = MaskRcnnResnet50(config)\n", + " param_dict = load_checkpoint(ckpt_path)\n", + " load_param_into_net(net, param_dict)\n", + " net.set_train(False)\n", + "\n", + " eval_iter = 0\n", + " total = ds.get_dataset_size()\n", + " outputs = []\n", + " dataset_coco = COCO(ann_file)\n", + "\n", + " print(\"total images num: \", total)\n", + " print(\"Processing, please wait a moment.\")\n", + " max_num = 128\n", + " start = time.time()\n", + " for data in ds.create_dict_iterator(output_numpy=True, num_epochs=1):\n", + " eval_iter = eval_iter + 1\n", + "\n", + " img_data = data['image']\n", + " img_metas = data['image_shape']\n", + " gt_bboxes = data['box']\n", + " gt_labels = data['label']\n", + " gt_num = data['valid_num']\n", + " gt_mask = data[\"mask\"]\n", + "\n", + " # run net\n", + " output = net(Tensor(img_data), Tensor(img_metas), Tensor(gt_bboxes),\n", + " Tensor(gt_labels), Tensor(gt_num), Tensor(gt_mask))\n", + "\n", + " # output\n", + " all_bbox = output[0]\n", + " all_label = output[1]\n", + " all_mask = output[2]\n", + " all_mask_fb = output[3]\n", + "\n", + " for j in range(config.test_batch_size):\n", + " all_bbox_squee = np.squeeze(all_bbox.asnumpy()[j, :, :])\n", + " all_label_squee = np.squeeze(all_label.asnumpy()[j, :, :])\n", + " all_mask_squee = np.squeeze(all_mask.asnumpy()[j, :, :])\n", + " all_mask_fb_squee = np.squeeze(all_mask_fb.asnumpy()[j, :, :, :])\n", + "\n", + " all_bboxes_tmp_mask = all_bbox_squee[all_mask_squee, :]\n", + " all_labels_tmp_mask = all_label_squee[all_mask_squee]\n", + " all_mask_fb_tmp_mask = all_mask_fb_squee[all_mask_squee, :, :]\n", + "\n", + " if all_bboxes_tmp_mask.shape[0] > max_num:\n", + " inds = np.argsort(-all_bboxes_tmp_mask[:, -1])\n", + " inds = inds[:max_num]\n", + " all_bboxes_tmp_mask = all_bboxes_tmp_mask[inds]\n", + " all_labels_tmp_mask = all_labels_tmp_mask[inds]\n", + " all_mask_fb_tmp_mask = all_mask_fb_tmp_mask[inds]\n", + "\n", + " bbox_results = bbox2result_1image(all_bboxes_tmp_mask, all_labels_tmp_mask, config.num_classes)\n", + " segm_results = get_seg_masks(all_mask_fb_tmp_mask, all_bboxes_tmp_mask, all_labels_tmp_mask,\n", + " img_metas[j], True, config.num_classes)\n", + " outputs.append((bbox_results, segm_results))\n", + "\n", + " end = time.time()\n", + " print(\"Evaluation cost time {}\".format(end - start))\n", + " eval_types = [\"bbox\", \"segm\"]\n", + " result_files = results2json(dataset_coco, outputs, \"./results.pkl\")\n", + " coco_eval(result_files, eval_types, dataset_coco, single_result=False)\n", + "\n", + "def eval_():\n", + " \"\"\"Execute the Evaluation.\"\"\"\n", + " device_target = config.device_target\n", + " context.set_context(mode=context.GRAPH_MODE, device_target=device_target)\n", + "\n", + " config.mindrecord_dir = os.path.join(config.data_root, config.mindrecord_dir)\n", + "\n", + " prefix = \"MaskRcnn_eval.mindrecord\"\n", + " mindrecord_dir = config.mindrecord_dir\n", + " mindrecord_file = os.path.join(mindrecord_dir, prefix)\n", + "\n", + " if not os.path.exists(mindrecord_file):\n", + " if not os.path.isdir(mindrecord_dir):\n", + " os.makedirs(mindrecord_dir)\n", + " if config.dataset == \"coco\":\n", + " if os.path.isdir(config.data_root):\n", + " print(\"Create Mindrecord.\")\n", + " data_to_mindrecord_byte_image(\"coco\", False, prefix, file_num=1)\n", + " print(\"Create Mindrecord Done, at {}\".format(mindrecord_dir))\n", + " else:\n", + " print(\"data_root not exits.\")\n", + " else:\n", + " if os.path.isdir(config.IMAGE_DIR) and os.path.exists(config.ANNO_PATH):\n", + " print(\"Create Mindrecord.\")\n", + " data_to_mindrecord_byte_image(\"other\", False, prefix, file_num=1)\n", + " print(\"Create Mindrecord Done, at {}\".format(mindrecord_dir))\n", + " else:\n", + " print(\"IMAGE_DIR or ANNO_PATH not exits.\")\n", + "\n", + " print(\"Start Eval!\")\n", + " maskrcnn_eval(mindrecord_file, config.checkpoint_path, config.ann_file)\n", + " print(\"ckpt_path=\", config.checkpoint_path)\n", + "\n", + "if __name__ == '__main__':\n", + " eval_()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 推理\n", + "\n", + "最后，可以使用自己的数据集来测试训练后的模型，完成目标检测。" + ] + }, + { + "cell_type": "code", + "execution_count": 38, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/maskrcnn/miniconda3/envs/mrcnn17/lib/python3.7/site-packages/ipykernel_launcher.py:155: DeprecationWarning: `np.bool` is a deprecated alias for the builtin `bool`. To silence this warning, use `bool` by itself. Doing this will not modify any behavior and is safe. If you specifically wanted the numpy scalar type, use `np.bool_` here.\n", + "Deprecated in NumPy 1.20; for more details and guidance: https://numpy.org/devdocs/release/1.20.0-notes.html#deprecations\n", + "/home/maskrcnn/miniconda3/envs/mrcnn17/lib/python3.7/site-packages/ipykernel_launcher.py:156: DeprecationWarning: `np.bool` is a deprecated alias for the builtin `bool`. To silence this warning, use `bool` by itself. Doing this will not modify any behavior and is safe. If you specifically wanted the numpy scalar type, use `np.bool_` here.\n", + "Deprecated in NumPy 1.20; for more details and guidance: https://numpy.org/devdocs/release/1.20.0-notes.html#deprecations\n", + "[WARNING] ME(1289646:140507235451840,MainProcess):2022-07-28-00:20:38.325.709 [mindspore/train/serialization.py:648] For 'load_param_into_net', 53 parameters in the 'net' are not loaded, because they are not in the 'parameter_dict', please check whether the network structure is consistent when training and loading checkpoint.\n", + "[WARNING] ME(1289646:140507235451840,MainProcess):2022-07-28-00:20:38.326.820 [mindspore/train/serialization.py:650] backbone.conv1.bias is not loaded.\n", + "[WARNING] ME(1289646:140507235451840,MainProcess):2022-07-28-00:20:38.327.509 [mindspore/train/serialization.py:650] backbone.layer1.0.conv1.bias is not loaded.\n", + "[WARNING] ME(1289646:140507235451840,MainProcess):2022-07-28-00:20:38.328.057 [mindspore/train/serialization.py:650] backbone.layer1.0.conv2.bias is not loaded.\n", + "[WARNING] ME(1289646:140507235451840,MainProcess):2022-07-28-00:20:38.328.627 [mindspore/train/serialization.py:650] backbone.layer1.0.conv3.bias is not loaded.\n", + "[WARNING] ME(1289646:140507235451840,MainProcess):2022-07-28-00:20:38.329.161 [mindspore/train/serialization.py:650] backbone.layer1.0.conv_down_sample.bias is not loaded.\n", + "[WARNING] ME(1289646:140507235451840,MainProcess):2022-07-28-00:20:38.329.722 [mindspore/train/serialization.py:650] backbone.layer1.1.conv1.bias is not loaded.\n", + "[WARNING] ME(1289646:140507235451840,MainProcess):2022-07-28-00:20:38.330.237 [mindspore/train/serialization.py:650] backbone.layer1.1.conv2.bias is not loaded.\n", + "[WARNING] ME(1289646:140507235451840,MainProcess):2022-07-28-00:20:38.330.765 [mindspore/train/serialization.py:650] backbone.layer1.1.conv3.bias is not loaded.\n", + "[WARNING] ME(1289646:140507235451840,MainProcess):2022-07-28-00:20:38.331.291 [mindspore/train/serialization.py:650] backbone.layer1.2.conv1.bias is not loaded.\n", + "[WARNING] ME(1289646:140507235451840,MainProcess):2022-07-28-00:20:38.331.863 [mindspore/train/serialization.py:650] backbone.layer1.2.conv2.bias is not loaded.\n", + "[WARNING] ME(1289646:140507235451840,MainProcess):2022-07-28-00:20:38.334.193 [mindspore/train/serialization.py:650] backbone.layer1.2.conv3.bias is not loaded.\n", + "[WARNING] ME(1289646:140507235451840,MainProcess):2022-07-28-00:20:38.334.770 [mindspore/train/serialization.py:650] backbone.layer2.0.conv1.bias is not loaded.\n", + "[WARNING] ME(1289646:140507235451840,MainProcess):2022-07-28-00:20:38.335.286 [mindspore/train/serialization.py:650] backbone.layer2.0.conv2.bias is not loaded.\n", + "[WARNING] ME(1289646:140507235451840,MainProcess):2022-07-28-00:20:38.335.863 [mindspore/train/serialization.py:650] backbone.layer2.0.conv3.bias is not loaded.\n", + "[WARNING] ME(1289646:140507235451840,MainProcess):2022-07-28-00:20:38.336.367 [mindspore/train/serialization.py:650] backbone.layer2.0.conv_down_sample.bias is not loaded.\n", + "[WARNING] ME(1289646:140507235451840,MainProcess):2022-07-28-00:20:38.336.922 [mindspore/train/serialization.py:650] backbone.layer2.1.conv1.bias is not loaded.\n", + "[WARNING] ME(1289646:140507235451840,MainProcess):2022-07-28-00:20:38.337.450 [mindspore/train/serialization.py:650] backbone.layer2.1.conv2.bias is not loaded.\n", + "[WARNING] ME(1289646:140507235451840,MainProcess):2022-07-28-00:20:38.338.010 [mindspore/train/serialization.py:650] backbone.layer2.1.conv3.bias is not loaded.\n", + "[WARNING] ME(1289646:140507235451840,MainProcess):2022-07-28-00:20:38.338.512 [mindspore/train/serialization.py:650] backbone.layer2.2.conv1.bias is not loaded.\n", + "[WARNING] ME(1289646:140507235451840,MainProcess):2022-07-28-00:20:38.339.082 [mindspore/train/serialization.py:650] backbone.layer2.2.conv2.bias is not loaded.\n", + "[WARNING] ME(1289646:140507235451840,MainProcess):2022-07-28-00:20:38.339.586 [mindspore/train/serialization.py:650] backbone.layer2.2.conv3.bias is not loaded.\n", + "[WARNING] ME(1289646:140507235451840,MainProcess):2022-07-28-00:20:38.340.157 [mindspore/train/serialization.py:650] backbone.layer2.3.conv1.bias is not loaded.\n", + "[WARNING] ME(1289646:140507235451840,MainProcess):2022-07-28-00:20:38.340.659 [mindspore/train/serialization.py:650] backbone.layer2.3.conv2.bias is not loaded.\n", + "[WARNING] ME(1289646:140507235451840,MainProcess):2022-07-28-00:20:38.340.959 [mindspore/train/serialization.py:650] backbone.layer2.3.conv3.bias is not loaded.\n", + "[WARNING] ME(1289646:140507235451840,MainProcess):2022-07-28-00:20:38.341.191 [mindspore/train/serialization.py:650] backbone.layer3.0.conv1.bias is not loaded.\n", + "[WARNING] ME(1289646:140507235451840,MainProcess):2022-07-28-00:20:38.341.427 [mindspore/train/serialization.py:650] backbone.layer3.0.conv2.bias is not loaded.\n", + "[WARNING] ME(1289646:140507235451840,MainProcess):2022-07-28-00:20:38.341.664 [mindspore/train/serialization.py:650] backbone.layer3.0.conv3.bias is not loaded.\n", + "[WARNING] ME(1289646:140507235451840,MainProcess):2022-07-28-00:20:38.341.898 [mindspore/train/serialization.py:650] backbone.layer3.0.conv_down_sample.bias is not loaded.\n", + "[WARNING] ME(1289646:140507235451840,MainProcess):2022-07-28-00:20:38.342.142 [mindspore/train/serialization.py:650] backbone.layer3.1.conv1.bias is not loaded.\n", + "[WARNING] ME(1289646:140507235451840,MainProcess):2022-07-28-00:20:38.342.369 [mindspore/train/serialization.py:650] backbone.layer3.1.conv2.bias is not loaded.\n", + "[WARNING] ME(1289646:140507235451840,MainProcess):2022-07-28-00:20:38.342.598 [mindspore/train/serialization.py:650] backbone.layer3.1.conv3.bias is not loaded.\n", + "[WARNING] ME(1289646:140507235451840,MainProcess):2022-07-28-00:20:38.342.832 [mindspore/train/serialization.py:650] backbone.layer3.2.conv1.bias is not loaded.\n", + "[WARNING] ME(1289646:140507235451840,MainProcess):2022-07-28-00:20:38.343.072 [mindspore/train/serialization.py:650] backbone.layer3.2.conv2.bias is not loaded.\n", + "[WARNING] ME(1289646:140507235451840,MainProcess):2022-07-28-00:20:38.343.297 [mindspore/train/serialization.py:650] backbone.layer3.2.conv3.bias is not loaded.\n", + "[WARNING] ME(1289646:140507235451840,MainProcess):2022-07-28-00:20:38.343.526 [mindspore/train/serialization.py:650] backbone.layer3.3.conv1.bias is not loaded.\n", + "[WARNING] ME(1289646:140507235451840,MainProcess):2022-07-28-00:20:38.343.755 [mindspore/train/serialization.py:650] backbone.layer3.3.conv2.bias is not loaded.\n", + "[WARNING] ME(1289646:140507235451840,MainProcess):2022-07-28-00:20:38.343.991 [mindspore/train/serialization.py:650] backbone.layer3.3.conv3.bias is not loaded.\n", + "[WARNING] ME(1289646:140507235451840,MainProcess):2022-07-28-00:20:38.344.235 [mindspore/train/serialization.py:650] backbone.layer3.4.conv1.bias is not loaded.\n", + "[WARNING] ME(1289646:140507235451840,MainProcess):2022-07-28-00:20:38.344.489 [mindspore/train/serialization.py:650] backbone.layer3.4.conv2.bias is not loaded.\n", + "[WARNING] ME(1289646:140507235451840,MainProcess):2022-07-28-00:20:38.344.737 [mindspore/train/serialization.py:650] backbone.layer3.4.conv3.bias is not loaded.\n", + "[WARNING] ME(1289646:140507235451840,MainProcess):2022-07-28-00:20:38.344.995 [mindspore/train/serialization.py:650] backbone.layer3.5.conv1.bias is not loaded.\n", + "[WARNING] ME(1289646:140507235451840,MainProcess):2022-07-28-00:20:38.345.244 [mindspore/train/serialization.py:650] backbone.layer3.5.conv2.bias is not loaded.\n", + "[WARNING] ME(1289646:140507235451840,MainProcess):2022-07-28-00:20:38.345.505 [mindspore/train/serialization.py:650] backbone.layer3.5.conv3.bias is not loaded.\n", + "[WARNING] ME(1289646:140507235451840,MainProcess):2022-07-28-00:20:38.345.768 [mindspore/train/serialization.py:650] backbone.layer4.0.conv1.bias is not loaded.\n", + "[WARNING] ME(1289646:140507235451840,MainProcess):2022-07-28-00:20:38.347.967 [mindspore/train/serialization.py:650] backbone.layer4.0.conv2.bias is not loaded.\n", + "[WARNING] ME(1289646:140507235451840,MainProcess):2022-07-28-00:20:38.348.233 [mindspore/train/serialization.py:650] backbone.layer4.0.conv3.bias is not loaded.\n", + "[WARNING] ME(1289646:140507235451840,MainProcess):2022-07-28-00:20:38.348.494 [mindspore/train/serialization.py:650] backbone.layer4.0.conv_down_sample.bias is not loaded.\n", + "[WARNING] ME(1289646:140507235451840,MainProcess):2022-07-28-00:20:38.348.758 [mindspore/train/serialization.py:650] backbone.layer4.1.conv1.bias is not loaded.\n", + "[WARNING] ME(1289646:140507235451840,MainProcess):2022-07-28-00:20:38.349.290 [mindspore/train/serialization.py:650] backbone.layer4.1.conv2.bias is not loaded.\n", + "[WARNING] ME(1289646:140507235451840,MainProcess):2022-07-28-00:20:38.349.560 [mindspore/train/serialization.py:650] backbone.layer4.1.conv3.bias is not loaded.\n", + "[WARNING] ME(1289646:140507235451840,MainProcess):2022-07-28-00:20:38.349.817 [mindspore/train/serialization.py:650] backbone.layer4.2.conv1.bias is not loaded.\n", + "[WARNING] ME(1289646:140507235451840,MainProcess):2022-07-28-00:20:38.350.074 [mindspore/train/serialization.py:650] backbone.layer4.2.conv2.bias is not loaded.\n", + "[WARNING] ME(1289646:140507235451840,MainProcess):2022-07-28-00:20:38.350.332 [mindspore/train/serialization.py:650] backbone.layer4.2.conv3.bias is not loaded.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Image ID: 1061\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "[WARNING] PIPELINE(1289646,7fca63db83c0,python):2022-07-28-00:21:29.239.761 [mindspore/ccsrc/pipeline/jit/pipeline.cc:173] CheckArgValid] The data types of Tensor:[[False False False False False False False False False False False False\n", + " False False False False False False False False False False False False\n", + " False False False False False False False False False False False False\n", + " False False False False False False False False False False False False\n", + " False False False False False False False False False False False False\n", + " False False False False False False False False False False False False\n", + " False False False False False False False False False False False False\n", + " False False False False False False False False False False False False\n", + " False False False False False False False False False False False False\n", + " False False False False False False False False False False False False\n", + " False False False False False False False False]\n", + " [False False False False False False False False False False False False\n", + " False False False False False False False False False False False False\n", + " False False False False False False False False False False False False\n", + " False False False False False False False False False False False False\n", + " False False False False False False False False False False False False\n", + " False False False False False False False False False False False False\n", + " False False False False False False False False False False False False\n", + " False False False False False False False False False False False False\n", + " False False False False False False False False False False False False\n", + " False False False False False False False False False False False False\n", + " False False False False False False False False]] is bool, which may cause SelectKernelInfo failure for operator [AddN]. For more details, please refer to the FAQ at https://www.mindspore.cn.\n", + "[WARNING] PIPELINE(1289646,7fca63db83c0,python):2022-07-28-00:21:29.239.874 [mindspore/ccsrc/pipeline/jit/pipeline.cc:173] CheckArgValid] The data types of Tensor:[[[[False]]]\n", + "\n", + "\n", + " [[[False]]]] is bool, which may cause SelectKernelInfo failure for operator [AddN]. For more details, please refer to the FAQ at https://www.mindspore.cn.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Cost time of detection: 34.88\n", + "Class Num: 4\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "import random\n", + "import colorsys\n", + "\n", + "import matplotlib.pyplot as plt\n", + "import matplotlib.patches as patches\n", + "\n", + "\n", + "set_seed(1)\n", + "\n", + "def get_ax(rows=1, cols=1, size=16):\n", + " \"\"\"\n", + " Set axis\n", + "\n", + " Return a Matplotlib Axes array to be used in all visualizations in the notebook. Provide a central\n", + " point to control graph sizes.\n", + " Adjust the size attribute to control how big to render images.\n", + "\n", + " Args:\n", + " rows(int): Row size. Default: 1.\n", + " cols(int): Column size. Default: 1.\n", + " size(int): Pixel size. Default: 16.\n", + "\n", + " Returns:\n", + " Array, array of Axes\n", + " \"\"\"\n", + " _, axis = plt.subplots(rows, cols, figsize=(size*cols, size*rows))\n", + " return axis\n", + "\n", + "def mindrecord_to_rgb(img_data):\n", + " \"\"\"\n", + " Returns a RGB image from evaluated results.\n", + " Args:\n", + " rows(Array): An image.\n", + "\n", + " Returns:\n", + " Array, a RGB image.\n", + " \"\"\"\n", + " index = 0\n", + " convert_img = (-np.min(img_data[index, :, :, :])+img_data[index, :, :, :]) *\\\n", + " 255/(np.max(img_data[index, :, :, :])-np.min(img_data[index, :, :, :]))\n", + " temp_img = convert_img.astype(np.uint8)\n", + " image = np.zeros([config.img_height, config.img_width, 3])\n", + " image[:, :, 0] = temp_img[0, :, :]\n", + " image[:, :, 1] = temp_img[1, :, :]\n", + " image[:, :, 2] = temp_img[2, :, :]\n", + " return image\n", + "\n", + "def random_colors(num, bright=True):\n", + " \"\"\"\n", + " Generate random colors.\n", + "\n", + " To get visually distinct colors, generate them in HSV space then\n", + " convert to RGB.\n", + "\n", + " Args:\n", + " num(int): The color number.\n", + "\n", + " Returns:\n", + " List, a list of different colors.\n", + " \"\"\"\n", + " brightness = 1.0 if bright else 0.7\n", + " hsv = [(i / num, 1, brightness) for i in range(num)]\n", + " colors = list(map(lambda c: colorsys.hsv_to_rgb(*c), hsv))\n", + " random.shuffle(colors)\n", + " return colors\n", + "\n", + "def infer():\n", + " \"\"\"\n", + " Return Mask RCNN evaluated results.\n", + "\n", + " Returns:\n", + " - output, tensor, Mask RCNN evaluated result.\n", + " [Tensor[2,80000,5], Tensor[2,80000,1], Tensor[2,80000,1], Tensor[2,80000,28,28]]\n", + " - img, tensor, RGB image.\n", + " - img_metas, list, shape (height, width, 3).\n", + " \"\"\"\n", + " # load image\n", + " device_target = config.device_target\n", + " context.set_context(mode=context.GRAPH_MODE, device_target=device_target)\n", + "\n", + " mindrecord_dir = os.path.join(config.data_root, config.mindrecord_dir)\n", + "\n", + " prefix = \"MaskRcnn_eval.mindrecord\"\n", + "\n", + " mindrecord_file = os.path.join(mindrecord_dir, prefix)\n", + "\n", + " dataset = create_coco_dataset(mindrecord_file, batch_size=config.test_batch_size, is_training=False)\n", + "\n", + " total = dataset.get_dataset_size()\n", + " image_id = np.random.choice(total, 1)\n", + "\n", + " # load model\n", + " ckpt_path = config.checkpoint_path\n", + " net = MaskRcnnResnet50(config)\n", + " param_dict = load_checkpoint(ckpt_path)\n", + " load_param_into_net(net, param_dict)\n", + " net.set_train(False)\n", + "\n", + " data = list(dataset.create_dict_iterator(output_numpy=True, num_epochs=1))[image_id[0]]\n", + " print(\"Image ID: \", image_id[0])\n", + " img_data = data['image']\n", + " img_metas = data['image_shape']\n", + " gt_bboxes = data['box']\n", + " gt_labels = data['label']\n", + " gt_num = data['valid_num']\n", + " gt_mask = data[\"mask\"]\n", + "\n", + " img = mindrecord_to_rgb(img_data)\n", + "\n", + " start = time.time()\n", + " # run net\n", + " output = net(Tensor(img_data), Tensor(img_metas), Tensor(gt_bboxes),\n", + " Tensor(gt_labels), Tensor(gt_num), Tensor(gt_mask))\n", + " end = time.time()\n", + " print(\"Cost time of detection: {:.2f}\".format(end - start))\n", + " return output, img, img_metas\n", + "\n", + "def detection(output, img, img_metas):\n", + " \"\"\"Mask RCNN Detection.\n", + " Arg:\n", + " output(Tensor): evaluated results by Mask RCNN.\n", + " [Tensor[2,80000,5], Tensor[2,80000,1], Tensor[2,80000,1], Tensor[2,80000,28,28]]\n", + " img(Tensor): RGB image.\n", + " img_metas(List): image shape.\n", + " \"\"\"\n", + " # scaling ratio\n", + " ratio = img_metas[0, 2]\n", + "\n", + " # output\n", + " all_bbox = output[0][0].asnumpy()\n", + " all_label = output[1][0].asnumpy()\n", + " all_mask = output[2][0].asnumpy()\n", + "\n", + " num = 0\n", + " mask_id = -1\n", + " type_ids = []\n", + " for bool_ in all_mask:\n", + " mask_id += 1\n", + " if np.equal(bool_, True) and all_bbox[mask_id, 4] > 0.8:\n", + " type_ids.append(mask_id)\n", + " num += 1\n", + " print(\"Class Num:\", num)\n", + "\n", + " # Generate random colors\n", + " colors = random_colors(num)\n", + "\n", + " # Show area outside image boundaries.\n", + " height = config.img_height\n", + " width = config.img_width\n", + " ax = get_ax(1)\n", + " ax.set_ylim(height + 10, -10)\n", + " ax.set_xlim(-10, width + 10)\n", + " ax.axis('off')\n", + " ax.set_title(\"Precision\")\n", + "\n", + " masked_image = img.astype(np.uint32).copy()\n", + " for j in range(num):\n", + " color = colors[j]\n", + " i = type_ids[j]\n", + " # Bounding box\n", + " x1, y1, x2, y2, _ = all_bbox[i]*ratio\n", + " score = all_bbox[i, 4]\n", + "\n", + " p = patches.Rectangle((x1, y1), x2 - x1, y2 - y1, linewidth=2, alpha=0.7,\n", + " linestyle=\"dashed\", edgecolor=color, facecolor='none')\n", + " ax.add_patch(p)\n", + "\n", + " # Label\n", + " class_names = config.data_classes\n", + " class_id = all_label[i, 0].astype(np.uint8)+1\n", + " score = all_bbox[i, 4]\n", + " label = class_names[class_id]\n", + "\n", + " caption = \"{} {:.3f}\".format(label, score)\n", + " ax.text(x1, y1 + 8, caption, color='w', size=11, backgroundcolor=\"none\")\n", + "\n", + " ax.imshow(masked_image.astype(np.uint8))\n", + " plt.show()\n", + "\n", + "if __name__ == '__main__':\n", + " out, img_rgb, img_shape = infer()\n", + " detection(out, img_rgb, img_shape)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 参考文献\n", + "\n", + "[1] He K, Gkioxari G, Dollár P, et al. Mask r-cnn[C]//Proceedings of the IEEE international conference on computer vision. 2017: 2961-2969." + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3.10.6 64-bit", + "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.10.6" + }, + "orig_nbformat": 4, + "vscode": { + "interpreter": { + "hash": "31f2aee4e71d21fbe5cf8b01ff0e069b9275f58929596ceb00d14d90e3e16cd6" + } + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/application_example/maskrcnn/src/model/roi_align.py b/application_example/maskrcnn/src/model/roi_align.py index b13ecd16d25cd3d9647dbb49616131e04854ce7b..42579a23256d47ed25b4ec112d525101eca813fd 100644 --- a/application_example/maskrcnn/src/model/roi_align.py +++ b/application_example/maskrcnn/src/model/roi_align.py @@ -1,4 +1,4 @@ -# Copyright 2022 Huawei Technologies Co., Ltd +# Copyright 2020-2021 Huawei Technologies Co., Ltd # # Licensed under the Apache License, Version 2.0 (the "License"); # you may not use this file except in compliance with the License. @@ -13,6 +13,7 @@ # limitations under the License. # ============================================================================ """MaskRcnn ROIAlign module.""" + import numpy as np import mindspore.nn as nn import mindspore.common.dtype as mstype @@ -27,32 +28,18 @@ class ROIAlign(nn.Cell): Extract RoI features from mulitiple feature map. Args: - out_size_h (int): RoI height. - out_size_w (int): RoI width. - spatial_scale (int): RoI spatial scale. - sample_num (int): RoI sample number. Default: 0. - roi_align_mode (int): RoI align mode. Default: 1. - - Inputs: - - **features** (Tensor) - The input features, whose shape must be :math:'(N, C, H, W)'. - - **rois** (Tensor) - The shape is :math:'(rois_n, 5)'. With data type of float16 or float32. - - Outputs: - Tensor, the shape is :math: '(rois_n, C, pooled_height, pooled_width)'. - - Support Platform: - ``Ascend`` ``CPU`` ``GPU`` - - Examples: - >>> features = Tensor(np.array([[[[1., 2.], [3., 4.]]]]), mindspore.float32) - >>> rois = Tensor(np.array([[0, 0.2, 0.3, 0.2, 0.3]]), mindspore.float32) - >>> roi_align = ops.ROIAlign(2, 2, 0.5, 2) - >>> output = roi_align(features, rois) - >>> print(output) - [[[[1.775 2.025] - [2.275 2.525]]]] + out_size_h (int) - RoI height. + out_size_w (int) - RoI width. + spatial_scale (int) - RoI spatial scale. + sample_num (int) - RoI sample number. + roi_align_mode (int)- RoI align mode """ - def __init__(self, out_size_h, out_size_w, spatial_scale, sample_num=0, roi_align_mode=1): + def __init__(self, + out_size_h, + out_size_w, + spatial_scale, + sample_num=0, + roi_align_mode=1): super(ROIAlign, self).__init__() self.out_size = (out_size_h, out_size_w) @@ -68,8 +55,8 @@ class ROIAlign(nn.Cell): def __repr__(self): format_str = self.__class__.__name__ - format_str += \ - '(out_size={}, spatial_scale={}, sample_num={}'.format(self.out_size, self.spatial_scale, self.sample_num) + format_str += '(out_size={}, spatial_scale={}, sample_num={}'.format( + self.out_size, self.spatial_scale, self.sample_num) return format_str @@ -77,49 +64,37 @@ class SingleRoIExtractor(nn.Cell): """ Extract RoI features from a single level feature map. - If there are multiple input feature levels, each RoI is mapped to a level according to its scale. + If there are multiple input feature levels, each RoI is mapped to a level + according to its scale. Args: config (dict): Config + roi_layer (dict): Specify RoI layer type and arguments. out_channels (int): Output channels of RoI layers. featmap_strides (int): Strides of input feature maps. - batch_size (int): Batchsize. Default: 1. - finest_scale (int): Scale threshold of mapping to level 0. Default: 56. - mask (bool): Specify ROIAlign for cls or mask branch. Default: False. - - Inputs: - - **rois** (Tensor) - The shape is :math:'(rois_n, 5)'. With data type of float16 or float32. - - **feat1** (Tensor) - The input features, whose shape must be :math:'(N, C, H, W)'. - - **feat2** (Tensor) - The input features, whose shape must be :math:'(N, C, H, W)'. - - **feat3** (Tensor) - The input features, whose shape must be :math:'(N, C, H, W)'. - - **feat4** (Tensor) - The input features, whose shape must be :math:'(N, C, H, W)'. - - Outputs: - Tensor, the shape is :math:'(rois_n, C, pooled_height, pooled_width)'. - - Support Platform: - ``Ascend`` ``CPU`` ``GPU`` - - Examples: - >>> fea1 = Tensor(np.array([[[[1., 2.], [3., 4.]]]]), mindspore.float32) - >>> fea2 = Tensor(np.array([[[[1., 2.], [3., 4.]]]]), mindspore.float32) - >>> fea3 = Tensor(np.array([[[[1., 2.], [3., 4.]]]]), mindspore.float32) - >>> fea4 = Tensor(np.array([[[[1., 2.], [3., 4.]]]]), mindspore.float32) - >>> rois = Tensor(np.array([[0, 0.2, 0.3, 0.2, 0.3]]), mindspore.float32) - >>> single_roi = ops.SingleRoIExtractor(conifg, 2, 1, 2, 2, mask) - >>> output = single_roi(rois, fea1, fea2, fea3, fea4) + batch_size (int)： Batchsize. + finest_scale (int): Scale threshold of mapping to level 0. + mask (bool): Specify ROIAlign for cls or mask branch """ - def __init__(self, config, roi_layer, out_channels, featmap_strides, batch_size=1, finest_scale=56, mask=False): + def __init__(self, + config, + roi_layer, + out_channels, + featmap_strides, + batch_size=1, + finest_scale=56, + mask=False): super(SingleRoIExtractor, self).__init__() cfg = config self.train_batch_size = batch_size self.out_channels = out_channels self.featmap_strides = featmap_strides self.num_levels = len(self.featmap_strides) - self.out_size = roi_layer.mask_out_size if mask else roi_layer.out_size + + self.out_size = config.roi_layer.mask_out_size if mask else config.roi_layer.out_size self.mask = mask - self.sample_num = roi_layer.sample_num + self.sample_num = config.roi_layer.sample_num self.roi_layers = self.build_roi_layers(self.featmap_strides) self.roi_layers = L.CellList(self.roi_layers) @@ -132,9 +107,9 @@ class SingleRoIExtractor(nn.Cell): self.equal = P.Equal() self.select = P.Select() - in_mode_16 = False - self.dtype = np.float16 if in_mode_16 else np.float32 - self.ms_dtype = mstype.float16 if in_mode_16 else mstype.float32 +# _mode_16 = False + self.dtype = np.float32 #np.float16 if _mode_16 else np.float32 + self.ms_dtype = mstype.float32 #mstype.float16 if _mode_16 else mstype.float32 self.set_train_local(cfg, training=True) def set_train_local(self, config, training=True): @@ -143,24 +118,43 @@ class SingleRoIExtractor(nn.Cell): cfg = config # Init tensor - roi_sample_num = cfg.num_expected_pos_stage2 if self.mask else cfg.roi_sample_num - self.batch_size = roi_sample_num if self.training_local else cfg.rpn_max_num + roi_sample_num = \ + cfg.num_expected_pos_stage2 if self.mask else cfg.roi_sample_num + self.batch_size = \ + roi_sample_num if self.training_local else cfg.rpn_max_num self.batch_size = self.train_batch_size*self.batch_size \ if self.training_local else cfg.test_batch_size*self.batch_size - self.ones = Tensor(np.array(np.ones((self.batch_size, 1)), dtype=self.dtype)) - finest_scale = np.array(np.ones((self.batch_size, 1)), dtype=self.dtype) * self.finest_scale_ + self.ones = \ + Tensor(np.array(np.ones((self.batch_size, 1)), dtype=self.dtype)) + finest_scale = \ + np.array(np.ones((self.batch_size, 1)), + dtype=self.dtype) * self.finest_scale_ self.finest_scale = Tensor(finest_scale) - self.epslion = Tensor(np.array(np.ones((self.batch_size, 1)), dtype=self.dtype)*self.dtype(1e-6)) - self.zeros = Tensor(np.array(np.zeros((self.batch_size, 1)), dtype=np.int32)) - self.max_levels = Tensor(np.array(np.ones((self.batch_size, 1)), dtype=np.int32)*(self.num_levels-1)) - self.twos = Tensor(np.array(np.ones((self.batch_size, 1)), dtype=self.dtype) * 2) - self.res_ = Tensor(np.array(np.zeros((self.batch_size, self.out_channels, self.out_size, self.out_size)), - dtype=self.dtype)) + self.epslion = \ + Tensor(np.array(np.ones((self.batch_size, 1)), + dtype=self.dtype)*self.dtype(1e-6)) + self.zeros = \ + Tensor(np.array(np.zeros((self.batch_size, 1)), + dtype=np.int32)) + self.max_levels = \ + Tensor(np.array(np.ones((self.batch_size, 1)), + dtype=np.int32)*(self.num_levels-1)) + self.twos = \ + Tensor(np.array(np.ones((self.batch_size, 1)), + dtype=self.dtype) * 2) + self.res_ = \ + Tensor(np.array(np.zeros((self.batch_size, self.out_channels, + self.out_size, self.out_size)), + dtype=self.dtype)) def num_inputs(self): """input number.""" return len(self.featmap_strides) + def init_weights(self): + """initialize weights.""" + pass + def log2(self, value): """calculate log2.""" return self.log(value) / self.log(self.twos) @@ -169,8 +163,10 @@ class SingleRoIExtractor(nn.Cell): """build ROI layers.""" roi_layers = [] for s in featmap_strides: - layer_cls = ROIAlign(self.out_size, self.out_size, spatial_scale=1 / s, - sample_num=self.sample_num, roi_align_mode=0) + layer_cls = ROIAlign(self.out_size, self.out_size, + spatial_scale=1 / s, + sample_num=self.sample_num, + roi_align_mode=0) roi_layers.append(layer_cls) return roi_layers @@ -187,7 +183,7 @@ class SingleRoIExtractor(nn.Cell): num_levels (int): Total level number. Returns: - Tensor, Level index (0-based) of each RoI, shape (k, ) + Tensor: Level index (0-based) of each RoI, shape (k, ) """ scale = self.sqrt(rois[::, 3:4:1] - rois[::, 1:2:1] + self.ones) * \ self.sqrt(rois[::, 4:5:1] - rois[::, 2:3:1] + self.ones) @@ -208,8 +204,9 @@ class SingleRoIExtractor(nn.Cell): mask = self.equal(target_lvls, P.ScalarToArray()(i)) mask = P.Reshape()(mask, (-1, 1, 1, 1)) roi_feats_t = self.roi_layers[i](feats[i], rois) - mask = \ - self.cast(P.Tile()(self.cast(mask, mstype.int32), (1, 256, self.out_size, self.out_size)), mstype.bool_) + mask = self.cast(P.Tile()(self.cast(mask, mstype.int32), + (1, 256, self.out_size, self.out_size)), + mstype.bool_) res = self.select(mask, roi_feats_t, res) return res diff --git a/application_example/maskrcnn/src/train.py b/application_example/maskrcnn/src/train.py index beead122f1a2b02e4014953b61ecb83b9baef9df..64bcb315246a2f26b27eff3c70b490d76df6094d 100644 --- a/application_example/maskrcnn/src/train.py +++ b/application_example/maskrcnn/src/train.py @@ -25,12 +25,12 @@ from mindspore.train.serialization import load_checkpoint, load_param_into_net from mindspore.nn import Momentum from mindspore.common import set_seed +from utils.config import config # when use maskrcnn mobilenetv1, just change the following backbone and defined network # from mask_rcnn_mobilenetv1 and network_define_maskrcnnmobilenetv1 from model.mask_rcnn_r50 import MaskRcnnResnet50 from utils.network_define import LossCallBack, WithLossCell, TrainOneStepCell, LossNet from utils.lr_schedule import dynamic_lr -from utils.config import config from dataset.dataset import create_coco_dataset, data_to_mindrecord_byte_image diff --git a/application_example/maskrcnn/src/utils/__init__.py b/application_example/maskrcnn/src/utils/__init__.py deleted file mode 100644 index e69de29bb2d1d6434b8b29ae775ad8c2e48c5391..0000000000000000000000000000000000000000 diff --git a/application_example/maskrcnn/src/utils/config.py b/application_example/maskrcnn/src/utils/config.py index e2daf39f5aefd94eddb93b768e11a2a29474d9d2..57f67d9508ca8a51a8d7844f7c95397a814c1139 100644 --- a/application_example/maskrcnn/src/utils/config.py +++ b/application_example/maskrcnn/src/utils/config.py @@ -40,13 +40,12 @@ def parse_args(): help="File path of dataset in training.") # MaskRcnn training - parser.add_argument('--only_create_dataset', default=False, type=ast.literal_eval, - help="Whether to create dataset.") + parser.add_argument('--only_create_dataset', default=False, type=ast.literal_eval, help="Whether to create dataset.") parser.add_argument('--run_distribute', default=False, type=ast.literal_eval, help="Whether to run distribute.") parser.add_argument('--do_train', default=True, type=ast.literal_eval, help="Whether to do train.") parser.add_argument('--do_eval', default=False, type=ast.literal_eval, help="Whether to do eval.") parser.add_argument('--dataset', default='coco', type=str, help="Dataset name") - parser.add_argument('--pre_trained', default='../../maskrcnnr5/checkpoint/resnet50.ckpt', + parser.add_argument('--pre_trained', default='../../maskrcnnr5/checkpoint/resnet50_ascend_v180_imagenet2012_official_cv_top1acc76.97_top5acc93.44.ckpt', type=str, help="File path of pretrained checkpoint in training.") parser.add_argument('--device_id', default=0, type=int, help="Target device id.") parser.add_argument('--device_num', default=1, type=int, help="Target device number.") @@ -80,8 +79,7 @@ def parse_args(): parser.add_argument('--img_width', default=1280, type=int, help="The input image width.") parser.add_argument('--img_height', default=768, type=int, help="The input image height.") - parser.add_argument('--keep_ratio', default=True, type=ast.literal_eval, - help="Whether to keep the same image scaling ratio.") + parser.add_argument('--keep_ratio', default=True, type=ast.literal_eval, help="Whether to keep the same image scaling ratio.") parser.add_argument('--flip_ratio', default=0.5, type=float, help="The flip ratio.") parser.add_argument('--expand_ratio', default=1.0, type=float, help="The expand ratio.") @@ -130,8 +128,7 @@ def parse_args(): # proposal parser.add_argument('--activate_num_classes', default=256, type=int, help="The activate number of classes.") - parser.add_argument('--use_sigmoid_cls', default=True, type=ast.literal_eval, - help="Whether to use sigmoid for classification.") + parser.add_argument('--use_sigmoid_cls', default=True, type=ast.literal_eval, help="Whether to use sigmoid for classification.") # roi_align parser.add_argument('--roi_layer', default=ed(type='RoIAlign', out_size=7, mask_out_size=14, sample_num=2), diff --git a/application_example/maskrcnn/src/utils/network_define.py b/application_example/maskrcnn/src/utils/network_define.py index fc398688f647235ec760cc68d457732435c85a8e..4a7ebe473f36a03eeb22b730ee968f02b42269d9 100644 --- a/application_example/maskrcnn/src/utils/network_define.py +++ b/application_example/maskrcnn/src/utils/network_define.py @@ -156,7 +156,8 @@ class WithLossCell(nn.Cell): self._loss_fn = loss_fn def construct(self, x, img_shape, gt_bboxe, gt_label, gt_num, gt_mask): - loss1, loss2, _, _, _, _, _ = self._backbone(x, img_shape, gt_bboxe, gt_label, gt_num, gt_mask) + loss1, loss2, loss3, loss4, loss5, loss6, loss7 = \ + self._backbone(x, img_shape, gt_bboxe, gt_label, gt_num, gt_mask) return self._loss_fn(loss1, loss2) @property