HIT神经网络与深度学习第5周课程总结

6 深度学习视觉应用

6.3 目标检测实现

6.3.1 目标检测预备知识

• 目标检测基本原理

很多时候图像里有多个我们感兴趣的目标，我们不仅想知道它们的类别，还想得到它们在图像中的具体位置。在计算机视觉里，我们将这类任务称为目标检测（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])

为了描绘图像中以某个像素为中心的所有锚框，我们先定义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）。

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

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

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

假设图像中锚框分别为

 真实边界框分别为

 且

 定义矩阵

 其中第i行第j列的元素X_ij为锚框Ai与真实边界框Bj的交并比。

首先，我们找出矩阵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个预测边界框（已经按照得分从小到大排序）

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

6.3.2 目标检测数据集

• 数据集的介绍

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

1. 首先，用一个开源的皮卡丘3D模型生成了1000张不同角度和大小的皮卡丘图像。
2. 然后我们收集了一系列背景图像，并在每张图的随机位置放置一张随机的皮卡丘图像。

• 数据集的下载

皮卡丘数据集使用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'])

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

•  小节总结

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

6.4 语义分割

6.4.1 语义分割

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

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

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

• 语义分割数据集

语义分割的一个重要数据集叫作Pascal VOC2012 。

• 小节总结

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

6.4.2 语义分割实例

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

6.5 风格迁移

6.5.1 风格迁移

• 简介

如果你是一位摄影爱好者，也许接触过滤镜。它能改变照片的颜色样式，从而使风景照更加锐利或者令人像更加美白。但一个滤镜通常只能改变照片的某个方面。如果要照片达到理想中的样式，经常需要尝试大量不同的组合，其复杂程度不亚于模型调参。

在本节中，我们将介绍如何使用卷积神经网络自动将某图像中的样式应用在另一图像之上，即风格迁移。

这里我们需要两张输入图像，一张是内容图像，另一张是样式图像，我们将使用神经网络修改内容图像使其在样式上接近样式图像。

• 方法

首先，我们初始化合成图像，例如将其初始化成内容图像。该合成图像是样式迁移过程中唯一需要更新的变量，即样式迁移所需迭代的模型参数。

然后，我们选择一个预训练的卷积神经网络来抽取图像的特征，其中的模型参数在训练中无须更新。深度卷积神经网络凭借多个层逐级抽取图像的特征。我们可以选择其中某些层的输出作为内容特征或样式特征。

• 样式迁移常用的损失函数由3部分组成：

1. 内容损失（content loss）使合成图像与内容图像在内容特征上接近
2. 样式损失（style loss）令合成图像与样式图像在样式特征上接近
3. 总变差损失（total variation loss）则有助于减少合成图像中的噪点。

最后，当模型训练结束时，我们输出样式迁移的模型参数，即得到最终的合成图像。

• 章节小节

1. 样式迁移常用的损失函数由3部分组成：内容损失使合成图像与内容图像在内容特征上接近，样式损失令合成图像与样式图像在样式特征上接近，而总变差损失则有助于减少合成图像中的噪点。
2. 可以通过预训练的卷积神经网络来抽取图像的特征，并通过最小化损失函数来不断更新合成图像。
3. 用格拉姆矩阵表达样式层输出的样式。

6.6 人脸识别

6.6.1 人脸验证与人脸识别

• 两类问题的区别

人脸验证：

 人脸识别：

 6.6.2 人脸验证

• 旧有思路

转化为分类问题

• 构建神经网络

双输入结构

 相似度函数的具体定义

•  训练神经网络

通过训练神经网络，我们希望同一人的两张照片间的相似度函数值尽可能小，不同人的两张片间的相似度函数值尽可能大，下以此为目标制作训练集、定义Loss函数。

• 运行神经网络

利用人脸验证实现人脸识别

对于训练完毕的神经网络，输入照片，通过简单的for循环语句遍历数据库中存储的所有照片，依次通过相似度函数进行计算，记录遍历过程中相似程度最大的值，在遍历结束后与预先设定的阈值进行比较，得出预测结果，完成人脸识别。