单发多框检测（SSD）

:label:sec_ssd

在 :numref:sec_bbox— :numref:sec_object-detection-dataset中，我们分别介绍了边界框、锚框、多尺度目标检测和用于目标检测的数据集。 现在我们已经准备好使用这样的背景知识来设计一个目标检测模型：单发多框检测（SSD） :cite:Liu.Anguelov.Erhan.ea.2016。 该模型简单、快速且被广泛使用。尽管这只是其中一种目标检测模型，但本节中的一些设计原则和实现细节也适用于其他模型。

模型

:numref:fig_ssd描述了单发多框检测模型的设计。 此模型主要由基础网络组成，其后是几个多尺度特征块。 基本网络用于从输入图像中提取特征，因此它可以使用深度卷积神经网络。 单发多框检测论文中选用了在分类层之前截断的VGG :cite:Liu.Anguelov.Erhan.ea.2016，现在也常用ResNet替代。 我们可以设计基础网络，使它输出的高和宽较大。 这样一来，基于该特征图生成的锚框数量较多，可以用来检测尺寸较小的目标。 接下来的每个多尺度特征块将上一层提供的特征图的高和宽缩小（如减半），并使特征图中每个单元在输入图像上的感受野变得更广阔。

回想一下在 :numref:sec_multiscale-object-detection中，通过深度神经网络分层表示图像的多尺度目标检测的设计。 由于接近 :numref:fig_ssd顶部的多尺度特征图较小，但具有较大的感受野，它们适合检测较少但较大的物体。 简而言之，通过多尺度特征块，单发多框检测生成不同大小的锚框，并通过预测边界框的类别和偏移量来检测大小不同的目标，因此这是一个多尺度目标检测模型。

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

在下面，我们将介绍 :numref:fig_ssd中不同块的实施细节。 首先，我们将讨论如何实施类别和边界框预测。

[类别预测层]

设目标类别的数量为$q$。这样一来，锚框有$q+1$个类别，其中0类是背景。 在某个尺度下，设特征图的高和宽分别为$h$和$w$。 如果以其中每个单元为中心生成$a$个锚框，那么我们需要对$hwa$个锚框进行分类。 如果使用全连接层作为输出，很容易导致模型参数过多。 回忆 :numref:sec_nin一节介绍的使用卷积层的通道来输出类别预测的方法， 单发多框检测采用同样的方法来降低模型复杂度。

具体来说，类别预测层使用一个保持输入高和宽的卷积层。 这样一来，输出和输入在特征图宽和高上的空间坐标一一对应。 考虑输出和输入同一空间坐标（$x$、$y$）：输出特征图上（$x$、$y$）坐标的通道里包含了以输入特征图（$x$、$y$）坐标为中心生成的所有锚框的类别预测。 因此输出通道数为$a(q+1)$，其中索引为$i(q+1) + j$（$0 \leq j \leq q$）的通道代表了索引为$i$的锚框有关类别索引为$j$的预测。

在下面，我们定义了这样一个类别预测层，通过参数num_anchors和num_classes分别指定了$a$和$q$。 该图层使用填充为1的$3\times3$的卷积层。此卷积层的输入和输出的宽度和高度保持不变。

```{.python .input} %matplotlib inline from d2l import mxnet as d2l from mxnet import autograd, gluon, image, init, np, npx from mxnet.gluon import nn

npx.set_np()

def cls_predictor(num_anchors, num_classes): return nn.Conv2D(num_anchors * (num_classes + 1), kernel_size=3, padding=1)

  2. ```{.python .input}
  3. #@tab pytorch
  4. %matplotlib inline
  5. from d2l import torch as d2l
  6. import torch
  7. import torchvision
  8. from torch import nn
  9. from torch.nn import functional as F
  11. def cls_predictor(num_inputs, num_anchors, num_classes):
  12.     return nn.Conv2d(num_inputs, num_anchors * (num_classes + 1),
  13.                      kernel_size=3, padding=1)

(边界框预测层)

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

```{.python .input} def bbox_predictor(num_anchors): return nn.Conv2D(num_anchors * 4, kernel_size=3, padding=1)

  2. ```{.python .input}
  3. #@tab pytorch
  4. def bbox_predictor(num_inputs, num_anchors):
  5.     return nn.Conv2d(num_inputs, num_anchors * 4, kernel_size=3, padding=1)

[连结多尺度的预测]

正如我们所提到的，单发多框检测使用多尺度特征图来生成锚框并预测其类别和偏移量。 在不同的尺度下，特征图的形状或以同一单元为中心的锚框的数量可能会有所不同。 因此，不同尺度下预测输出的形状可能会有所不同。

在以下示例中，我们为同一个小批量构建两个不同比例（Y1和Y2）的特征图，其中Y2的高度和宽度是Y1的一半。 以类别预测为例，假设Y1和Y2的每个单元分别生成了$5$个和$3$个锚框。 进一步假设目标类别的数量为$10$，对于特征图Y1和Y2，类别预测输出中的通道数分别为$5\times(10+1)=55$和$3\times(10+1)=33$，其中任一输出的形状是（批量大小，通道数，高度，宽度）。

```{.python .input} def forward(x, block): block.initialize() return block(x)

Y1 = forward(np.zeros((2, 8, 20, 20)), cls_predictor(5, 10)) Y2 = forward(np.zeros((2, 16, 10, 10)), cls_predictor(3, 10)) Y1.shape, Y2.shape

  2. ```{.python .input}
  3. #@tab pytorch
  4. def forward(x, block):
  5.     return block(x)
  7. Y1 = forward(torch.zeros((2, 8, 20, 20)), cls_predictor(8, 5, 10))
  8. Y2 = forward(torch.zeros((2, 16, 10, 10)), cls_predictor(16, 3, 10))
  9. Y1.shape, Y2.shape

正如我们所看到的，除了批量大小这一维度外，其他三个维度都具有不同的尺寸。 为了将这两个预测输出链接起来以提高计算效率，我们将把这些张量转换为更一致的格式。

通道维包含中心相同的锚框的预测结果。我们首先将通道维移到最后一维。 因为不同尺度下批量大小仍保持不变，我们可以将预测结果转成二维的（批量大小，高$\times$宽$\times$通道数）的格式，以方便之后在维度$1$上的连结。

```{.python .input} def flatten_pred(pred): return npx.batch_flatten(pred.transpose(0, 2, 3, 1))

def concat_preds(preds): return np.concatenate([flatten_pred(p) for p in preds], axis=1)

  2. ```{.python .input}
  3. #@tab pytorch
  4. def flatten_pred(pred):
  5.     return torch.flatten(pred.permute(0, 2, 3, 1), start_dim=1)
  7. def concat_preds(preds):
  8.     return torch.cat([flatten_pred(p) for p in preds], dim=1)

这样一来，尽管Y1和Y2在通道数、高度和宽度方面具有不同的大小，我们仍然可以在同一个小批量的两个不同尺度上连接这两个预测输出。

```{.python .input}

@tab all

concat_preds([Y1, Y2]).shape

  2. ### [**高和宽减半块**]
  4. 为了在多个尺度下检测目标，我们在下面定义了高和宽减半块`down_sample_blk`，该模块将输入特征图的高度和宽度减半。
  5. 事实上，该块应用了在 :numref:`subsec_vgg-blocks`中的VGG模块设计。
  6. 更具体地说，每个高和宽减半块由两个填充为$1$的$3\times3$的卷积层、以及步幅为$2$的$2\times2$最大汇聚层组成。
  7. 我们知道，填充为$1$的$3\times3$卷积层不改变特征图的形状。但是，其后的$2\times2$的最大汇聚层将输入特征图的高度和宽度减少了一半。
  8. 对于此高和宽减半块的输入和输出特征图，因为$1\times 2+(3-1)+(3-1)=6$，所以输出中的每个单元在输入上都有一个$6\times6$的感受野。因此，高和宽减半块会扩大每个单元在其输出特征图中的感受野。
  10. ```{.python .input}
  11. def down_sample_blk(num_channels):
  12.     blk = nn.Sequential()
  13.     for _ in range(2):
  14.         blk.add(nn.Conv2D(num_channels, kernel_size=3, padding=1),
  15.                 nn.BatchNorm(in_channels=num_channels),
  16.                 nn.Activation('relu'))
  17.     blk.add(nn.MaxPool2D(2))
  18.     return blk

```{.python .input}

@tab pytorch

def downsample_blk(in_channels, out_channels): blk = [] for in range(2): blk.append(nn.Conv2d(in_channels, out_channels, kernel_size=3, padding=1)) blk.append(nn.BatchNorm2d(out_channels)) blk.append(nn.ReLU()) in_channels = out_channels blk.append(nn.MaxPool2d(2)) return nn.Sequential(*blk)

  2. 在以下示例中，我们构建的高和宽减半块会更改输入通道的数量，并将输入特征图的高度和宽度减半。
  4. ```{.python .input}
  5. forward(np.zeros((2, 3, 20, 20)), down_sample_blk(10)).shape

```{.python .input}

@tab pytorch

forward(torch.zeros((2, 3, 20, 20)), down_sample_blk(3, 10)).shape

  2. ### [**基本网络块**]
  4. 基本网络块用于从输入图像中抽取特征。
  5. 为了计算简洁，我们构造了一个小的基础网络，该网络串联3个高和宽减半块，并逐步将通道数翻倍。
  6. 给定输入图像的形状为$256\times256$，此基本网络块输出的特征图形状为$32 \times 32$（$256/2^3=32$）。
  8. ```{.python .input}
  9. def base_net():
  10.     blk = nn.Sequential()
  11.     for num_filters in [16, 32, 64]:
  12.         blk.add(down_sample_blk(num_filters))
  13.     return blk
  15. forward(np.zeros((2, 3, 256, 256)), base_net()).shape

```{.python .input}

@tab pytorch

def base_net(): blk = [] num_filters = [3, 16, 32, 64] for i in range(len(num_filters) - 1): blk.append(down_sample_blk(num_filters[i], num_filters[i+1])) return nn.Sequential(*blk)

forward(torch.zeros((2, 3, 256, 256)), base_net()).shape

  2. ### 完整的模型
  4. [**完整的单发多框检测模型由五个模块组成**]。每个块生成的特征图既用于生成锚框，又用于预测这些锚框的类别和偏移量。在这五个模块中，第一个是基本网络块，第二个到第四个是高和宽减半块，最后一个模块使用全局最大池将高度和宽度都降到1。从技术上讲，第二到第五个区块都是 :numref:`fig_ssd`中的多尺度特征块。
  6. ```{.python .input}
  7. def get_blk(i):
  8.     if i == 0:
  9.         blk = base_net()
  10.     elif i == 4:
  11.         blk = nn.GlobalMaxPool2D()
  12.     else:
  13.         blk = down_sample_blk(128)
  14.     return blk

```{.python .input}

@tab pytorch

def get_blk(i): if i == 0: blk = base_net() elif i == 1: blk = down_sample_blk(64, 128) elif i == 4: blk = nn.AdaptiveMaxPool2d((1,1)) else: blk = down_sample_blk(128, 128) return blk

  2. 现在我们[**为每个块定义前向传播**]。与图像分类任务不同，此处的输出包括：CNN特征图`Y`；在当前尺度下根据`Y`生成的锚框；预测的这些锚框的类别和偏移量（基于`Y`）。
  4. ```{.python .input}
  5. def blk_forward(X, blk, size, ratio, cls_predictor, bbox_predictor):
  6.     Y = blk(X)
  7.     anchors = d2l.multibox_prior(Y, sizes=size, ratios=ratio)
  8.     cls_preds = cls_predictor(Y)
  9.     bbox_preds = bbox_predictor(Y)
  10.     return (Y, anchors, cls_preds, bbox_preds)

```{.python .input}

@tab pytorch

def blk_forward(X, blk, size, ratio, cls_predictor, bbox_predictor): Y = blk(X) anchors = d2l.multibox_prior(Y, sizes=size, ratios=ratio) cls_preds = cls_predictor(Y) bbox_preds = bbox_predictor(Y) return (Y, anchors, cls_preds, bbox_preds)

  2. 回想一下，在 :numref:`fig_ssd`中，一个较接近顶部的多尺度特征块是用于检测较大目标的，因此需要生成更大的锚框。
  3. 在上面的前向传播中，在每个多尺度特征块上，我们通过调用的`multibox_prior`函数（见 :numref:`sec_anchor`）的`sizes`参数传递两个比例值的列表。
  4. 在下面，0.2和1.05之间的区间被均匀分成五个部分，以确定五个模块的在不同尺度下的较小值：0.2、0.37、0.54、0.71和0.88。
  5. 之后，他们较大的值由$\sqrt{0.2 \times 0.37} = 0.272$、$\sqrt{0.37 \times 0.54} = 0.447$等给出。
  7. [~~超参数~~]
  9. ```{.python .input}
  10. #@tab all
  11. sizes = [[0.2, 0.272], [0.37, 0.447], [0.54, 0.619], [0.71, 0.79],
  12.          [0.88, 0.961]]
  13. ratios = [[1, 2, 0.5]] * 5
  14. num_anchors = len(sizes[0]) + len(ratios[0]) - 1

现在，我们就可以按如下方式[定义完整的模型]TinySSD了。

```{.python .input} class TinySSD(nn.Block): def init(self, numclasses, **kwargs): super(TinySSD, self)._init(**kwargs) self.num_classes = num_classes for i in range(5):

  1.         # 即赋值语句self.blk_i=get_blk(i)
  2.         setattr(self, f'blk_{i}', get_blk(i))
  3.         setattr(self, f'cls_{i}', cls_predictor(num_anchors, num_classes))
  4.         setattr(self, f'bbox_{i}', bbox_predictor(num_anchors))
  6. def forward(self, X):
  7.     anchors, cls_preds, bbox_preds = [None] * 5, [None] * 5, [None] * 5
  8.     for i in range(5):
  9.         # getattr(self,'blk_%d'%i)即访问self.blk_i
  10.         X, anchors[i], cls_preds[i], bbox_preds[i] = blk_forward(
  11.             X, getattr(self, f'blk_{i}'), sizes[i], ratios[i],
  12.             getattr(self, f'cls_{i}'), getattr(self, f'bbox_{i}'))
  13.     anchors = np.concatenate(anchors, axis=1)
  14.     cls_preds = concat_preds(cls_preds)
  15.     cls_preds = cls_preds.reshape(
  16.         cls_preds.shape[0], -1, self.num_classes + 1)
  17.     bbox_preds = concat_preds(bbox_preds)
  18.     return anchors, cls_preds, bbox_preds
  2. ```{.python .input}
  3. #@tab pytorch
  4. class TinySSD(nn.Module):
  5.     def __init__(self, num_classes, **kwargs):
  6.         super(TinySSD, self).__init__(**kwargs)
  7.         self.num_classes = num_classes
  8.         idx_to_in_channels = [64, 128, 128, 128, 128]
  9.         for i in range(5):
  10.             # 即赋值语句self.blk_i=get_blk(i)
  11.             setattr(self, f'blk_{i}', get_blk(i))
  12.             setattr(self, f'cls_{i}', cls_predictor(idx_to_in_channels[i],
  13.                                                     num_anchors, num_classes))
  14.             setattr(self, f'bbox_{i}', bbox_predictor(idx_to_in_channels[i],
  15.                                                       num_anchors))
  17.     def forward(self, X):
  18.         anchors, cls_preds, bbox_preds = [None] * 5, [None] * 5, [None] * 5
  19.         for i in range(5):
  20.             # getattr(self,'blk_%d'%i)即访问self.blk_i
  21.             X, anchors[i], cls_preds[i], bbox_preds[i] = blk_forward(
  22.                 X, getattr(self, f'blk_{i}'), sizes[i], ratios[i],
  23.                 getattr(self, f'cls_{i}'), getattr(self, f'bbox_{i}'))
  24.         anchors = torch.cat(anchors, dim=1)
  25.         cls_preds = concat_preds(cls_preds)
  26.         cls_preds = cls_preds.reshape(
  27.             cls_preds.shape[0], -1, self.num_classes + 1)
  28.         bbox_preds = concat_preds(bbox_preds)
  29.         return anchors, cls_preds, bbox_preds

我们[创建一个模型实例，然后使用它]对一个$256 \times 256$像素的小批量图像X(执行前向传播)。

如本节前面部分所示，第一个模块输出特征图的形状为$32 \times 32$。 回想一下，第二到第四个模块为高和宽减半块，第五个模块为全局汇聚层。 由于以特征图的每个单元为中心有$4$个锚框生成，因此在所有五个尺度下，每个图像总共生成$(32^2 + 16^2 + 8^2 + 4^2 + 1)\times 4 = 5444$个锚框。

```{.python .input} net = TinySSD(num_classes=1) net.initialize() X = np.zeros((32, 3, 256, 256)) anchors, cls_preds, bbox_preds = net(X)

print(‘output anchors:’, anchors.shape) print(‘output class preds:’, cls_preds.shape) print(‘output bbox preds:’, bbox_preds.shape)

  2. ```{.python .input}
  3. #@tab pytorch
  4. net = TinySSD(num_classes=1)
  5. X = torch.zeros((32, 3, 256, 256))
  6. anchors, cls_preds, bbox_preds = net(X)
  8. print('output anchors:', anchors.shape)
  9. print('output class preds:', cls_preds.shape)
  10. print('output bbox preds:', bbox_preds.shape)

训练模型

现在，我们将描述如何训练用于目标检测的单发多框检测模型。

读取数据集和初始化

首先，让我们[读取] :numref:sec_object-detection-dataset中描述的(香蕉检测数据集)。

```{.python .input}

@tab all

batchsize = 32 train_iter, = d2l.load_data_bananas(batch_size)

  2. 香蕉检测数据集中，目标的类别数为1。
  3. 定义好模型后，我们需要(**初始化其参数并定义优化算法**)。
  5. ```{.python .input}
  6. device, net = d2l.try_gpu(), TinySSD(num_classes=1)
  7. net.initialize(init=init.Xavier(), ctx=device)
  8. trainer = gluon.Trainer(net.collect_params(), 'sgd',
  9.                         {'learning_rate': 0.2, 'wd': 5e-4})

```{.python .input}

@tab pytorch

device, net = d2l.try_gpu(), TinySSD(num_classes=1) trainer = torch.optim.SGD(net.parameters(), lr=0.2, weight_decay=5e-4)

  2. ### [**定义损失函数和评价函数**]
  4. 目标检测有两种类型的损失。
  5. 第一种有关锚框类别的损失：我们可以简单地复用之前图像分类问题里一直使用的交叉熵损失函数来计算；
  6. 第二种有关正类锚框偏移量的损失：预测偏移量是一个回归问题。
  7. 但是，对于这个回归问题，我们在这里不使用 :numref:`subsec_normal_distribution_and_squared_loss`中描述的平方损失，而是使用$L_1$范数损失，即预测值和真实值之差的绝对值。
  8. 掩码变量`bbox_masks`令负类锚框和填充锚框不参与损失的计算。
  9. 最后，我们将锚框类别和偏移量的损失相加，以获得模型的最终损失函数。
  11. ```{.python .input}
  12. cls_loss = gluon.loss.SoftmaxCrossEntropyLoss()
  13. bbox_loss = gluon.loss.L1Loss()
  15. def calc_loss(cls_preds, cls_labels, bbox_preds, bbox_labels, bbox_masks):
  16.     cls = cls_loss(cls_preds, cls_labels)
  17.     bbox = bbox_loss(bbox_preds * bbox_masks, bbox_labels * bbox_masks)
  18.     return cls + bbox

```{.python .input}

@tab pytorch

cls_loss = nn.CrossEntropyLoss(reduction=’none’) bbox_loss = nn.L1Loss(reduction=’none’)

def calc_loss(cls_preds, cls_labels, bbox_preds, bbox_labels, bbox_masks): batch_size, num_classes = cls_preds.shape[0], cls_preds.shape[2] cls = cls_loss(cls_preds.reshape(-1, num_classes), cls_labels.reshape(-1)).reshape(batch_size, -1).mean(dim=1) bbox = bbox_loss(bbox_preds bbox_masks, bbox_labels bbox_masks).mean(dim=1) return cls + bbox

  2. 我们可以沿用准确率评价分类结果。
  3. 由于偏移量使用了$L_1$范数损失，我们使用*平均绝对误差*来评价边界框的预测结果。这些预测结果是从生成的锚框及其预测偏移量中获得的。
  5. ```{.python .input}
  6. def cls_eval(cls_preds, cls_labels):
  7.     # 由于类别预测结果放在最后一维，argmax需要指定最后一维。
  8.     return float((cls_preds.argmax(axis=-1).astype(
  9.         cls_labels.dtype) == cls_labels).sum())
  11. def bbox_eval(bbox_preds, bbox_labels, bbox_masks):
  12.     return float((np.abs((bbox_labels - bbox_preds) * bbox_masks)).sum())

```{.python .input}

@tab pytorch

def cls_eval(cls_preds, cls_labels):

  1. # 由于类别预测结果放在最后一维，argmax需要指定最后一维。
  2. return float((cls_preds.argmax(dim=-1).type(
  3.     cls_labels.dtype) == cls_labels).sum())

def bbox_eval(bbox_preds, bbox_labels, bbox_masks): return float((torch.abs((bbox_labels - bbox_preds) * bbox_masks)).sum())

  2. ### [**训练模型**]
  4. 在训练模型时，我们需要在模型的前向传播过程中生成多尺度锚框（`anchors`），并预测其类别（`cls_preds`）和偏移量（`bbox_preds`）。
  5. 然后，我们根据标签信息`Y`为生成的锚框标记类别（`cls_labels`）和偏移量（`bbox_labels`）。
  6. 最后，我们根据类别和偏移量的预测和标注值计算损失函数。为了代码简洁，这里没有评价测试数据集。
  8. ```{.python .input}
  9. num_epochs, timer = 20, d2l.Timer()
  10. animator = d2l.Animator(xlabel='epoch', xlim=[1, num_epochs],
  11.                         legend=['class error', 'bbox mae'])
  12. for epoch in range(num_epochs):
  13.     # 指标包括：训练精确度的和，训练精确度的和中的示例数，
  14.     # 绝对误差的和，绝对误差的和中的示例数
  15.     metric = d2l.Accumulator(4)
  16.     for features, target in train_iter:
  17.         timer.start()
  18.         X = features.as_in_ctx(device)
  19.         Y = target.as_in_ctx(device)
  20.         with autograd.record():
  21.             # 生成多尺度的锚框，为每个锚框预测类别和偏移量
  22.             anchors, cls_preds, bbox_preds = net(X)
  23.             # 为每个锚框标注类别和偏移量
  24.             bbox_labels, bbox_masks, cls_labels = d2l.multibox_target(anchors,
  25.                                                                       Y)
  26.             # 根据类别和偏移量的预测和标注值计算损失函数
  27.             l = calc_loss(cls_preds, cls_labels, bbox_preds, bbox_labels,
  28.                           bbox_masks)
  29.         l.backward()
  30.         trainer.step(batch_size)
  31.         metric.add(cls_eval(cls_preds, cls_labels), cls_labels.size,
  32.                    bbox_eval(bbox_preds, bbox_labels, bbox_masks),
  33.                    bbox_labels.size)
  34.     cls_err, bbox_mae = 1 - metric[0] / metric[1], metric[2] / metric[3]
  35.     animator.add(epoch + 1, (cls_err, bbox_mae))
  36. print(f'class err {cls_err:.2e}, bbox mae {bbox_mae:.2e}')
  37. print(f'{len(train_iter._dataset) / timer.stop():.1f} examples/sec on '
  38.       f'{str(device)}')

```{.python .input}

@tab pytorch

num_epochs, timer = 20, d2l.Timer() animator = d2l.Animator(xlabel=’epoch’, xlim=[1, num_epochs], legend=[‘class error’, ‘bbox mae’]) net = net.to(device) for epoch in range(num_epochs):

  1. # 训练精确度的和，训练精确度的和中的示例数
  2. # 绝对误差的和，绝对误差的和中的示例数
  3. metric = d2l.Accumulator(4)
  4. net.train()
  5. for features, target in train_iter:
  6.     timer.start()
  7.     trainer.zero_grad()
  8.     X, Y = features.to(device), target.to(device)
  9.     # 生成多尺度的锚框，为每个锚框预测类别和偏移量
  10.     anchors, cls_preds, bbox_preds = net(X)
  11.     # 为每个锚框标注类别和偏移量
  12.     bbox_labels, bbox_masks, cls_labels = d2l.multibox_target(anchors, Y)
  13.     # 根据类别和偏移量的预测和标注值计算损失函数
  14.     l = calc_loss(cls_preds, cls_labels, bbox_preds, bbox_labels,
  15.                   bbox_masks)
  16.     l.mean().backward()
  17.     trainer.step()
  18.     metric.add(cls_eval(cls_preds, cls_labels), cls_labels.numel(),
  19.                bbox_eval(bbox_preds, bbox_labels, bbox_masks),
  20.                bbox_labels.numel())
  21. cls_err, bbox_mae = 1 - metric[0] / metric[1], metric[2] / metric[3]
  22. animator.add(epoch + 1, (cls_err, bbox_mae))

print(f’class err {cls_err:.2e}, bbox mae {bbox_mae:.2e}’) print(f’{len(train_iter.dataset) / timer.stop():.1f} examples/sec on ‘ f’{str(device)}’)

  2. ## [**预测目标**]
  4. 在预测阶段，我们希望能把图像里面所有我们感兴趣的目标检测出来。在下面，我们读取并调整测试图像的大小，然后将其转成卷积层需要的四维格式。
  6. ```{.python .input}
  7. img = image.imread('../img/banana.jpg')
  8. feature = image.imresize(img, 256, 256).astype('float32')
  9. X = np.expand_dims(feature.transpose(2, 0, 1), axis=0)

```{.python .input}

@tab pytorch

X = torchvision.io.read_image(‘../img/banana.jpg’).unsqueeze(0).float() img = X.squeeze(0).permute(1, 2, 0).long()

  2. 使用下面的`multibox_detection`函数，我们可以根据锚框及其预测偏移量得到预测边界框。然后，通过非极大值抑制来移除相似的预测边界框。
  4. ```{.python .input}
  5. def predict(X):
  6.     anchors, cls_preds, bbox_preds = net(X.as_in_ctx(device))
  7.     cls_probs = npx.softmax(cls_preds).transpose(0, 2, 1)
  8.     output = d2l.multibox_detection(cls_probs, bbox_preds, anchors)
  9.     idx = [i for i, row in enumerate(output[0]) if row[0] != -1]
  10.     return output[0, idx]
  12. output = predict(X)

```{.python .input}

@tab pytorch

def predict(X): net.eval() anchors, cls_preds, bbox_preds = net(X.to(device)) cls_probs = F.softmax(cls_preds, dim=2).permute(0, 2, 1) output = d2l.multibox_detection(cls_probs, bbox_preds, anchors) idx = [i for i, row in enumerate(output[0]) if row[0] != -1] return output[0, idx]

output = predict(X)

  2. 最后，我们[**筛选所有置信度不低于0.9的边界框，做为最终输出**]。
  4. ```{.python .input}
  5. def display(img, output, threshold):
  6.     d2l.set_figsize((5, 5))
  7.     fig = d2l.plt.imshow(img.asnumpy())
  8.     for row in output:
  9.         score = float(row[1])
  10.         if score < threshold:
  11.             continue
  12.         h, w = img.shape[0:2]
  13.         bbox = [row[2:6] * np.array((w, h, w, h), ctx=row.ctx)]
  14.         d2l.show_bboxes(fig.axes, bbox, '%.2f' % score, 'w')
  16. display(img, output, threshold=0.9)

```{.python .input}

@tab pytorch

def display(img, output, threshold): d2l.set_figsize((5, 5)) fig = d2l.plt.imshow(img) for row in output: score = float(row[1]) if score < threshold: continue h, w = img.shape[0:2] bbox = [row[2:6] * torch.tensor((w, h, w, h), device=row.device)] d2l.show_bboxes(fig.axes, bbox, ‘%.2f’ % score, ‘w’)

display(img, output.cpu(), threshold=0.9)

  2. ## 小结
  4. * 单发多框检测是一种多尺度目标检测模型。基于基础网络块和各个多尺度特征块，单发多框检测生成不同数量和不同大小的锚框，并通过预测这些锚框的类别和偏移量检测不同大小的目标。
  5. * 在训练单发多框检测模型时，损失函数是根据锚框的类别和偏移量的预测及标注值计算得出的。
  7. ## 练习
  9. 1. 你能通过改进损失函数来改进单发多框检测吗？例如，将预测偏移量用到的$L_1$范数损失替换为平滑$L_1$范数损失。它在零点附近使用平方函数从而更加平滑，这是通过一个超参数$\sigma$来控制平滑区域的：
  11. $$
  12. f(x) =
  13.     \begin{cases}
  14.     (\sigma x)^2/2,& \text{if }|x| < 1/\sigma^2\\
  15.     |x|-0.5/\sigma^2,& \text{otherwise}
  16.     \end{cases}
  17. $$
  19. 当$\sigma$非常大时，这种损失类似于$L_1$范数损失。当它的值较小时，损失函数较平滑。
  21. ```{.python .input}
  22. sigmas = [10, 1, 0.5]
  23. lines = ['-', '--', '-.']
  24. x = np.arange(-2, 2, 0.1)
  25. d2l.set_figsize()
  27. for l, s in zip(lines, sigmas):
  28.     y = npx.smooth_l1(x, scalar=s)
  29.     d2l.plt.plot(x.asnumpy(), y.asnumpy(), l, label='sigma=%.1f' % s)
  30. d2l.plt.legend();

```{.python .input}

@tab pytorch

def smooth_l1(data, scalar): out = [] for i in data: if abs(i) < 1 / (scalar 2): out.append(((scalar * i) 2) / 2) else: out.append(abs(i) - 0.5 / (scalar ** 2)) return torch.tensor(out)

sigmas = [10, 1, 0.5] lines = [‘-‘, ‘—‘, ‘-.’] x = torch.arange(-2, 2, 0.1) d2l.set_figsize()

for l, s in zip(lines, sigmas): y = smooth_l1(x, scalar=s) d2l.plt.plot(x, y, l, label=’sigma=%.1f’ % s) d2l.plt.legend();

  2. 此外，在类别预测时，实验中使用了交叉熵损失：设真实类别$j$的预测概率是$p_j$，交叉熵损失为$-\log p_j$。我们还可以使用焦点损失 :cite:`Lin.Goyal.Girshick.ea.2017`：给定超参数$\gamma > 0$和$\alpha > 0$，此损失的定义为：
  4. $$ - \alpha (1-p_j)^{\gamma} \log p_j.$$
  6. 可以看到，增大$\gamma$可以有效地减少正类预测概率较大时（例如$p_j > 0.5$）的相对损失，因此训练可以更集中在那些错误分类的困难示例上。
  8. ```{.python .input}
  9. def focal_loss(gamma, x):
  10.     return -(1 - x) ** gamma * np.log(x)
  12. x = np.arange(0.01, 1, 0.01)
  13. for l, gamma in zip(lines, [0, 1, 5]):
  14.     y = d2l.plt.plot(x.asnumpy(), focal_loss(gamma, x).asnumpy(), l,
  15.                      label='gamma=%.1f' % gamma)
  16. d2l.plt.legend();

```{.python .input}

@tab pytorch

def focal_loss(gamma, x): return -(1 - x) * gamma torch.log(x)

x = torch.arange(0.01, 1, 0.01) for l, gamma in zip(lines, [0, 1, 5]): y = d2l.plt.plot(x, focal_loss(gamma, x), l, label=’gamma=%.1f’ % gamma) d2l.plt.legend(); ```

  1. 由于篇幅限制，我们在本节中省略了单发多框检测模型的一些实现细节。你能否从以下几个方面进一步改进模型：
    1. 当目标比图像小得多时，模型可以将输入图像调大。
    2. 通常会存在大量的负锚框。为了使类别分布更加平衡，我们可以将负锚框的高和宽减半。
    3. 在损失函数中，给类别损失和偏移损失设置不同比重的超参数。
    4. 使用其他方法评估目标检测模型，例如单发多框检测论文 :cite:Liu.Anguelov.Erhan.ea.2016中的方法。

:begin_tab:mxnet Discussions :end_tab:

:begin_tab:pytorch Discussions :end_tab: