零基础-动手学深度学习-13.7. 单发多框检测（SSD）

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

single shot 单发 跑一次的意思

13.7.1. 模型

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

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

底部来拟合小物体，顶部段来拟合大物体，在下面，我们将介绍 图13.7.1中不同块的实施细节。 首先，我们将讨论如何实施类别和边界框预测。

13.7.1.1. 类别预测层

意思就是卷积层来降低模型复杂度，因为权重只有核，全连接层的作用，和之前说的一样，输出通道将会变为a(q+1),索引也是和之前标注分配的思想是一样的，有点难理解我画了一下图

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


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

13.7.1.2. 边界框预测层

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

这里的意思是网络输出的不是一个类别向量，而是同一个锚框的这 4 个偏移值，把锚框按这 4 个数调整后就得到预测的真实边界框。（就是上面确定x,y对应的类别，而这里预测我们只要预测4个偏移量来确定大小和位置？分别是：Δx —— 中心点在水平方向的偏移；Δy —— 中心点在竖直方向的偏移；Δw —— 宽度的缩放因子（或绝对增量）；Δh —— 高度的缩放因子（或绝对增量））

def bbox_predictor(num_inputs, num_anchors):
    return nn.Conv2d(num_inputs, num_anchors * 4, kernel_size=3, padding=1)

13.7.1.3. 连结多尺度的预测

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

SSD 会在 不同分辨率的特征图（P3, P4, P5 …）上同时做检测：

• 低分辨率（小尺寸）特征图 → 感受野大 → 负责检测大目标

• 高分辨率（大尺寸）特征图 → 感受野小 → 负责检测小目标

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

• 特征图 Y1：20×20，每个像素点放 5 个锚框

• 特征图 Y2：10×10，每个像素点放 3 个锚框

• 锚框数量、通道数、宽高全部都不一样，不能直接 cat 在一起。

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

Y1 = forward(torch.zeros((2, 8, 20, 20)), cls_predictor(8, 5, 10))#cls_predictor(in_channels, num_anchors, num_classes)
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]))

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

通道维包含中心相同的锚框的预测结果(bs,C:该空间位置上 所有锚框 × 所有类别 的置信度,h,w

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

#pred.permute(0, 2, 3, 1) 把通道维挪到最后 → (N, H, W, C)
def flatten_pred(pred):
    return torch.flatten(pred.permute(0, 2, 3, 1), start_dim=1)
#torch.flatten(..., start_dim=1) 从 dim=1 开始拉平 → (N, HWC)
#Y1 变成 (2, 20×20×55)= (2, 22000)；Y2 变成 (2, 10×10×33)= (2, 3300)

#把每个尺度拉平后的 (N, ·) 在 dim=1 上拼接 最终形状 (2, 22000+3300)= (2, 25300)
def concat_preds(preds):
    return torch.cat([flatten_pred(p) for p in preds], dim=1)

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

concat_preds([Y1, Y2]).shape

输出：torch.Size([2, 25300])

这里有同学就会问了（真有吗博主？）为什么可以做这样的flatten，其实到这里还有疑问只能说明你和博主一样前面的代码没有吃透，而且博主至少记得前面有很多此flatten的操作并且为之啧啧称奇，这里我们做一个比较官方的解释，因为把高宽×通道“乘在一起”之后，并没有破坏锚框与特征图的对应关系，为什么这么说？

首先你既然可以相乘后拉平，我就不可以重新再压缩回去吗？

其次网络最后如果是做1*1卷积的话其实呃博主这里也不知道为什么李沐老师用的3*3，反正1*1的话就更没有影响啦！

最后就是后面讲的，你会发现损失函数是按照索引对齐根本不丢失！

13.7.1.4. 高和宽减半块

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

这里好像有点云里雾里？

1. 第一个3x3卷积层：填充（padding）为1，这意味着卷积操作不会改变特征图的尺寸。感受野是3x3。

2. 第二个3x3卷积层：同样填充为1，不改变特征图尺寸。由于第一个卷积层的感受野是3x3，第二个卷积层的感受野是第一个卷积层感受野的每个点再“看到”的3x3区域，即3+(3-1)=5x5。

3. 2x2最大池化层：步幅（stride）为2，这会将特征图的高度和宽度减半。池化层本身的感受野是2x2，但是它作用于前一层5x5的感受野上，所以最终的感受野是5+(2-1)=6x6

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)#先用一个列表把所有操作放进去，然后用nn.Sequential连起来

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

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

输出：torch.Size([2, 10, 10, 10])

13.7.1.5. 基本网络块

基本网络块用于从输入图像中抽取特征。 为了计算简洁，我们构造了一个小的基础网络，该网络串联3个高和宽减半块，并逐步将通道数翻倍。 给定输入图像的形状为256*256，此基本网络块输出的特征图形状为32*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)

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

输出：torch.Size([2, 64, 32, 32])

13.7.1.6. 完整的模型

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

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)

回想一下，在 图13.7.1中，一个较接近顶部的多尺度特征块是用于检测较大目标的，因此需要生成更大的锚框。 在上面的前向传播中，在每个多尺度特征块上，我们通过调用的multibox_prior函数（见 13.4节）的sizes参数传递两个比例值的列表。 在下面，0.2和1.05之间的区间被均匀分成五个部分，以确定五个模块的在不同尺度下的较小值：0.2、0.37、0.54、0.71和0.88。 之后，他们较大的值由sqrt(0.2*0.37)=0.272、sqrt(0.37*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]] * 5
num_anchors = len(sizes[0]) + len(ratios[0]) - 1

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

class TinySSD(nn.Module):
    def __init__(self, num_classes, **kwargs):#num_class类别数
        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) 这样写的话会自动注册成为子模块，里面的参数也会被parameters（）自动收集 不能写成self.blk[i]
            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
#准备 3 个长度 5 的列表，用来分别存放 5 个尺度的锚框坐标 anchors[i]、类别预测 cls_preds[i]、边框预测 bbox_preds[i]
        for i in range(5):
            # getattr(self,'blk_%d'%i)即访问self.blk_i
            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)#把 5 个尺度的锚框在第 1 维（锚框数维）拼接 →形状：(batch, 总锚框, 4)
        cls_preds = concat_preds(cls_preds)#concat_preds 把 5 个尺度的类别预测 flatten 后 cat →(batch, 总锚框*(num_classes+1))
        cls_preds = cls_preds.reshape(
            cls_preds.shape[0], -1, self.num_classes + 1)#再 reshape 成 (batch, 总锚框, num_classes+1)，方便后面 softmax/sigmoid，这里-1是自动计算
        bbox_preds = concat_preds(bbox_preds)
        return anchors, cls_preds, bbox_preds
#anchors：所有尺度的锚框坐标：cls_preds：每个锚框的类别分数：bbox_preds：每个锚框的 4 个坐标偏移
#后续只需计算损失或 NMS 即可。

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

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

net = TinySSD(num_classes=1)#在这里其实会自动转译out = net.forward(x)，上面forward函数意义所在，而且还需要它来反向传播梯度
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])

13.7.2. 训练模型

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

13.7.2.1. 读取数据集和初始化

首先，让我们读取 13.6节中描述的香蕉检测数据集。

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

输出：read 1000 training examples
read 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)

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

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

cls_loss = nn.CrossEntropyLoss(reduction='none')#返回形状 (batch*total_anchors)
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_preds 形状：(batch, total_anchors, num_classes+1)
#cls_labels 形状：(batch, total_anchors)（里面是 0~num_classes 的整数标签）
    cls = cls_loss(cls_preds.reshape(-1, num_classes),
#拉成 (batch*total_anchors, num_classes)
                   cls_labels.reshape(-1)).reshape(batch_size, -1).mean(dim=1)#恢复成 (batch, total_anchors)，每行是一张图所有锚框的损失。.mean(dim=1) → 对每张图求平均，得到 (batch) 长度的向量，即每张图的类别损失均值。



#bbox_preds/bbox_labels/bbox_masks 形状：(batch, total_anchors, 4)
    bbox = bbox_loss(bbox_preds * bbox_masks,#负类背景隐藏
                     bbox_labels * bbox_masks).mean(dim=1)
    return cls + bbox

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

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())

13.7.2.3. 训练模型

在训练模型时，我们需要在模型的前向传播过程中生成多尺度锚框（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.22e-03, bbox mae 3.16e-03
3353.9 examples/sec on cuda:0

13.7.3. 预测目标

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

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)

13.7.4. 小结

• 单发多框检测是一种多尺度目标检测模型。基于基础网络块和各个多尺度特征块，单发多框检测生成不同数量和不同大小的锚框，并通过预测这些锚框的类别和偏移量检测不同大小的目标。

• 在训练单发多框检测模型时，损失函数是根据锚框的类别和偏移量的预测及标注值计算得出的。

13.7.5. 练习

1. 能通过改进损失函数来改进单发多框检测吗？例如，将预测偏移量用到的L1范数损失替换为平滑L1范数损失。它在零点附近使用平方函数从而更加平滑，这是通过一个超参数σ来控制平滑区域的：

当σ非常大时，这种损失类似于L1范数损失。当它的值较小时，损失函数较平滑。

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();

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();