SSD：Single Shot Detection

单发多框检测（SSD）

BaseNet: 作为主干
多个VGG块串联：用于feature map减半，生成多尺度的feature map，并扩大通道数
BaseNet和VGG都会有三个输出：即类别预测层，bounding box（偏移）预测层和生成锚框（生成锚框其实并不网络输出，这是这样表示更容易看懂）

假设每个VGG和BaseNet的输出feature map尺寸为（通道数，h,w），每个像素生成的锚框数目为a，类别数目为q，加上背景为(q+1)。

如果采用全连接层做最后的输出，参数会非常多，并且输入的图片的尺寸也会被限制为一定大小，因此这里采用类似NiN的设计，即将要输出的数目扩大为通道数。
类别预测层：输出为（a(q+1)，h, w）
偏移预测层：输出为（a*4, h, w）

但是每个VGG块或者BaseNet的h和w不同，因此将多个类别预测层和偏移预测层连接起来需要进行特殊处理。
压平+连接：
首先调换上面两个输出层输出的顺序，(h,w,a(q+1))和（h,w,a4）
然后压平为，(hwa(q+1))和（hwa4）
这样就可以把所有输出连接起来了

预测

在进行预测时，需要多加两个步骤：
偏移修正：由于每个锚框会输出4个偏移量，因此需要将生成的锚框借助输出的偏移量进行修正
NMS：对生成的锚框进行非极大值抑制

训练

在训练时，不同于图像分类，在这里每个锚框在一定意义上相当于一个样本，那么我们需要为样本匹配标签
锚框匹配边缘框：为每个锚框标上类别，并匹配一个边缘框，计算与边缘框的偏移量
损失函数构建：用交叉熵计算每个锚框的类别损失，用L1 loss计算每个锚框的每个偏移量的损失和，连着相加，并进行反向传播即可

---

动手深度学习代码（附带注释）

在 :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顶部的多尺度特征图较小，但具有较大的感受野，它们适合检测较少但较大的物体。
简而言之，通过多尺度特征块，单发多框检测生成不同大小的锚框，并通过预测边界框的类别和偏移量来检测大小不同的目标，因此这是一个多尺度目标检测模型。

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-20sMxtz9-1645624171800)(http://d2l.ai/_images/ssd.svg)]
🏷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\le j\le q$）的通道代表了索引为$i$的锚框有关类别索引为$j$的预测。

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

%matplotlib inline
import torch
import torchvision
from torch import nn
from torch.nn import functional as F
from d2l import torch as d2l


#  采用NiN的设计，用卷积层代替全连接层（可以减少参数，而且可以适应不同的输出）
#  不管输入通道数是多少，每个元素的方框数a, 类别数q+1， 输出的通道数为  a(q+1)，于是总共有输出值个数hw*a(q+1)，符合要求
def cls_predictor(num_inputs, num_anchors, num_classes):
    return nn.Conv2d(num_inputs, num_anchors * (num_classes + 1),
                     kernel_size=3, padding=1)

(边界框预测层)

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

def bbox_predictor(num_inputs, num_anchors):
    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$，其中任一输出的形状是（批量大小，通道数，高度，宽度）。

def forward(x, block):
    return block(x)

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

(torch.Size([2, 55, 20, 20]), torch.Size([2, 33, 10, 10]))

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

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

# 为对多尺度的输出结果进行连接，需要对输出的特征图进行压平
# 为使压平之后的列向量结构为 a(q+1)个值（像素1）、a(q+1)个值（像素2）、...、a(q+1)个值（像素h*w）
# 需要把输出的形状由（批量，通道数，高，宽）调整为（批量，高，宽，通道数）
def flatten_pred(pred):
    return torch.flatten(pred.permute(0, 2, 3, 1), start_dim=1)

def concat_preds(preds):
    return torch.cat([flatten_pred(p) for p in preds], dim=1)

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

# 25300 = 20*20*55 + 10*10*33
concat_preds([Y1, Y2]).shape

torch.Size([2, 25300])

[高和宽减半块]

为了在多个尺度下检测目标，我们在下面定义了高和宽减半块down_sample_blk，该模块将输入特征图的高度和宽度减半。
事实上，该块应用了在 :numref:subsec_vgg-blocks中的VGG模块设计。
更具体地说，每个高和宽减半块由两个填充为$1$的$3\times 3$的卷积层、以及步幅为$2$的$2\times 2$最大汇聚层组成。
我们知道，填充为$1$的$3\times 3$卷积层不改变特征图的形状。但是，其后的$2\times 2$的最大汇聚层将输入特征图的高度和宽度减少了一半。
对于此高和宽减半块的输入和输出特征图，因为$1\times 2+(3-1)+(3-1)=6$，所以输出中的每个单元在输入上都有一个$6\times 6$的感受野。因此，高和宽减半块会扩大每个单元在其输出特征图中的感受野。

# 这个是非常典型的VGG模块
# 卷积层（BatchNorm+ReLU）+卷积层（BatchNorm+ReLU）+最大池化层
def down_sample_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)

在以下示例中，我们构建的高和宽减半块会更改输入通道的数量，并将输入特征图的高度和宽度减半。

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

torch.Size([2, 10, 10, 10])

[基本网络块]

基本网络块用于从输入图像中抽取特征。
为了计算简洁，我们构造了一个小的基础网络，该网络串联3个高和宽减半块，并逐步将通道数翻倍。
给定输入图像的形状为$256\times 256$，此基本网络块输出的特征图形状为$32\times 32$（$256/2^3=32$）。

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)

# 测试函数X = torch.zeros((2,3,256,256))for blk in base_net():    X = blk(X)    print(blk.__class__.__name__, ' : ', X.shape)

Sequential  :  torch.Size([2, 16, 128, 128])Sequential  :  torch.Size([2, 32, 64, 64])Sequential  :  torch.Size([2, 64, 32, 32])

完整的模型

[完整的单发多框检测模型由五个模块组成]。每个块生成的特征图既用于生成锚框，又用于预测这些锚框的类别和偏移量。在这五个模块中，第一个是基本网络块，第二个到第四个是高和宽减半块，最后一个模块使用全局最大池将高度和宽度都降到1。从技术上讲，第二到第五个区块都是 :numref:fig_ssd中的多尺度特征块。

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

现在我们[为每个块定义前向传播]。与图像分类任务不同，此处的输出包括：CNN特征图Y；在当前尺度下根据Y生成的锚框；预测的这些锚框的类别和偏移量（基于Y）。

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)

回想一下，在 :numref:fig_ssd中，一个较接近顶部的多尺度特征块是用于检测较大目标的，因此需要生成更大的锚框。
在上面的前向传播中，在每个多尺度特征块上，我们通过调用的multibox_prior函数（见 :numref:sec_anchor）的sizes参数传递两个比例值的列表。
在下面，0.2和1.05之间的区间被均匀分成五个部分，以确定五个模块的在不同尺度下的较小值：0.2、0.37、0.54、0.71和0.88。
之后，他们较大的值由$\sqrt{0.2\times 0.37}=0.272$、$\sqrt{0.37\times 0.54}=0.447$等给出。

[超参数]

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

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

class TinySSD(nn.Module):    def __init__(self, num_classes, **kwargs):        super(TinySSD, self).__init__(**kwargs)        self.num_classes = num_classes        idx_to_in_channels = [64, 128, 128, 128, 128]        for i in range(5):            # 即赋值语句self.blk_i=get_blk(i)            # setattr可以用字符串设置属性名字，因此适用于批量设置属性            setattr(self, f'blk_{i}', get_blk(i))            setattr(self, f'cls_{i}', cls_predictor(idx_to_in_channels[i],                                                    num_anchors, num_classes))            setattr(self, f'bbox_{i}', bbox_predictor(idx_to_in_channels[i],                                                      num_anchors))    def forward(self, X):        anchors, cls_preds, bbox_preds = [None] * 5, [None] * 5, [None] * 5        for i in range(5):            # getattr(self,'blk_%d'%i)即访问self.blk_i            #  getattr用字符串获取属性            X, anchors[i], cls_preds[i], bbox_preds[i] = blk_forward(                X, getattr(self, f'blk_{i}'), sizes[i], ratios[i],                getattr(self, f'cls_{i}'), getattr(self, f'bbox_{i}'))        anchors = torch.cat(anchors, dim=1)        cls_preds = concat_preds(cls_preds)        cls_preds = cls_preds.reshape(            cls_preds.shape[0], -1, self.num_classes + 1) # (batch_size, h*w*a, q+1)        bbox_preds = concat_preds(bbox_preds) # (batch_size, h*w*a*(q+1))        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$个锚框。

net = TinySSD(num_classes=1)X = torch.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)

output anchors: torch.Size([1, 5444, 4])output class preds: torch.Size([32, 5444, 2])output bbox preds: torch.Size([32, 21776])

训练模型

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

读取数据集和初始化

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

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

read 1000 training examplesread 100 validation examples

香蕉检测数据集中，目标的类别数为1。
定义好模型后，我们需要(初始化其参数并定义优化算法)。

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

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

[定义损失函数和评价函数]

目标检测有两种类型的损失。
第一种有关锚框类别的损失：我们可以简单地复用之前图像分类问题里一直使用的交叉熵损失函数来计算；
第二种有关正类锚框偏移量的损失：预测偏移量是一个回归问题。
但是，对于这个回归问题，我们在这里不使用 :numref:subsec_normal_distribution_and_squared_loss中描述的平方损失，而是使用$L_1$范数损失，即预测值和真实值之差的绝对值。
掩码变量bbox_masks令负类锚框和填充锚框不参与损失的计算。
最后，我们将锚框类别和偏移量的损失相加，以获得模型的最终损失函数。

#' none'输出的loss是一个矩阵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]    # 估计是因为分类这种简单网络都是批量x种类（两维度）    # 但是因为生成锚框，变成批量x锚框数x种类（三维度），所以先压缩一个维度    cls = cls_loss(cls_preds.reshape(-1, num_classes),                   cls_labels.reshape(-1)).reshape(batch_size, -1).mean(dim=1)    # 不太清楚这里为什么要先压缩掉批量的维度    # mean(dim=1): 计算每个批量中所有锚框的平均值    bbox = bbox_loss(bbox_preds * bbox_masks,                     bbox_labels * bbox_masks).mean(dim=1)    return cls + bbox

我们可以沿用准确率评价分类结果。
由于偏移量使用了$L_1$范数损失，我们使用平均绝对误差来评价边界框的预测结果。这些预测结果是从生成的锚框及其预测偏移量中获得的。

def cls_eval(cls_preds, cls_labels):    # 由于类别预测结果放在最后一维，argmax需要指定最后一维。    return float((cls_preds.argmax(dim=-1).type(        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())

[训练模型]

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

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):    # 训练精确度的和，训练精确度的和中的示例数    # 绝对误差的和，绝对误差的和中的示例数    metric = d2l.Accumulator(4)    net.train()    for features, target in train_iter:        timer.start()        trainer.zero_grad()        X, Y = features.to(device), target.to(device)        # 生成多尺度的锚框，为每个锚框预测类别和偏移量        anchors, cls_preds, bbox_preds = net(X)        # 为每个锚框标注类别和偏移量        bbox_labels, bbox_masks, cls_labels = d2l.multibox_target(anchors, Y)        # 根据类别和偏移量的预测和标注值计算损失函数        l = calc_loss(cls_preds, cls_labels, bbox_preds, bbox_labels,                      bbox_masks)        # 计算每个批量的平均值        l.mean().backward()        trainer.step()        metric.add(cls_eval(cls_preds, cls_labels), cls_labels.numel(),                   bbox_eval(bbox_preds, bbox_labels, bbox_masks),                   bbox_labels.numel())    cls_err, bbox_mae = 1 - metric[0] / metric[1], metric[2] / metric[3]    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)}')

class err 3.33e-03, bbox mae 3.19e-036911.4 examples/sec on cuda:0

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-elMfHUFy-1645624171802)(ssd_files/ssd_37_1.svg)]

[预测目标]

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

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

使用下面的multibox_detection函数，我们可以根据锚框及其预测偏移量得到预测边界框。然后，通过非极大值抑制来移除相似的预测边界框。

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)

最后，我们[筛选所有置信度不低于0.9的边界框，做为最终输出]。

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)

单发多框检测（SSD）

🏷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顶部的多尺度特征图较小，但具有较大的感受野，它们适合检测较少但较大的物体。
简而言之，通过多尺度特征块，单发多框检测生成不同大小的锚框，并通过预测边界框的类别和偏移量来检测大小不同的目标，因此这是一个多尺度目标检测模型。

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-82ijLbkH-1645624215301)(http://d2l.ai/_images/ssd.svg)]
🏷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\le j\le q$）的通道代表了索引为$i$的锚框有关类别索引为$j$的预测。

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

%matplotlib inline
import torch
import torchvision
from torch import nn
from torch.nn import functional as F
from d2l import torch as d2l


#  采用NiN的设计，用卷积层代替全连接层（可以减少参数，而且可以适应不同的输出）
#  不管输入通道数是多少，每个元素的方框数a, 类别数q+1， 输出的通道数为  a(q+1)，于是总共有输出值个数hw*a(q+1)，符合要求
def cls_predictor(num_inputs, num_anchors, num_classes):
    return nn.Conv2d(num_inputs, num_anchors * (num_classes + 1),
                     kernel_size=3, padding=1)

(边界框预测层)

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

def bbox_predictor(num_inputs, num_anchors):
    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$，其中任一输出的形状是（批量大小，通道数，高度，宽度）。

def forward(x, block):
    return block(x)

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

(torch.Size([2, 55, 20, 20]), torch.Size([2, 33, 10, 10]))

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

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

# 为对多尺度的输出结果进行连接，需要对输出的特征图进行压平
# 为使压平之后的列向量结构为 a(q+1)个值（像素1）、a(q+1)个值（像素2）、...、a(q+1)个值（像素h*w）
# 需要把输出的形状由（批量，通道数，高，宽）调整为（批量，高，宽，通道数）
def flatten_pred(pred):
    return torch.flatten(pred.permute(0, 2, 3, 1), start_dim=1)

def concat_preds(preds):
    return torch.cat([flatten_pred(p) for p in preds], dim=1)

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

# 25300 = 20*20*55 + 10*10*33
concat_preds([Y1, Y2]).shape

torch.Size([2, 25300])

[高和宽减半块]

为了在多个尺度下检测目标，我们在下面定义了高和宽减半块down_sample_blk，该模块将输入特征图的高度和宽度减半。
事实上，该块应用了在 :numref:subsec_vgg-blocks中的VGG模块设计。
更具体地说，每个高和宽减半块由两个填充为$1$的$3\times 3$的卷积层、以及步幅为$2$的$2\times 2$最大汇聚层组成。
我们知道，填充为$1$的$3\times 3$卷积层不改变特征图的形状。但是，其后的$2\times 2$的最大汇聚层将输入特征图的高度和宽度减少了一半。
对于此高和宽减半块的输入和输出特征图，因为$1\times 2+(3-1)+(3-1)=6$，所以输出中的每个单元在输入上都有一个$6\times 6$的感受野。因此，高和宽减半块会扩大每个单元在其输出特征图中的感受野。

# 这个是非常典型的VGG模块
# 卷积层（BatchNorm+ReLU）+卷积层（BatchNorm+ReLU）+最大池化层
def down_sample_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)

在以下示例中，我们构建的高和宽减半块会更改输入通道的数量，并将输入特征图的高度和宽度减半。

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

torch.Size([2, 10, 10, 10])

[基本网络块]

基本网络块用于从输入图像中抽取特征。
为了计算简洁，我们构造了一个小的基础网络，该网络串联3个高和宽减半块，并逐步将通道数翻倍。
给定输入图像的形状为$256\times 256$，此基本网络块输出的特征图形状为$32\times 32$（$256/2^3=32$）。

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)

# 测试函数X = torch.zeros((2,3,256,256))for blk in base_net():    X = blk(X)    print(blk.__class__.__name__, ' : ', X.shape)

Sequential  :  torch.Size([2, 16, 128, 128])Sequential  :  torch.Size([2, 32, 64, 64])Sequential  :  torch.Size([2, 64, 32, 32])

完整的模型

[完整的单发多框检测模型由五个模块组成]。每个块生成的特征图既用于生成锚框，又用于预测这些锚框的类别和偏移量。在这五个模块中，第一个是基本网络块，第二个到第四个是高和宽减半块，最后一个模块使用全局最大池将高度和宽度都降到1。从技术上讲，第二到第五个区块都是 :numref:fig_ssd中的多尺度特征块。

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

现在我们[为每个块定义前向传播]。与图像分类任务不同，此处的输出包括：CNN特征图Y；在当前尺度下根据Y生成的锚框；预测的这些锚框的类别和偏移量（基于Y）。

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)

回想一下，在 :numref:fig_ssd中，一个较接近顶部的多尺度特征块是用于检测较大目标的，因此需要生成更大的锚框。
在上面的前向传播中，在每个多尺度特征块上，我们通过调用的multibox_prior函数（见 :numref:sec_anchor）的sizes参数传递两个比例值的列表。
在下面，0.2和1.05之间的区间被均匀分成五个部分，以确定五个模块的在不同尺度下的较小值：0.2、0.37、0.54、0.71和0.88。
之后，他们较大的值由$\sqrt{0.2\times 0.37}=0.272$、$\sqrt{0.37\times 0.54}=0.447$等给出。

[超参数]

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

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

class TinySSD(nn.Module):    def __init__(self, num_classes, **kwargs):        super(TinySSD, self).__init__(**kwargs)        self.num_classes = num_classes        idx_to_in_channels = [64, 128, 128, 128, 128]        for i in range(5):            # 即赋值语句self.blk_i=get_blk(i)            # setattr可以用字符串设置属性名字，因此适用于批量设置属性            setattr(self, f'blk_{i}', get_blk(i))            setattr(self, f'cls_{i}', cls_predictor(idx_to_in_channels[i],                                                    num_anchors, num_classes))            setattr(self, f'bbox_{i}', bbox_predictor(idx_to_in_channels[i],                                                      num_anchors))    def forward(self, X):        anchors, cls_preds, bbox_preds = [None] * 5, [None] * 5, [None] * 5        for i in range(5):            # getattr(self,'blk_%d'%i)即访问self.blk_i            #  getattr用字符串获取属性            X, anchors[i], cls_preds[i], bbox_preds[i] = blk_forward(                X, getattr(self, f'blk_{i}'), sizes[i], ratios[i],                getattr(self, f'cls_{i}'), getattr(self, f'bbox_{i}'))        anchors = torch.cat(anchors, dim=1)        cls_preds = concat_preds(cls_preds)        cls_preds = cls_preds.reshape(            cls_preds.shape[0], -1, self.num_classes + 1) # (batch_size, h*w*a, q+1)        bbox_preds = concat_preds(bbox_preds) # (batch_size, h*w*a*(q+1))        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$个锚框。

net = TinySSD(num_classes=1)X = torch.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)

output anchors: torch.Size([1, 5444, 4])output class preds: torch.Size([32, 5444, 2])output bbox preds: torch.Size([32, 21776])

训练模型

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

读取数据集和初始化

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

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

read 1000 training examplesread 100 validation examples

香蕉检测数据集中，目标的类别数为1。
定义好模型后，我们需要(初始化其参数并定义优化算法)。

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

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

[定义损失函数和评价函数]

目标检测有两种类型的损失。
第一种有关锚框类别的损失：我们可以简单地复用之前图像分类问题里一直使用的交叉熵损失函数来计算；
第二种有关正类锚框偏移量的损失：预测偏移量是一个回归问题。
但是，对于这个回归问题，我们在这里不使用 :numref:subsec_normal_distribution_and_squared_loss中描述的平方损失，而是使用$L_1$范数损失，即预测值和真实值之差的绝对值。
掩码变量bbox_masks令负类锚框和填充锚框不参与损失的计算。
最后，我们将锚框类别和偏移量的损失相加，以获得模型的最终损失函数。

#' none'输出的loss是一个矩阵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]    # 估计是因为分类这种简单网络都是批量x种类（两维度）    # 但是因为生成锚框，变成批量x锚框数x种类（三维度），所以先压缩一个维度    cls = cls_loss(cls_preds.reshape(-1, num_classes),                   cls_labels.reshape(-1)).reshape(batch_size, -1).mean(dim=1)    # 不太清楚这里为什么要先压缩掉批量的维度    # mean(dim=1): 计算每个批量中所有锚框的平均值    bbox = bbox_loss(bbox_preds * bbox_masks,                     bbox_labels * bbox_masks).mean(dim=1)    return cls + bbox

我们可以沿用准确率评价分类结果。
由于偏移量使用了$L_1$范数损失，我们使用平均绝对误差来评价边界框的预测结果。这些预测结果是从生成的锚框及其预测偏移量中获得的。

def cls_eval(cls_preds, cls_labels):    # 由于类别预测结果放在最后一维，argmax需要指定最后一维。    return float((cls_preds.argmax(dim=-1).type(        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())

[训练模型]

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

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):    # 训练精确度的和，训练精确度的和中的示例数    # 绝对误差的和，绝对误差的和中的示例数    metric = d2l.Accumulator(4)    net.train()    for features, target in train_iter:        timer.start()        trainer.zero_grad()        X, Y = features.to(device), target.to(device)        # 生成多尺度的锚框，为每个锚框预测类别和偏移量        anchors, cls_preds, bbox_preds = net(X)        # 为每个锚框标注类别和偏移量        bbox_labels, bbox_masks, cls_labels = d2l.multibox_target(anchors, Y)        # 根据类别和偏移量的预测和标注值计算损失函数        l = calc_loss(cls_preds, cls_labels, bbox_preds, bbox_labels,                      bbox_masks)        # 计算每个批量的平均值        l.mean().backward()        trainer.step()        metric.add(cls_eval(cls_preds, cls_labels), cls_labels.numel(),                   bbox_eval(bbox_preds, bbox_labels, bbox_masks),                   bbox_labels.numel())    cls_err, bbox_mae = 1 - metric[0] / metric[1], metric[2] / metric[3]    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)}')

class err 3.33e-03, bbox mae 3.19e-036911.4 examples/sec on cuda:0

[预测目标]

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

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

使用下面的multibox_detection函数，我们可以根据锚框及其预测偏移量得到预测边界框。然后，通过非极大值抑制来移除相似的预测边界框。

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)

最后，我们[筛选所有置信度不低于0.9的边界框，做为最终输出]。

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)

​
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-No9HJ0x7-1645624215303)(ssd_files/ssd_43_0.svg)]

​

​