[人工智能]动手深度学习13——计算机视觉（数据增广、微调、锚框目标检测）

一、数据增广

参考李沐《动手深度学习》、哔哩哔哩视频

1.1 为何进行数据增广？

1. CES真实案例：
   几年前，一家做无人售货的公司发现演示机器在现场的效果很差，因为现场在赌城拉斯维加斯，现场与之前的开发测试办公室：

• 色温不同。赌城灯光很暗，偏黄
• 测试demo时机器放在桌子上，桌子很亮，反射后图片取景有变化

解决：开场前一天现场测试有问题，马上现场采集数据发回国内，训练一个新的模型，并且买了一块桌布就没有反光了。

例如语音识别、CV等场景，训练模型时可以模拟部署场景的各种情况，是提高模型泛化性的一种手段。

2. 数据增广的优点：

• 数据增?可以?成相似但不同的训练样本，从?扩?了训练集的规模，增加数据多样性。
• 此外，随机改变训练样本可以减少模型对某些属性的依赖，从?提?模型的泛化能?。例如，我们可以以不同的?式裁剪图像，使感兴趣的对象出现在不同的位置，减少模型对于对象出现位置的依赖。我们还可以调整亮度、颜?等因素来降低模型对颜?的敏感度
• 增广方式：语音中加入不同背景音，图片可以改变颜色、亮度和形状等。

一般的做法是图片进行随机在线数据增广之后再进行训练，相当于一个正则项。

3. 软件安装：

pip install torch==1.10.2
pip install torchvision==0.11.3
pip install d2l==0.17.4

1.2 常见图片增广方式

%matplotlib inline
import torch
import torchvision
from torch import nn
from d2l import torch as d2l

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

定义辅助函数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)]#对num_rows * num_cols的图片进行增广存储到Y
    d2l.show_images(Y, num_rows, num_cols, scale=scale)#打印出增广后的图片

img：被增广图片
aug：增广办法
num_rows、num_cols：图片被增广成几行几列
scale：放大比例

1.2.1 翻转

• 图片可以左右、上下翻转，但不一定总是可行。比如树叶可以上下翻转，但是建筑上下翻转就很奇怪，所以要根据样本来决定。
• 使?transforms模块来创建RandomFlipLeftRight实例，这样就各有50%的?率使图像向左或向右翻转

apply(img,torchvision.transforms.RandomHorizontalFlip())#随机左右翻转

apply(img, torchvision.transforms.RandomVerticalFlip())#随机上下翻转

1.2.2 切割（裁剪）

从原图切割一块，再变形到固定形状（卷积网络固定输入）。切割方式可以是随机高宽比、随机大小、随机位置。

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

• (200, 200)：裁剪后resize到200*200像素（卷积网络输入是固定的）
• scale（0.1,1）：随机裁剪?个?积为原始?积10%到100%的区域
• ratio=(0.5, 2))：裁剪区域的宽??从0.5到2之间随机取值
  

1.2.3 改变颜色

主要是改变色调（偏黄偏蓝等等）、饱和度（浓度）、亮度等等。创建一个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)

#brightness=0.5表示明度在50%-150%之间随机变化，其它参数类同
#四个参数随机取值组合决定图片变化

1.2.4 综合使用

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

shape_aug = torchvision.transforms.RandomResizedCrop(
    (200, 200), scale=(0.1, 1), ratio=(0.5, 2))
color_aug = torchvision.transforms.ColorJitter(
    brightness=0.2, contrast=0, saturation=0.2, hue=0.05)

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

• 还可以有其它方式，比如高斯模糊、锐化、图片中间去块等等。但不是每一种都有用。如果测试集或者部署环境中没有那些奇怪的图片，某些方法可以不用。所以是应该先考虑测试集、部署环境中图片会有哪些变化，再考虑图片增广应该使用哪些方法。

1.3 使用图像增广进行训练

我们使?CIFAR-10数据集进行图像增广之后再训练模型。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);

• 为了在预测过程中得到确切的结果，我们通常对训练样本只进行图像增广，且在预测过程中不使用随机操作的图像增广。在这里，我们[只使用最简单的随机左右翻转]。（因为图片已经在最中间了，且比较小，大概32*32。且训练测试集亮度颜色差不多，不需要做太厉害的增广）
• 此外，我们使用ToTensor实例将一批图像转换为4d的Tensor矩阵方便训练，即形状为（批量大小，通道数，高度，宽度）的32位浮点数，取值范围为0到1。

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

test_augs = torchvision.transforms.Compose([
     torchvision.transforms.ToTensor()])

2. 生成数据集
   接下来，我们[定义一个辅助函数，以便于读取图像和应用图像增广]。PyTorch数据集提供的transform函数应用图像增广来转化图像：

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

这里的d2l.get_dataloader_workers()=4，多开进程是因为图片随机增广的时候计算量很大，开多进程可以快一点。

3. 定义模型
   我们在CIFAR-10数据集上训练一个多GPU的ResNet-18模型：

#@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]#如果X是list就一个个copy到devices
    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)}')

4. 增广训练
   定义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_augs
    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)

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

train_with_data_aug(train_augs, test_augs, net)

loss 0.167, train acc 0.943, test acc 0.843
5486.0 examples/sec on [device(type='cuda', index=0), device(type='cuda', index=1)]

不用图像增广，效果：

loss 0.072, train acc 0.975, test acc 0.824
5560.0 examples/sec on [device(type='cuda', index=0), device(type='cuda', index=1)]

对比可以看到，简单翻转图片可以有效降低过拟合程度（训练测试集精度差异更小，overfiting更小）。有些情况下测试集精度高于训练集精度，是由于训练集图片增广太狠，出现很多奇怪的图片，精度下降。而测试集中图片不会那么奇怪，效果反而更好。

1.4 小结

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

二、微调

参考李沐《动手深度学习》、哔哩哔哩视频

2.1 为啥要微调

• 实际工作中，我们训练的模型数据集大小通常在Fashion-MNIST（6万张）训练数据集和ImageNet（120万张）数据集之间。假如我们需要训练一个识别车的模型，适合ImageNet的复杂模型可能会在这个汽车数据集上过拟合（汽车数据集多样性比ImageNet小）。
• 此外，由于训练样本数量有限，训练模型的准确性可能无法满足实际要求。
  
  解决方案有两种：

1. 收集更多的数据。 但是，收集和标记数据可能需要大量的时间和金钱。 例如，为了收集ImageNet数据集，研究人员花费了数百万美元的研究资金。 尽管目前的数据收集成本已大幅降低，但这一成本仍不能忽视。

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

2.2 微调（fine-tuning）步骤

当目标数据集比源数据集小得多时，微调有助于提高模型的泛化能力。（其实相当于用源模型的参数作为目标模型的参数初始化，这样比目标模型随机初始化效果好。而输出层是随机初始化来训练）

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

• 源数据集可能包含目标数据集中的某些类别，这些样本可以加入目标数据集一起初始化。（在初始化期间使用来自预训练模型的相应权重向量）
• 在已有神经网络上微调目标数据集，但具有强大的正则化
  • 使用较小的学习率
  • 使用较少的迭代周期
• 如果源数据集比目标数据集更复杂，则微调通常会得到更高质量的模型

• 神经网络学习分层特征表示
  • 低层特征是通用的（底层权重可以固定，模型复杂度变低，数据集小的时候相当于正则）
  • 高层特征与数据集中的对象更相关
• 在微调期间修复底层的参数
  • 另一个强有力的正则

2.3 总结

• 微调通过使用在大数据集上训练好的模型，来初始化目标模型权重以得到更好的精度
• 预训练模型质量很重要
• 微调通常速度更快，精度更高
• 以后学术界或者大公司才会从头训练大的深度学习模型，慢慢的几乎所有基于深度学习的应用都会基于微调。
• 如果目标数据集和源数据集差异非常大，那么从头训练目标数据集效果可能更好。或者医学的就找医学的预训练模型。

2.4 代码举例

参考《13.2. 微调》

简介：热狗数据集有正负两类，预下载在ImageNet上训练好的resnet-18模型，然后在热狗数据集上微调。微调时，最后一个fc层学习率为10*lr，其它层学习率为lr，最后效果很好。（基本2个epoch效果就很好了，lr=5e-5比较小）

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

注意：

• 因为在ImageNet上做了RGB三通道标准化，所以热狗数据集也要做这一步。（如果网络中有BN就不需要这么做了）
• ImageNet输入是224*224，所以热狗数据集图片也要resize到224
• 数据增强只用简单的水平翻转

三、目标检测

参考李沐《动手深度学习》、哔哩哔哩视频

3.1 目标检测简介

计算机视觉中除了图片分类，还有一类任务：目标检测（object detection）或目标识别（object recognition）。

• 图片分类一般默认图片中只有一个主体，而目标检测任务中，图片通常含有多个主体。不仅想知道它们的类别，还想得到它们在图像中的具体位置。
• 在目标检测中，我们通常使用边界框（bounding box）来描述对象的空间位置。边界框是矩形的，表示方式有三种：
  • （左上x，左上y，右下x，右下y）
  • （左上x，左上y，宽，高）
  • （中心x，中心y，宽，高）
• 目标检测数据集的常见表示：每一行表示一个物体，对于每一个物体而言，用“图片文件名，物体类别，边缘框”表示，由于边缘框用4个数值表示，因此对于每一行的那一个物体而言，需要用6个数值表示。
• 目标检测领域常用数据集：COCO（80类物体，330K图片，所有图片共标注1.5M物体）

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

%matplotlib inline
import torch
from d2l import torch as d2l

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

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

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

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

我们可以[将边界框在图中画出]，以检查其是否准确。 画之前，我们定义一个辅助函数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)

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

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

我们还可以在两种常用的边界框表示（中间，宽度，高度）和（左上，右下）坐标之间进行转换。

#@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

3.2 目标检测数据集

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

1. 下载数据集

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

%matplotlib inline
import os
import pandas as pd
from mxnet import gluon, image, np, npx
from d2l import mxnet as d2l

npx.set_np()

#@save
d2l.DATA_HUB['banana-detection'] = (
    d2l.DATA_URL + 'banana-detection.zip',
    '5de26c8fce5ccdea9f91267273464dc968d20d72')

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
    #返回图片和标签tensor。/256是除以高宽（图片是256*256），得到一个0-1的数

label.csv格式如下：

读出来csv_data数据集格式如下：

• 通过使用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)

• 最后，我们定义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

• 让我们读取一个小批量，并打印其中的图像和标签的形状。 图像的小批量batch[0]的形状为（批量大小、通道数、高度、宽度）这与我们之前图像分类任务中的相同。 标签的小批量batch[1]的形状为（批量大小，m，5），其中m是数据集的任何图像中边界框可能出现的最大数量。
• 通常来说，图像可能拥有不同数量的主体，则有不同数据的边界框，这样会造成每个批量标签不一样。所以限制每张图片主体最多有m个。
• 对于不到m个主体的图像将被非法边界框填充。这样，每个边界框的标签将被长度为5的数组表示， 即[𝑙𝑎𝑏𝑒𝑙,𝑥𝑚𝑖𝑛,𝑦𝑚𝑖𝑛,𝑥𝑚𝑎𝑥,𝑦𝑚𝑎𝑥] （坐标值域在0到1之间）。这样每个批次物体数量一样。 对于香蕉数据集而言，由于每张图像上只有一个边界框，因此 𝑚=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

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

让我们展?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'])

3. 小结

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

3.3 锚框

参考李沐《动手深度学习》、哔哩哔哩视频

3.3.1 生成锚框

目标检测算法通常会在输入图像中采样大量的区域，然后判断这些区域中是否包含我们感兴趣的目标，并调整区域边界从而更准确地预测目标的真实边界框（ground-truth bounding box）。主流算法为锚框。即：

• 读取图片，和图片已经标记好的边缘框
• 根据图片生成大量锚框，每个锚框是一个训练样本
• 预测每个锚框是否包含目标物体
• 如果是，则预测从锚框到实际边界框的偏移量

3.3.2 锚框的交并比

交并比（IoU）：对于两个边界框，我们通常将它们的杰卡德系数（Jaccard 系数）称为交并比。给定集A和B：
$$J(\mathcal{A},\mathcal{B})=\frac{\left|\mathcal{A}\cap \mathcal{B}\right|}{\left|\mathcal{A}\cup \mathcal{B}\right|}.$$
交并比的取值范围在0和1之间。0 表示不重叠，1 表示完全相同。

接下来我们会对一张图片生成大量锚框，然后对这些锚框进行标记，即：

• 每个锚框是一个训练样本（要么固定生成，要么根据图片生成）
• 对锚框标记，要么标成背景，要么关联上一个真实的边界框。
• 生成的大量锚框都是负样本。

3.3.3标号锚框的常见算法

如下图，矩阵的列表示标记好的四个真实边界框$A_1$、$A_2$、$A_3$、$A_4$，行表示生成好的锚框$B_1$—-$B_9$。这样我们计算每个边界框和锚框的交并比值，填在矩阵中。

1. 假设矩阵 X 中最大值为$x_{23}$，我们将分配真实边界框 $B_3$ 给锚框 $A_2$（重合度最高）。
2. 丢弃矩阵中第2行和第3列的所有元素，找出剩余阴影部分的最大元素 $x_{71}$，为锚框$A_7$分配真实边界框 $B_1$ 。
3. 丢弃矩阵中第7行和第1列的所有元素，找出剩余阴影部分的最大元素 $x_{54}$，为锚框$A_5$分配真实边界框 $B_4$ 。
4. 最后，丢弃矩阵中第5行和第4列的所有元素，找出剩余阴影部分的最大元素$x_{92}$，为锚框$A_9$分配真实边界框 $B_2$ 。

3.3.4 非极大值抑制NMS（non-maximum suppression）

由于实际中，每张图片会生成很多锚框，其中很多锚框其实是很相似的。所以其实可以把这些相似的锚框合并，删除多余的，保留剩下的锚框。NMS是其中一种合并锚框方法，步骤为：

• 选择所有非背景类锚框的最大预测值对应的锚框A（比如下图蓝色框dog=0.9，预测最相似）
• 删除所有和锚框A交并比大于某个值$\theta$的锚框（删除绿色框和红色框）
• 重复以上过程，直到所有锚框要么被选中，要么被删除（选择紫色框，开始合并。紫色和蓝色不相似，所以上一轮没被删除）
  
  总结：
• 一类目标检测方法基于锚框来预测
• 每个锚框是一个训练样本。在训练集中，我们需要给每个锚框两种类型的标签。一个是预测锚框中是否含有要检测的物体，另一个是锚框相对于边界框的偏移量。
• 预测时，我们可以使用非极大值抑制（NMS）来删除类似的预测边界框，从而简化输出。

四、 目标检测（锚框）代码举例

4.1 锚框算法

4.1.1 以每个像素为中心点生成锚框

??各种目标检测算法，都会研究如何生成高质量的锚框。这里介绍一种简单的生成算法：以每个像素为中心点生成锚框。

??假设输入图像的高度为$h$，宽度为$w$。我们以图像的每个像素为中心生成不同形状的锚框：缩放比为$s\in (0,1]$（即锚框占图片大小的比例），宽高比为$r>0$。那么锚框的宽度和高度分别是$ws\sqrt{r}$和$hs/\sqrt{r}$。
??缩放比scale取值$s_1,\dots ,s_n$,宽高比aspect ratio取值$r_1,\dots ,r_m$。当使用这些比例和长宽比的所有组合以每个像素为中心时，输入图像将总共有$whnm$个锚框，计算复杂性很容易过高。在实践中，我们只考虑包含$s_1$或$r_1$的组合：（$s_1$、$r_1$是最合适的比例）

$$(s_1,r_1),(s_1,r_2),\dots ,(s_1,r_m),(s_2,r_1),(s_3,r_1),\dots ,(s_n,r_1).$$

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

上图中，$s_1$、$r_1$是最合适的缩放比和高宽比。比如下面代码中选取锚框的sizes=[0.75, 0.5, 0.25], ratios=[1, 2, 0.5]。$s_1=0.75$、$r_1=1$是最合适的取值，是一定要选的。

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

%matplotlib inline
import torch
from d2l import torch as d2l

torch.set_printoptions(2)  # 精简输出精度

#@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)
    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)

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

561 728#读取的图片大小
torch.Size([1, 2042040, 4])#（批量大小，锚框的数量，锚框坐标）

将锚框变量Y的形状更改为(h,w,锚框的数量,4)，然后访问以（250,250）为中心的第1个锚框。它有四个元素（xmin,ymin,xmax,ymax），且坐标都分别除以了图像的宽度和高度，所得的值介于0和1之间。

boxes = Y.reshape(h, w, 5, 4)#锚框数量=len（sizes）+len（ratios）-1=5
boxes[250, 250, 0, :]

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

??变量boxes中x轴和y轴的坐标值已分别除以图像的宽度和高度。 绘制锚框时，我们需要恢复它们原始的坐标值。 因此，我们在下面定义了变量bbox_scale。 现在，我们可以绘制出图像中所有以(250,250)为中心的锚框了

d2l.set_figsize()
bbox_scale = torch.tensor((w, h, w, h))
fig = d2l.plt.imshow(img)
#坐标是（xmin,ymin,xmax,ymax）除以了w、h。所以反过来乘以（w,h,w,h）
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'])

4.1.2 计算交并比

?? 给定两个锚框或边界框的列表，以下box_iou函数将在这两个列表中计算它们成对的交并比。

 #@save
def box_iou(boxes1, boxes2):
    """计算两个锚框或边界框列表中成对的交并比"""
    
    #计算box面积
    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

4.1.3 在训练数据中标注锚框

assign_anchor_to_bbox：将真实边界框分配给锚框
??在训练集中，我们将每个锚框视为?个训练样本。为了训练目标检测模型，我们需要每个锚框的类别（class）和偏移量（offset）标签。预测时，我们为每个图像生成多个锚框，预测所有锚框的类别和偏移量，最后只输出符合特定条件的预测边界框。
??定义assign_anchor_to_bbox函数，将真实边界框分配给锚框（参考上面标号锚框的常见算法）：

#@save
def assign_anchor_to_bbox(ground_truth, anchors, device, iou_threshold=0.5):
    """将最接近的真实边界框分配给锚框
   ground_truth：边界框 ，anchors：锚框
   iou_threshold=0.5表示某个锚框和任何其它锚框小于0.5，就把它删掉"""
   
    num_anchors, num_gt_boxes = anchors.shape[0], ground_truth.shape[0]
    # 计算所有锚框和边界框的IoU。位于第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 >= 0.5).reshape(-1)
    box_j = indices[max_ious >= 0.5]
    anchors_bbox_map[anc_i] = box_j
    col_discard = torch.full((num_anchors,), -1)
    row_discard = torch.full((num_gt_boxes,), -1)
    
    #每次找出最大的IoU
    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

offset_boxes：标记偏移量

??假设一个锚框A被分配了一个真实边界框B。那么，锚框A的类别将被标记为与B相同。另外，锚框A的偏移量将根据B和A中心坐标的相对位置以及这两个框的相对位置进行标记（如果是两个框的四个坐标直接相减算偏移，后续不好预测）。给定框A和B，中心坐标分别为$(x_a,y_a)$和$(x_b,y_b)$，宽度分别为$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$。这样做使数值分的比较开，均值方差都比较好做预测。

下面的 offset_boxes 函数中可以实现这种转换。

#@save
def offset_boxes(anchors, assigned_bb, eps=1e-6):
    """对锚框偏移量的转换"""
    c_anc = d2l.box_corner_to_center(anchors)
    c_assigned_bb = d2l.box_corner_to_center(assigned_bb)
    offset_xy = 10 * (c_assigned_bb[:, :2] - c_anc[:, :2]) / c_anc[:, 2:]
    offset_wh = 5 * torch.log(eps + c_assigned_bb[:, 2:] / c_anc[:, 2:])
    offset = torch.cat([offset_xy, offset_wh], axis=1)
    return offset

multibox_target：标记类别和偏移量
??如果一个锚框没有被分配真实边界框，我们只需将锚框的类别标记为“背景”（background）。 背景类别的锚框通常被称为“负类”锚框，其余的被称为“正类”锚框。 我们使用以下multibox_target函数，来标记锚框的类别和偏移量（anchors参数）。 此函数将背景类别的索引设置为零，然后将新类别的整数索引递增一：

#@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)
    #锚框对应真实边界框的偏移量offset，bbox_mask=0表示锚框是背景框，不需要预测类别；
	#bbox_mask=1表示锚框对应一个真实边缘框。class_labels 表示锚框对应的类别

4.2 举例测试

代码见https://zh-v2.d2l.ai/chapter_computer-vision/anchor.html

4.2.1 生成锚框，并用multibox_target标记锚框类别和偏移量

??如下图，我们已经为加载图像中的狗和猫定义了真实边界框（黑色）。第一个元素是类别（0代表狗，1代表猫），其余四个元素是左上角和右下角的 (𝑥,𝑦) 轴坐标（范围介于0和1之间）。 我们还构建了五个锚框$A_0,\dots ,A_4$。然后我们在图像中绘制这些真实边界框和锚框。

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

我们可以使用上面定义的multibox_target函数，根据狗和猫的真实边界框，标注这些锚框的分类和偏移量（背景、狗和猫的类索引分别为0、1和2）。另外我们为锚框和真实边界框样本添加一个维度（批量大小）：

#unsqueeze表示增加一个维度
labels = multibox_target(anchors.unsqueeze(dim=0),
                         ground_truth.unsqueeze(dim=0))

print(labels[0])
print(labels[1])
print(labels[2])

• 上面multibox_target函数最后return (bbox_offset, bbox_mask, class_labels)
• labels[0]包含了为每个锚框标记的四个偏移值。 请注意，负类锚框的偏移量被标记为零
• labels[1]是掩码（mask）变量，形状为（批量大小，锚框数的四倍）。 掩码变量中的元素与每个锚框的4个偏移量一一对应。 由于我们不关心对背景的检测，负类的偏移量不应影响目标函数。 通过元素乘法，掩码变量中的零将在计算目标函数之前过滤掉负类偏移量
• labels[2]表示锚框被标记的类别

#背景类偏移为0
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]])

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

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

具体的，让我们根据图像中的锚框和真实边界框的位置来分析下面返回的类别标签。

• 首先，在所有的锚框和真实边界框配对中，锚框$A_4$与猫的真实边界框的IoU是最大的。因此，$A_4$的类别被标记为猫。
• 去除包含$A_4$或猫的真实边界框的配对，在剩下的配对中，锚框$A_1$和狗的真实边界框有最大的IoU。因此，$A_1$的类别被标记为狗。
• 接下来，我们需要遍历剩下的三个未标记的锚框：$A_0$、$A_2$和$A_3$。
  对于$A_0$，与它拥有最大IoU的真实边界框的类别是狗，但IoU低于预定义的阈值（0.5），因此该类别被标记为背景；
  对于$A_2$，与它拥有最大IoU的真实边界框的类别是猫，IoU超过阈值，所以类别被标记为猫；
  对于$A_3$，与它拥有最大IoU的真实边界框的类别是猫，但值低于阈值，因此该类别被标记为背景。

4.2.2 offset_inverse函数预测边界框坐标

??在前面，我们用multibox_target函数为锚框一一预测类别和偏移量。 预测时，根据其中某个带有预测偏移量的锚框而生成一个“预测好的边界框”。
??下面的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

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

??在前面我们讲过，以每个像素为中心点生成锚框时会产生大量的锚框，许多锚框非常相似，使用NMS方法可以合并属于同一目标的类似的预测边界框。其原理为：
??对于一个预测边界框$B$，目标检测模型会计算每个类别的预测概率。假设最大的预测概率为$p$，则该概率所对应的类别$B$即为预测的类别。具体来说，我们将$p$称为预测边界框$B$的置信度（confidence）。
??在同一张图像中，所有预测的非背景边界框都按置信度降序排序，以生成列表$L$。然后我们通过以下步骤操作排序列表$L$：

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

定义nms函数按降序对置信度进行排序并返回其索引：

#@save
def nms(boxes, scores, iou_threshold):
    """对预测边界框的置信度进行排序"""
    B = torch.argsort(scores, dim=-1, descending=True)#按照scores进行置信度排序
    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)

定义以下multibox_detection函数来将nms应用于预测边界框：

#@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):#对所有样本，拿出预测值做nms
        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)

4.2.4 举例测试

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

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]])  # 猫的预测概率

在图像上绘制这些预测边界框和置信度：

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

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

output = multibox_detection(cls_probs.unsqueeze(dim=0),
                            offset_preds.unsqueeze(dim=0),
                            anchors.unsqueeze(dim=0),
                            nms_threshold=0.5)
output

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

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

删除-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)

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

4.3 小结

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

本人理解的整个算法过程：

1. 读取图片，和图片已经标记好的边缘框
2. 使用multibox_prior函数为每个图片生成大量锚框，每个锚框是一个训练样本
3. 训练阶段：为每个锚框标记类别和偏移量。具体的：
   • 使用assign_anchor_to_bbox函数将最接近的真实边界框分配给锚框（3.3.3根据box_iou值进行计算）
   • 使用multibox_target函数标记锚框的类别和对边界框的偏移量（4.1.3）。multibox_target举例见4.2.1.
4. 预测阶段：根据生成的锚框预测边缘框：
   • offset_inverse函数，反过来根据锚框的偏移量预测边界框坐标
   • 预测前，multibox_detection函数根据nms算法去除相似的锚框和无效的锚框（背景框）

4.4.讨论

1. 最大预测值指的是分类的置信度还是锚框预测的置信度？这两个置信度是混在一起预测吗？
   只有分类有置信度，锚框预测是一个回归问题，没有置信度
2. 每次做nms时，是针对相同类别（狗）做循环过滤去除，还是对所有类别（猫和狗）都做去除？
   两种方法一般都支持，本节讲的是对所有类别（猫和狗）放在一起做去除（见4.2.3）。也可以在每一类里面做nms。
3. assign_anchor_to_bbox里面真实边缘框哪里来的？
   真实边缘框是人工标注的，读取数据集的时候就会读入进来。锚框的生成是根据算法（以每个像素为中心点生成锚框）生成，且生成时不能看真实边缘框。预测时没有真实边缘框，是根据生成的锚框预测边缘框（offset_inverse函数预测边界框坐标，且预测前锚框经过nms去除太相似的）
4. 锚框的宽度和高度分别是$ws\sqrt{r}$和$hs/\sqrt{r}$，这是怎么计算的
   二者相除保证高宽比是r
5. 为啥要给每个像素都做锚框，可以合并像素吗？
   这是为了保证有足够多的 覆盖率
6. 锚框的损失函数怎么定义？
   锚框的预测是一个回归问题，损失函数根据偏移量来定义。后面目标检测算法会讲
7. 可以根据特征点筛选像素再生成锚框吗？
   可以的。yolo就是根据先验知识来选锚框，而不是真的每个像素都扫一遍。之所以本节用每个像素点来生成，一是有算法这么做，也可以用python实现。二是目标检测有很多其它优化，有很多工程点在里面没时间讲完，这里只是简单过一遍。

开发者涨薪指南

48位大咖的思考法则、工作方式、逻辑体系