单发多框检测-SSD

云噫

已于 2025-06-24 16:05:33 修改

阅读量995

点赞数 9

CC 4.0 BY-SA版权

分类专栏：计算机视觉文章标签：目标检测 pytorch 人工智能图像处理深度学习

于 2025-06-24 15:49:39 首次发布

本文链接：https://blog.youkuaiyun.com/weixin_63936336/article/details/148872880

计算机视觉专栏收录该内容

3 篇文章

订阅专栏

文章目录

模型介绍
模型不同层的实现
模型训练
目标预测

模型介绍

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

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

SSD框架

模型不同层的实现

类别预测层

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

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

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

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

上面的函数用于输入图片经过卷积后得到的feature_map，feature_map里的每一个像素都会有num_anchors个锚框，每一个锚框都会对num_classes个类进行预测，所以在该函数的返回值中，经过一层卷积后的通道数为num_anchors * (num_classes + 1)，一个通道可以理解为一个特征，一个通道上 $(x, y)$ 位置上值就是feature_map在 $(x, y)$ 位置的像素点在该特征的值。通道数就代表着feature_map里每一个像素点需要做多少次类别预测。

边界框预测层

边界框预测层的设计与类别预测层的设计类似。唯一不同的是，这里需要为每个锚框预测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$ 上的连结。

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在通道数、高度和宽度方面具有不同的大小，我们仍然可以在同一个小批量的两个不同尺度上连接这两个预测输出。

concat_preds([Y1, Y2]).shape

torch.Size([2, 25300])

对于上面代码torch.flatten(pred.permute(0, 2, 3, 1), start_dim=1)是将通道位置调整到了最后一维，然后再将后三维展成一维，之所以要将维度的顺序进行一个调整是为了将同一个像素的类别预测放在一起，这样利于我们后面取数据。

高宽减半模块

因为在不同尺度的预测要求图像的feature_map逐步减小，感受野要逐步增大，所以要逐尺度的对feature_map高宽减半。

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

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\times256$ ，此基本网络块输出的特征图形状为 $32\times32(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])

完整模型框架

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

    # 通过block生成feature_map
    Y = blk(X)
    
    # 针对feature_map为每个像素点生成a个锚框
    anchors = d2l.multibox_prior(Y, sizes=size, ratios=ratio)

    # 通过cls_predictor()函数得到每个锚框对所有类别的预测值
    cls_preds = cls_predictor(Y)

    # 通过cls_predictor()函数得到每个锚框与真实边界框差值的预测值
    bbox_preds = bbox_predictor(Y)
    return (Y, anchors, cls_preds, bbox_preds)

一个较接近顶部的多尺度特征块是用于检测较大目标的，因此需要生成更大的锚框。在上面的前向传播中，在每个多尺度特征块上，我们通过调用的multibox_prior函数(见另一篇写锚框生成的博客)的sizes参数传递两个比例值的列表。在下面，0.2和1.05之间的区间被均匀分成五个部分，以确定五个模块的在不同尺度下的较小值：0.2、0.37、0.54、0.71和0.88。之后，他们较大的值由 $\sqrt{0.2\times0.37}=0.272$ 、 $\sqrt{0.37\times0.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):
        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

从提取feature_map模块的构建到利用feature_map通过cls_predictor()函数进行预测，会发现对于类别的预测并不是所想象中的，先划分锚框，然后为真实边界框分配锚框，再将锚框里的信息单独提取出来进行预测。

而是，先划分锚框，部分与真实边界框相近的锚框分给真实边界框(被分配给真实边界框的锚框已经能获得它的目标预测偏移值和目标类别了)，其他的锚框则被标记为背景(背景也算是一种类别，也需要预测，但我们在计算损失函数时只将背景框预测类别计入损失函数，而不对它的预测偏移计算，因为我们并不关心背景)然后就对所有的锚框预测类别，并且是给出完整的feature_map信息，并不是只给锚框划出来的信息。

然后进行模型的训练，注意这里我们对锚框位置的训练有一个易疑惑的点:
就是一开始根据像素生成的anchors是不参与训练的，它是一个先验框。SSD的思路是对生成锚框的偏移量进行随机生成之后，再进行训练，即anchors的参数是不会做step的，而是对锚框和真实边界框之间的offset做预测并训练，bbox_preds好像不关心anchors的具体信息，它只代表了锚框与真实边界框的预测偏移量，而bbox_labels(它是利用锚框与真实边界框计算而得)代表了真实的偏移值，我们要做的就是对bbox_labels做拟合，最终使得我们的预测偏移值bbox_preds贴近真实的偏移值bbox_labels，由此来训练。最后，在训练完成，我们做预测，通过先验生成锚框(注意，不论是训练图片和预测图片size都一样，先验框anchors的位置大小都是一样的)和训练好的网络来生成偏移值，做offest_inverse，就能得到最后预测框的参数。

我们创建一个模型实例，然后使用它对一个 $256\times256$ 像素的小批量图像X执行前向传播。
如前面部分所示，第一个模块输出特征图的形状为 $32\times32$ 。回想一下，第二到第四个模块为高和宽减半块，第五个模块为全局汇聚层。由于以特征图的每个单元为中心有 $4$ 个锚框生成，因此在所有五个尺度下，每个图像总共生成 $({32}^2+16^2+8^2+4^2+)\times4=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])

模型训练

数据读取和初始化

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

read 1000 training examples
read 100 validation examples

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

定义损失函数与评价函数

目标检测有两种类型的损失。第一种有关锚框类别的损失：我们可以简单地复用之前图像分类问题里一直使用的交叉熵损失函数来计算；第二种有关正类锚框偏移量的损失：预测偏移量是一个回归问题。但是，对于这个回归问题，我们在这里不使用平方损失，而是使用 $L_1$ 范数损失，即预测值和真实值之差的绝对值。掩码变量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):
    # cls_preds:所有图片锚框的预测类别
    # cls_preds:所有图片锚框的真实类别
    # 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$ 范数损失，我们使用平均绝对误差来评价边界框的预测结果。这些预测结果是从生成的锚框及其预测偏移量中获得的。

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:
        # features:一个batch图片信息
        # target:一个batch中图片的真实边界框信息及其对应类别
        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.15e-03
4302.4 examples/sec on cuda:0

xunlian

目标预测

X = torchvision.io.read_image('../img/banana.jpg').unsqueeze(0).float()

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

def predict(X):
    net.eval()
    # 通过训练好的模型得到需要预测图片的anchors,cls_preds,bbox_preds
    anchors, cls_preds, bbox_preds = net(X.to(device))
    
    # 对dim=2维度(即锚框对每个类别的预测值)做softmax
    # 然后通过premute()将cls_probs的维度转为[batch_size, 真实类别数， 锚框数(存放对类别的预测置信度)]
    cls_probs = F.softmax(cls_preds, dim=2).permute(0, 2, 1)

    # 因为可能会有多个锚框预测了同一个真实边界框，所以用multibox_detection()函数对锚框进行筛选，留下一个类中
    # 最大的预测值锚框。

    # output:[batch_size, num_anchors, class_id+conf+predicted_bb]
    output = d2l.multibox_detection(cls_probs, bbox_preds, anchors)

    # 去除背景锚框，inx保存预测图片需要留下来的锚框索引
    idx = [i for i, row in enumerate(output[0]) if row[0] != -1]

    # 返回
    return output[0, idx]

output = predict(X)

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

img = X.squeeze(0).permute(1, 2, 0).long()

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)