目标检测/动手实现SSD.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "参考：[单发多框检测（SSD）](https://zh.gluon.ai/chapter_computer-vision/ssd.html)\n",
    "\n",
    "先载入一些必备包："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "%matplotlib inline\n",
    "import d2lzh as d2l\n",
    "from mxnet import autograd, contrib, gluon, image, init, nd\n",
    "from mxnet.gluon import loss as gloss, nn\n",
    "import time"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 基础组件\n",
    "\n",
    "单发多框检测（single shot multibox detection，SSD）[^1] 主要由一个基础网络块和若干个多尺度特征块串联而成。其中基础网络块用来从原始图像中抽取特征，因此一般会选择常用的深度卷积神经网络。大体上可以将 SSD 分为：基网络层，类别预测层，边界框预测层以及高和宽减半块四个个不同的类别。\n",
    "\n",
    "[^1]: Liu, W., Anguelov, D., Erhan, D., Szegedy, C., Reed, S., Fu, C. Y., & Berg, A. C. (2016, October). Ssd: Single shot multibox detector. In European conference on computer vision (pp. 21-37). Springer, Cham.\n",
    "\n",
    "类别预测层与边界框预测层的设计思路与使用全局平均池化替换全连接层的想法类似。\n",
    "\n",
    "\n",
    "## 类别预测层\n",
    "\n",
    "下面我们来完成类别预测层："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [],
   "source": [
    "class ClassPredictor(nn.Block):\n",
    "    def __init__(self, num_anchors, num_classes, **kwargs):\n",
    "        super().__init__(**kwargs)\n",
    "        self.num_classes = num_classes  # 类别数目\n",
    "        self.num_anchors = num_anchors  # 边界框数目\n",
    "        # 类别预测层\n",
    "        self.cls_predictor = nn.Conv2D(\n",
    "            self.num_anchors * (self.num_classes + 1), kernel_size=3, padding=1)\n",
    "\n",
    "    def forward(self, Y):\n",
    "        cls_preds = self.cls_predictor(Y)\n",
    "        return cls_preds"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`ClassPredictor` 生成了与某一个尺度的特征图相同尺度的 num_classes + 1 个类别特征图(包括背景)。\n",
    "\n",
    "下面我们模拟两个不同尺度的特征图来测试效果："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "((2, 55, 20, 20), (2, 55, 10, 10))"
      ]
     },
     "execution_count": 21,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "Y = nd.zeros((2, 8, 20, 20))  # 批量的 20 x 20 的 8 个特征图\n",
    "cls = ClassPredictor(5, 10)  # 实例化\n",
    "cls.initialize()           # 初始化\n",
    "cls_preds = cls(Y)       # 类特征图\n",
    "\n",
    "Y1 = nd.zeros((2, 16, 10, 10))  # 批量的 10 x 10 的 16 个特征图\n",
    "cls1 = ClassPredictor(5, 10)  # 实例化\n",
    "cls1.initialize()           # 初始化\n",
    "cls_preds1 = cls1(Y1)       # 类特征图2\n",
    "\n",
    "cls_preds.shape, cls_preds1.shape"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "我们需要将它们变形成统一的格式并将多尺度的预测连结，从而让后续计算更简单。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [],
   "source": [
    "def flatten_pred(pred):  # 转换为通道维度在后\n",
    "    return pred.transpose((0, 2, 3, 1)).flatten()\n",
    "\n",
    "def concat_preds(preds): # 拼接不同尺度的类别预测\n",
    "    return nd.concat(*[flatten_pred(p) for p in preds], dim=1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(2, 27500)"
      ]
     },
     "execution_count": 27,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "concat_preds([cls_preds, cls_preds1]).shape  # 拼接多个尺度特征图的类特征图"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 边界框预测层\n",
    "\n",
    "同样使用一个类完成："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [],
   "source": [
    "class BBoxPredictor(nn.Block):\n",
    "    def __init__(self, num_anchors, **kwargs):\n",
    "        super().__init__(**kwargs)\n",
    "        self.num_anchors = num_anchors\n",
    "        # 边界框预测层\n",
    "        self.bbox_predictor = nn.Conv2D(\n",
    "            self.num_anchors * 4, kernel_size=3, padding=1)\n",
    "\n",
    "    def forward(self, Y):\n",
    "        bbox_preds = self.bbox_predictor(Y)\n",
    "        return bbox_preds"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "测试效果："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(2, 40, 20, 20)"
      ]
     },
     "execution_count": 34,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "Y = nd.zeros((2, 8, 20, 20))  # 批量的 20 x 20 的 8 个特征图\n",
    "bbox = BBoxPredictor(10)  # 实例化\n",
    "bbox.initialize()           # 初始化\n",
    "bbox_preds = bbox(Y)       # 边界框特征图\n",
    "bbox_preds.shape"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`ClassPredictor` 生成了与某一个尺度的特征图相同尺度的 num_anchors x 4 个边界框坐标的特征图。\n",
    "\n",
    "## 高和宽减半块"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [],
   "source": [
    "class DownSampleBlock(nn.Block):\n",
    "    def __init__(self, num_channels, **kwargs):\n",
    "        '''\n",
    "        高和宽减半块\n",
    "        '''\n",
    "        super().__init__(**kwargs)\n",
    "        self.block = nn.Sequential()\n",
    "        with self.block.name_scope():\n",
    "            for _ in range(2):\n",
    "                self.block.add(nn.Conv2D(num_channels, kernel_size=3, padding=1),\n",
    "                               nn.BatchNorm(in_channels=num_channels),\n",
    "                               nn.Activation('relu'))\n",
    "            self.block.add(nn.MaxPool2D(2))\n",
    "\n",
    "    def forward(self, X):\n",
    "        return self.block(X)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "测试效果："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(2, 10, 10, 10)"
      ]
     },
     "execution_count": 39,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "Y = nd.zeros((2, 8, 20, 20))  # 批量的 20 x 20 的 8 个特征图\n",
    "down_sample = DownSampleBlock(10)\n",
    "down_sample.initialize()\n",
    "down_sample(Y).shape"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 基网络\n",
    "\n",
    "为了简洁这里仅仅设计一个简单的基网络："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [],
   "source": [
    "class BaseNet(nn.Block):\n",
    "    def __init__(self, **kwargs):\n",
    "        '''\n",
    "        基网络\n",
    "        '''\n",
    "        super().__init__(**kwargs)\n",
    "        self.block = nn.Sequential()\n",
    "        with self.block.name_scope():\n",
    "            for num_filters in [16, 32, 64]:\n",
    "                self.block.add(DownSampleBlock(num_filters))\n",
    "\n",
    "    def forward(self, X):\n",
    "        return self.block(X)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "测试效果："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(2, 64, 64, 64)"
      ]
     },
     "execution_count": 42,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "Y = nd.zeros((2, 8, 512, 512))  # 批量的 20 x 20 的 8 个特征图\n",
    "base_net = BaseNet()\n",
    "base_net.initialize()\n",
    "base_net(Y).shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 锚框生成"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {},
   "outputs": [],
   "source": [
    "class AnchorY(nn.Block):\n",
    "    def __init__(self, block, size, ratio, **kwargs):\n",
    "        super().__init__(**kwargs)\n",
    "        self.block = block\n",
    "        self._size = size\n",
    "        self._ratio = ratio\n",
    "\n",
    "    def forward(self, X):\n",
    "        Y = self.block(X)\n",
    "        anchors = contrib.ndarray.MultiBoxPrior(\n",
    "            Y, sizes=self._size, ratios=self._ratio)\n",
    "        return Y, anchors"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "测试效果："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "((2, 64, 32, 32), (1, 1024, 4))"
      ]
     },
     "execution_count": 47,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "block = BaseNet()\n",
    "anchor_gen = AnchorY(block, .4, .7)\n",
    "anchor_gen.initialize()\n",
    "X = nd.zeros((2, 8, 256, 256))\n",
    "Y, anchors = anchor_gen(X)\n",
    "Y.shape, anchors.shape"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# SSD 组装"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {},
   "outputs": [],
   "source": [
    "class TinySSD(nn.Block):\n",
    "    def __init__(self, sizes, ratios, num_classes, **kwargs):\n",
    "        super().__init__(**kwargs)\n",
    "        sizes, ratios, self.num_classes = sizes, ratios, num_classes\n",
    "        self.num_anchors = len(sizes[0]) + len(ratios[0]) - 1\n",
    "        for i in range(5):\n",
    "            # 即赋值语句self.blk_i = get_blk(i)\n",
    "            setattr(self, 'blk_%d' % i, self.block(i))\n",
    "            setattr(self, 'cls_%d' % i, ClassPredictor(self.num_anchors,\n",
    "                                                       self.num_classes))\n",
    "            setattr(self, 'bbox_%d' % i, BBoxPredictor(self.num_anchors))\n",
    "            setattr(self, 'anchor_%d' % i, AnchorY(\n",
    "                getattr(self, 'blk_%d' % i), sizes[i], ratios[i]))\n",
    "\n",
    "    def block(self, i):\n",
    "        if i == 0:\n",
    "            blk = BaseNet()\n",
    "        elif i == 4:\n",
    "            blk = nn.GlobalMaxPool2D()\n",
    "        else:\n",
    "            blk = DownSampleBlock(128)\n",
    "        return blk\n",
    "\n",
    "    def forward(self, X):\n",
    "        anchors, cls_preds, bbox_preds = [None] * 5, [None] * 5, [None] * 5\n",
    "        for i in range(5):\n",
    "            # getattr(self, 'blk_%d' % i)即访问self.blk_i\n",
    "            Y, anchors[i] = getattr(self, 'anchor_%d' % i)(X)\n",
    "            cls_preds[i] = getattr(self, 'cls_%d' % i)(Y)\n",
    "            bbox_preds[i] = getattr(self, 'bbox_%d' % i)(Y)\n",
    "            X = Y\n",
    "        # reshape函数中的0表示保持批量大小不变\n",
    "        cls_preds = concat_preds(cls_preds).reshape(\n",
    "            (0, -1, self.num_classes + 1))\n",
    "        return nd.concat(*anchors, dim=1), cls_preds, concat_preds(bbox_preds)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "测试代码："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "output anchors: (1, 5444, 4)\n",
      "output class preds: (32, 5444, 2)\n",
      "output bbox preds: (32, 21776)\n"
     ]
    }
   ],
   "source": [
    "sizes = [[0.2, 0.272], [0.37, 0.447], [0.54, 0.619], [0.71, 0.79],\n",
    "         [0.88, 0.961]]\n",
    "ratios = [[1, 2, 0.5]] * 5\n",
    "num_classes = 1\n",
    "\n",
    "X = nd.zeros((32, 3, 256, 256))\n",
    "net = TinySSD(sizes, ratios, num_classes)\n",
    "net.initialize()\n",
    "anchors, cls_preds, bbox_preds = net(X)\n",
    "\n",
    "print('output anchors:', anchors.shape)\n",
    "print('output class preds:', cls_preds.shape)\n",
    "print('output bbox preds:', bbox_preds.shape)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "网络结构："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "TinySSD(\n",
       "  (blk_0): BaseNet(\n",
       "    (block): Sequential(\n",
       "      (0): DownSampleBlock(\n",
       "        (block): Sequential(\n",
       "          (0): Conv2D(3 -> 16, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n",
       "          (1): BatchNorm(axis=1, eps=1e-05, momentum=0.9, fix_gamma=False, use_global_stats=False, in_channels=16)\n",
       "          (2): Activation(relu)\n",
       "          (3): Conv2D(16 -> 16, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n",
       "          (4): BatchNorm(axis=1, eps=1e-05, momentum=0.9, fix_gamma=False, use_global_stats=False, in_channels=16)\n",
       "          (5): Activation(relu)\n",
       "          (6): MaxPool2D(size=(2, 2), stride=(2, 2), padding=(0, 0), ceil_mode=False)\n",
       "        )\n",
       "      )\n",
       "      (1): DownSampleBlock(\n",
       "        (block): Sequential(\n",
       "          (0): Conv2D(16 -> 32, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n",
       "          (1): BatchNorm(axis=1, eps=1e-05, momentum=0.9, fix_gamma=False, use_global_stats=False, in_channels=32)\n",
       "          (2): Activation(relu)\n",
       "          (3): Conv2D(32 -> 32, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n",
       "          (4): BatchNorm(axis=1, eps=1e-05, momentum=0.9, fix_gamma=False, use_global_stats=False, in_channels=32)\n",
       "          (5): Activation(relu)\n",
       "          (6): MaxPool2D(size=(2, 2), stride=(2, 2), padding=(0, 0), ceil_mode=False)\n",
       "        )\n",
       "      )\n",
       "      (2): DownSampleBlock(\n",
       "        (block): Sequential(\n",
       "          (0): Conv2D(32 -> 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n",
       "          (1): BatchNorm(axis=1, eps=1e-05, momentum=0.9, fix_gamma=False, use_global_stats=False, in_channels=64)\n",
       "          (2): Activation(relu)\n",
       "          (3): Conv2D(64 -> 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n",
       "          (4): BatchNorm(axis=1, eps=1e-05, momentum=0.9, fix_gamma=False, use_global_stats=False, in_channels=64)\n",
       "          (5): Activation(relu)\n",
       "          (6): MaxPool2D(size=(2, 2), stride=(2, 2), padding=(0, 0), ceil_mode=False)\n",
       "        )\n",
       "      )\n",
       "    )\n",
       "  )\n",
       "  (cls_0): ClassPredictor(\n",
       "    (cls_predictor): Conv2D(64 -> 8, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n",
       "  )\n",
       "  (bbox_0): BBoxPredictor(\n",
       "    (bbox_predictor): Conv2D(64 -> 16, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n",
       "  )\n",
       "  (anchor_0): AnchorY(\n",
       "    (block): BaseNet(\n",
       "      (block): Sequential(\n",
       "        (0): DownSampleBlock(\n",
       "          (block): Sequential(\n",
       "            (0): Conv2D(3 -> 16, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n",
       "            (1): BatchNorm(axis=1, eps=1e-05, momentum=0.9, fix_gamma=False, use_global_stats=False, in_channels=16)\n",
       "            (2): Activation(relu)\n",
       "            (3): Conv2D(16 -> 16, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n",
       "            (4): BatchNorm(axis=1, eps=1e-05, momentum=0.9, fix_gamma=False, use_global_stats=False, in_channels=16)\n",
       "            (5): Activation(relu)\n",
       "            (6): MaxPool2D(size=(2, 2), stride=(2, 2), padding=(0, 0), ceil_mode=False)\n",
       "          )\n",
       "        )\n",
       "        (1): DownSampleBlock(\n",
       "          (block): Sequential(\n",
       "            (0): Conv2D(16 -> 32, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n",
       "            (1): BatchNorm(axis=1, eps=1e-05, momentum=0.9, fix_gamma=False, use_global_stats=False, in_channels=32)\n",
       "            (2): Activation(relu)\n",
       "            (3): Conv2D(32 -> 32, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n",
       "            (4): BatchNorm(axis=1, eps=1e-05, momentum=0.9, fix_gamma=False, use_global_stats=False, in_channels=32)\n",
       "            (5): Activation(relu)\n",
       "            (6): MaxPool2D(size=(2, 2), stride=(2, 2), padding=(0, 0), ceil_mode=False)\n",
       "          )\n",
       "        )\n",
       "        (2): DownSampleBlock(\n",
       "          (block): Sequential(\n",
       "            (0): Conv2D(32 -> 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n",
       "            (1): BatchNorm(axis=1, eps=1e-05, momentum=0.9, fix_gamma=False, use_global_stats=False, in_channels=64)\n",
       "            (2): Activation(relu)\n",
       "            (3): Conv2D(64 -> 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n",
       "            (4): BatchNorm(axis=1, eps=1e-05, momentum=0.9, fix_gamma=False, use_global_stats=False, in_channels=64)\n",
       "            (5): Activation(relu)\n",
       "            (6): MaxPool2D(size=(2, 2), stride=(2, 2), padding=(0, 0), ceil_mode=False)\n",
       "          )\n",
       "        )\n",
       "      )\n",
       "    )\n",
       "  )\n",
       "  (blk_1): DownSampleBlock(\n",
       "    (block): Sequential(\n",
       "      (0): Conv2D(64 -> 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n",
       "      (1): BatchNorm(axis=1, eps=1e-05, momentum=0.9, fix_gamma=False, use_global_stats=False, in_channels=128)\n",
       "      (2): Activation(relu)\n",
       "      (3): Conv2D(128 -> 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n",
       "      (4): BatchNorm(axis=1, eps=1e-05, momentum=0.9, fix_gamma=False, use_global_stats=False, in_channels=128)\n",
       "      (5): Activation(relu)\n",
       "      (6): MaxPool2D(size=(2, 2), stride=(2, 2), padding=(0, 0), ceil_mode=False)\n",
       "    )\n",
       "  )\n",
       "  (cls_1): ClassPredictor(\n",
       "    (cls_predictor): Conv2D(128 -> 8, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n",
       "  )\n",
       "  (bbox_1): BBoxPredictor(\n",
       "    (bbox_predictor): Conv2D(128 -> 16, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n",
       "  )\n",
       "  (anchor_1): AnchorY(\n",
       "    (block): DownSampleBlock(\n",
       "      (block): Sequential(\n",
       "        (0): Conv2D(64 -> 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n",
       "        (1): BatchNorm(axis=1, eps=1e-05, momentum=0.9, fix_gamma=False, use_global_stats=False, in_channels=128)\n",
       "        (2): Activation(relu)\n",
       "        (3): Conv2D(128 -> 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n",
       "        (4): BatchNorm(axis=1, eps=1e-05, momentum=0.9, fix_gamma=False, use_global_stats=False, in_channels=128)\n",
       "        (5): Activation(relu)\n",
       "        (6): MaxPool2D(size=(2, 2), stride=(2, 2), padding=(0, 0), ceil_mode=False)\n",
       "      )\n",
       "    )\n",
       "  )\n",
       "  (blk_2): DownSampleBlock(\n",
       "    (block): Sequential(\n",
       "      (0): Conv2D(128 -> 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n",
       "      (1): BatchNorm(axis=1, eps=1e-05, momentum=0.9, fix_gamma=False, use_global_stats=False, in_channels=128)\n",
       "      (2): Activation(relu)\n",
       "      (3): Conv2D(128 -> 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n",
       "      (4): BatchNorm(axis=1, eps=1e-05, momentum=0.9, fix_gamma=False, use_global_stats=False, in_channels=128)\n",
       "      (5): Activation(relu)\n",
       "      (6): MaxPool2D(size=(2, 2), stride=(2, 2), padding=(0, 0), ceil_mode=False)\n",
       "    )\n",
       "  )\n",
       "  (cls_2): ClassPredictor(\n",
       "    (cls_predictor): Conv2D(128 -> 8, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n",
       "  )\n",
       "  (bbox_2): BBoxPredictor(\n",
       "    (bbox_predictor): Conv2D(128 -> 16, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n",
       "  )\n",
       "  (anchor_2): AnchorY(\n",
       "    (block): DownSampleBlock(\n",
       "      (block): Sequential(\n",
       "        (0): Conv2D(128 -> 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n",
       "        (1): BatchNorm(axis=1, eps=1e-05, momentum=0.9, fix_gamma=False, use_global_stats=False, in_channels=128)\n",
       "        (2): Activation(relu)\n",
       "        (3): Conv2D(128 -> 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n",
       "        (4): BatchNorm(axis=1, eps=1e-05, momentum=0.9, fix_gamma=False, use_global_stats=False, in_channels=128)\n",
       "        (5): Activation(relu)\n",
       "        (6): MaxPool2D(size=(2, 2), stride=(2, 2), padding=(0, 0), ceil_mode=False)\n",
       "      )\n",
       "    )\n",
       "  )\n",
       "  (blk_3): DownSampleBlock(\n",
       "    (block): Sequential(\n",
       "      (0): Conv2D(128 -> 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n",
       "      (1): BatchNorm(axis=1, eps=1e-05, momentum=0.9, fix_gamma=False, use_global_stats=False, in_channels=128)\n",
       "      (2): Activation(relu)\n",
       "      (3): Conv2D(128 -> 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n",
       "      (4): BatchNorm(axis=1, eps=1e-05, momentum=0.9, fix_gamma=False, use_global_stats=False, in_channels=128)\n",
       "      (5): Activation(relu)\n",
       "      (6): MaxPool2D(size=(2, 2), stride=(2, 2), padding=(0, 0), ceil_mode=False)\n",
       "    )\n",
       "  )\n",
       "  (cls_3): ClassPredictor(\n",
       "    (cls_predictor): Conv2D(128 -> 8, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n",
       "  )\n",
       "  (bbox_3): BBoxPredictor(\n",
       "    (bbox_predictor): Conv2D(128 -> 16, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n",
       "  )\n",
       "  (anchor_3): AnchorY(\n",
       "    (block): DownSampleBlock(\n",
       "      (block): Sequential(\n",
       "        (0): Conv2D(128 -> 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n",
       "        (1): BatchNorm(axis=1, eps=1e-05, momentum=0.9, fix_gamma=False, use_global_stats=False, in_channels=128)\n",
       "        (2): Activation(relu)\n",
       "        (3): Conv2D(128 -> 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n",
       "        (4): BatchNorm(axis=1, eps=1e-05, momentum=0.9, fix_gamma=False, use_global_stats=False, in_channels=128)\n",
       "        (5): Activation(relu)\n",
       "        (6): MaxPool2D(size=(2, 2), stride=(2, 2), padding=(0, 0), ceil_mode=False)\n",
       "      )\n",
       "    )\n",
       "  )\n",
       "  (blk_4): GlobalMaxPool2D(size=(1, 1), stride=(1, 1), padding=(0, 0), ceil_mode=True)\n",
       "  (cls_4): ClassPredictor(\n",
       "    (cls_predictor): Conv2D(128 -> 8, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n",
       "  )\n",
       "  (bbox_4): BBoxPredictor(\n",
       "    (bbox_predictor): Conv2D(128 -> 16, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n",
       "  )\n",
       "  (anchor_4): AnchorY(\n",
       "    (block): GlobalMaxPool2D(size=(1, 1), stride=(1, 1), padding=(0, 0), ceil_mode=True)\n",
       "  )\n",
       ")"
      ]
     },
     "execution_count": 52,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "net"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "下面你便可以使用该网络进行目标检测了。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "gluoncv",
   "language": "python",
   "name": "gluoncv"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.7.0"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}