9.7. 单发多框检测（SSD）

我们在前几节分别介绍了边界框、锚框、多尺度目标检测和数据集，下面我们基于这些背景知识来构造一个目标检测模型：单发多框检测（singleshot multiboxdetection，SSD）[1]。它简单、快速，并得到了广泛应用。该模型的一些设计思想和实现细节常适用于其他目标检测模型。

9.7.1. 模型

图9.4描述了单发多框检测模型的设计。它主要由一个基础网络块和若干个多尺度特征块串联而成。其中基础网络块用来从原始图像中抽取特征，因此一般会选择常用的深度卷积神经网络。单发多框检测论文中选用了在分类层之前截断的VGG[1]，现在也常用ResNet替代。我们可以设计基础网络，使它输出的高和宽较大。这样一来，基于该特征图生成的锚框数量较多，可以用来检测尺寸较小的目标。接下来的每个多尺度特征块将上一层提供的特征图的高和宽缩小（如减半），并使特征图中每个单元在输入图像上的感受野变得更广阔。如此一来，图9.4中越靠近顶部的多尺度特征块输出的特征图越小，故而基于特征图生成的锚框也越少，加之特征图中每个单元感受野越大，因此更适合检测尺寸较大的目标。由于单发多框检测基于基础网络块和各个多尺度特征块生成不同数量和不同大小的锚框，并通过预测锚框的类别和偏移量（即预测边界框）检测不同大小的目标，因此单发多框检测是一个多尺度的目标检测模型。

单发多框检测模型主要由一个基础网络块和若干多尺度特征块串联而成

图 9.4 单发多框检测模型主要由一个基础网络块和若干多尺度特征块串联而成

接下来我们介绍如何实现图中的各个模块。我们先介绍如何实现类别预测和边界框预测。

9.7.1.1. 类别预测层

设目标的类别个数为

9.7. 单发多框检测（SSD） - 图2 。每个锚框的类别个数将是 9.7. 单发多框检测（SSD） - 图3 ，其中类别0表示锚框只包含背景。在某个尺度下，设特征图的高和宽分别为 9.7. 单发多框检测（SSD） - 图4 和 9.7. 单发多框检测（SSD） - 图5 ，如果以其中每个单元为中心生成 9.7. 单发多框检测（SSD） - 图6 个锚框，那么我们需要对 9.7. 单发多框检测（SSD） - 图7 个锚框进行分类。如果使用全连接层作为输出，很容易导致模型参数过多。回忆“网络中的网络（NiN）”一节介绍的使用卷积层的通道来输出类别预测的方法。单发多框检测采用同样的方法来降低模型复杂度。

具体来说，类别预测层使用一个保持输入高和宽的卷积层。这样一来，输出和输入在特征图宽和高上的空间坐标一一对应。考虑输出和输入同一空间坐标

9.7. 单发多框检测（SSD） - 图8 ：输出特征图上 9.7. 单发多框检测（SSD） - 图9 坐标的通道里包含了以输入特征图 9.7. 单发多框检测（SSD） - 图10 坐标为中心生成的所有锚框的类别预测。因此输出通道数为 9.7. 单发多框检测（SSD） - 图11 ，其中索引为 9.7. 单发多框检测（SSD） - 图12 （ 9.7. 单发多框检测（SSD） - 图13 ）的通道代表了索引为 9.7. 单发多框检测（SSD） - 图14 的锚框有关类别索引为 9.7. 单发多框检测（SSD） - 图15 的预测。

下面我们定义一个这样的类别预测层：指定参数

9.7. 单发多框检测（SSD） - 图16 和 9.7. 单发多框检测（SSD） - 图17 后，它使用一个填充为1的 9.7. 单发多框检测（SSD） - 图18 卷积层。该卷积层的输入和输出的高和宽保持不变。

  1. In [1]:
  1. %matplotlib inline
  2. import d2lzh as d2l
  3. from mxnet import autograd, contrib, gluon, image, init, nd
  4. from mxnet.gluon import loss as gloss, nn
  5. import time
  6.  
  7. def cls_predictor(num_anchors, num_classes):
  8.     return nn.Conv2D(num_anchors * (num_classes + 1), kernel_size=3,
  9.                      padding=1)

9.7.1.2. 边界框预测层

边界框预测层的设计与类别预测层的设计类似。唯一不同的是，这里需要为每个锚框预测4个偏移量，而不是

9.7. 单发多框检测（SSD） - 图19 个类别。

  1. In [2]:
  1. def bbox_predictor(num_anchors):
  2.     return nn.Conv2D(num_anchors * 4, kernel_size=3, padding=1)

9.7.1.3. 连结多尺度的预测

前面提到，单发多框检测根据多个尺度下的特征图生成锚框并预测类别和偏移量。由于每个尺度上特征图的形状或以同一单元为中心生成的锚框个数都可能不同，因此不同尺度的预测输出形状可能不同。

在下面的例子中，我们对同一批量数据构造两个不同尺度下的特征图Y1和Y2，其中Y2相对于Y1来说高和宽分别减半。以类别预测为例，假设以Y1和Y2特征图中每个单元生成的锚框个数分别是5和3，当目标类别个数为10时，类别预测输出的通道数分别为

9.7. 单发多框检测（SSD） - 图20 和 9.7. 单发多框检测（SSD） - 图21 。预测输出的格式为(批量大小,通道数, 高,宽)。可以看到，除了批量大小外，其他维度大小均不一样。我们需要将它们变形成统一的格式并将多尺度的预测连结，从而让后续计算更简单。

  1. In [3]:
  1. def forward(x, block):
  2.     block.initialize()
  3.     return block(x)
  4.  
  5. Y1 = forward(nd.zeros((2, 8, 20, 20)), cls_predictor(5, 10))
  6. Y2 = forward(nd.zeros((2, 16, 10, 10)), cls_predictor(3, 10))
  7. (Y1.shape, Y2.shape)
  1. Out[3]:
  1. ((2, 55, 20, 20), (2, 33, 10, 10))

通道维包含中心相同的锚框的预测结果。我们首先将通道维移到最后一维。因为不同尺度下批量大小仍保持不变，我们可以将预测结果转成二维的(批量大小,高

9.7. 单发多框检测（SSD） - 图22 宽 9.7. 单发多框检测（SSD） - 图23 通道数)的格式，以方便之后在维度1上的连结。

  1. In [4]:
  1. def flatten_pred(pred):
  2.     return pred.transpose((0, 2, 3, 1)).flatten()
  3.  
  4. def concat_preds(preds):
  5.     return nd.concat(*[flatten_pred(p) for p in preds], dim=1)

这样一来，尽管Y1和Y2形状不同，我们仍然可以将这两个同一批量不同尺度的预测结果连结在一起。

  1. In [5]:
  1. concat_preds([Y1, Y2]).shape
  1. Out[5]:
  1. (2, 25300)

9.7.1.4. 高和宽减半块

为了在多尺度检测目标，下面定义高和宽减半块down_sample_blk。它串联了两个填充为1的

9.7. 单发多框检测（SSD） - 图24 卷积层和步幅为2的 9.7. 单发多框检测（SSD） - 图25 最大池化层。我们知道，填充为1的 9.7. 单发多框检测（SSD） - 图26 卷积层不改变特征图的形状，而后面的池化层则直接将特征图的高和宽减半。由于 9.7. 单发多框检测（SSD） - 图27 ，输出特征图中每个单元在输入特征图上的感受野形状为 9.7. 单发多框检测（SSD） - 图28 。可以看出，高和宽减半块使输出特征图中每个单元的感受野变得更广阔。

  1. In [6]:
  1. def down_sample_blk(num_channels):
  2.     blk = nn.Sequential()
  3.     for _ in range(2):
  4.         blk.add(nn.Conv2D(num_channels, kernel_size=3, padding=1),
  5.                 nn.BatchNorm(in_channels=num_channels),
  6.                 nn.Activation('relu'))
  7.     blk.add(nn.MaxPool2D(2))
  8.     return blk

测试高和宽减半块的前向计算。可以看到，它改变了输入的通道数，并将高和宽减半。

  1. In [7]:
  1. forward(nd.zeros((2, 3, 20, 20)), down_sample_blk(10)).shape
  1. Out[7]:
  1. (2, 10, 10, 10)

9.7.1.5. 基础网络块

基础网络块用来从原始图像中抽取特征。为了计算简洁，我们在这里构造一个小的基础网络。该网络串联3个高和宽减半块，并逐步将通道数翻倍。当输入的原始图像的形状为

9.7. 单发多框检测（SSD） - 图29 时，基础网络块输出的特征图的形状为 9.7. 单发多框检测（SSD） - 图30 。

  1. In [8]:
  1. def base_net():
  2.     blk = nn.Sequential()
  3.     for num_filters in [16, 32, 64]:
  4.         blk.add(down_sample_blk(num_filters))
  5.     return blk
  6.  
  7. forward(nd.zeros((2, 3, 256, 256)), base_net()).shape
  1. Out[8]:
  1. (2, 64, 32, 32)

9.7.1.6. 完整的模型

单发多框检测模型一共包含5个模块，每个模块输出的特征图既用来生成锚框，又用来预测这些锚框的类别和偏移量。第一模块为基础网络块，第二模块至第四模块为高和宽减半块，第五模块使用全局最大池化层将高和宽降到1。因此第二模块至第五模块均为图9.4中的多尺度特征块。

  1. In [9]:
  1. def get_blk(i):
  2.     if i == 0:
  3.         blk = base_net()
  4.     elif i == 4:
  5.         blk = nn.GlobalMaxPool2D()
  6.     else:
  7.         blk = down_sample_blk(128)
  8.     return blk

接下来，我们定义每个模块如何进行前向计算。跟之前介绍的卷积神经网络不同，这里不仅返回卷积计算输出的特征图Y，还返回根据Y生成的当前尺度的锚框，以及基于Y预测的锚框类别和偏移量。

  1. In [10]:
  1. def blk_forward(X, blk, size, ratio, cls_predictor, bbox_predictor):
  2.     Y = blk(X)
  3.     anchors = contrib.ndarray.MultiBoxPrior(Y, sizes=size, ratios=ratio)
  4.     cls_preds = cls_predictor(Y)
  5.     bbox_preds = bbox_predictor(Y)
  6.     return (Y, anchors, cls_preds, bbox_preds)

我们提到，图9.4中较靠近顶部的多尺度特征块用来检测尺寸较大的目标，因此需要生成较大的锚框。我们在这里先将0.2到1.05之间均分5份，以确定不同尺度下锚框大小的较小值0.2、0.37、0.54等，再按

9.7. 单发多框检测（SSD） - 图31 、 9.7. 单发多框检测（SSD） - 图32 等来确定不同尺度下锚框大小的较大值。

  1. In [11]:
  1. sizes = [[0.2, 0.272], [0.37, 0.447], [0.54, 0.619], [0.71, 0.79],
  2.          [0.88, 0.961]]
  3. ratios = [[1, 2, 0.5]] * 5
  4. num_anchors = len(sizes[0]) + len(ratios[0]) - 1

现在，我们就可以定义出完整的模型TinySSD了。

  1. In [12]:
  1. class TinySSD(nn.Block):
  2.     def __init__(self, num_classes, **kwargs):
  3.         super(TinySSD, self).__init__(**kwargs)
  4.         self.num_classes = num_classes
  5.         for i in range(5):
  6.             # 即赋值语句self.blk_i = get_blk(i)
  7.             setattr(self, 'blk_%d' % i, get_blk(i))
  8.             setattr(self, 'cls_%d' % i, cls_predictor(num_anchors,
  9.                                                       num_classes))
  10.             setattr(self, 'bbox_%d' % i, bbox_predictor(num_anchors))
  11.  
  12.     def forward(self, X):
  13.         anchors, cls_preds, bbox_preds = [None] * 5, [None] * 5, [None] * 5
  14.         for i in range(5):
  15.             # getattr(self, 'blk_%d' % i)即访问self.blk_i
  16.             X, anchors[i], cls_preds[i], bbox_preds[i] = blk_forward(
  17.                 X, getattr(self, 'blk_%d' % i), sizes[i], ratios[i],
  18.                 getattr(self, 'cls_%d' % i), getattr(self, 'bbox_%d' % i))
  19.         # reshape函数中的0表示保持批量大小不变
  20.         return (nd.concat(*anchors, dim=1),
  21.                 concat_preds(cls_preds).reshape(
  22.                     (0, -1, self.num_classes + 1)), concat_preds(bbox_preds))

我们创建单发多框检测模型实例并对一个高和宽均为256像素的小批量图像X做前向计算。我们在之前验证过，第一模块输出的特征图的形状为

9.7. 单发多框检测（SSD） - 图33 。由于第二至第四模块为高和宽减半块、第五模块为全局池化层，并且以特征图每个单元为中心生成4个锚框，每个图像在5个尺度下生成的锚框总数为 9.7. 单发多框检测（SSD） - 图34 。

  1. In [13]:
  1. net = TinySSD(num_classes=1)
  2. net.initialize()
  3. X = nd.zeros((32, 3, 256, 256))
  4. anchors, cls_preds, bbox_preds = net(X)
  5.  
  6. print('output anchors:', anchors.shape)
  7. print('output class preds:', cls_preds.shape)
  8. print('output bbox preds:', bbox_preds.shape)
  1. output anchors: (1, 5444, 4)
  2. output class preds: (32, 5444, 2)
  3. output bbox preds: (32, 21776)

9.7.2.3. 训练模型

下面我们描述如何一步步训练单发多框检测模型来进行目标检测。

9.7.2.1. 读取数据集和初始化

我们读取“目标检测数据集（皮卡丘）”一节构造的皮卡丘数据集。

  1. In [14]:
  1. batch_size = 32
  2. train_iter, _ = d2l.load_data_pikachu(batch_size)

在皮卡丘数据集中，目标的类别数为1。定义好模型以后，我们需要初始化模型参数并定义优化算法。

  1. In [15]:
  1. ctx, net = d2l.try_gpu(), TinySSD(num_classes=1)
  2. net.initialize(init=init.Xavier(), ctx=ctx)
  3. trainer = gluon.Trainer(net.collect_params(), 'sgd',
  4.                         {'learning_rate': 0.2, 'wd': 5e-4})

9.7.2.2. 定义损失函数和评价函数

目标检测有两个损失：一是有关锚框类别的损失，我们可以重用之前图像分类问题里一直使用的交叉熵损失函数；二是有关正类锚框偏移量的损失。预测偏移量是一个回归问题，但这里不使用前面介绍过的平方损失，而使用

9.7. 单发多框检测（SSD） - 图35 范数损失，即预测值与真实值之间差的绝对值。掩码变量bbox_masks令负类锚框和填充锚框不参与损失的计算。最后，我们将有关锚框类别和偏移量的损失相加得到模型的最终损失函数。

  1. In [16]:
  1. cls_loss = gloss.SoftmaxCrossEntropyLoss()
  2. bbox_loss = gloss.L1Loss()
  3.  
  4. def calc_loss(cls_preds, cls_labels, bbox_preds, bbox_labels, bbox_masks):
  5.     cls = cls_loss(cls_preds, cls_labels)
  6.     bbox = bbox_loss(bbox_preds * bbox_masks, bbox_labels * bbox_masks)
  7.     return cls + bbox

我们可以沿用准确率评价分类结果。因为使用了

9.7. 单发多框检测（SSD） - 图36 范数损失，我们用平均绝对误差评价边界框的预测结果。

  1. In [17]:
  1. def cls_eval(cls_preds, cls_labels):
  2.     # 由于类别预测结果放在最后一维，argmax需要指定最后一维
  3.     return (cls_preds.argmax(axis=-1) == cls_labels).sum().asscalar()
  4.  
  5. def bbox_eval(bbox_preds, bbox_labels, bbox_masks):
  6.     return ((bbox_labels - bbox_preds) * bbox_masks).abs().sum().asscalar()

9.7.2.3. 训练模型

在训练模型时，我们需要在模型的前向计算过程中生成多尺度的锚框anchors，并为每个锚框预测类别cls_preds和偏移量bbox_preds。之后，我们根据标签信息Y为生成的每个锚框标注类别cls_labels和偏移量bbox_labels。最后，我们根据类别和偏移量的预测和标注值计算损失函数。为了代码简洁，这里没有评价测试数据集。

  1. In [18]:
  1. for epoch in range(20):
  2.     acc_sum, mae_sum, n, m = 0.0, 0.0, 0, 0
  3.     train_iter.reset()  # 从头读取数据
  4.     start = time.time()
  5.     for batch in train_iter:
  6.         X = batch.data[0].as_in_context(ctx)
  7.         Y = batch.label[0].as_in_context(ctx)
  8.         with autograd.record():
  9.             # 生成多尺度的锚框，为每个锚框预测类别和偏移量
  10.             anchors, cls_preds, bbox_preds = net(X)
  11.             # 为每个锚框标注类别和偏移量
  12.             bbox_labels, bbox_masks, cls_labels = contrib.nd.MultiBoxTarget(
  13.                 anchors, Y, cls_preds.transpose((0, 2, 1)))
  14.             # 根据类别和偏移量的预测和标注值计算损失函数
  15.             l = calc_loss(cls_preds, cls_labels, bbox_preds, bbox_labels,
  16.                           bbox_masks)
  17.         l.backward()
  18.         trainer.step(batch_size)
  19.         acc_sum += cls_eval(cls_preds, cls_labels)
  20.         n += cls_labels.size
  21.         mae_sum += bbox_eval(bbox_preds, bbox_labels, bbox_masks)
  22.         m += bbox_labels.size
  23.  
  24.     if (epoch + 1) % 5 == 0:
  25.         print('epoch %2d, class err %.2e, bbox mae %.2e, time %.1f sec' % (
  26.             epoch + 1, 1 - acc_sum / n, mae_sum / m, time.time() - start))
  1. epoch  5, class err 3.02e-03, bbox mae 3.14e-03, time 9.6 sec
  2. epoch 10, class err 2.72e-03, bbox mae 2.90e-03, time 9.5 sec
  3. epoch 15, class err 2.50e-03, bbox mae 2.68e-03, time 9.5 sec
  4. epoch 20, class err 2.45e-03, bbox mae 2.63e-03, time 9.4 sec

9.7.3. 预测

在预测阶段，我们希望能把图像里面所有我们感兴趣的目标检测出来。下面读取测试图像，将其变换尺寸，然后转成卷积层需要的四维格式。

  1. In [19]:
  1. img = image.imread('../img/pikachu.jpg')
  2. feature = image.imresize(img, 256, 256).astype('float32')
  3. X = feature.transpose((2, 0, 1)).expand_dims(axis=0)

我们通过MultiBoxDetection函数根据锚框及其预测偏移量得到预测边界框，并通过非极大值抑制移除相似的预测边界框。

  1. In [20]:
  1. def predict(X):
  2.     anchors, cls_preds, bbox_preds = net(X.as_in_context(ctx))
  3.     cls_probs = cls_preds.softmax().transpose((0, 2, 1))
  4.     output = contrib.nd.MultiBoxDetection(cls_probs, bbox_preds, anchors)
  5.     idx = [i for i, row in enumerate(output[0]) if row[0].asscalar() != -1]
  6.     return output[0, idx]
  7.  
  8. output = predict(X)

最后，我们将置信度不低于0.3的边界框筛选为最终输出用以展示。

  1. In [21]:
  1. d2l.set_figsize((5, 5))
  2.  
  3. def display(img, output, threshold):
  4.     fig = d2l.plt.imshow(img.asnumpy())
  5.     for row in output:
  6.         score = row[1].asscalar()
  7.         if score < threshold:
  8.             continue
  9.         h, w = img.shape[0:2]
  10.         bbox = [row[2:6] * nd.array((w, h, w, h), ctx=row.context)]
  11.         d2l.show_bboxes(fig.axes, bbox, '%.2f' % score, 'w')
  12.  
  13. display(img, output, threshold=0.3)

../_images/chapter_computer-vision_ssd_41_0.svg

9.7.4. 小结

  • 单发多框检测是一个多尺度的目标检测模型。该模型基于基础网络块和各个多尺度特征块生成不同数量和不同大小的锚框，并通过预测锚框的类别和偏移量检测不同大小的目标。
  • 单发多框检测在训练中根据类别和偏移量的预测和标注值计算损失函数。

9.7.5. 练习

  • 限于篇幅原因，实验中忽略了单发多框检测的一些实现细节。你能从以下几个方面进一步改进模型吗？

9.7.5.1. 损失函数

将预测偏移量用到的

9.7. 单发多框检测（SSD） - 图38 范数损失替换为平滑 9.7. 单发多框检测（SSD） - 图39 范数损失。它在零点附近使用平方函数从而更加平滑，这是通过一个超参数 9.7. 单发多框检测（SSD） - 图40 来控制平滑区域的：

9.7. 单发多框检测（SSD） - 图41

当

9.7. 单发多框检测（SSD） - 图42 很大时该损失类似于 9.7. 单发多框检测（SSD） - 图43 范数损失。当它较小时，损失函数较平滑。

  1. In [22]:
  1. sigmas = [10, 1, 0.5]
  2. lines = ['-', '--', '-.']
  3. x = nd.arange(-2, 2, 0.1)
  4. d2l.set_figsize()
  5.  
  6. for l, s in zip(lines, sigmas):
  7.     y = nd.smooth_l1(x, scalar=s)
  8.     d2l.plt.plot(x.asnumpy(), y.asnumpy(), l, label='sigma=%.1f' % s)
  9. d2l.plt.legend();

../_images/chapter_computer-vision_ssd_43_0.svg

在类别预测时，实验中使用了交叉熵损失：设真实类别

9.7. 单发多框检测（SSD） - 图45 的预测概率是 9.7. 单发多框检测（SSD） - 图46 ，交叉熵损失为 9.7. 单发多框检测（SSD） - 图47 。我们还可以使用焦点损失（focalloss）[2]：给定正的超参数 9.7. 单发多框检测（SSD） - 图48 和 9.7. 单发多框检测（SSD） - 图49 ，该损失的定义为

9.7. 单发多框检测（SSD） - 图50

可以看到，增大

9.7. 单发多框检测（SSD） - 图51 可以有效减小正类预测概率较大时的损失。

  1. In [23]:
  1. def focal_loss(gamma, x):
  2.     return -(1 - x) ** gamma * x.log()
  3.  
  4. x = nd.arange(0.01, 1, 0.01)
  5. for l, gamma in zip(lines, [0, 1, 5]):
  6.     y = d2l.plt.plot(x.asnumpy(), focal_loss(gamma, x).asnumpy(), l,
  7.                      label='gamma=%.1f' % gamma)
  8. d2l.plt.legend();

../_images/chapter_computer-vision_ssd_45_0.svg

9.7.5.2. 训练和预测

  • 当目标在图像中占比较小时，模型通常会采用比较大的输入图像尺寸。
  • 为锚框标注类别时，通常会产生大量的负类锚框。可以对负类锚框进行采样，从而使数据类别更加平衡。这个可以通过设置MultiBoxTarget函数的negative_mining_ratio参数来完成。
  • 在损失函数中为有关锚框类别和有关正类锚框偏移量的损失分别赋予不同的权重超参数。
  • 参考单发多框检测论文，还有哪些方法可以评价目标检测模型的精度 [1]？

9.7.6. 参考文献

[1] Liu, W., Anguelov, D., Erhan, D., Szegedy, C., Reed, S., Fu, C. Y.,& Berg, A. C. (2016, October). Ssd: Single shot multibox detector. InEuropean conference on computer vision (pp. 21-37). Springer, Cham.

[2] Lin, T. Y., Goyal, P., Girshick, R., He, K., & Dollár, P. (2018).Focal loss for dense object detection. IEEE transactions on patternanalysis and machine intelligence.