深度学习笔记其七：计算机视觉和PYTORCH

Reference：

1. 《动手学深度学习》 强烈建议看原书

文章跳转：

1. 深度学习笔记其一：基础知识和PYTORCH
2. 深度学习笔记其二：线性神经网络和PYTORCH
3. 深度学习笔记其三：多层感知机和PYTORCH
4. 深度学习笔记其四：深度学习计算和PYTORCH
5. 深度学习笔记其五：卷积神经网络和PYTORCH
6. 深度学习笔记其六：现代卷积神经网络和PYTORCH
7. 深度学习笔记其七：计算机视觉和PYTORCH

1. 图像增广

在深度卷积神经网络章节中，我们提到过大型数据集是成功应用深度神经网络的先决条件。图像增广在对训练图像进行一系列的随机变化之后，生成相似但不同的训练样本，从而扩大了训练集的规模。此外，应用图像增广的原因是，随机改变训练样本可以减少模型对某些属性的依赖，从而提高模型的泛化能力。例如，我们可以以不同的方式裁剪图像，使感兴趣的对象出现在不同的位置，减少模型对于对象出现位置的依赖。我们还可以调整亮度、颜色等因素来降低模型对颜色的敏感度。可以说，图像增广技术对于 AlexNet 的成功是必不可少的。在本节中，我们将讨论这项广泛应用于计算机视觉的技术。

%matplotlib inline
import torch
import torchvision
from torch import nn
from d2l import torch as d2l
1
2
3
4
5

1.1 常用的图像增广方法

在对常用图像增广方法的探索时，我们将使用下面这个尺寸为 $400\times 500$ 的图像作为示例。

d2l.set_figsize()
img = d2l.Image.open('../img/cat1.jpg')
d2l.plt.imshow(img);
1
2
3

大多数图像增广方法都具有一定的随机性。为了便于观察图像增广的效果，我们下面定义辅助函数 apply。此函数在输入图像 img 上多次运行图像增广方法 aug 并显示所有结果。

def apply(img, aug, num_rows=2, num_cols=4, scale=1.5):
    Y = [aug(img) for _ in range(num_rows * num_cols)]
    d2l.show_images(Y, num_rows, num_cols, scale=scale)
1
2
3

1.1.1 翻转和裁剪

左右翻转图像通常不会改变对象的类别。这是最早且最广泛使用的图像增广方法之一。接下来，我们使用transforms模块来创建RandomFlipLeftRight实例，这样就各有50%的几率使图像向左或向右翻转。

apply(img, torchvision.transforms.RandomHorizontalFlip())
1

上下翻转图像不如左右图像翻转那样常用。但是，至少对于这个示例图像，上下翻转不会妨碍识别。接下来，我们创建一个RandomFlipTopBottom实例，使图像各有50%的几率向上或向下翻转。

apply(img, torchvision.transforms.RandomVerticalFlip())
1

在我们使用的示例图像中，猫位于图像的中间，但并非所有图像都是这样。在深度学习笔记其五：卷积神经网络和PYTORCH中，我们解释了汇聚层可以降低卷积层对目标位置的敏感性。另外，我们可以通过对图像进行随机裁剪，使物体以不同的比例出现在图像的不同位置。这也可以降低模型对目标位置的敏感性。

在下面的代码中，我们随机裁剪一个面积为原始面积 $10\%$ 到 $100\%$ 的区域，该区域的宽高比从 $0.5$ 到 $2$ 之间随机取值。然后，区域的宽度和高度都被缩放到 $200$ 像素。在本节中（除非另有说明），$a$ 和 $b$ 之间的随机数指的是在区间 $[a,b]$ 中通过均匀采样获得的连续值。

shape_aug = torchvision.transforms.RandomResizedCrop(
    (200, 200), scale=(0.1, 1), ratio=(0.5, 2))
apply(img, shape_aug)
1
2
3

1.1.2 改变颜色

另一种增广方法是改变颜色。我们可以改变图像颜色的四个方面：亮度、对比度、饱和度和色调。在下面的示例中，我们随机更改图像的亮度，随机值为原始图像的 $50\%$（$1-0.5$）到 $150\%$（$1+0.5$）之间。

apply(img, torchvision.transforms.ColorJitter(
    brightness=0.5, contrast=0, saturation=0, hue=0))
1
2

同样，我们可以随机更改图像的色调。

apply(img, torchvision.transforms.ColorJitter(
    brightness=0, contrast=0, saturation=0, hue=0.5))
1
2

我们还可以创建一个RandomColorJitter实例，并设置如何同时随机更改图像的亮度（brightness）、对比度（contrast）、饱和度（saturation）和色调（hue）。

color_aug = torchvision.transforms.ColorJitter(
    brightness=0.5, contrast=0.5, saturation=0.5, hue=0.5)
apply(img, color_aug)
1
2
3

1.1.3 结合多种图像增广方法

在实践中，我们将结合多种图像增广方法。比如，我们可以通过使用一个 Compose 实例来综合上面定义的不同的图像增广方法，并将它们应用到每个图像。

augs = torchvision.transforms.Compose([
    torchvision.transforms.RandomHorizontalFlip(), color_aug, shape_aug])
apply(img, augs)
1
2
3

1.2 使用图像增广进行训练

让我们使用图像增广来训练模型。这里，我们使用 CIFAR-10 数据集，而不是我们之前使用的 Fashion-MNIST 数据集。这是因为 Fashion-MNIST 数据集中对象的位置和大小已被规范化，而 CIFAR-10 数据集中对象的颜色和大小差异更明显。CIFAR-10 数据集中的前 $32$ 个训练图像如下所示。

all_images = torchvision.datasets.CIFAR10(train=True, root="../data",
                                          download=True)
d2l.show_images([all_images[i][0] for i in range(32)], 4, 8, scale=0.8);
1
2
3

Files already downloaded and verified

为了在预测过程中得到确切的结果，我们通常对训练样本只进行图像增广，且在预测过程中不使用随机操作的图像增广。在这里，我们只使用最简单的随机左右翻转。此外，我们使用 ToTensor 实例将一批图像转换为深度学习框架所要求的格式，即形状为（批量大小，通道数，高度，宽度）的 $32$ 位浮点数，取值范围为 $0$ 到 $1$。

train_augs = torchvision.transforms.Compose([
     torchvision.transforms.RandomHorizontalFlip(),
     torchvision.transforms.ToTensor()])

test_augs = torchvision.transforms.Compose([
     torchvision.transforms.ToTensor()])
1
2
3
4
5
6

接下来，我们定义一个辅助函数，以便于读取图像和应用图像增广。PyTorch数据集提供的transform参数应用图像增广来转化图像。(train_augs和test_augs 声明了要增广的方式，在torchvision.datasets.CIFAR10调用来转换图像)

def load_cifar10(is_train, augs, batch_size):
    dataset = torchvision.datasets.CIFAR10(root="../data", train=is_train,
                                           transform=augs, download=True)
    dataloader = torch.utils.data.DataLoader(dataset, batch_size=batch_size,
                    shuffle=is_train, num_workers=d2l.get_dataloader_workers())
    return dataloader
1
2
3
4
5
6

1.2.1 多GPU训练

我们在 CIFAR-10 数据集上训练 ResNet-18 模型。接下来，我们定义一个函数，使用多 GPU 对模型进行训练和评估。

#@save
def train_batch_ch13(net, X, y, loss, trainer, devices):
    """用多GPU进行小批量训练"""
    if isinstance(X, list):
        # 微调BERT中所需（稍后讨论）
        X = [x.to(devices[0]) for x in X]
    else:
        X = X.to(devices[0])
    y = y.to(devices[0])
    net.train()
    trainer.zero_grad()
    pred = net(X)
    l = loss(pred, y)
    l.sum().backward()
    trainer.step()
    train_loss_sum = l.sum()
    train_acc_sum = d2l.accuracy(pred, y)
    return train_loss_sum, train_acc_sum

#@save
def train_ch13(net, train_iter, test_iter, loss, trainer, num_epochs,
               devices=d2l.try_all_gpus()):
    """用多GPU进行模型训练"""
    timer, num_batches = d2l.Timer(), len(train_iter)
    animator = d2l.Animator(xlabel='epoch', xlim=[1, num_epochs], ylim=[0, 1],
                            legend=['train loss', 'train acc', 'test acc'])
    net = nn.DataParallel(net, device_ids=devices).to(devices[0])
    for epoch in range(num_epochs):
        # 4个维度：储存训练损失，训练准确度，实例数，特点数
        metric = d2l.Accumulator(4)
        for i, (features, labels) in enumerate(train_iter):
            timer.start()
            l, acc = train_batch_ch13(
                net, features, labels, loss, trainer, devices)
            metric.add(l, acc, labels.shape[0], labels.numel())
            timer.stop()
            if (i + 1) % (num_batches // 5) == 0 or i == num_batches - 1:
                animator.add(epoch + (i + 1) / num_batches,
                             (metric[0] / metric[2], metric[1] / metric[3],
                              None))
        test_acc = d2l.evaluate_accuracy_gpu(net, test_iter)
        animator.add(epoch + 1, (None, None, test_acc))
    print(f'loss {metric[0] / metric[2]:.3f}, train acc '
          f'{metric[1] / metric[3]:.3f}, test acc {test_acc:.3f}')
    print(f'{metric[2] * num_epochs / timer.sum():.1f} examples/sec on '
          f'{str(devices)}')
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46

现在，我们可以定义 train_with_data_aug 函数，使用图像增广来训练模型。该函数获取所有的 GPU，并使用 Adam 作为训练的优化算法，将图像增广应用于训练集，最后调用刚刚定义的用于训练和评估模型的 train_ch13 函数。

batch_size, devices, net = 256, d2l.try_all_gpus(), d2l.resnet18(10, 3)

def init_weights(m):
    if type(m) in [nn.Linear, nn.Conv2d]:
        nn.init.xavier_uniform_(m.weight)

net.apply(init_weights)

def train_with_data_aug(train_augs, test_augs, net, lr=0.001):
    train_iter = load_cifar10(True, train_augs, batch_size)
    test_iter = load_cifar10(False, test_augs, batch_size)
    loss = nn.CrossEntropyLoss(reduction="none")
    trainer = torch.optim.Adam(net.parameters(), lr=lr)
    train_ch13(net, train_iter, test_iter, loss, trainer, 10, devices)
1
2
3
4
5
6
7
8
9
10
11
12
13
14

让我们使用基于随机左右翻转的图像增广来训练模型。

train_with_data_aug(train_augs, test_augs, net)
1

loss 0.177, train acc 0.938, test acc 0.835
5616.3 examples/sec on [device(type=‘cuda’, index=0), device(type=‘cuda’, index=1)]

1.3 小结

• 图像增广基于现有的训练数据生成随机图像，来提高模型的泛化能力。
• 为了在预测过程中得到确切的结果，我们通常对训练样本只进行图像增广，而在预测过程中不使用带随机操作的图像增广。
• 深度学习框架提供了许多不同的图像增广方法，这些方法可以被同时应用。

2. 微调

在前面的一些章节中，我们介绍了如何在只有6万张图像的 Fashion-MNIST 训练数据集上训练模型。我们还描述了学术界当下使用最广泛的大规模图像数据集 ImageNet，它有超过1000万的图像和1000类的物体。然而，我们平常接触到的数据集的规模通常在这两者之间。

假如我们想识别图片中不同类型的椅子，然后向用户推荐购买链接。一种可能的方法是首先识别100把普通椅子，为每把椅子拍摄1000张不同角度的图像，然后在收集的图像数据集上训练一个分类模型。尽管这个椅子数据集可能大于 Fashion-MNIST 数据集，但实例数量仍然不到 ImageNet 中的十分之一。适合 ImageNet 的复杂模型可能会在这个椅子数据集上过拟合。此外，由于训练样本数量有限，训练模型的准确性可能无法满足实际要求。

为了解决上述问题，一个显而易见的解决方案是收集更多的数据。但是，收集和标记数据可能需要大量的时间和金钱。例如，为了收集 ImageNet 数据集，研究人员花费了数百万美元的研究资金。尽管目前的数据收集成本已大幅降低，但这一成本仍不能忽视。

另一种解决方案是应用迁移学习（transfer learning）将从源数据集学到的知识迁移到目标数据集。例如，尽管 ImageNet 数据集中的大多数图像与椅子无关，但在此数据集上训练的模型可能会提取更通用的图像特征，这有助于识别边缘、纹理、形状和对象组合。这些类似的特征也可能有效地识别椅子。

2.1. 步骤

在本节中，我们将介绍迁移学习中的常见技巧：微调（fine-tuning）。如下图所示，微调包括以下四个步骤：

1. 在源数据集（例如 ImageNet 数据集）上预训练神经网络模型，即源模型。
2. 创建一个新的神经网络模型，即目标模型。这将复制源模型上的所有模型设计及其参数（输出层除外）。我们假定这些模型参数包含从源数据集中学到的知识，这些知识也将适用于目标数据集。我们还假设源模型的输出层与源数据集的标签密切相关；因此不在目标模型中使用该层。
3. 向目标模型添加输出层，其输出数是目标数据集中的类别数。然后随机初始化该层的模型参数。
4. 在目标数据集（如椅子数据集）上训练目标模型。输出层将从头开始进行训练，而所有其他层的参数将根据源模型的参数进行微调。

微调。

当目标数据集比源数据集小得多时，微调有助于提高模型的泛化能力。

2.2 热狗识别

让我们通过具体案例演示微调：热狗识别。我们将在一个小型数据集上微调 ResNet 模型。该模型已在 ImageNet 数据集上进行了预训练。这个小型数据集包含数千张 包含热狗 和 不包含热狗 的图像，我们将使用微调模型来识别图像中是否包含热狗。

%matplotlib inline
import os
import torch
import torchvision
from torch import nn
from d2l import torch as d2l
1
2
3
4
5
6

2.2.1 获取数据集

我们使用的热狗数据集来源于网络。该数据集包含 $1400$ 张热狗的“正类”图像，以及包含尽可能多的其他食物的“负类”图像。含着两个类别的 $1000$ 张图片用于训练，其余的则用于测试。

解压下载的数据集，我们获得了两个文件夹 hotdog/train 和 hotdog/test。这两个文件夹都有 hotdog（有热狗）和 hot-hotdog（无热狗）两个子文件夹，子文件夹内都包含相应类的图像。

#@save
d2l.DATA_HUB['hotdog'] = (d2l.DATA_URL + 'hotdog.zip',
                         'fba480ffa8aa7e0febbb511d181409f899b9baa5')

data_dir = d2l.download_extract('hotdog')
1
2
3
4
5

Downloading …/data/hotdog.zip from http://d2l-data.s3-accelerate.amazonaws.com/hotdog.zip…

我们创建两个实例来分别读取训练和测试数据集中的所有图像文件。

train_imgs = torchvision.datasets.ImageFolder(os.path.join(data_dir, 'train'))
test_imgs = torchvision.datasets.ImageFolder(os.path.join(data_dir, 'test'))
1
2

下面显示了前 $8$ 个正类样本图片和最后 $8$ 张负类样本图片。正如你所看到的，图像的大小和纵横比各有不同。

hotdogs = [train_imgs[i][0] for i in range(8)]
not_hotdogs = [train_imgs[-i - 1][0] for i in range(8)]
d2l.show_images(hotdogs + not_hotdogs, 2, 8, scale=1.4);
1
2
3

在训练期间，我们首先从图像中裁切随机大小和随机长宽比的区域，然后将该区域缩放为 $224\times 224$ 输入图像。在测试过程中，我们将图像的高度和宽度都缩放到 $256$ 像素，然后裁剪中央 $224\times 224$ 区域作为输入。此外，对于 RGB（红、绿和蓝）颜色通道，我们分别标准化每个通道。具体而言，该通道的每个值减去该通道的平均值，然后将结果除以该通道的标准差。

# 使用RGB通道的均值和标准差，以标准化每个通道
normalize = torchvision.transforms.Normalize(
    [0.485, 0.456, 0.406], [0.229, 0.224, 0.225])

train_augs = torchvision.transforms.Compose([
    torchvision.transforms.RandomResizedCrop(224),
    torchvision.transforms.RandomHorizontalFlip(),
    torchvision.transforms.ToTensor(),
    normalize])

test_augs = torchvision.transforms.Compose([
    torchvision.transforms.Resize(256),
    torchvision.transforms.CenterCrop(224),
    torchvision.transforms.ToTensor(),
    normalize])
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

2.2.2 定义和初始化模型

我们使用在 ImageNet 数据集上预训练的 ResNet-18 作为源模型。在这里，我们指定 pretrained=True 以自动下载预训练的模型参数。如果你首次使用此模型，则需要连接互联网才能下载。

pretrained_net = torchvision.models.resnet18(pretrained=True)
1

预训练的源模型实例包含许多特征层和一个输出层fc。此划分的主要目的是促进对除输出层以外所有层的模型参数进行微调。下面给出了源模型的成员变量fc。

pretrained_net.fc
1

Linear(in_features=512, out_features=1000, bias=True)

在 ResNet 的全局平均汇聚层后，全连接层转换为 ImageNet 数据集的 $1000$ 个类输出。之后，我们构建一个新的神经网络作为目标模型。它的定义方式与预训练源模型的定义方式相同，只是最终层中的输出数量被设置为目标数据集中的类数（而不是 $1000$ 个）。

在下面的代码中，目标模型 finetune_net 中成员变量 features 的参数被初始化为源模型相应层的模型参数。由于模型参数是在 ImageNet 数据集上预训练的，并且足够好，因此通常只需要较小的学习率即可微调这些参数。

成员变量 output 的参数是随机初始化的，通常需要更高的学习率才能从头开始训练。假设 Trainer 实例中的学习率为 $\eta$，我们将成员变量 output 中参数的学习率设置为 $10\eta$。

finetune_net = torchvision.models.resnet18(pretrained=True)
finetune_net.fc = nn.Linear(finetune_net.fc.in_features, 2)
nn.init.xavier_uniform_(finetune_net.fc.weight);
1
2
3

2.2.3 微调模型

首先，我们定义了一个训练函数 train_fine_tuning，该函数使用微调，因此可以多次调用。

# 如果param_group=True，输出层中的模型参数将使用十倍的学习率
def train_fine_tuning(net, learning_rate, batch_size=128, num_epochs=5,
                      param_group=True):
    train_iter = torch.utils.data.DataLoader(torchvision.datasets.ImageFolder(
        os.path.join(data_dir, 'train'), transform=train_augs),
        batch_size=batch_size, shuffle=True)
    test_iter = torch.utils.data.DataLoader(torchvision.datasets.ImageFolder(
        os.path.join(data_dir, 'test'), transform=test_augs),
        batch_size=batch_size)
    devices = d2l.try_all_gpus()
    loss = nn.CrossEntropyLoss(reduction="none")
    if param_group:
        params_1x = [param for name, param in net.named_parameters()
             if name not in ["fc.weight", "fc.bias"]]
        trainer = torch.optim.SGD([{'params': params_1x},
                                   {'params': net.fc.parameters(),
                                    'lr': learning_rate * 10}],
                                lr=learning_rate, weight_decay=0.001)
    else:
        trainer = torch.optim.SGD(net.parameters(), lr=learning_rate,
                                  weight_decay=0.001)
    d2l.train_ch13(net, train_iter, test_iter, loss, trainer, num_epochs,
                   devices)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

我们使用较小的学习率，通过微调预训练获得的模型参数。

train_fine_tuning(finetune_net, 5e-5)
1

loss 0.191, train acc 0.931, test acc 0.949
1086.6 examples/sec on [device(type=‘cuda’, index=0), device(type=‘cuda’, index=1)]

为了进行比较，我们定义了一个相同的模型，但是将其所有模型参数初始化为随机值。由于整个模型需要从头开始训练，因此我们需要使用更大的学习率。

scratch_net = torchvision.models.resnet18()
scratch_net.fc = nn.Linear(scratch_net.fc.in_features, 2)
train_fine_tuning(scratch_net, 5e-4, param_group=False)
1
2
3

loss 0.390, train acc 0.828, test acc 0.826
1610.3 examples/sec on [device(type=‘cuda’, index=0), device(type=‘cuda’, index=1)]

意料之中，微调模型往往表现更好，因为它的初始参数值更有效。

2.3 小结

• 迁移学习将从源数据集中学到的知识“迁移”到目标数据集，微调是迁移学习的常见技巧。
• 除输出层外，目标模型从源模型中复制所有模型设计及其参数，并根据目标数据集对这些参数进行微调。但是，目标模型的输出层需要从头开始训练。
• 通常，微调参数使用较小的学习率，而从头开始训练输出层可以使用更大的学习率。

3. 目标检测和边界框

在前面的章节中，我们介绍了各种图像分类模型。在图像分类任务中，我们假设图像中只有一个主要物体对象，我们只关注如何识别其类别。然而，很多时候图像里有多个我们感兴趣的目标，我们不仅想知道它们的类别，还想得到它们在图像中的具体位置。在计算机视觉里，我们将这类任务称为目标检测（object detection）或目标识别（object recognition）。

目标检测在多个领域中被广泛使用。例如，在无人驾驶里，我们需要通过识别拍摄到的视频图像里的车辆、行人、道路和障碍物的位置来规划行进线路。机器人也常通过该任务来检测感兴趣的目标。安防领域则需要检测异常目标，如歹徒或者炸弹。

在接下来的几节中，我们将介绍几种用于目标检测的深度学习方法。我们将首先介绍目标的位置。

%matplotlib inline
import torch
from d2l import torch as d2l
1
2
3

下面加载本节将使用的示例图像。可以看到图像左边是一只狗，右边是一只猫。它们是这张图像里的两个主要目标。

d2l.set_figsize()
img = d2l.plt.imread('../img/catdog.jpg')
d2l.plt.imshow(img);
1
2
3

3.1 边界框

在目标检测中，我们通常使用边界框（bounding box）来描述对象的空间位置。边界框是矩形的，由矩形左上角的以及右下角的 $x$ 和 $y$ 坐标决定。另一种常用的边界框表示方法是边界框中心的 $(x,y)$ 轴坐标以及框的宽度和高度。

在这里，我们定义在这两种表示法之间进行转换的函数：box_corner_to_center 从两角表示法转换为中心宽度表示法，而 box_center_to_corner 反之亦然。输入参数 boxes 可以是长度为 $4$ 的张量，也可以是形状为 $(n,4)$ 的二维张量，其中 $n$ 是边界框的数量。

#@save
def box_corner_to_center(boxes):
    """从（左上，右下）转换到（中间，宽度，高度）"""
    x1, y1, x2, y2 = boxes[:, 0], boxes[:, 1], boxes[:, 2], boxes[:, 3]
    cx = (x1 + x2) / 2 ## 中间
    cy = (y1 + y2) / 2
    w = x2 - x1 ## 宽度
    h = y2 - y1 ## 高度
    boxes = torch.stack((cx, cy, w, h), axis=-1)
    return boxes

#@save
def box_center_to_corner(boxes):
    """从（中间，宽度，高度）转换到（左上，右下）"""
    cx, cy, w, h = boxes[:, 0], boxes[:, 1], boxes[:, 2], boxes[:, 3]
    x1 = cx - 0.5 * w
    y1 = cy - 0.5 * h
    x2 = cx + 0.5 * w
    y2 = cy + 0.5 * h
    boxes = torch.stack((x1, y1, x2, y2), axis=-1)
    return boxes
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

我们将根据坐标信息定义图像中狗和猫的边界框。图像中坐标的原点是图像的左上角，向右的方向为 $x$ 轴的正方向，向下的方向为 $y$ 轴的正方向。

# bbox是边界框的英文缩写
dog_bbox, cat_bbox = [60.0, 45.0, 378.0, 516.0], [400.0, 112.0, 655.0, 493.0]
1
2

我们可以通过转换两次来验证边界框转换函数的正确性。

boxes = torch.tensor((dog_bbox, cat_bbox))
box_center_to_corner(box_corner_to_center(boxes)) == boxes
1
2

tensor([[True, True, True, True],
        [True, True, True, True]])

我们可以将边界框在图中画出，以检查其是否准确。画之前，我们定义一个辅助函数 bbox_to_rect。它将边界框表示成 matplotlib 的边界框格式。

#@save
def bbox_to_rect(bbox, color):
    # 将边界框(左上x,左上y,右下x,右下y)格式转换成matplotlib格式：
    # ((左上x,左上y),宽,高)
    return d2l.plt.Rectangle(
        xy=(bbox[0], bbox[1]), width=bbox[2]-bbox[0], height=bbox[3]-bbox[1],
        fill=False, edgecolor=color, linewidth=2)
1
2
3
4
5
6
7

在图像上添加边界框之后，我们可以看到两个物体的主要轮廓基本上在两个框内。

fig = d2l.plt.imshow(img)
fig.axes.add_patch(bbox_to_rect(dog_bbox, 'blue'))
fig.axes.add_patch(bbox_to_rect(cat_bbox, 'red'));
1
2
3

3.2 小结

• 目标检测不仅可以识别图像中所有感兴趣的物体，还能识别它们的位置，该位置通常由矩形边界框表示。
• 我们可以在两种常用的边界框表示（中间，宽度，高度）和（左上，右下）坐标之间进行转换。

4. 锚框

目标检测算法通常会在输入图像中采样大量的区域，然后判断这些区域中是否包含我们感兴趣的目标，并调整区域边界从而更准确地预测目标的真实边界框（ground-truth bounding box）。不同的模型使用的区域采样方法可能不同。这里我们介绍其中的一种方法：以每个像素为中心，生成多个缩放比和宽高比（aspect ratio）不同的边界框。这些边界框被称为锚框（anchor box），我们将在第七节中设计一个基于锚框的目标检测模型。

首先，让我们修改输出精度，以获得更简洁的输出。

%matplotlib inline
import torch
from d2l import torch as d2l

torch.set_printoptions(2)  # 精简输出精度
1
2
3
4
5

4.1 生成多个锚框

假设输入图像的高度为 $h$，宽度为 $w$。我们以图像的每个像素为中心生成不同形状的锚框：缩放比为 $s\in (0,1]$，宽高比为 $r>0$。那么锚框的宽度和高度分别是 $ws\sqrt{r}$ 和 $hs/\sqrt{r}$(宽高比那个，两个一除确实是 $r$)。请注意，当中心位置给定时，已知宽和高的锚框是确定的。

要生成多个不同形状的锚框，让我们设置许多缩放比 (scale) 取值 $s_1,\dots ,s_n$ 和许多宽高比 (aspect ratio) 取值 $r_1,\dots ,r_m$ 。当使用这些比例和长宽比的所有组合以每个像素为中心时，输入图像将总共有 $whnm$ 个锚框(每个像素有 $nm$ 个)。尽管这些锚框可能会覆盖所有真实边界框，但计算复杂性很容易过高。在实践中，我们只考虑包含 $s_1$ 或 $r_1$ 的组合($n=1$和$m$的组合 加上 $m=1$和$n$的组合)：
$$\left(s_1,r_1\right),\left(s_1,r_2\right),\dots ,\left(s_1,r_m\right),\left(s_2,r_1\right),\left(s_3,r_1\right),\dots ,\left(s_n,r_1\right).$$

也就是说，以同一像素为中心的锚框的数量是 $n+m-1$ 。对于整个输入图像，我们将共生成 $wh(n+m-1)$ 个锚框。

上述生成锚框的方法在下面的 multibox_prior 函数中实现。我们指定输入图像、尺寸列表和宽高比列表，然后此函数将返回所有的锚框。

#@save
def multibox_prior(data, sizes, ratios):
    """生成以每个像素为中心具有不同形状的锚框"""
    in_height, in_width = data.shape[-2:]
    device, num_sizes, num_ratios = data.device, len(sizes), len(ratios)
    boxes_per_pixel = (num_sizes + num_ratios - 1)
    size_tensor = torch.tensor(sizes, device=device)
    ratio_tensor = torch.tensor(ratios, device=device)

    # 为了将锚点移动到像素的中心，需要设置偏移量。
    # 因为一个像素的高为1且宽为1，我们选择偏移我们的中心0.5
    offset_h, offset_w = 0.5, 0.5
    steps_h = 1.0 / in_height  # 在y轴上缩放步长
    steps_w = 1.0 / in_width  # 在x轴上缩放步长

    # 生成锚框的所有中心点
    center_h = (torch.arange(in_height, device=device) + offset_h) * steps_h
    center_w = (torch.arange(in_width, device=device) + offset_w) * steps_w
    shift_y, shift_x = torch.meshgrid(center_h, center_w, indexing='ij')
    shift_y, shift_x = shift_y.reshape(-1), shift_x.reshape(-1)

    # 生成“boxes_per_pixel”个高和宽，
    # 之后用于创建锚框的四角坐标(xmin,xmax,ymin,ymax)
    w = torch.cat((size_tensor * torch.sqrt(ratio_tensor[0]),
                   sizes[0] * torch.sqrt(ratio_tensor[1:])))\
                   * in_height / in_width  # 处理矩形输入
    h = torch.cat((size_tensor / torch.sqrt(ratio_tensor[0]),
                   sizes[0] / torch.sqrt(ratio_tensor[1:])))
    # 除以2来获得半高和半宽
    anchor_manipulations = torch.stack((-w, -h, w, h)).T.repeat(
                                        in_height * in_width, 1) / 2

    # 每个中心点都将有“boxes_per_pixel”个锚框，
    # 所以生成含所有锚框中心的网格，重复了“boxes_per_pixel”次
    out_grid = torch.stack([shift_x, shift_y, shift_x, shift_y],
                dim=1).repeat_interleave(boxes_per_pixel, dim=0)
    output = out_grid + anchor_manipulations
    return output.unsqueeze(0)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38

我们可以看到返回的锚框变量Y的形状是（批量大小，锚框的数量，$4$）。

img = d2l.plt.imread('../img/catdog.jpg')
h, w = img.shape[:2]

print(h, w)
X = torch.rand(size=(1, 3, h, w))
Y = multibox_prior(X, sizes=[0.75, 0.5, 0.25], ratios=[1, 2, 0.5])
Y.shape
1
2
3
4
5
6
7

561 728
torch.Size([1, 2042040, 4])

将锚框变量Y的形状更改为(图像高度，图像宽度，以同一像素为中心的锚框的数量，$4$)后，我们可以获得以指定像素的位置为中心的所有锚框。在接下来的内容中，我们访问以（250,250）为中心的第一个锚框。它有四个元素：锚框左上角的 $(x,y)$ 轴坐标和右下角的 $(x,y)$ 轴坐标。将两个轴的坐标分别除以图像的宽度和高度后，所得的值介于 $0$ 和 $1$ 之间。

boxes = Y.reshape(h, w, 5, 4)
boxes[250, 250, 0, :]
1
2

tensor([0.06, 0.07, 0.63, 0.82])

为了显示以图像中某个像素为中心的所有锚框，我们定义了下面的 show_bboxes 函数来在图像上绘制多个边界框。

#@save
def show_bboxes(axes, bboxes, labels=None, colors=None):
    """显示所有边界框"""
    def _make_list(obj, default_values=None):
        if obj is None:
            obj = default_values
        elif not isinstance(obj, (list, tuple)):
            obj = [obj]
        return obj

    labels = _make_list(labels)
    colors = _make_list(colors, ['b', 'g', 'r', 'm', 'c'])
    for i, bbox in enumerate(bboxes):
        color = colors[i % len(colors)]
        rect = d2l.bbox_to_rect(bbox.detach().numpy(), color)
        axes.add_patch(rect)
        if labels and len(labels) > i:
            text_color = 'k' if color == 'w' else 'w'
            axes.text(rect.xy[0], rect.xy[1], labels[i],
                      va='center', ha='center', fontsize=9, color=text_color,
                      bbox=dict(facecolor=color, lw=0))
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

正如你所看到的，变量 boxes 中 $x$ 轴和 $y$ 轴的坐标值已分别除以图像的宽度和高度。绘制锚框时，我们需要恢复它们原始的坐标值。因此，我们在下面定义了变量 bbox_scale。现在，我们可以绘制出图像中所有以 $(250,250)$ 为中心的锚框了。如下所示，缩放比为 $0.75$ 且宽高比为 $1$ 的蓝色锚框很好地围绕着图像中的狗。

d2l.set_figsize()
bbox_scale = torch.tensor((w, h, w, h))
fig = d2l.plt.imshow(img)
show_bboxes(fig.axes, boxes[250, 250, :, :] * bbox_scale,
            ['s=0.75, r=1', 's=0.5, r=1', 's=0.25, r=1', 's=0.75, r=2',
             's=0.75, r=0.5'])
1
2
3
4
5
6

4.2 交并比(IoU)

我们刚刚提到某个锚框“较好地”覆盖了图像中的狗。如果已知目标的真实边界框, 那么这里的“好”该如何量化呢? 直观地说，我们可以衡量锚框和真实边界框之间的相似性。我们知道杰卡德系数（Jaccard）可以衡量两组之间的相似性。给定集合 $\mathcal{A}$ 和 $\mathcal{B}$ ，他们的杰卡德系数是他们交集的大小除以他们并集的大小：
$$J(\mathcal{A},\mathcal{B})=\frac{|\mathcal{A}\cap \mathcal{B}|}{|\mathcal{A}\cup \mathcal{B}|}$$

事实上，我们可以将任何边界框的像素区域视为一组像素。通过这种方式，我们可以通过其像素集的杰卡德系数来测量两个边界框的相似性。对于两个边界框，我们通常将它们的杰卡德系数称为交并比 (intersection over union，IoU），即两个边界框相交面积与相并面积之比，如下图所示。交并比的取值范围在 $0$ 和 $1$ 之间：$0$ 表示两个边界框无重合像素，$1$ 表示两个边界框完全重合。

交并比是两个边界框相交面积与相并面积之比。

在接下来部分中，我们将使用交并比来衡量锚框和真实边界框之间、以及不同锚框之间的相似度。给定两个锚框或边界框的列表，以下 box_iou 函数将在这两个列表中计算它们成对的交并比。

#@save
def box_iou(boxes1, boxes2):
    """计算两个锚框或边界框列表中成对的交并比"""
    box_area = lambda boxes: ((boxes[:, 2] - boxes[:, 0]) *
                              (boxes[:, 3] - boxes[:, 1]))
    # boxes1,boxes2,areas1,areas2的形状:
    # boxes1：(boxes1的数量,4),
    # boxes2：(boxes2的数量,4),
    # areas1：(boxes1的数量,),
    # areas2：(boxes2的数量,)
    areas1 = box_area(boxes1)
    areas2 = box_area(boxes2)
    # inter_upperlefts,inter_lowerrights,inters的形状:
    # (boxes1的数量,boxes2的数量,2)
    inter_upperlefts = torch.max(boxes1[:, None, :2], boxes2[:, :2])
    inter_lowerrights = torch.min(boxes1[:, None, 2:], boxes2[:, 2:])
    inters = (inter_lowerrights - inter_upperlefts).clamp(min=0)
    # inter_areasandunion_areas的形状:(boxes1的数量,boxes2的数量)
    inter_areas = inters[:, :, 0] * inters[:, :, 1]
    union_areas = areas1[:, None] + areas2 - inter_areas
    return inter_areas / union_areas
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

4.3 在训练数据中标注锚框

在训练集中，我们将每个锚框视为一个训练样本。为了训练目标检测模型，我们需要每个锚框的类别（class）和偏移量（offset）标签，其中前者是与锚框相关的对象的类别，后者是真实边界框相对于锚框的偏移量(这个锚框和标注出来的真实框相差多少，要计算四个值$\Delta x_c^{\ast }$,$\Delta y_c^{\ast }$,$w^{\ast }$,$\Delta h^{\ast }$)。在预测时，我们为每个图像生成多个锚框，预测所有锚框的类别和偏移量，根据预测的偏移量调整它们的位置以获得预测的边界框，最后只输出符合特定条件的预测边界框。

我们知道，目标检测训练集带有“真实边界框”的位置及其包围物体类别的标签。要标记任何生成的锚框，我们可以参考分配到的最接近此锚框的真实边界框的位置和类别标签。在下文中，我们将介绍一个算法，它能够把最接近的真实边界框分配给锚框。

4.3.1 将真实边界框分配给锚框

给定图像，假设锚框是 $A_1,A_2,\dots ,A_{n_a}$，真实边界框是 $B_1,B_2,\dots ,B_{n_b}$，其中 $n_a\ge n_b$。 让我们定义一个矩阵 $\mathbf{X}\in {\mathbb{R}}^{n_a\times n_b}$，其中第 $i$ 行、第 $j$ 列的元素 $x_{ij}$ 是锚框 $A_i$ 和真实边界框 $B_j$ 的 loU。该算法包含以下步骤：

1. 在矩阵 $\mathbf{X}$ 中找到最大的元素，并将它的行索引和列索引分别表示为 $i_1$ 和 $j_1$ 然后将真实边界框 $B_{j_1}$ 分配给锚框 $A_{i_1}$(这里写的感觉有点问题，直接看实例更好，使用的直接就是当前行和列，没必要说什么 $i_1$、$j_1$)。这很直观，因为 $A_{i_1}$ 和 $B_{j_1}$ 是所有锚框和真实边界框配对中最相近的。在第一个分配完成后，丢弃矩阵中 $i_1^{\text{th }}$ 行和 $j_1^{\text{th }}$ 列中的所有元素。
2. 在矩阵 $\mathbf{X}$ 中找到剩余元素中最大的元素，并将它的行索引和列索引分别表示为 $i_2$ 和 $j_2$ 。我们将真实边界框 $B_{j2}$ 分配给锚框 $A_{i2}$，并丟弃矩阵中 $i_2^{\text{th }}$ 行和 $j_2^{\text{th }}$ 列中的所有元素。
3. 此时，矩阵 $\mathbf{X}$ 中两行和两列中的元素已被丢弃。我们继续，直到丢弃掉矩阵 $\mathbf{X}$ 中 $n_b$ 列中的所有元素。此时，我们已经为这 $n_b$ 个锚框各自分配了一个真实边界框。
4. 只遍历剩下的 $n_a-n_b$ 个锚框。例如，给定任何锚框 $A_i$，在矩阵 $\mathbf{X}$ 的第 $i^{\text{th }}$ 行中找到与 $A_i$ 的 IoU 最大的真实边界框 $B_j$，只有当此 loU 大于预定义的阈值时，才将 $B_j$ 分配给 $A_i$ 。

让我们用一个具体的例子来说明上述算法。如下图(左) 所示，假设矩阵 $\mathbf{X}$ 中的最大值为 $x_{23}$，我们将真实边界框 $B_3$ 分配给锚框 $A_2$ 。然后，我们丢弃矩阵第 $2$ 行和第 3 列中的所有元素，在剩余元素 (阴影区域) 中找到最大的 $x_{71}$，然后将真实边界框 $B_1$ 分配给锚框 $A_7$ 。接下来，如下图(中）所示，丢弃矩阵第 $7$ 行和第 $1$ 列中的所有元素，在剩余元素 (阴影区域) 中找到最大的 $x_{54}$，然后将真实边界框 $B_4$ 分配给锚框 $A_5$ 。最后，如下图(右) 所示，丢弃矩阵第 $5$ 行和第 $4$ 列中的所有元素，在剩余元素（阴影区域）中找到最大的 $x_{92}$，然后将真实边界框 $B_2$ 分配给锚框 $A_9$ 。之后，我们只需要遍历剩余的锚框 $A_1,A_3,A_4,A_6,A_8$(这几个锚框没有匹配)，然后根据阈值确定是否为它们分配真实边界框。

将真实边界框分配给锚框。

此算法在下面的 assign_anchor_to_bbox 函数中实现。

#@save
def assign_anchor_to_bbox(ground_truth, anchors, device, iou_threshold=0.5):
    """将最接近的真实边界框分配给锚框"""
    num_anchors, num_gt_boxes = anchors.shape[0], ground_truth.shape[0]
    # 位于第i行和第j列的元素x_ij是锚框i和真实边界框j的IoU
    jaccard = box_iou(anchors, ground_truth)
    # 对于每个锚框，分配的真实边界框的张量
    anchors_bbox_map = torch.full((num_anchors,), -1, dtype=torch.long,
                                  device=device)
    # 根据阈值，决定是否分配真实边界框
    max_ious, indices = torch.max(jaccard, dim=1)
    anc_i = torch.nonzero(max_ious >= iou_threshold).reshape(-1)
    box_j = indices[max_ious >= iou_threshold]
    anchors_bbox_map[anc_i] = box_j
    col_discard = torch.full((num_anchors,), -1)
    row_discard = torch.full((num_gt_boxes,), -1)
    for _ in range(num_gt_boxes):
        max_idx = torch.argmax(jaccard)
        box_idx = (max_idx % num_gt_boxes).long()
        anc_idx = (max_idx / num_gt_boxes).long()
        anchors_bbox_map[anc_idx] = box_idx
        jaccard[:, box_idx] = col_discard
        jaccard[anc_idx, :] = row_discard
    return anchors_bbox_map
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

4.3.2 标记类别和偏移量

现在我们可以为每个锚框标记类别和偏移量了。假设一个锚框 $A$ 被分配了一个真实边界框 $B$ 。一方面，锚框 $A$ 的类别将被标记为与 $B$ 相同(毕竟被标记为了同一目标)。另一方面，锚框 $A$ 的偏移量将根据 $B$ 和 $A$ 中心坐标的相对位置以及这两个框的相对大小进行标记。鉴于数据集内不同的框的位置和大小不同，我们可以对那些相对位置和大小应用变换，使其获得分布更均匀且易于拟合的偏移量。在这里，我们介绍一种常见的变换。给定框 $A$ 和 $B$，中心坐标分别为 $\left(x_a,y_a\right)$ 和 $\left(x_b,y_b\right)$，宽度分别为 $w_a$ 和 $w_b$，高度分别为 $h_a$ 和 $h_b$。我们可以将 $A$ 的偏移量标记为：
$$\left(\frac{\frac{x_b-x_a}{w_a}-{\mu }_x}{{\sigma }_x},\frac{\frac{y_b-y_a}{h_a}-{\mu }_y}{{\sigma }_y},\frac{\log \frac{w_b}{w_a}-{\mu }_w}{{\sigma }_w},\frac{\log \frac{h_b}{h_a}-{\mu }_h}{{\sigma }_h}\right)$$

其中常量的默认值为 ${\mu }_x={\mu }_y={\mu }_w={\mu }_h=0,{\sigma }_x={\sigma }_y=0.1,{\sigma }_w={\sigma }_h=0.2$(这里为什么会用$\sigma$？不应该等于$1$么？)。 这种转换在下面的 offset_boxes 函数中实现。

#@save
def multibox_target(anchors, labels):
    """使用真实边界框标记锚框"""
    batch_size, anchors = labels.shape[0], anchors.squeeze(0)
    batch_offset, batch_mask, batch_class_labels = [], [], []
    device, num_anchors = anchors.device, anchors.shape[0]
    for i in range(batch_size):
        label = labels[i, :, :]
        anchors_bbox_map = assign_anchor_to_bbox(
            label[:, 1:], anchors, device)
        bbox_mask = ((anchors_bbox_map >= 0).float().unsqueeze(-1)).repeat(
            1, 4)
        # 将类标签和分配的边界框坐标初始化为零
        class_labels = torch.zeros(num_anchors, dtype=torch.long,
                                   device=device)
        assigned_bb = torch.zeros((num_anchors, 4), dtype=torch.float32,
                                  device=device)
        # 使用真实边界框来标记锚框的类别。
        # 如果一个锚框没有被分配，我们标记其为背景（值为零）
        indices_true = torch.nonzero(anchors_bbox_map >= 0)
        bb_idx = anchors_bbox_map[indices_true]
        class_labels[indices_true] = label[bb_idx, 0].long() + 1
        assigned_bb[indices_true] = label[bb_idx, 1:]
        # 偏移量转换
        offset = offset_boxes(anchors, assigned_bb) * bbox_mask
        batch_offset.append(offset.reshape(-1))
        batch_mask.append(bbox_mask.reshape(-1))
        batch_class_labels.append(class_labels)
    bbox_offset = torch.stack(batch_offset)
    bbox_mask = torch.stack(batch_mask)
    class_labels = torch.stack(batch_class_labels)
    return (bbox_offset, bbox_mask, class_labels)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32

4.3.3 一个例子

让我们通过一个具体的例子来说明锚框标签。我们已经为加载图像中的狗和猫定义了真实边界框，其中第一个元素是类别（$0$ 代表狗，$1$ 代表猫），其余四个元素是左上角和右下角的 $(x,y)$ 轴坐标（范围介于 $0$ 和 $1$ 之间）。我们还构建了五个锚框，用左上角和右下角的坐标进行标记：$A_0,...,A_4$（索引从 $0$ 开始）。然后我们在图像中绘制这些真实边界框和锚框。

ground_truth = torch.tensor([[0, 0.1, 0.08, 0.52, 0.92],
                         [1, 0.55, 0.2, 0.9, 0.88]])
anchors = torch.tensor([[0, 0.1, 0.2, 0.3], [0.15, 0.2, 0.4, 0.4],
                    [0.63, 0.05, 0.88, 0.98], [0.66, 0.45, 0.8, 0.8],
                    [0.57, 0.3, 0.92, 0.9]])

fig = d2l.plt.imshow(img)
show_bboxes(fig.axes, ground_truth[:, 1:] * bbox_scale, ['dog', 'cat'], 'k')
show_bboxes(fig.axes, anchors * bbox_scale, ['0', '1', '2', '3', '4']);
1
2
3
4
5
6
7
8
9

使用上面定义的 multibox_target 函数，我们可以根据狗和猫的真实边界框，标注这些锚框的分类和偏移量。在这个例子中，背景、狗和猫的类索引分别为 $0$、$1$ 和 $2$。下面我们为锚框和真实边界框样本添加一个维度。

labels = multibox_target(anchors.unsqueeze(dim=0),
                         ground_truth.unsqueeze(dim=0))
1
2

返回的结果中有三个元素，都是张量格式。第三个元素包含标记的输入锚框的类别。

让我们根据图像中的锚框和真实边界框的位置来分析下面返回的类别标签。首先，在所有的锚框和真实边界框配对中，锚框 $A_4$ 与猫的真实边界框的 loU 是最大的。因此，$A_4$ 的类别被标记为猫。去除包含 $A_4$ 或猫的真实边界框的配对，在剩下的配对中，锚框 $A_1$ 和狗的真实边界框有最大的loU。因此，$A_1$ 的类别被标记为狗。接下来，我们需要遍历剩下的三个未标记的锚框：$A_0$、$A_2$ 和 $A_3$ 。对于 $A_0$，与其拥有最大 loU 的真实边界框的类别是狗，但 IoU 低于预定义的阈值$(0.5)$，因此该类别被标记为背景；对于 $A_2$，与其拥有最大 IoU 的真实边界框的类别是猫，IoU 超过阈值，所以类别被标记为猫；对于 $A_3$，与其拥有最大 loU 的真实边界框的类别是猫，但值低于阈值，因此该类别被标记为背景(猫、狗、背景)。

labels[2]
1

tensor([[0, 1, 2, 0, 2]])

返回的第二个元素是掩码（mask）变量，形状为（批量大小，锚框数的四倍）。掩码变量中的元素与每个锚框的 $4$ 个偏移量一一对应。由于我们不关心对背景的检测，负类的偏移量不应影响目标函数。通过元素乘法，掩码变量中的零将在计算目标函数之前过滤掉负类偏移量(背景的不考虑，每四个一组)。

labels[1]
1

tensor([[0., 0., 0., 0., 1., 1., 1., 1., 1., 1., 1., 1., 0., 0., 0., 0., 1., 1., 1., 1.]])

返回的第一个元素包含了为每个锚框标记的四个偏移值。请注意，负类锚框的偏移量被标记为零。

labels[0]
1

tensor([[-0.00e+00, -0.00e+00, -0.00e+00, -0.00e+00, 1.40e+00, 1.00e+01,
          2.59e+00, 7.18e+00, -1.20e+00, 2.69e-01, 1.68e+00, -1.57e+00,
         -0.00e+00, -0.00e+00, -0.00e+00, -0.00e+00, -5.71e-01, -1.00e+00,
          4.17e-06, 6.26e-01]])

4.4 使用非极大值抑制预测边界框

在预测时，我们先为图像生成多个锚框，再为这些锚框一一预测类别和偏移量。一个“预测好的边界框”则根据其中某个带有预测偏移量的锚框而生成。下面我们实现了 offset_inverse 函数，该函数将锚框和偏移量预测作为输入，并应用逆偏移变换来返回预测的边界框坐标。

#@save
def offset_inverse(anchors, offset_preds):
    """根据带有预测偏移量的锚框来预测边界框"""
    anc = d2l.box_corner_to_center(anchors)
    pred_bbox_xy = (offset_preds[:, :2] * anc[:, 2:] / 10) + anc[:, :2]
    pred_bbox_wh = torch.exp(offset_preds[:, 2:] / 5) * anc[:, 2:]
    pred_bbox = torch.cat((pred_bbox_xy, pred_bbox_wh), axis=1)
    predicted_bbox = d2l.box_center_to_corner(pred_bbox)
    return predicted_bbox
1
2
3
4
5
6
7
8
9

当有许多锚框时，可能会输出许多相似的具有明显重叠的预测边界框，都围绕着同一目标。为了简化输出，我们可以使用非极大值抑制（non-maximum suppression，NMS）合并属于同一目标的类似的预测边界框。

以下是非极大值抑制的工作原理。对于一个预测边界框 $B$，目标检测模型会计算每个类别的预测概率。假设最大的预测概率为 $p$，则该概率所对应的类别 $B$ 即为预测的类别。具体来说，我们将 $p$ 称为预测边界框 $B$ 的置信度 (confidence)。在同一张图像中，所有预测的非背景边界框都按置信度降序排序，以生成列表 $L$ 。然后我们通过以下步骤操作排序列表 $L$ ：

1. 从 $L$ 中选取置信度最高的预测边界框 $B_1$ 作为基准，然后将所有与 $B_1$ 的 loU 超过预定阈值 $ϵ$ 的非基准预测边界框从 $L$ 中移除。这时，$L$ 保留了置信度最高的预测边界框，去除了与其太过相似的其他预测边界框。简而言之，那些具有非极大值置信度的边界框被抑制了。
2. 从 $L$ 中选取置信度第二高的预测边界框 $B_2$ 作为又一个基准，然后将所有与 $B_2$ 的 loU 大于 $ϵ$ 的非基准预测边界框从 $L$ 中移除。
3. 重复上述过程，直到 $L$ 中的所有预测边界框都曾被用作基准。此时，$L$ 中任意一对预测边界框的 IoU 都小于阈值 $ϵ$；因此，没有一对边界框过于相似。
4. 输出列表 $L$ 中的所有预测边界框。

以下 nms 函数按降序对置信度进行排序并返回其索引。

#@save
def nms(boxes, scores, iou_threshold):
    """对预测边界框的置信度进行排序"""
    B = torch.argsort(scores, dim=-1, descending=True)
    keep = []  # 保留预测边界框的指标
    while B.numel() > 0:
        i = B[0]
        keep.append(i)
        if B.numel() == 1: break
        iou = box_iou(boxes[i, :].reshape(-1, 4),
                      boxes[B[1:], :].reshape(-1, 4)).reshape(-1)
        inds = torch.nonzero(iou <= iou_threshold).reshape(-1)
        B = B[inds + 1]
    return torch.tensor(keep, device=boxes.device)
1
2
3
4
5
6
7
8
9
10
11
12
13
14

我们定义以下 multibox_detection 函数来将非极大值抑制应用于预测边界框。如果你发现实现有点复杂，请不要担心。我们将在实现之后，马上用一个具体的例子来展示它是如何工作的。

#@save
def multibox_detection(cls_probs, offset_preds, anchors, nms_threshold=0.5,
                       pos_threshold=0.009999999):
    """使用非极大值抑制来预测边界框"""
    device, batch_size = cls_probs.device, cls_probs.shape[0]
    anchors = anchors.squeeze(0)
    num_classes, num_anchors = cls_probs.shape[1], cls_probs.shape[2]
    out = []
    for i in range(batch_size):
        cls_prob, offset_pred = cls_probs[i], offset_preds[i].reshape(-1, 4)
        conf, class_id = torch.max(cls_prob[1:], 0)
        predicted_bb = offset_inverse(anchors, offset_pred)
        keep = nms(predicted_bb, conf, nms_threshold)

        # 找到所有的non_keep索引，并将类设置为背景
        all_idx = torch.arange(num_anchors, dtype=torch.long, device=device)
        combined = torch.cat((keep, all_idx))
        uniques, counts = combined.unique(return_counts=True)
        non_keep = uniques[counts == 1]
        all_id_sorted = torch.cat((keep, non_keep))
        class_id[non_keep] = -1
        class_id = class_id[all_id_sorted]
        conf, predicted_bb = conf[all_id_sorted], predicted_bb[all_id_sorted]
        # pos_threshold是一个用于非背景预测的阈值
        below_min_idx = (conf < pos_threshold)
        class_id[below_min_idx] = -1
        conf[below_min_idx] = 1 - conf[below_min_idx]
        pred_info = torch.cat((class_id.unsqueeze(1),
                               conf.unsqueeze(1),
                               predicted_bb), dim=1)
        out.append(pred_info)
    return torch.stack(out)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32

现在让我们将上述算法应用到一个带有四个锚框的具体示例中。为简单起见，我们假设预测的偏移量都是零，这意味着预测的边界框即是锚框。对于背景、狗和猫其中的每个类，我们还定义了它的预测概率。

anchors = torch.tensor([[0.1, 0.08, 0.52, 0.92], [0.08, 0.2, 0.56, 0.95],
                      [0.15, 0.3, 0.62, 0.91], [0.55, 0.2, 0.9, 0.88]])
offset_preds = torch.tensor([0] * anchors.numel())
cls_probs = torch.tensor([[0] * 4,  # 背景的预测概率
                      [0.9, 0.8, 0.7, 0.1],  # 狗的预测概率
                      [0.1, 0.2, 0.3, 0.9]])  # 猫的预测概率
1
2
3
4
5
6

我们可以在图像上绘制这些预测边界框和置信度。

fig = d2l.plt.imshow(img)
show_bboxes(fig.axes, anchors * bbox_scale,
            ['dog=0.9', 'dog=0.8', 'dog=0.7', 'cat=0.9'])
1
2
3

现在我们可以调用 multibox_detection 函数来执行非极大值抑制，其中阈值设置为 $0.5$。请注意，我们在示例的张量输入中添加了维度。

我们可以看到返回结果的形状是（批量大小，锚框的数量，$6$）。最内层维度中的六个元素提供了同一预测边界框的输出信息。第一个元素是预测的类索引，从 $0$ 开始（$0$ 代表狗，$1$ 代表猫），值 $-1$ 表示背景或在非极大值抑制中被移除了。第二个元素是预测的边界框的置信度。其余四个元素分别是预测边界框左上角和右下角的 $(x,y)$ 轴坐标（范围介于 $0$ 和 $1$ 之间）。

output = multibox_detection(cls_probs.unsqueeze(dim=0),
                            offset_preds.unsqueeze(dim=0),
                            anchors.unsqueeze(dim=0),
                            nms_threshold=0.5)
output
1
2
3
4
5

tensor([[[ 0.00, 0.90, 0.10, 0.08, 0.52, 0.92],
         [ 1.00, 0.90, 0.55, 0.20, 0.90, 0.88],
         [-1.00, 0.80, 0.08, 0.20, 0.56, 0.95],
         [-1.00, 0.70, 0.15, 0.30, 0.62, 0.91]]])

删除 $-1$ 类别（背景）的预测边界框后，我们可以输出由非极大值抑制保存的最终预测边界框。

fig = d2l.plt.imshow(img)
for i in output[0].detach().numpy():
    if i[0] == -1:
        continue
    label = ('dog=', 'cat=')[int(i[0])] + str(i[1])
    show_bboxes(fig.axes, [torch.tensor(i[2:]) * bbox_scale], label)
1
2
3
4
5
6

实践中，在执行非极大值抑制前，我们甚至可以将置信度较低的预测边界框移除，从而减少此算法中的计算量。我们也可以对非极大值抑制的输出结果进行后处理。例如，只保留置信度更高的结果作为最终输出。

4.5 小结

• 我们以图像的每个像素为中心生成不同形状的锚框。
• 交并比（IoU）也被称为杰卡德系数，用于衡量两个边界框的相似性。它是相交面积与相并面积的比率。
• 在训练集中，我们需要给每个锚框两种类型的标签。一个是与锚框中目标检测的类别，另一个是锚框真实相对于边界框的偏移量。
• 在预测期间，我们可以使用非极大值抑制（NMS）来移除类似的预测边界框，从而简化输出。

5. 多尺度目标检测

在上一节中，我们以输入图像的每个像素为中心，生成了多个锚框。基本而言，这些锚框代表了图像不同区域的样本。 然而，如果为每个像素都生成的锚框，我们最终可能会得到太多需要计算的锚框。想象一个 $561\times 728$ 的输入图像，如果以每个像素为中心生成五个形状不同的锚框，就需要在图像上标记和预测超过200万个锚框 $(561\times 728\times 5)$。

5.1 多尺度锚框

你可能会意识到，减少图像上的锚框数量并不困难。比如，我们可以在输入图像中均匀采样一小部分像素，并以它们为中心生成锚框。此外，在不同尺度下，我们可以生成不同数量和不同大小的锚框。直观地说，比起较大的目标，较小的目标在图像上出现的可能性更多样。例如，$1\times 1$、$1\times 2$ 和 $2\times 2$ 的目标可以分别以 $4$、$2$ 和 $1$ 种可能的方式出现在 $2\times 2$ 图像上。因此，当使用较小的锚框检测较小的物体时，我们可以采样更多的区域，而对于较大的物体，我们可以采样较少的区域。

为了演示如何在多个尺度下生成锚框，让我们先读取一张图像。它的高度和宽度分别为 $561$ 和 $728$ 像素。

%matplotlib inline
import torch
from d2l import torch as d2l

img = d2l.plt.imread('../img/catdog.jpg')
h, w = img.shape[:2]
h, w
1
2
3
4
5
6
7

(561, 728)

我们将卷积图层的二维数组输出称为特征图。通过定义特征图的形状，我们可以确定任何图像上均匀采样锚框的中心。

display_anchors 函数定义如下。我们在特征图（fmap）上生成锚框（anchors），每个单位（像素）作为锚框的中心。由于锚框中的 $(x,y)$ 轴坐标值（anchors）已经被除以特征图（fmap）的宽度和高度，因此这些值介于 $0$ 和 $1$ 之间，表示特征图中锚框的相对位置。

由于锚框（anchors）的中心分布于特征图（fmap）上的所有单位，因此这些中心必须根据其相对空间位置在任何输入图像上均匀分布。更具体地说，给定特征图的宽度和高度 fmap_w 和 fmap_h，以下函数将均匀地对任何输入图像中 fmap_h 行和 fmap_w 列中的像素进行采样。以这些均匀采样的像素为中心，将会生成大小为 s（假设列表s的长度为 $1$）且宽高比（ratios）不同的锚框。

def display_anchors(fmap_w, fmap_h, s):
    d2l.set_figsize()
    # 前两个维度上的值不影响输出
    fmap = torch.zeros((1, 10, fmap_h, fmap_w))
    anchors = d2l.multibox_prior(fmap, sizes=s, ratios=[1, 2, 0.5])
    bbox_scale = torch.tensor((w, h, w, h))
    d2l.show_bboxes(d2l.plt.imshow(img).axes,
                    anchors[0] * bbox_scale)
1
2
3
4
5
6
7
8

首先，让我们考虑探测小目标。为了在显示时更容易分辨，在这里具有不同中心的锚框不会重叠：锚框的尺度设置为 $0.15$($s$ 在上一章有写)，特征图的高度和宽度设置为 $4$(特征图中设置的长和宽的个数)。我们可以看到，图像上 $4$ 行和 $4$ 列的锚框的中心是均匀分布的。

display_anchors(fmap_w=4, fmap_h=4, s=[0.15])
1

/home/d2l-worker/miniconda3/envs/d2l-zh-release-1/lib/python3.8/site-packages/torch/functional.py:568: 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:2228.)
return _VF.meshgrid(tensors, **kwargs) # type: ignore[attr-defined]

然后，我们将特征图的高度和宽度减小一半，然后使用较大的锚框来检测较大的目标。当尺度设置为 $0.4$ 时，一些锚框将彼此重叠(长和宽的基础大小为图像上长和宽的0.4，有的锚框长款比可能为2，所以占得大小为：$2\ast 0.4\ast \sqrt{2}=1.1314$)。

display_anchors(fmap_w=2, fmap_h=2, s=[0.4])
1

最后，我们进一步将特征图的高度和宽度减小一半，然后将锚框的尺度增加到 $0.8$。此时，锚框的中心即是图像的中心。

display_anchors(fmap_w=1, fmap_h=1, s=[0.8])
1

5.3 小结

• 在多个尺度下，我们可以生成不同尺寸的锚框来检测不同尺寸的目标。
• 通过定义特征图的形状，我们可以决定任何图像上均匀采样的锚框的中心。
• 我们使用输入图像在某个感受野区域内的信息，来预测输入图像上与该区域位置相近的锚框类别和偏移量。
• 我们可以通过深入学习，在多个层次上的图像分层表示进行多尺度目标检测。

6. 目标检测数据集

目标检测领域没有像 MNIST 和 Fashion-MNIST 那样的小数据集。为了快速测试目标检测模型，我们收集并标记了一个小型数据集。首先，我们拍摄了一组香蕉的照片，并生成了 $1000$ 张不同角度和大小的香蕉图像。然后，我们在一些背景图片的随机位置上放一张香蕉的图像。最后，我们在图片上为这些香蕉标记了边界框。

6.1 下载数据集

包含所有图像和 CSV 标签文件的香蕉检测数据集可以直接从互联网下载。

%matplotlib inline
import os
import pandas as pd
import torch
import torchvision
from d2l import torch as d2l

#@save
d2l.DATA_HUB['banana-detection'] = (
    d2l.DATA_URL + 'banana-detection.zip',
    '5de26c8fce5ccdea9f91267273464dc968d20d72')
1
2
3
4
5
6
7
8
9
10
11

6.2 读取数据集

通过 read_data_bananas 函数，我们读取香蕉检测数据集。该数据集包括一个的 CSV 文件，内含目标类别标签和位于左上角和右下角的真实边界框坐标。

#@save
def read_data_bananas(is_train=True):
    """读取香蕉检测数据集中的图像和标签"""
    data_dir = d2l.download_extract('banana-detection')
    csv_fname = os.path.join(data_dir, 'bananas_train' if is_train
                             else 'bananas_val', 'label.csv')
    csv_data = pd.read_csv(csv_fname)
    csv_data = csv_data.set_index('img_name')
    images, targets = [], []
    for img_name, target in csv_data.iterrows():
        images.append(torchvision.io.read_image(
            os.path.join(data_dir, 'bananas_train' if is_train else
                         'bananas_val', 'images', f'{img_name}')))
        # 这里的target包含（类别，左上角x，左上角y，右下角x，右下角y），
        # 其中所有图像都具有相同的香蕉类（索引为0）
        targets.append(list(target))
    return images, torch.tensor(targets).unsqueeze(1) / 256
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

通过使用 read_data_bananas 函数读取图像和标签，以下 BananasDataset 类别将允许我们创建一个自定义 Dataset 实例来加载香蕉检测数据集。

#@save
class BananasDataset(torch.utils.data.Dataset):
    """一个用于加载香蕉检测数据集的自定义数据集"""
    def __init__(self, is_train):
        self.features, self.labels = read_data_bananas(is_train)
        print('read ' + str(len(self.features)) + (f' training examples' if
              is_train else f' validation examples'))

    def __getitem__(self, idx):
        return (self.features[idx].float(), self.labels[idx])

    def __len__(self):
        return len(self.features)
1
2
3
4
5
6
7
8
9
10
11
12
13

最后，我们定义 load_data_bananas 函数，来为训练集和测试集返回两个数据加载器实例。对于测试集，无须按随机顺序读取它。

#@save
def load_data_bananas(batch_size):
    """加载香蕉检测数据集"""
    train_iter = torch.utils.data.DataLoader(BananasDataset(is_train=True),
                                             batch_size, shuffle=True)
    val_iter = torch.utils.data.DataLoader(BananasDataset(is_train=False),
                                           batch_size)
    return train_iter, val_iter
1
2
3
4
5
6
7
8

让我们读取一个小批量，并打印其中的图像和标签的形状。图像的小批量的形状为（批量大小、通道数、高度、宽度），看起来很眼熟：它与我们之前图像分类任务中的相同。标签的小批量的形状为（批量大小，$m$，$5$），其中 $m$ 是数据集的任何图像中边界框可能出现的最大数量。

小批量计算虽然高效，但它要求每张图像含有相同数量的边界框，以便放在同一个批量中。通常来说，图像可能拥有不同数量个边界框；因此，在达到 $m$ 之前，边界框少于 $m$ 的图像将被非法边界框填充。这样，每个边界框的标签将被长度为 $5$ 的数组表示。数组中的第一个元素是边界框中对象的类别，其中 $-1$ 表示用于填充的非法边界框。数组的其余四个元素是边界框左上角和右下角的 $(x,y)$ 坐标值（值域在 $0$ 到 $1$ 之间）。 对于香蕉数据集而言，由于每张图像上只有一个边界框，因此 $m=1$。

batch_size, edge_size = 32, 256
train_iter, _ = load_data_bananas(batch_size)
batch = next(iter(train_iter))
batch[0].shape, batch[1].shape
1
2
3
4

read 1000 training examples
read 100 validation examples

(torch.Size([32, 3, 256, 256]), torch.Size([32, 1, 5]))

6.3 演示

让我们展示 $10$ 幅带有真实边界框的图像。我们可以看到在所有这些图像中香蕉的旋转角度、大小和位置都有所不同。当然，这只是一个简单的人工数据集，实践中真实世界的数据集通常要复杂得多。

imgs = (batch[0][0:10].permute(0, 2, 3, 1)) / 255
axes = d2l.show_images(imgs, 2, 5, scale=2)
for ax, label in zip(axes, batch[1][0:10]):
    d2l.show_bboxes(ax, [label[0][1:5] * edge_size], colors=['w'])
1
2
3
4

6.4 小结

• 我们收集的香蕉检测数据集可用于演示目标检测模型。
• 用于目标检测的数据加载与图像分类的数据加载类似。但是，在目标检测中，标签还包含真实边界框的信息，它不出现在图像分类中。

7. 单发多框检测（SSD）

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

7.1 模型

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

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

单发多框检测模型主要由一个基础网络块和若干多尺度特征块串联而成。

在下面，我们将介绍该图中不同块的实施细节。首先，我们将讨论如何实施类别和边界框预测。

7.1.1 类别预测层

分别为 $h$ 和 $w$ 。如果以其中每个单元为中心生成 $a$ 个锚框，那么我们需要对 $hwa$ 个锚框进行分类。如果使用全连接层作为输出, 很容易导致模型参数过多。回忆 7.3节一节介绍的使用卷积层的通道来输出类别预测的方法，单发多框检测采用同样的方法来降低模型复杂度。

具体来说，类别预测层使用一个保持输入高和宽的卷积层。这样一来，输出和输入在特征图宽和高上的空间坐标一一对应。考虑输出和输入同一空间坐标 $(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


def cls_predictor(num_inputs, num_anchors, num_classes):
    return nn.Conv2d(num_inputs, num_anchors * (num_classes + 1),
                     kernel_size=3, padding=1)
1
2
3
4
5
6
7
8
9
10
11

7.1.2 边界框预测层

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

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

7.1.3 连结多尺度的预测

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

在以下示例中，我们为同一个小批量构建两个不同比例（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
1
2
3
4
5
6

(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)
1
2
3
4
5

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

concat_preds([Y1, Y2]).shape
1

torch.Size([2, 25300])

7.1.4 高和宽减半块

为了在多个尺度下检测目标，我们在下面定义了高和宽减半块 down_sample_blk，该模块将输入特征图的高度和宽度减半。事实上，该块应用了在 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$ 的感受野。因此，高和宽减半块会扩大每个单元在其输出特征图中的感受野。

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)
1
2
3
4
5
6
7
8
9
10

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

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

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

7.1.5 基本网络块

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

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
1
2
3
4
5
6
7
8

torch.Size([2, 64, 32, 32])

7.1.6 完整的模型

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

现在我们为每个块定义前向传播。与图像分类任务不同，此处的输出包括：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)
1
2
3
4
5
6

回想一下，在上图中，一个较接近顶部的多尺度特征块是用于检测较大目标的，因此需要生成更大的锚框。在上面的前向传播中，在每个多尺度特征块上，我们通过调用的 multibox_prior 函数（见第四节）的 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$ 等给出。

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
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26

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

如本节前面部分所示，第一个模块输出特征图的形状为 $32\times 32$ 。回想一下，第二到第四个模块为高和宽减半块，第五个模块为全局汇聚层。由于以特征图的每个单元为中心有 $4$ 个锚框生成，因此在所有五个尺度下，每个图像总共生成 $\left(32^2+16^2+8^2+4^2+1\right)\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)
1
2
3
4
5
6
7

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.8/site-packages/torch/functional.py:568: 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:2228.)
return _VF.meshgrid(tensors, **kwargs) # type: ignore[attr-defined]

7.2 训练模型

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

7.2.1 读取数据集和初始化

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

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

Downloading …/data/banana-detection.zip from http://d2l-data.s3-accelerate.amazonaws.com/banana-detection.zip…
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)
1
2

7.2.2 定义损失函数和评价函数

目标检测有两种类型的损失。第一种有关锚框类别的损失：我们可以简单地复用之前图像分类问题里一直使用的交叉熵损失函数来计算；第二种有关正类锚框偏移量的损失：预测偏移量是一个回归问题。但是，对于这个回归问题，我们在这里不使用之前描述的平方损失，而是使用 $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):
    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
1
2
3
4
5
6
7
8
9
10

我们可以沿用准确率评价分类结果。由于偏移量使用了 $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())
1
2
3
4
5
6
7

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)}')
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30

class err 3.29e-03, bbox mae 3.18e-03
6280.8 examples/sec on cuda:0

7.3 预测目标

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

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

使用下面的 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)
1
2
3
4
5
6
7
8
9

最后，我们筛选所有置信度不低于 $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)
1
2
3
4
5
6
7
8
9
10
11
12

7.4 小结

• 单发多框检测是一种多尺度目标检测模型。基于基础网络块和各个多尺度特征块，单发多框检测生成不同数量和不同大小的锚框，并通过预测这些锚框的类别和偏移量检测不同大小的目标。
• 在训练单发多框检测模型时，损失函数是根据锚框的类别和偏移量的预测及标注值计算得出的。

8. 区域卷积神经网络（R-CNN）系列

除了上一节中描述的单发多框检测之外，区域卷积神经网络（region-based CNN或regions with CNN features，R-CNN） [Girshick et al., 2014]也是将深度模型应用于目标检测的开创性工作之一。在本节中，我们将介绍 R-CNN 及其一系列改进方法：快速的 R-CNN（Fast R-CNN） [Girshick, 2015]、更快的 R-CNN（Faster R-CNN） [Ren et al., 2015] 和 掩码 R-CNN（Mask R-CNN） [He et al., 2017]。限于篇幅，我们只着重介绍这些模型的设计思路。

8.1 R-CNN

R-CNN 首先从输入图像中选取若干（例如2000个）提议区域（如锚框也是一种选取方法），并标注它们的类别和边界框（如偏移量）。[Girshick et al., 2014] 然后，用卷积神经网络对每个提议区域进行前向传播以抽取其特征。接下来，我们用每个提议区域的特征来预测类别和边界框。

R-CNN模型

上图展示了 R-CNN 模型。具体来说，R-CNN 包括以下四个步骤：

1. 对输入图像使用选择性搜索来选取多个高质量的提议区域 [Uijlings et al., 2013]。这些提议区域通常是在多个尺度下选取的，并具有不同的形状和大小。每个提议区域都将被标注类别和真实边界框。
2. 选择一个预训练的卷积神经网络，并将其在输出层之前截断。将每个提议区域变形为网络需要的输入尺寸，并通过前向传播输出抽取的提议区域特征。
3. 将每个提议区域的特征连同其标注的类别作为一个样本。训练多个支持向量机对目标分类，其中每个支持向量机用来判断样本是否属于某一个类别。
4. 将每个提议区域的特征连同其标注的边界框作为一个样本，训练线性回归模型来预测真实边界框。

尽管 R-CNN 模型通过预训练的卷积神经网络有效地抽取了图像特征，但它的速度很慢。想象一下，我们可能从一张图像中选出上千个提议区域，这需要上千次的卷积神经网络的前向传播来执行目标检测。这种庞大的计算量使得 R-CNN 在现实世界中难以被广泛应用。

8.2 Fast R-CNN

R-CNN 的主要性能瓶颈在于，对每个提议区域，卷积神经网络的前向传播是独立的，而没有共享计算。由于这些区域通常有重叠，独立的特征抽取会导致重复的计算。Fast R-CNN 对 R-CNN 的主要改进之一，是仅在整张图象上执行卷积神经网络的前向传播。

R-CNN模型

上图中描述了 Fast R-CNN 模型。它的主要计算如下：

1. 与 R-CNN 相比，Fast R-CNN 用来提取特征的卷积神经网络的输入是整个图像，而不是各个提议区域。此外，这个网络通常会参与训练。设输入为一张图像，将卷积神经网络的输出的形状记为 $1\times c\times h_1\times w_1$。
2. 假设选择性搜索生成了 $n$ 个提议区域。这些形状各异的提议区域在卷积神经网络的输出上分别标出了形状 各异的兴趣区域。然后，这些感兴趣的区域需要进一步抽取出形状相同的特征（比如指定高度 $h_2$ 和宽度 $w_2$ ），以便于连结后输出。为了实现这一目标，Fast R-CNN 引入了兴趣区域汇聚层（Rol pooling）：将卷积神经网络的输出和提议区域作为输入，输出连结后的各个提议区域抽取的特征，形状为 $n\times c\times h_2\times w_2$。
3. 通过全连接层将输出形状变换为 $n\times d$，其中超参数 $d$ 取决于模型设计。
4. 预测 $n$ 个提议区域中每个区域的类别和边界框。更具体地说，在预测类别和边界框时，将全连接层的输出分别转换为形状为 $n\times q$ ( $q$ 是类别的数量）的输出和形状为 $n\times 4$ 的输出。其中预测类别时使用 $softmax$ 回归。

在 Fast R-CNN 中提出的兴趣区域汇聚层与之前介绍的汇聚（池化）层有所不同。在汇聚层中，我们通过设置汇聚窗口、填充和步幅的大小来间接控制输出形状。而兴趣区域汇聚层对每个区域的输出形状是可以直接指定的。

例如，指定每个区域输出的高和宽分别为 $h_2$ 和 $w_2$ 。对于任何形状为 $h\times w$ 的兴趣区域窗口，该窗口将被划分为 $h_2\times w_2$ 子窗口网格，其中每个子窗口的大小约为 $\left(h/h_2\right)\times \left(w/w_2\right)$ 。在实践中，任何子窗口的高度和宽度都 应向上取整，其中的最大元素作为该子窗口的输出。因此，兴趣区域汇聚层可从形状各异的兴趣区域中均抽取出形状相同的特征。

作为说明性示例，下图中提到，在 $4\times 4$ 的输入中，我们选取了左上角 $3\times 3$ 的兴趣区域。对于该兴趣区域，我们通过 $2\times 2$ 的兴趣区域汇聚层得到一个 $2\times 2$ 的输出。请注意，四个划分后的子窗口中分别含有元素 0、1、4、5（5最大)； 2、6（6最大)；8、9（9最大)；以及 10。

一个 $2\times 2$ 的兴趣区域汇聚层

下面，我们演示了兴趣区域汇聚层的计算方法。假设卷积神经网络抽取的特征 X 的高度和宽度都是4，且只有单通道。

import torch
import torchvision

X = torch.arange(16.).reshape(1, 1, 4, 4)
X
1
2
3
4
5

tensor([[[[ 0., 1., 2., 3.],
          [ 4., 5., 6., 7.],
          [ 8., 9., 10., 11.],
          [12., 13., 14., 15.]]]])

让我们进一步假设输入图像的高度和宽度都是 $40$ 像素，且选择性搜索在此图像上生成了两个提议区域。每个区域由 $5$ 个元素表示：区域目标类别、左上角和右下角的$(x,y)$坐标。

rois = torch.Tensor([[0, 0, 0, 20, 20], [0, 0, 10, 30, 30]])
1

由于X的高和宽是输入图像高和宽的 $1/10$，因此，两个提议区域的坐标先按 spatial_scale 乘以 $0.1$。 然后，在X上分别标出这两个兴趣区域 X[:, :, 0:3, 0:3] 和 X[:, :, 1:4, 0:4]。 最后，在 $2\times 2$ 的兴趣区域汇聚层中，每个兴趣区域被划分为子窗口网格，并进一步抽取相同形状 $2\times 2$ 的特征。

torchvision.ops.roi_pool(X, rois, output_size=(2, 2), spatial_scale=0.1)
1

tensor([[[[ 5., 6.],
          [ 9., 10.]]],

        [[[ 9., 11.],
          [13., 15.]]]])

8.3 Faster R-CNN

为了较精确地检测目标结果，Fast R-CNN 模型通常需要在选择性搜索中生成大量的提议区域。Faster R-CNN 提出将选择性搜索替换为区域提议网络（region proposal network），从而减少提议区域的生成数量，并保证目标检测的精度。

Faster R-CNN 模型

上图描述了 Faster R-CNN 模型。与 Fast R-CNN 相比，Faster R-CNN 只将生成提议区域的方法从选择性搜索改为了区域提议网络，模型的其余部分保持不变。具体来说，区域提议网络的计算步骤如下：

1. 使用填充为 $1$ 的 $3\times 3$ 的卷积层变换卷积神经网络的输出，并将输出通道数记为 $c$。这样，卷积神经网络为图像抽取的特征图中的每个单元均得到一个长度为 $c$ 的新特征。
2. 以特征图的每个像素为中心，生成多个不同大小和宽高比的锚框并标注它们。
3. 使用锚框中心单元长度为 $c$ 的特征，分别预测该锚框的二元类别（含目标还是背景）和边界框。
4. 使用非极大值抑制，从预测类别为目标的预测边界框中移除相似的结果。最终输出的预测边界框即是兴趣区域汇聚层所需的提议区域。

值得一提的是，区域提议网络作为 Faster R-CNN 模型的一部分，是和整个模型一起训练得到的。换句话说，Faster R-CNN 的目标函数不仅包括目标检测中的类别和边界框预测，还包括区域提议网络中锚框的二元类别和边界框预测。作为端到端训练的结果，区域提议网络能够学习到如何生成高质量的提议区域，从而在减少了从数据中学习的提议区域的数量的情况下，仍保持目标检测的精度。

8.4 Mask R-CNN

如果在训练集中还标注了每个目标在图像上的像素级位置，那么 Mask R-CNN 能够有效地利用这些详尽的标注信息进一步提升目标检测的精度。

Mask R-CNN 模型

如上图所示，Mask R-CNN 是基于 Faster R-CNN 修改而来的。具体来说，Mask R-CNN 将兴趣区域汇聚层替换为了兴趣区域对齐层，使用双线性插值（bilinear interpolation）来保留特征图上的空间信息，从而更适于像素级预测。兴趣区域对齐层的输出包含了所有与兴趣区域的形状相同的特征图。它们不仅被用于预测每个兴趣区域的类别和边界框，还通过额外的全卷积网络预测目标的像素级位置。本章的后续章节将更详细地介绍如何使用全卷积网络预测图像中像素级的语义。

8.5 小结

• R-CNN 对图像选取若干提议区域，使用卷积神经网络对每个提议区域执行前向传播以抽取其特征，然后再用这些特征来预测提议区域的类别和边界框。
• Fast R-CNN 对 R-CNN 的一个主要改进：只对整个图像做卷积神经网络的前向传播。它还引入了兴趣区域汇聚层，从而为具有不同形状的兴趣区域抽取相同形状的特征。
• Faster R-CNN 将 Fast R-CNN 中使用的选择性搜索替换为参与训练的区域提议网络，这样后者可以在减少提议区域数量的情况下仍保证目标检测的精度。
• Mask R-CNN 在 Faster R-CNN 的基础上引入了一个全卷积网络，从而借助目标的像素级位置进一步提升目标检测的精度。

9. 语义分割和数据集

在第三节到第八节中讨论的目标检测问题中，我们一直使用方形边界框来标注和预测图像中的目标。本节将探讨语义分割（semantic segmentation）问题，它重点关注于如何将图像分割成属于不同语义类别的区域。与目标检测不同，语义分割可以识别并理解图像中每一个像素的内容：其语义区域的标注和预测是像素级的。下图展示了语义分割中图像有关狗、猫和背景的标签。与目标检测相比，语义分割标注的像素级的边框显然更加精细。

语义分割中图像有关狗、猫和背景的标签

9.1 图像分割和实例分割

计算机视觉领域还有 $2$ 个与语义分割相似的重要问题，即图像分割（image segmentation）和实例分割（instance segmentation）。我们在这里将它们同语义分割简单区分一下。

• 图像分割将图像划分为若干组成区域，这类问题的方法通常利用图像中像素之间的相关性。它在训练时不需要有关图像像素的标签信息，在预测时也无法保证分割出的区域具有我们希望得到的语义。以上图中的图像作为输入，图像分割可能会将狗分为两个区域：一个覆盖以黑色为主的嘴和眼睛，另一个覆盖以黄色为主的其余部分身体。
• 实例分割也叫同时检测并分割（simultaneous detection and segmentation），它研究如何识别图像中各个目标实例的像素级区域。与语义分割不同，实例分割不仅需要区分语义，还要区分不同的目标实例。例如，如果图像中有两条狗，则实例分割需要区分像素属于的两条狗中的哪一条。(语义分割只是将两条狗都分出来是狗，还可能连着)

9.2 Pascal VOC2012 语义分割数据集

最重要的语义分割数据集之一是 Pascal VOC2012。下面我们深入了解一下这个数据集。

%matplotlib inline
import os
import torch
import torchvision
from d2l import torch as d2l
1
2
3
4
5

数据集的tar文件大约为 2GB，所以下载可能需要一段时间。提取出的数据集位于 …/data/VOCdevkit/VOC2012。

#@save
d2l.DATA_HUB['voc2012'] = (d2l.DATA_URL + 'VOCtrainval_11-May-2012.tar',
                           '4e443f8a2eca6b1dac8a6c57641b67dd40621a49')

voc_dir = d2l.download_extract('voc2012', 'VOCdevkit/VOC2012')
1
2
3
4
5

Downloading …/data/VOCtrainval_11-May-2012.tar from http://d2l-data.s3-accelerate.amazonaws.com/VOCtrainval_11-May-2012.tar…

进入路径 …/data/VOCdevkit/VOC2012 之后，我们可以看到数据集的不同组件。ImageSets/Segmentation 路径包含用于训练和测试样本的文本文件，而 JPEGImages 和 SegmentationClass 路径分别存储着每个示例的输入图像和标签。此处的标签也采用图像格式，其尺寸和它所标注的输入图像的尺寸相同。此外，标签中颜色相同的像素属于同一个语义类别。下面将 read_voc_images 函数定义为将所有输入的图像和标签读入内存。

#@save
def read_voc_images(voc_dir, is_train=True):
    """读取所有VOC图像并标注"""
    txt_fname = os.path.join(voc_dir, 'ImageSets', 'Segmentation',
                             'train.txt' if is_train else 'val.txt')
    mode = torchvision.io.image.ImageReadMode.RGB
    with open(txt_fname, 'r') as f:
        images = f.read().split()
    features, labels = [], []
    for i, fname in enumerate(images):
        features.append(torchvision.io.read_image(os.path.join(
            voc_dir, 'JPEGImages', f'{fname}.jpg')))
        labels.append(torchvision.io.read_image(os.path.join(
            voc_dir, 'SegmentationClass' ,f'{fname}.png'), mode))
    return features, labels

train_features, train_labels = read_voc_images(voc_dir, True)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

下面我们绘制前 $5$ 个输入图像及其标签。 在标签图像中，白色和黑色分别表示边框和背景，而其他颜色则对应不同的类别。

n = 5
imgs = train_features[0:n] + train_labels[0:n]
imgs = [img.permute(1,2,0) for img in imgs]
d2l.show_images(imgs, 2, n);
1
2
3
4

接下来，我们列举 RGB 颜色值和类名。

#@save
VOC_COLORMAP = [[0, 0, 0], [128, 0, 0], [0, 128, 0], [128, 128, 0],
                [0, 0, 128], [128, 0, 128], [0, 128, 128], [128, 128, 128],
                [64, 0, 0], [192, 0, 0], [64, 128, 0], [192, 128, 0],
                [64, 0, 128], [192, 0, 128], [64, 128, 128], [192, 128, 128],
                [0, 64, 0], [128, 64, 0], [0, 192, 0], [128, 192, 0],
                [0, 64, 128]]

#@save
VOC_CLASSES = ['background', 'aeroplane', 'bicycle', 'bird', 'boat',
               'bottle', 'bus', 'car', 'cat', 'chair', 'cow',
               'diningtable', 'dog', 'horse', 'motorbike', 'person',
               'potted plant', 'sheep', 'sofa', 'train', 'tv/monitor']
1
2
3
4
5
6
7
8
9
10
11
12
13

通过上面定义的两个常量，我们可以方便地查找标签中每个像素的类索引。我们定义了 voc_colormap2label 函数来构建从上述 RGB 颜色值到类别索引的映射，而 voc_label_indices 函数将 RGB 值映射到在 Pascal VOC2012 数据集中的类别索引。

#@save
def voc_colormap2label():
    """构建从RGB到VOC类别索引的映射"""
    colormap2label = torch.zeros(256 ** 3, dtype=torch.long)
    for i, colormap in enumerate(VOC_COLORMAP):
        colormap2label[
            (colormap[0] * 256 + colormap[1]) * 256 + colormap[2]] = i
    return colormap2label

#@save
def voc_label_indices(colormap, colormap2label):
    """将VOC标签中的RGB值映射到它们的类别索引"""
    colormap = colormap.permute(1, 2, 0).numpy().astype('int32')
    idx = ((colormap[:, :, 0] * 256 + colormap[:, :, 1]) * 256
           + colormap[:, :, 2])
    return colormap2label[idx]
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

例如，在第一张样本图像中，飞机头部区域的类别索引为 $1$，而背景索引为 $0$。

y = voc_label_indices(train_labels[0], voc_colormap2label())
y[105:115, 130:140], VOC_CLASSES[1]
1
2

(tensor([[0, 0, 0, 0, 0, 0, 0, 0, 0, 1],
         [0, 0, 0, 0, 0, 0, 0, 1, 1, 1],
         [0, 0, 0, 0, 0, 0, 1, 1, 1, 1],
         [0, 0, 0, 0, 0, 1, 1, 1, 1, 1],
         [0, 0, 0, 0, 0, 1, 1, 1, 1, 1],
         [0, 0, 0, 0, 1, 1, 1, 1, 1, 1],
         [0, 0, 0, 0, 0, 1, 1, 1, 1, 1],
         [0, 0, 0, 0, 0, 1, 1, 1, 1, 1],
         [0, 0, 0, 0, 0, 0, 1, 1, 1, 1],
         [0, 0, 0, 0, 0, 0, 0, 0, 1, 1]]),
‘aeroplane’)

9.2.1 预处理数据

在之前的实验，我们有通过再缩放图像使其符合模型的输入形状。然而在语义分割中，这样做需要将预测的像素类别重新映射回原始尺寸的输入图像。这样的映射可能不够精确，尤其在不同语义的分割区域。
为了避免这个问题，我们将图像裁剪为固定尺寸，而不是再缩放。具体来说，我们使用图像增广中的随机裁剪，裁剪输入图像和标签的相同区域。

#@save
def voc_rand_crop(feature, label, height, width):
    """随机裁剪特征和标签图像"""
    rect = torchvision.transforms.RandomCrop.get_params(
        feature, (height, width))
    feature = torchvision.transforms.functional.crop(feature, *rect)
    label = torchvision.transforms.functional.crop(label, *rect)
    return feature, label

imgs = []
for _ in range(n):
    imgs += voc_rand_crop(train_features[0], train_labels[0], 200, 300)

imgs = [img.permute(1, 2, 0) for img in imgs]
d2l.show_images(imgs[::2] + imgs[1::2], 2, n);
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

9.2.2 自定义语义分割数据集类

我们通过继承高级API提供的Dataset类，自定义了一个语义分割数据集类VOCSegDataset。通过实现__getitem__函数，我们可以任意访问数据集中索引为idx的输入图像及其每个像素的类别索引。由于数据集中有些图像的尺寸可能小于随机裁剪所指定的输出尺寸，这些样本可以通过自定义的filter函数移除掉。此外，我们还定义了normalize_image函数，从而对输入图像的RGB三个通道的值分别做标准化。

#@save
class VOCSegDataset(torch.utils.data.Dataset):
    """一个用于加载VOC数据集的自定义数据集"""

    def __init__(self, is_train, crop_size, voc_dir):
        self.transform = torchvision.transforms.Normalize(
            mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225])
        self.crop_size = crop_size
        features, labels = read_voc_images(voc_dir, is_train=is_train)
        self.features = [self.normalize_image(feature)
                         for feature in self.filter(features)]
        self.labels = self.filter(labels)
        self.colormap2label = voc_colormap2label()
        print('read ' + str(len(self.features)) + ' examples')

    def normalize_image(self, img):
        return self.transform(img.float() / 255)

    def filter(self, imgs):
        return [img for img in imgs if (
            img.shape[1] >= self.crop_size[0] and
            img.shape[2] >= self.crop_size[1])]

    def __getitem__(self, idx):
        feature, label = voc_rand_crop(self.features[idx], self.labels[idx],
                                       *self.crop_size)
        return (feature, voc_label_indices(label, self.colormap2label))

    def __len__(self):
        return len(self.features)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30

9.2.3 读取数据集

我们通过自定义的 VOCSegDataset 类来分别创建训练集和测试集的实例。假设我们指定随机裁剪的输出图像的形状为 $320\times 480$，下面我们可以查看训练集和测试集所保留的样本个数。

crop_size = (320, 480)
voc_train = VOCSegDataset(True, crop_size, voc_dir)
voc_test = VOCSegDataset(False, crop_size, voc_dir)
1
2
3

read 1114 examples
read 1078 examples

设批量大小为 $64$，我们定义训练集的迭代器。打印第一个小批量的形状会发现：与图像分类或目标检测不同，这里的标签是一个三维数组。

batch_size = 64
train_iter = torch.utils.data.DataLoader(voc_train, batch_size, shuffle=True,
                                    drop_last=True,
                                    num_workers=d2l.get_dataloader_workers())
for X, Y in train_iter:
    print(X.shape)
    print(Y.shape)
    break
1
2
3
4
5
6
7
8

torch.Size([64, 3, 320, 480])
torch.Size([64, 320, 480])

9.2.4 整合所有组件

最后，我们定义以下 load_data_voc 函数来下载并读取 Pascal VOC2012 语义分割数据集。它返回训练集和测试集的数据迭代器。

#@save
def load_data_voc(batch_size, crop_size):
    """加载VOC语义分割数据集"""
    voc_dir = d2l.download_extract('voc2012', os.path.join(
        'VOCdevkit', 'VOC2012'))
    num_workers = d2l.get_dataloader_workers()
    train_iter = torch.utils.data.DataLoader(
        VOCSegDataset(True, crop_size, voc_dir), batch_size,
        shuffle=True, drop_last=True, num_workers=num_workers)
    test_iter = torch.utils.data.DataLoader(
        VOCSegDataset(False, crop_size, voc_dir), batch_size,
        drop_last=True, num_workers=num_workers)
    return train_iter, test_iter
1
2
3
4
5
6
7
8
9
10
11
12
13

9.3 小结

• 语义分割通过将图像划分为属于不同语义类别的区域，来识别并理解图像中像素级别的内容。
• 语义分割的一个重要的数据集叫做 Pascal VOC2012。
• 由于语义分割的输入图像和标签在像素上一一对应，输入图像会被随机裁剪为固定尺寸而不是缩放。