神经网络与深度学习（三）

6 深度学习视觉应用

6.3 目标检测实现

6.3.1 目标检测与YOLO

目标检测基本原理
很多时候图像里有多个我们感兴趣的目标，我们不仅想知道它们的类别，还想得到它们在图像中的具体位置。在计算机视觉里，我们将这类任务称为目标检测（object detection）或物体检测。
目标检测在多个领域中被广泛使用。例如，在无人驾驶里，我们需要通过识别拍摄到的视频图像里的车辆、行人、道路和障碍的位置来规划行进线路。机器人也常通过该任务来检测感兴趣的目标。安防领域则需要检测异常目标，如歹徒或者炸弹。
先导入实验所需的包或模块。 

%matplotlib inline
from PIL import Image
import sys
sys.path.append("..") 
import d2lzh_pytorch as d2l

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

d2l.set_figsize()
img = Image.open('img/catdog.jpg')
d2l.plt.imshow(img); 
# 加分号只显示图

边界框
在目标检测里，我们通常使用边界框（bounding box）来描述目标位置边界框是一个矩形框，可以由矩形左上角的x和y轴坐标与右下角的x和轴坐标确定。我们根据下面的图的坐标信息来定义图中狗和猫的边界。图中的坐标原点在图像的左上角，原点往右和往下分别为x轴和y轴正方向。

dog_bbox, cat_bbox = [60, 45, 378, 516], [400, 112, 655, 493]

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

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

 

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

不同的模型使用的区域采样方法可能不同。这里我们介绍其中的一种方法：它以每个像素为中心生成多个大小和宽高比（aspect ratio）不同的边界框。这些边界框被称为锚框（anchor box）。我们将在后面基于锚框实践目标检测。

先导相关包。

%matplotlib inline
from PIL import Image
import numpy as np
import math
import torch
import sys
sys.path.append("..") 
import d2lzh_pytorch as d2l
print(torch.__version__) 
# 1.6.0

生成多个锚框
假设输入图像高为h，宽为w。我们分别以图像的每个像素为中心生成不同形状的锚框。设大小为s∈(0,1]且宽高比为r>0，那么锚框的宽和高将分别为𝑤𝑠√𝑟 和ℎ𝑠/ √𝑟。当中心位置给定时，已知宽和高的锚框是确定的。

下面我们分别设定好一组大小s1,…,sn和一组宽高比r1,…,rm。如果以每个像素为中心时使用所有的大小与宽高比的组合，输入图像将一共得到w*h*n*m个锚框。虽然这些锚框可能覆盖了所有的真实边界框，但计算复杂度容易过高。因此，我们通常只对包含s1或r1的大小与宽高比的组合感兴趣，即

 也就是说，以相同像素为中心的锚框的数量为n+m−1。对于整个输入图像，我们将一共生成w*h(n+m−1)个锚框。以上生成锚框的方法实现在下面的MultiBoxPrior函数中。指定输入、一组大小和一组宽高比，该函数将返回输入的所有锚框。

d2l.set_figsize()
img = Image.open('img/catdog.jpg')
w, h = img.size
print("w = %d, h = %d" % (w, h)) # w = 728, h = 561
def MultiBoxPrior(feature_map, sizes=[0.75, 0.5, 0.25], ratios=[1, 2, 0.5])
    pairs = [] # pair of (size, sqrt(ration))
    for r in ratios:
        pairs.append([sizes[0], math.sqrt(r)])
    for s in sizes[1:]:
        pairs.append([s, math.sqrt(ratios[0])])
    pairs = np.array(pairs)
 
    ss1 = pairs[:, 0] * pairs[:, 1] # size * sqrt(ration)
    ss2 = pairs[:, 0] / pairs[:, 1] # size / sqrt(ration)
 
    base_anchors = np.stack([-ss1, -ss2, ss1, ss2], axis=1) / 2
 
    h, w = feature_map.shape[-2:]
    shifts_x = np.arange(0, w) / w
    shifts_y = np.arange(0, h) / h
    shift_x, shift_y = np.meshgrid(shifts_x, shifts_y)
    shift_x = shift_x.reshape(-1)
    shift_y = shift_y.reshape(-1)
 
    shifts = np.stack((shift_x, shift_y, shift_x, shift_y), axis=1)
    
    anchors = shifts.reshape((-1, 1, 4)) + base_anchors.reshape((1, -1, 4))
 
    return torch.tensor(anchors, dtype=torch.float32).view(1, -1, 4)
 
X = torch.Tensor(1, 3, h, w) # 构造输入数据
Y = MultiBoxPrior(X, sizes=[0.75, 0.5, 0.25], ratios=[1, 2, 0.5])
Y.shape # torch.Size([1, 2042040, 4])

shifts_x和shifts_y是将宽高进行归一化处理然后用meshgrid函数生成一个向量矩阵，最后reshape成一行向量。

将reshape之后的向量进行stack操作，之后将得到的shift与原始的base_anchors相加从而自动生成所有的anchor

我们看到，返回锚框变量y的形状为（1，锚框个数，4）。将锚框变量y的形状变为（图像高，图像宽，以相同像素为中心的锚框个数，4）后，我们就可以通过指定像素位置来获取所有以该像素为中心的锚框了。下面的例子里我们访问以（250，250）为中心的第一个锚框。它有4个元素，分别是锚框左上角的x和y轴坐标和右下角的x和y轴坐标，其中x和y轴的坐标值分别已除以图像的宽和高，因此值域均为0和1之间。

boxes = Y.reshape((h, w, 5, 4))
boxes[250, 250, 0, :]# * torch.tensor([w, h, w, h], dtype=torch.float32)

输出：

tensor([-0.0316, 0.0706, 0.7184, 0.8206])

tensor([-0.0316, 0.0706, 0.7184, 0.8206])为了描绘图像中以某个像素为中心的所有锚框，我们先定义show_bboxes函数以便在图像上画出多个边界框。

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().cpu().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=6, color=text_color,
                bbox=dict(facecolor=color, lw=0))

刚刚我们看到，变量boxes中xx和yy轴的坐标值分别已除以图像的宽和高。在绘图时，我们需要恢复锚框的原始坐标值，并因此定义了变量bbox_scale。现在，我们可以画出图像中以(250, 250)为中心的所有锚框了。可以看到，大小为0.75且宽高比为1的锚框较好地覆盖了图像中的狗。

d2l.set_figsize()
fig = d2l.plt.imshow(img)
bbox_scale = torch.tensor([[x, y, w, h]], dtype=torch.float32)
show_bboxes(fig.axes, boxes[250, 250, :, :] * bbox_scale,
    ['s=0.75, r=1', 's=0.75, r=2', 's=0.55, 
    r=0.5', 's=0.5, r=1', 's=0.25, r=1'])

交并比
刚刚提到某个锚框较好地覆盖了图像中的狗。如果该目标的真实边界框已知，这里的“较好”该如何量化呢？一种直观的方法是衡量锚框和真实边界框之间的相似度。我们知道，Jaccard系数（Jaccard index）可以衡量两个集合的相似度。给定集合A和B，它们的Jaccard系数即二者交集大小除以二者并集大小：

 实际上，我们可以把边界框内的像素区域看成是像素的集合。如此一来，我们可以用两个边界框的像素集合的Jaccard系数衡量这两个边界框的相似度。当衡量两个边界框的相似度时，我们通常将Jaccard系数称为交并比，即两个边界框相交面积与相并面积之比，如图所示。交并比的取值范围在0和1之间：0表示两个边界框无重合像素，1表示两个边界框相等。

 下面我们对其进行实现。

def compute_intersection(set_1, set_2):
    #计算anchor之间的交集
    # PyTorch auto-broadcasts singleton dimensions
    lower_bounds = torch.max(set_1[:, :2].unsqueeze(1), set_2[:, :2].unsqueeze(0)) # (n1, n2, 2)
    upper_bounds = torch.min(set_1[:, 2:].unsqueeze(1), set_2[:, 2:].unsqueeze(0)) # (n1, n2, 2)
    intersection_dims = torch.clamp(upper_bounds - lower_bounds, min=0) # (n1, n2, 2)
    return intersection_dims[:, :, 0] * intersection_dims[:, :, 1] # (n1, n2)

 set1和set2分别为(n1,4),(n2,4)大小的张量，利用clamp函数和向量运算直接计算了相交面积大小，当二者不相交时clamp函数将二者的upper_bounds-lower_bounds置为零，IOU计算时就不会有负值。

def compute_jaccard(set_1, set_2):
    #计算anchor之间的Jaccard系数(IoU)
    # Find intersections
    intersection = compute_intersection(set_1, set_2) # (n1, n2)
 
    # Find areas of each box in both sets
    areas_set_1 = (set_1[:, 2] - set_1[:, 0]) * (set_1[:, 3] - set_1[:, 1]) # (n1)
    areas_set_2 = (set_2[:, 2] - set_2[:, 0]) * (set_2[:, 3] - set_2[:, 1]) # (n2)
 
    # Find the union
    # PyTorch auto-broadcasts singleton dimensions
    union = areas_set_1.unsqueeze(1) + areas_set_2.unsqueeze(0) - intersection # (n1, n2)
    return intersection / union # (n1, n2)

计算IOU来衡量锚框与真实边界框以及锚框与锚框之间的相似度。

标注训练集的锚框
在训练集中，我们将每个锚框视为一个训练样本。为了训练目标检测模型，我们需要为每个锚框标注两类标签：一是锚框所含目标的类别，简称类别；二是真实边界框相对锚框的偏移量，简称偏移量（offset）。

在目标检测时，我们首先生成多个锚框，然后为每个锚框预测类别以及偏移量。

接着根据预测的偏移量调整锚框位置从而得到预测边界框。

最后筛选需要输出的预测边界框。

首先，我们找出矩阵X中最大元素，并将该元素的行索引与列索引分别记为i1,j1。我们为锚框Ai1分配真实边界框Bj1。显然，锚框Ai1和真实边界框Bj1在所有的“锚框—真实边界框”的配对中相似度最高。

接下来，将矩阵X中第i1行和第j1列上的所有元素丢弃。找出矩阵XX中剩余的最大元素，并将该元素的行索引与列索引分别记为i2,j2。我们为锚框Ai2分配真实边界框Bj2，再将矩阵X中第i2行和第j2列上的所有元素丢弃。此时矩阵X中已有两行两列的元素被丢弃。

依此类推，直到矩阵X中所有n[b]列元素全部被丢弃。这个时候，我们已为n[b]个锚框各分配了一个真实边界框。 接下来，我们只遍历剩余的n[a]−n[b]个锚框：给定其中的锚框Ai，根据矩阵X的第i行找到与Ai交并比最大的真实边界框Bj，且只有当该交并比大于预先设定的阈值时，才为锚框Ai分配真实边界框Bj。

 如果一个锚框A被分配了真实边界框B，将锚框A的类别设为B的类别，并根据B和A的中心坐标的相对位置以及两个框的相对大小为锚框A标注偏移量。

设锚框A及其被分配的真实边界框B的中心坐标分别为(x[a],y[a])和(x[b],y[b])，A和B的宽分别为w[a]和w[b]，高分别为h[a]和h[b]，一个常用的技巧是将A的偏移量标注为

 其中常数的默认值为μx=μy=μw=μh=0,σx=σy=0.1,σw=σh=0.2,如果一个锚框没有被分配真实边界框，我们只需将该锚框的类别设为背景。类别为背景的锚框通常被称为负类锚框，其余则被称为正类锚框。

输出预测边界框
锚框数量较多时，同一个目标上可能会输出较多相似的预测边界框。为了使结果更加简洁，我们可以移除相似的预测边界框。常用的方法叫作非极大值抑制。假设有ABCDEF6个预测边界框（已经按照得分从小到大排序）

从最大概率矩形框F开始，分别判断A~E与F的重叠度IOU是否大于某个设定的阈值;
假设B、D与F的重叠度超过阈值，那么就扔掉B、D；并标记第一个矩形框F，是我们保留下来的。
从剩下的矩形框A、C、E中，选择概率最大的E，然后判断E与A、C的重叠度，重叠度大于一定的阈值，那么就扔掉；并标记E是我们保留下来的第二个矩形框。
一直重复这个过程，找到所有曾经被保留下来的矩形框。

6.3.2 目标检测数据集与评价指标

数据集的介绍
在目标检测领域并没有类似MNIST或Fashion-MNIST那样的小数据集。为了快速测试模型，我们合成了一个小的数据集。

首先，用一个开源的皮卡丘3D模型生成了1000张不同角度和大小的皮卡丘图像。
然后我们收集了一系列背景图像，并在每张图的随机位置放置一张随机的皮卡丘图像。
数据集的下载
皮卡丘数据集使用MXNet提供的im2rec工具将图像转换成了二进制的RecordIO格式，但是我们后续要使用PyTorch，所以我们先用脚本将其转换成了PNG图片并用json文件存放对应的label信息。最终pikachu文件夹的结构如下：

 数据集的读取
首先定义一个数据集类PikachuDetDataset，数据集每个样本包含label和image。

label是一个 m×5m×5 的向量，即m个边界框，每个边界框由[class, x_min, y_min, x_max, y_max]表示，这里的皮卡丘数据集中每个图像只有一个边界框，因此m=1。

image是一个所有元素都位于[0.0, 1.0]的浮点tensor，代表图片数据。

数据集类PikachuDetDataset的定义如下

class PikachuDetDataset(torch.utils.data.Dataset):
    """皮卡丘检测数据集类"""
    def __init__(self, data_dir, part, image_size=(256, 256)):
        assert part in ["train", "val"]
        self.image_size = image_size
        self.image_dir = os.path.join(data_dir, part, "images")
        with open(os.path.join(data_dir, part, "label.json")) as f:
            self.label = json.load(f)
        self.transform = torchvision.transforms.Compose([
            # 将 PIL 图片转换成位于[0.0, 1.0]的floatTensor, shape (C x H x W)
            torchvision.transforms.ToTensor()])
#os.path.join的功能是将路径拼接起来
#json.load的功能是加载路径指向的文件
#torchvision.transforms.Compose可以将多个transform操作组合使用。
 
    def __len__(self):
        return len(self.label)
 
    def __getitem__(self, index):
        image_path = str(index + 1) + ".png"
        cls = self.label[image_path]["class"]
        label = np.array([cls] + self.label[image_path]["loc"], dtype="float32")[None, :]
        PIL_img = Image.open(os.path.join(self.image_dir, image_path)).convert('RGB').resize(self.image_size)
        img = self.transform(PIL_img)
        sample = {
            "label": label, # shape: (1, 5) [class, xmin, ymin, xmax, ymax]
            "image": img # shape: (3, *image_size)
        }
        return sample

然后我们通过创建DataLoader实例来读取目标检测数据集。我们将以随机顺序读取训练数据集，按序读取测试数据集。

def load_data_pikachu(batch_size, edge_size=256, data_dir = '../../data/pikachu'): 
    """edge_size：输出图像的宽和高"""
    image_size = (edge_size, edge_size)
    train_dataset = PikachuDetDataset(data_dir, 'train', image_size)
    val_dataset = PikachuDetDataset(data_dir, 'val', image_size)
    train_iter = torch.utils.data.DataLoader(train_dataset, batch_size=batch_size, shuffle=True, num_workers=4)
    val_iter = torch.utils.data.DataLoader(val_dataset, batch_size=batch_size,shuffle=False, num_workers=4)
    return train_iter, val_iter

下面我们读取一个小批量并打印图像和标签的形状。图像的形状和之前实验中的一样，依然是(批量大小, 通道数, 高, 宽)。而标签的形状则是(批量大小, m, 5)，其中m等于数据集中单个图像最多含有的边界框个数。

batch_size, edge_size = 32, 256
train_iter, _ = load_data_pikachu(batch_size, edge_size, data_dir)
batch = iter(train_iter).next()
print(batch["image"].shape, batch["label"].shape)

其输出为

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

图示数据
我们用以下代码画出10张图像和它们中的边界框。

imgs = batch["image"][0:10].permute(0,2,3,1)
bboxes = batch["label"][0:10, 0, 1:]
 
axes = d2l.show_images(imgs, 2, 5).flatten()
for ax, bb in zip(axes, bboxes):
    d2l.show_bboxes(ax, [bb*edge_size], colors=['w'])

可以看到，皮卡丘的角度、大小和位置在每张图像中都不一样。当然，这是一个简单的人工数据集。实际中的数据通常会复杂得多。

 小节总结
合成的皮卡丘数据集可用于测试目标检测模型。
目标检测的数据读取跟图像分类的类似。然而，在引入边界框后，标签形状和图像增广（如随机裁剪）发生了变化。

6.4 语义分割

6.4.1 语义分割

语义分割关注如何将图像分割成属于不同语义类别的区域。值得一提的是，这些语义区域的标注和预测都是像素级的。下图展示了语义分割中图像有关狗、猫和背景的标签。可以看到，与目标检测相比，语义分割标注的像素级的边框显然更加精细。

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

图像分割将图像分割成若干组成区域。这类问题的方法通常利用图像中像素之间的相关性。它在训练时不需要有关图像像素的标签信息，在预测时也无法保证分割出的区域具有我们希望得到的语义。
实例分割又叫同时检测并分割。它研究如何识别图像中各个目标实例的像素级区域。与语义分割有所不同。
以ppt中的两只狗为例，图像分割可能将狗分割成两个区域：一个覆盖以黑色为主的嘴巴和眼睛，而另一个覆盖以黄色为主的其余部分身体。而实例分割不仅需要区分语义，还要区分不同的目标实例。如果图像中有两只狗，实例分割需要区分像素属于这两只狗中的哪一只。
语义分割数据集
语义分割的一个重要数据集叫作Pascal VOC2012 。

小节总结
语义分割关注如何将图像分割成属于不同语义类别的区域。
语义分割的一个重要数据集叫作Pascal VOC2012。
由于语义分割的输入图像和标签在像素上一一对应，所以将图像随机裁剪成固定尺寸而不是缩放。

6.4.2 语义分割实例

Deeplab v3是目前广泛使用的语义分割方法