用代碼實現(xiàn)SSD

此模型主要由基礎(chǔ)網(wǎng)絡組成，其后是幾個多尺度特征塊。 基本網(wǎng)絡用于從輸入圖像中提取特征，因此它可以使用深度卷積神經(jīng)網(wǎng)絡。 單發(fā)多框檢測論文中選用了在分類層之前截斷的VGG?(Liu?et al., 2016)，現(xiàn)在也常用ResNet替代。 我們可以設計基礎(chǔ)網(wǎng)絡，使它輸出的高和寬較大。 這樣一來，基于該特征圖生成的錨框數(shù)量較多，可以用來檢測尺寸較小的目標。 接下來的每個多尺度特征塊將上一層提供的特征圖的高和寬縮?。ㄈ鐪p半），并使特征圖中每個單元在輸入圖像上的感受野變得更廣闊。

回想一下在?13.5節(jié)中，通過深度神經(jīng)網(wǎng)絡分層表示圖像的多尺度目標檢測的設計。 由于接近?圖13.7.1頂部的多尺度特征圖較小，但具有較大的感受野，它們適合檢測較少但較大的物體。 簡而言之，通過多尺度特征塊，單發(fā)多框檢測生成不同大小的錨框，并通過預測邊界框的類別和偏移量來檢測大小不同的目標，因此這是一個多尺度目標檢測模型。

代碼實現(xiàn)

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

類別預測層：

注意，這里設目標類別的數(shù)量為q。這樣一來，錨框有q+1個類別，其中0類是背景。

特征圖每個像素對應a錨框,每個錨框?qū)猶個分類,單個像素就要a*(q+1)個預測信息

這個信息，通過卷積核的多個通道來存儲, 所以這里進行卷積操作

圖像分類,只預測分類情況,所以接全連接層,這里單個像素的預測結(jié)果太多,就用多個通道來存

位置預測層：

bounding box predictor:預測錨框與真實框之間的位置偏差。邊界框預測層的設計與類別預測層的設計類似。 唯一不同的是，這里需要為每個錨框預測4個偏移量，而不是q+1個類別。

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

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

除了批量大小這一維度外，其他三個維度都具有不同的尺寸。 為了將這兩個預測輸出鏈接起來以提高計算效率，我們將把這些張量轉(zhuǎn)換為更一致的格式。

通道維包含中心相同的錨框的預測結(jié)果。我們首先將通道維移到最后一維。 因為不同尺度下批量大小仍保持不變，我們可以將預測結(jié)果轉(zhuǎn)成二維的（批量大小，高×寬×通道數(shù)）的格式，以方便之后在維度1

上的連結(jié)。

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在通道數(shù)、高度和寬度方面具有不同的大小，我們?nèi)匀豢梢栽谕粋€小批量的兩個不同尺度上連接這兩個預測輸出。

批量維度不變，2，3位表示像素坐標，4表示5個框所預測的類別數(shù)（5*11），這樣拉直之后同一個像素的框所判斷的類是集中在一起的

concat_preds([Y1, Y2]).shape

torch.Size([2, 25300])

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)

以下示例中，我們構(gòu)建的高和寬減半塊會更改輸入通道的數(shù)量，并將輸入特征圖的高度和寬度減半。

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

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

基本網(wǎng)絡塊用于從輸入圖像中抽取特征。 為了計算簡潔，我們構(gòu)造了一個小的基礎(chǔ)網(wǎng)絡，該網(wǎng)絡串聯(lián)3個高和寬減半塊，并逐步將通道數(shù)翻倍。 給定輸入圖像的形狀為256×256，此基本網(wǎng)絡塊輸出的特征圖形狀為32×32（256/2/2/2=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])

完整的單發(fā)多框檢測模型由五個模塊組成。每個塊生成的特征圖既用于生成錨框，又用于預測這些錨框的類別和偏移量。在這五個模塊中，第一個是基本網(wǎng)絡塊，第二個到第四個是高和寬減半塊，最后一個模塊使用全局最大池將高度和寬度都降到1。從技術(shù)上講，第二到第五個區(qū)塊都是?圖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；在當前尺度下根據(jù)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)

超參數(shù)sizes和ratios

一個較接近頂部的多尺度特征塊是用于檢測較大目標的，因此需要生成更大的錨框。 在上面的前向傳播中，在每個多尺度特征塊上，我們通過調(diào)用的multibox_prior函數(shù)（見?13.4節(jié)）的sizes參數(shù)傳遞兩個比例值的列表。 在下面，0.2和1.05之間的區(qū)間被均勻分成五個部分，以確定五個模塊的在不同尺度下的較小值：0.2、0.37、0.54、0.71和0.88。

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

現(xiàn)在，我們就可以按如下方式定義完整的模型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

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])
/home/d2l-worker/miniconda3/envs/d2l-zh-release-1/lib/python3.9/site-packages/torch/functional.py:478: UserWarning: torch.meshgrid: in an upcoming release, it will be required to pass the indexing argument. (Triggered internally at  ../aten/src/ATen/native/TensorShape.cpp:2895.)
  return _VF.meshgrid(tensors, **kwargs)  # type: ignore[attr-defined]

讀取數(shù)據(jù)集和初始化

首先，讓我們讀取?13.6節(jié)中描述的香蕉檢測數(shù)據(jù)集。

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

read 1000 training examples
read 100 validation examples

香蕉檢測數(shù)據(jù)集中，目標的類別數(shù)為1。 定義好模型后，我們需要初始化其參數(shù)并定義優(yōu)化算法。

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

目標檢測有兩種類型的損失。 第一種有關(guān)錨框類別的損失：我們可以簡單地復用之前圖像分類問題里一直使用的交叉熵損失函數(shù)來計算； 第二種有關(guān)正類錨框偏移量的損失：預測偏移量是一個回歸問題。 但是，對于這個回歸問題，我們在這里不使用?3.1.3節(jié)中描述的平方損失，而是使用L1范數(shù)損失，即預測值和真實值之差的絕對值。

掩碼變量bbox_masks令負類錨框和填充錨框不參與損失的計算。 最后，我們將錨框類別和偏移量的損失相加，以獲得模型的最終損失函數(shù)。

bbox_mask作用：錨框為背景框時，mask=0.否則為1.

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

我們可以沿用準確率評價分類結(jié)果。 由于偏移量使用了L1

范數(shù)損失，我們使用平均絕對誤差來評價邊界框的預測結(jié)果。這些預測結(jié)果是從生成的錨框及其預測偏移量中獲得的。

def cls_eval(cls_preds, cls_labels):
    # 由于類別預測結(jié)果放在最后一維，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）。 然后，我們根據(jù)標簽信息Y為生成的錨框標記類別（cls_labels）和偏移量（bbox_labels）。 最后，我們根據(jù)類別和偏移量的預測和標注值計算損失函數(shù)。為了代碼簡潔，這里沒有評價測試數(shù)據(jù)集。

Y是標簽真實值 結(jié)合網(wǎng)絡得出的錨框算出每個錨框應該是什么類以及邊界偏移多少 再和網(wǎng)絡得出的錨框的預測值算損失

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):
    # 訓練精確度的和，訓練精確度的和中的示例數(shù)
    # 絕對誤差的和，絕對誤差的和中的示例數(shù)
    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)
        # 根據(jù)類別和偏移量的預測和標注值計算損失函數(shù)
        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.17e-03, bbox mae 3.01e-03
6261.8 examples/sec on cuda:0

在預測階段，我們希望能把圖像里面所有我們感興趣的目標檢測出來。在下面，我們讀取并調(diào)整測試圖像的大小，然后將其轉(zhuǎn)成卷積層需要的四維格式。

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

使用下面的multibox_detection函數(shù)，我們可以根據(jù)錨框及其預測偏移量得到預測邊界框。然后，通過非極大值抑制來移除相似的預測邊界框。

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)

輸出結(jié)果

知識補充：

對于圖像尺寸過大的圖片，SSD不適合進行目標檢測任務（生成錨框數(shù)過多）

目標識別任務中有兩種loss：種類loss和位置loss，在計算總損失時需要將多種loss進行相加（因為回傳時只能回傳一個數(shù)），這樣做的前提是這些loss的數(shù)量級較為接近。