动手学深度学习（pytorch|动手学深度学习（二十九）——SSD目标检测算法理论到实践） SSD|动手学深度学习|目标检测

文章目录

- 一、SSD目标检测算法
- - 1.1 采用多尺度特征图用于检测
  - 1.2 采用卷积进行检测
  - 1.3 设置先验框
- 二、SSD目标检测算法实现（简易版本）
- - 2.1 类别预测层
  - 2.2 边界框预测层（Bounding box）
  - 2.3 连接多尺度的预测
  - 2.4 高和宽减半块
  - 2.5 基本网络块
  - 2.6 完整的模型
  - 2.7 模型训练
  - 2.8 预测目标
- 三、参考整理

一、SSD目标检测算法 【动手学深度学习（pytorch|动手学深度学习（二十九）——SSD目标检测算法理论到实践）】SSD（单发多框检测）设计理念
参考：这篇Blog讲得非常详细了，我也从中学会了很多：https://zhuanlan.zhihu.com/p/33544892

文章图片

SSD和Yolo一样都是采用一个CNN网络来进行检测，但是却采用了多尺度的特征图，其基本架构如图所示。下面将SSD核心设计理念总结为以下三点：
1.1 采用多尺度特征图用于检测
??所谓多尺度采用大小不同的特征图，CNN网络一般前面的特征图比较大，后面会逐渐采用stride=2的卷积或者pool来降低特征图大小，这正如上图所示，一个比较大的特征图和一个比较小的特征图，它们都用来做检测。这样做的好处是比较大的特征图来用来检测相对较小的目标，而小的特征图负责检测大目标，如下所示，8x8的特征图可以划分更多的单元，但是其每个单元的先验框尺度比较小。

文章图片
1.2 采用卷积进行检测
??与Yolo最后采用全连接层不同，SSD直接采用卷积对不同的特征图来进行提取检测结果。对于形状为 m × n × p m \times n \times p m×n×p 的特征图，只需要采用 3 × 3 × p 3 \times 3 \times p 3×3×p这样比较小的卷积核得到检测值。
1.3 设置先验框
??在Yolo中，每个单元预测多个边界框，但是其都是相对这个单元本身（正方块），但是真实目标的形状是多变的，Yolo需要在训练过程中自适应目标的形状。而SSD借鉴了Faster R-CNN中anchor的理念，每个单元设置尺度或者长宽比不同的先验框，预测的边界框（bounding boxes）是以这些先验框为基准的，在一定程度上减少训练难度。一般情况下，每个单元会设置多个先验框，其尺度和长宽比存在差异，如下图所示，可以看到每个单元使用了4个不同的先验框，图片中猫和狗分别采用最适合它们形状的先验框来进行训练，后面会详细讲解训练过程中的先验框匹配原则。

文章图片
??SSD的检测值也与Yolo不太一样。对于每个单元的每个先验框，其都输出一套独立的检测值，对应一个边界框，主要分为两个部分：第一部分是各个类别的置信度或者评分，值得注意的是SSD将背景也当做了一个特殊的类别，如果检测目标共有 c c c个类别，SSD其实需要预测 c + 1 c+1 c+1个置信度值，其中第一个置信度指的是不含目标或者属于背景的评分。在预测过程中，置信度最高的那个类别就是边界框所属的类别，特别地，当第一个置信度值最高时，表示边界框中并不包含目标。第二部分就是边界框的location，包含4个值 ( c x , c y , w , h ) (cx,cy,w,h) (cx,cy,w,h)，分别表示边界框的中心坐标以及宽高。但是真实预测值其实只是边界框相对于先验框的转换值(paper里面说是offset，但是觉得transformation更合适，参见R-CNN）。先验框位置用 d = ( d c x , d c y , d w , d h ) d=(d^{cx},d^{cy},d^{w},d^{h}) d=(dcx,dcy,dw,dh)表示，其对应边界框用 b = ( b c x , b c y , b w , b h ) b=(b^{cx},b^{cy},b^{w},b^{h}) b=(bcx,bcy,bw,bh)表示，那么边界框的预测值 l l l其实是 b b b相对于 d d d的转换值：(我愿意称之为归一化，哈哈哈！！！)
l c x = ( b c x ? d c x ) / d w , l c y = ( b c y ? d c y ) / d h l^{cx}=(b^{cx}?d^{cx})/d^{w}, l^{cy}=(b^{cy}?d^{cy})/d^{h} lcx=(bcx?dcx)/dw,lcy=(bcy?dcy)/dhl w = l o g ( b w / d w ) , l h = l o g ( b h / d h ) l^{w}=log(b^w/d^w), l^h=log(b^h/d^h) lw=log(bw/dw),lh=log(bh/dh)
??习惯上，我们称上面这个过程为边界框的编码（encode），预测时，你需要反向这个过程，即进行解码（decode），从预测值l l l中得到边界框的真实位置 b b b：
b c x = d w l c x + d c x , b c y = d y l c y + d c y b^{cx}=d^wl^{cx}+d^{cx}, b^{cy}=d^yl^{cy}+d^{cy} bcx=dwlcx+dcx,bcy=dylcy+dcy b w = d w e x p ( l w ) , b h = d h e x p ( l h ) b^w=d^w exp(l^w), b^h=d^h exp(l^h) bw=dwexp(lw),bh=dhexp(lh)
??然而，在SSD的 Caffe源码实现中还有trick，那就是设置variance超参数来调整检测值，通过bool参数variance_encoded_in_target来控制两种模式，当其为True时，表示variance被包含在预测值中，就是上面那种情况。但是如果是Fasle（大部分采用这种方式，训练更容易？），就需要手动设置超参数variance，用来对l l l的4个值进行放缩，此时边界框需要这样解码：
b c x = d w ( v a r i a n c e [ 0 ] ? l c x ) + d c x , b c y = d y ( v a r i a n c e [ 1 ] ? l c y ) + d c y b^{cx}=d^w(variance[0]?l^{cx})+d^{cx}, b^{cy}=d^y(variance[1]?l^{cy})+d^{cy} bcx=dw(variance[0]?lcx)+dcx,bcy=dy(variance[1]?lcy)+dcyb w = d w e x p ? ( v a r i a n c e [ 2 ] ? l w ) , b h = d h e x p ? ( v a r i a n c e [ 3 ] ? l h ) b^w=d^w exp?(variance[2]?l^w), b^h=d^h exp?(variance[3]?l^h) bw=dwexp?(variance[2]?lw),bh=dhexp?(variance[3]?lh)??综上所述，对于一个大小 m × n m×n m×n的特征图，共有 m n mn mn个单元，每个单元设置的先验框数目记为 k k k，那么每个单元共需要 ( c + 4 ) k (c+4)k (c+4)k个预测值，所有的单元共需要 ( c + 4 ) k m n (c+4)kmn (c+4)kmn个预测值，由于SSD采用卷积做检测，所以就需要 ( c + 4 ) (c+4) (c+4)个卷积核完成这个特征图的检测过程。
二、SSD目标检测算法实现（简易版本） SSD模型：

文章图片

主要是由基础网络组成，其后几个是多尺度特征模块。

基础网从图像中提取特征，因此可以使用深卷及神经网络。单发多框检测论文中应用的是截断的VGG块，现在也常用ResNet替代
可以设计基础网络，使得输出的高宽较大，这样一来，基于该特征图生成的锚框数量较多，可以用来检测尺寸较小的目标。
接下来的每个多尺度特征块将上一层提供的特征图的高和宽缩小（如减半），并使特征图中每个单元在输入图像上的感受野变得更加广阔。

然后看看SSD和YOLO网络结构的对比：

文章图片

2.1 类别预测层
??设目标类别的数量为q q q。这样一来，锚框有q + 1 q+1 q+1 个类别，其中 0 类是背景。在某个尺度下，设特征图的高和宽分别为h h h 和w w w。如果以其中每个单元为中心生成a a a 个锚框，那么我们需要对h w a hwa hwa 个锚框进行分类。
??如果使用全连接层作为输出，很容易导致模型参数过多。这里我们使用卷积层的通道输出类别预测的方法，来降低模型复杂度。具体来说，类别预测层使用一个保持输入高和宽的卷积层，这样一来，输出和输入在特征图宽和高上的空间坐标一一对应。考虑输出和输入同一空间坐标（ x x x、 y y y）：输出特征图上（ x x x、 y y y）坐标的通道里包含了以输入特征图（ x x x、 y y y）坐标为中心生成的所有锚框的类别预测。因此输出通道数为a ( q + 1 ) a(q+1) a(q+1) ，其中索引为i ( q + 1 ) + j i(q+1) + j i(q+1)+j （ 0 ≤ j ≤ q 0 \leq j \leq q 0≤j≤q）的通道代表了索引为i i i 的锚框有关类别索引为j j j 的预测。
??在下面，我们定义了这样一个类别预测层，通过参数 num_anchors 和num_classes 分别指定了a a a 和q q q 。该图层使用填充为 1 的3 × 3 3\times3 3×3 的卷积层。此卷积层的输入和输出的宽度和高度保持不变。

%matplotlib inline import torch import torchvision from torch import nn from torch.nn import functional as F from d2l import torch as d2ldef cls_predictor(num_inputs, num_anchors, num_classes): """ 输入：输入通道数、锚框的数量、类别数量输出：一个神经网络层。输出通道数=锚框的数量*每个锚框所需要识别的类别 """ return nn.Conv2d(num_inputs, num_anchors * (num_classes + 1), # 1是背景类 kernel_size=3, padding=1)

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

def bbox_predictor(num_inputs, num_anchors): """ bounding box：输出为一层神经网络。输出通道数=锚框数量*4 这里的4指的是每个锚框由四个参数确定 """ return nn.Conv2d(num_inputs, num_anchors * 4, kernel_size=3, padding=1)

2.3 连接多尺度的预测
??正如我们所提到的，单发多框检测使用多尺度特征图来生成锚框并预测其类别和偏移量。在不同的尺度下，特征图的形状或以同一单元为中心的锚框的数量可能会有所不同。因此，不同尺度下预测输出的形状可能会有所不同。
??在以下示例中，我们为同一个小批量构建两个不同比例（ Y1 和 Y2 ）的特征图，其中 Y2 的高度和宽度是 Y1 的一半。以类别预测为例，假设 Y1 和 Y2 的每个单元分别生成了5 5 5 个和3 3 3 个锚框。进一步假设目标类别的数量为10 10 10，对于特征图 Y1 和 Y2 ，类别预测输出中的通道数分别为5 × ( 10 + 1 ) = 55 5\times(10+1)=55 5×(10+1)=55 和3 × ( 10 + 1 ) = 33 3\times(10+1)=33 3×(10+1)=33，其中任一输出的形状是（批量大小，通道数，高度，宽度）。

def forward(x, block): """ X：feature map；block：神经层，从feature map中提取特征 """ 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 1 1 上的连结。

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)concat_preds([Y1, Y2]).shape

torch.Size([2, 25300])

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

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) test_block = down_sample_blk(3,10) test_block.modules

构建的高和宽减半块会更改输入通道的数量，并将输入特征图的高度和宽度减半。

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

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

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

2.6 完整的模型
??完整的单发多框检测模型由五个模块组成。每个块生成的特征图既用于 (i) 生成锚框，又用于 (ii) 预测这些锚框的类别和偏移量。在这五个模块中，第一个是基本网络块，第二个到第四个是高和宽减半块，最后一个模块使用全局最大池将高度和宽度都降到 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

为每个块儿定义forward计算。与图像分类任务不同，此处输出包括：

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) # 根据当前的特征图生成对应的anchors cls_preds = cls_predictor(Y) # anchor的类别 bbox_preds = bbox_predictor(Y) # anchor的偏移量 return (Y, anchors, cls_preds, bbox_preds)

??回想一下，在 SSD介绍中，一个较接近顶部的多尺度特征块是用于检测较大目标的，因此需要生成更大的锚框。在上面的前向计算中，在每个多尺度特征块上，我们通过调用的 multibox_prior 函数的 sizes 参数传递两个比例值的列表。在下面，0.2 和 1.05 之间的区间被均匀分成五个部分，以确定五个模块的在不同尺度下的较小值：0.2、0.37、0.54、0.71 和 0.88。之后，他们较大的值由0.2 × 0.37 = 0.272 \sqrt{0.2 \times 0.37} = 0.272 0.2×0.37 ?=0.272 、0.37 × 0.54 = 0.447 \sqrt{0.37 \times 0.54} = 0.447 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]] # 越到后面看到的区域越小，size应该更大才能覆盖得比较好 ratios = [[1, 2, 0.5]] * 5 num_anchors = len(sizes[0]) + len(ratios[0]) - 1

# 完整模型 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(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` 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) bbox_preds = concat_preds(bbox_preds) return anchors, cls_preds, bbox_preds

输入一张 256 ? 256 256*256 256?256像素的图，网络中：

第一个是基本网络模块，其输出特征图的形状为 32 ? 32 32*32 32?32；
第二个、三个和第四个模块都是高宽减半块
第五个模块是全局池化层

输出的特征图的每个单元有四个锚框生成，在五个尺度下，每个图像可以生成 ( 3 2 2 + 1 6 2 + 8 2 + 4 2 + 1 ) × 4 = 5444 (32^2 + 16^2 + 8^2 + 4^2 + 1)\times 4 = 5444 (322+162+82+42+1)×4=5444 个锚框。其中这个4：锚框数量 = l e n ( s i z e ) + l e n ( r a t i o ) ? 1 = 4 锚框数量=len(size)+len(ratio)-1=4 锚框数量=len(size)+len(ratio)?1=4

# 模型实例 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])

2.7 模型训练

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

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

定义损失函数和评价函数
目标检测有两种类型的损失。

第一种有关锚框类别的损失：我们可以简单地重用之前图像分类问题里一直使用的交叉熵损失函数来计算；
第二种有关正类锚框偏移量的损失：预测偏移量是一个回归问题。

??但是，对于这个回归问题，我们在这里不使用平方损失，而是使用L 1 L_1 L1? 范数损失，即预测值和真实值之差的绝对值。掩码变量 bbox_masks 令负类锚框和填充锚框不参与损失的计算。最后，我们将锚框类别和偏移量的损失相加，以获得模型的最终损失函数。

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

??我们可以沿用准确率评价分类结果。由于偏移量使用了L 1 L_1 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())

训练模型
??在训练模型时，我们需要在模型的前向计算过程中生成多尺度锚框 ( 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.44e-03, bbox mae 3.47e-03 5991.8 examples/sec on cuda:0

文章图片

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

X = torchvision.io.read_image('./data/Coco/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)