动手学深度学习pytorch学习笔记—基于锚框的目标检测基础

目标检测基础（学渣版）

代码没几行，注释写成翔
参考文献：1）动手学DL PyTorch版本 2）MXNet版本(原版)

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

1、生成多个锚框

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

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

(s1,r1),(s1,r2),…,(s1,rm),(s2,r1),(s3,r1),…,(sn,r1).

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

以上生成锚框的方法已实现在MultiBoxPrior函数中。指定输入、一组大小和一组宽高比，该函数将返回输入的所有锚框。

def MultiBoxPrior(feature_map, sizes=[0.75, 0.5, 0.25], ratios=[1, 2, 0.5]):
    """
    #  anchor表示成(xmin, ymin, xmax, ymax).
    参考 https://zh.d2l.ai/chapter_computer-vision/anchor.html
    Args:
        feature_map: torch tensor, Shape: [N, C, H, W].
        sizes: List of sizes (0~1) of generated MultiBoxPriores. 
        ratios: List of aspect ratios (non-negative) of generated MultiBoxPriores. 
    Returns:
        anchors of shape (1, num_anchors, 4). 由于batch里每个都一样, 所以第一维为1
    """
    pairs = [] # pair of (size, sqrt(ration))
    
    # 生成n + m -1个框
    for r in ratios:
        pairs.append([sizes[0], math.sqrt(r)]) #s和r各三个时 shape 5x2
    for s in sizes[1:]:
        pairs.append([s, math.sqrt(ratios[0])])
    
    pairs = np.array(pairs)
    
    # 生成相对于坐标中心点的框（x,y,x,y）
    ss1 = pairs[:, 0] * pairs[:, 1] # size * sqrt(ration) shape (5,)
    ss2 = pairs[:, 0] / pairs[:, 1] # size / sqrt(ration)
    
    base_anchors = np.stack([-ss1, -ss2, ss1, ss2], axis=1) / 2 #增加新的维度 (5,4) 
    
    #将坐标点和anchor组合起来生成hw（n+m-1）个框输出
    h, w = feature_map.shape[-2:]
    shifts_x = np.arange(0, w) / w # 生成间隔为1的坐标轴，除w、h是因为要相对于图片大小为1生成锚框
    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) #(x,y,x,y)
    anchors = shifts.reshape((-1, 1, 4)) + base_anchors.reshape((1, -1, 4))
    
    return torch.tensor(anchors, dtype=torch.float32).view(1, -1, 4)

meshgrid函数理解参考这里

---

上述代码中的一些问题讲解（讨论区抄的= =）

给大家详细阐述一下各个符合的含义，再配一个例子，可能更好理解一些。

w，h 整个feature map的宽和高，下面均以 w = 728, h = 561 为例进行阐述

代码中的ss1，代表的是anchor的宽，是相对于整个feature map的宽w的一个归一化系数。

例如 ss1 = 0.75，则anchor的实际大小为 ss1 = 728 * 0.75 = 546

ss2 同理，代表的是anchor的高，是相对于整个feature map的高h的一个归一化系数。

r 代表anchor的宽高比，因为本身就是一个比例，所以这个符合不会有什么争议。

显然 r = anchor的宽 / anchor的高 = ss1 / ss2

最有问题的标注出现在这里！！！ s

s 应该理解为 anchor的 宽=高 时ss1和ss2的一个基准大小

也可以证明理解 s^2 为 anchor 的面积相对于 整个feature map的比例

也就是说 s^2 = ss1 * ss2

当 r = 1时，s = ss1 = ss2; 当r = 2时，ss1 = sqrt(2) * s, ss2 = s / sqrt®

因此才有的代码中的 ss1 = s * sqrt®, ss2 = s / sqrt® 的定义

举个例子，假设 s = 0.5， r = 1

代表的含义是 anchor的面积 = s ^ 2 = 0.25 也就是整个feature map的 1/4

面积有了，长宽比有了，anchor的尺寸也就确定了。 ss1 = ss2 = 0.25

---

2、接下来，我们带个数据试一下：

# 构造输入数据 1张3通道的图片
X = torch.Tensor(1, 3, h, w)  
Y = MultiBoxPrior(X, sizes=[0.75, 0.5, 0.25], ratios=[1, 2, 0.5]) #si(i=1...m) ri(i=1...n)
Y.shape   # torch.Size([1, 2042040, 4]) 其中 w = 728, h = 561 故总共锚框个数 wh(m+n-1) 

我们看到，返回锚框变量y的形状为（1，锚框个数，4）。将锚框变量y的形状变为（图像高，图像宽，以相同像素为中心的锚框个数，4）后，我们就可以通过指定像素位置来获取所有以该像素为中心的锚框了。

下面的例子里我们访问以（250，250）为中心的第一个锚框。它有4个元素，分别是锚框左上角的x和y轴坐标和右下角的x和y轴坐标，其中x和y轴的坐标值分别已除以图像的宽和高，因此值域均为0和1之间。

# 展示某个像素点的anchor
boxes = Y.reshape((h, w, 5, 4)) 
boxes[250, 250, 0, :]  # * torch.tensor([w, h, w, h], dtype=torch.float32)
# Out：tensor([-0.0316,  0.0706,  0.7184,  0.8206])

注：可以验证一下以上输出对不对：第一个size和ratio分别为0.75和1, 则(归一化后的)宽高均为0.75, 所以输出是正确的（0.75 = 0.7184 + 0.0316 = 0.8206 - 0.0706）。

补充：

• reshape中的参数5可以想成是每个像素点框的索引，因为我们设定的sizes有3个，ratio有3个，故每个像素点都会有3+3-1个框。最前面有讲过这个思想。
• reshape中的参数4是因为每个框都需要2个坐标点（x，y）
• Y.reshape()中第一维是高h，第二维是宽w，顺序不能变。因为我们在保存像素点坐标时，先保存每一行的坐标，再把每一行的坐标组合起来，从而组成所有的坐标。所以我们在reshape时，要先通过h把它分成一行一行的点，再通过w分成每一个点，参数5表示了每一个像素点的anchor，参数4表示每一个anchor的两个(x,y)坐标点。

3、为了描绘图像中以某个像素为中心的所有锚框，我们先定义show_bboxes函数以便在图像上画出多个边界框。

#将边界框表示成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)


#axes：图片坐标对象  bboxes：要展示的框  labels：框的标签 colors：框的颜色
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中x和y轴的坐标值分别已除以图像的宽和高。在绘图时，我们需要恢复锚框的原始坐标值，并因此定义了变量bbox_scale。现在，我们可以画出图像中以(250, 250)为中心的所有锚框了。可以看到，大小为0.75且宽高比为1的锚框较好地覆盖了图像中的狗。

# 展示 250 250像素点的anchor
d2l.set_figsize()
fig = d2l.plt.imshow(img)
bbox_scale = torch.tensor([[w, h, w, h]], dtype=torch.float32) #我们一开始生成的框boxes是分别比上w和h，进行过归一化的，所以需要乘上(x,y,x,y)进行还原
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'])

效果如下图：

4、 交并比

我们刚刚提到某个锚框较好地覆盖了图像中的狗。如果该目标的真实边界框已知，这里的“较好”该如何量化呢？一种直观的方法是衡量锚框和真实边界框之间的相似度。我们知道，Jaccard系数（Jaccard index）可以衡量两个集合的相似度。给定集合A和B，它们的Jaccard系数即二者交集大小除以二者并集大小：
$$J(\mathcal{A},\mathcal{B})=\frac{\left|\mathcal{A}\cap \mathcal{B}\right|}{\left|\mathcal{A}\cup \mathcal{B}\right|}.$$
实际上，我们可以把边界框内的像素区域看成是像素的集合。如此一来，我们可以用两个边界框的像素集合的Jaccard系数衡量这两个边界框的相似度。当衡量两个边界框的相似度时，我们通常将Jaccard系数称为交并比（Intersection over Union，IoU），即两个边界框相交面积与相并面积之比，如下图所示。交并比的取值范围在0和1之间：0表示两个边界框无重合像素，1表示两个边界框相等。

下面我们对其进行实现。

# 参考https://github.com/sgrvinod/a-PyTorch-Tutorial-to-Object-Detection/blob/master/utils.py#L356
def compute_intersection(set_1, set_2):
    """
    计算anchor之间的交集
    Args:
        set_1: a tensor of dimensions (n1, 4), anchor表示成(xmin, ymin, xmax, ymax) n1个anchor
        set_2: a tensor of dimensions (n2, 4), anchor表示成(xmin, ymin, xmax, ymax) n2个anchor
    Returns:
        intersection of each of the boxes in set 1 with respect to each of the boxes in set 2, shape: (n1, n2)
   
   总结：我们要计算n1，n2中每一个元素的交集，用扩充维度的方法进行组合。set1扩充第1维，set2扩充第0维，组合起来变成(n1,n2,2)维。我们又怎么样计算交集的点呢，比如set1为上面图中的靠左上的的框，set2为上图中靠右下的框，于是我们用torch.max寻找相交面积中左上角的坐标，用torch.min寻找相交面积中右下角的坐标,根据这两个坐标找到相交的anchor命名为intersection。
   相并的面积我们直接用两个框的面积相加，然后减去相交的面积即可得到union。左后相除记得到交并比intersection / union
    """
    # 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)


def compute_jaccard(set_1, set_2):
    """
    计算anchor之间的Jaccard系数(IoU)
    Args:
        set_1: a tensor of dimensions (n1, 4), anchor表示成(xmin, ymin, xmax, ymax)
        set_2: a tensor of dimensions (n2, 4), anchor表示成(xmin, ymin, xmax, ymax)
    Returns:
        Jaccard Overlap of each of the boxes in set 1 with respect to each of the boxes in set 2, shape: (n1, n2)
    """
    # 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)

我们将使用交并比来衡量锚框与真实边界框以及锚框与锚框之间的相似度。

5、标注训练集的锚框

在训练集中，我们将每个锚框视为一个训练样本。为了训练目标检测模型，我们需要为每个锚框标注两类标签：一是锚框所含目标的类别，简称类别；二是真实边界框相对锚框的偏移量，简称偏移量（offset）。在目标检测时，我们首先生成多个锚框，然后为每个锚框预测类别以及偏移量，接着根据预测的偏移量调整锚框位置从而得到预测边界框，最后筛选需要输出的预测边界框。

我们知道，在目标检测的训练集中，每个图像已标注了真实边界框的位置以及所含目标的类别。在生成锚框之后，我们主要依据与锚框相似的真实边界框的位置和类别信息为锚框标注。那么，该如何为锚框分配与其相似的真实边界框呢？

假设图像中锚框分别为A1,A2,…,Ana，真实边界框分别为B1,B2,…,Bnb，且na≥nb。定义矩阵X∈R(na×nb)，其中第i行第j列的元素xij为锚框Ai与真实边界框Bj的交并比。 首先，我们找出矩阵X中最大元素，并将该元素的行索引与列索引分别记为i1,j1。我们为锚框Ai1分配真实边界框Bj1。显然，锚框Ai1和真实边界框Bj1在所有的“锚框—真实边界框”的配对中相似度最高。接下来，将矩阵X中第i1行和第j1列上的所有元素丢弃。找出矩阵X中剩余的最大元素，并将该元素的行索引与列索引分别记为i2,j2。我们为锚框Ai2分配真实边界框Bj2，再将矩阵X中第i2行和第j2列上的所有元素丢弃。此时矩阵X中已有两行两列的元素被丢弃。 依此类推，直到矩阵X中所有nb列元素全部被丢弃。这个时候，我们已为nb个锚框各分配了一个真实边界框。 接下来，我们只遍历剩余的na−nb个锚框：给定其中的锚框Ai，根据矩阵X的第i行找到与Ai交并比最大的真实边界框Bj，且只有当该交并比大于预先设定的阈值时，才为锚框Ai分配真实边界框Bj。

如下图（左）所示，假设矩阵X中最大值为x23，我们将为锚框A2分配真实边界框B3。然后，丢弃矩阵中第2行和第3列的所有元素，找出剩余阴影部分的最大元素x71，为锚框A7分配真实边界框B1。接着如下图（中）所示，丢弃矩阵中第7行和第1列的所有元素，找出剩余阴影部分的最大元素x54，为锚框A5分配真实边界框B4。最后如下图（右）所示，丢弃矩阵中第5行和第4列的所有元素，找出剩余阴影部分的最大元素x92，为锚框A9分配真实边界框B2。之后，我们只需遍历除去A2,A5,A7,A9的剩余锚框，并根据阈值判断是否为剩余锚框分配真实边界框。

现在我们可以标注锚框的类别和偏移量了。如果一个锚框A被分配了真实边界框B，将锚框A的类别设为B的类别，并根据B和A的中心坐标的相对位置以及两个框的相对大小为锚框A标注偏移量。由于数据集中各个框的位置和大小各异，因此这些相对位置和相对大小通常需要一些特殊变换，才能使偏移量的分布更均匀从而更容易拟合。设锚框A及其被分配的真实边界框B的中心坐标分别为(xa,ya)和(xb,yb)，A和B的宽分别为wa和wb，高分别为ha和hb，一个常用的技巧是将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)$$
其中常数的默认值为 μx=μy=μw=μh=0，σx=σy=0.1，σw=σh=0.2。如果一个锚框没有被分配真实边界框，我们只需将该锚框的类别设为背景。类别为背景的锚框通常被称为负类锚框，其余则被称为正类锚框。

偏移量的理解：我们这个anchor与真实标注的锚框相比，是变大了还是变小了，是往左偏了还是往右了，亦或是往上、往下。上面公式中4个元素分别表示，边界框x轴偏移量，边界框y轴的偏移量，宽度变化和高度变化。

下面演示一个具体的例子。我们为读取的图像中的猫和狗定义真实边界框，其中第一个元素为类别（0为狗，1为猫），剩余4个元素分别为左上角的x和y轴坐标以及右下角的x和y轴坐标（值域在0到1之间）。这里通过左上角和右下角的坐标构造了5个需要标注的锚框，分别记为A0,…,A4（程序中索引从0开始）。先画出这些锚框与真实边界框在图像中的位置。

#高和宽做了归一化，都是1，展示的时候要乘以bbox_scale进行还原
bbox_scale = torch.tensor((w, h, w, h), dtype=torch.float32) 
ground_truth = torch.tensor([[0, 0.1, 0.08, 0.52, 0.92],
                            [1, 0.55, 0.2, 0.9, 0.88]])
#为了简单，这里之定义了5个锚框。一开始的图像是会生成200多万个锚框，最前边见到过。
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']);

效果图如下：

6、验证一下写的compute_jaccard函数（结合上面的效果图来看返回结果）

compute_jaccard(anchors, ground_truth[:, 1:]) 
'''
input: 锚框和真实的边界框
out:
tensor([[0.0536, 0.0000],
        [0.1417, 0.0000],
        [0.0000, 0.5657],
        [0.0000, 0.2059],
        [0.0000, 0.7459]]) 
 该tensor形状(5,2) 
 拿第一行作说明：第一个锚框与第一个真实边界框(dog)交并比是0.0536，第一个锚框与第二个真实边界框(cat)交并比是0.0000。验证正确
 其余几行同理。
 '''

7、下面实现MultiBoxTarget函数来为锚框标注类别和偏移量。该函数将背景类别设为0，并令从零开始的目标类别的整数索引自加1（1为狗，2为猫）。

#定义assign_anchor函数为两百多万锚框分配真实标签和偏移量
#函数参数：bb为真实边界框，anchor为待分配的边界框(锚框)  目的为每一个锚框分配一个真实的边界框
#j_h为设定的阈值，小于表示背景，大于才保留
def assign_anchor(bb, anchor, jaccard_threshold=0.5):
    """
    # 按照「9.4.1. 生成多个锚框」图9.3所讲为每个anchor分配真实的bb, anchor表示成归一化(xmin, ymin, xmax, ymax).
    https://zh.d2l.ai/chapter_computer-vision/anchor.html
    Args:
        bb: 真实边界框(bounding box), shape:（nb, 4）   nb个真实边界框
        anchor: 待分配的anchor, shape:（na, 4）         na个锚框 
        jaccard_threshold: 预先设定的阈值
    Returns:
        assigned_idx: shape: (na, ), 每个anchor分配的真实bb对应的索引, 若未分配任何bb则为-1
    """
    na = anchor.shape[0] 
    nb = bb.shape[0]
    jaccard = compute_jaccard(anchor, bb).detach().cpu().numpy() # shape: (na, nb) 交并比
    assigned_idx = np.ones(na) * -1  # 存放标签初始全为-1
    
    # 先为每个bb分配一个anchor(不要求满足jaccard_threshold)
    jaccard_cp = jaccard.copy()
    for j in range(nb):   # 先遍历每一个真实边界框，为它们找到交并比最大的那个锚框
        i = np.argmax(jaccard_cp[:, j])
        assigned_idx[i] = j
        jaccard_cp[i, :] = float("-inf") # 赋值为负无穷, 相当于去掉这一行
     
    # 处理还未被分配的anchor, 要求满足jaccard_threshold
    for i in range(na):
        if assigned_idx[i] == -1:
            j = np.argmax(jaccard[i, :])
            if jaccard[i, j] >= jaccard_threshold:
                assigned_idx[i] = j
                
    return torch.tensor(assigned_idx, dtype=torch.long)


def xy_to_cxcy(xy):
    """
    将(x_min, y_min, x_max, y_max)形式的anchor转换成(center_x, center_y, w, h)形式的anchor.
    https://github.com/sgrvinod/a-PyTorch-Tutorial-to-Object-Detection/blob/master/utils.py
    Args:
        xy: bounding boxes in boundary coordinates, a tensor of size (n_boxes, 4)
        n_boxes行数表示个数，4列表示4个点x,y,x,y（左上坐标和右下坐标） 
    Returns: 
        bounding boxes in center-size coordinates, a tensor of size (n_boxes, 4)
    """
    return torch.cat([(xy[:, 2:] + xy[:, :2]) / 2,  # c_x, c_y 把右下角的点和左上角的点相加除以2得到中心点坐标值。xy 是行数表示anchor个数，列数分别取两列对应于左上角坐标x,y和右下角坐标x,y
                      xy[:, 2:] - xy[:, :2]], 1)  # w, h cat函数dim=1按维度1拼接(横着拼) 假设有n个anchor，相当于两个形状为(n,2)的左右拼接，拼接后形状为(n,4),4列分别代表(center_x, center_y, w, h)

def MultiBoxTarget(anchor, label):
    """
    # 按照「9.4.1. 生成多个锚框」所讲的实现, anchor表示成归一化(xmin, ymin, xmax, ymax).
    https://zh.d2l.ai/chapter_computer-vision/anchor.html
    Args:
        anchor: torch tensor, 输入的锚框, 一般是通过MultiBoxPrior生成, shape:（1，锚框总数，4）
        label: 真实标签, shape为(bn, 每张图片最多的真实锚框数, 5)
               bn就是batch_number,一次处理多少anchor
               第二维中，如果给定图片没有这么多锚框, 可以先用-1填充空白, 最后一维中的元素为[类别标签, 四个坐标值]
    Returns:
        列表, [bbox_offset, bbox_mask, cls_labels]
        bbox_offset: 每个锚框的标注偏移量，形状为(bn，锚框总数*4) 
        bbox_mask: 形状同bbox_offset, 每个锚框的掩码, 一一对应上面的偏移量, 负类锚框(背景)对应的掩码均为0, 正类锚框的掩码均为1
        cls_labels: 每个锚框的标注类别, 其中0表示为背景, 形状为(bn，锚框总数)
    """
    assert len(anchor.shape) == 3 and len(label.shape) == 3
    bn = label.shape[0]
    
    def MultiBoxTarget_one(anc, lab, eps=1e-6):
        """
        MultiBoxTarget函数的辅助函数, 处理batch中的一个anchor
        Args:
            anc: shape of (锚框总数, 4) 
            lab: shape of (真实锚框数, 5), 5代表[类别标签, 四个坐标值]
            eps: 一个极小值, 防止log0
        Returns:
            offset: (锚框总数*4, )
            bbox_mask: (锚框总数*4, ), 0代表背景, 1代表非背景
            cls_labels: (锚框总数, 4), 0代表背景
        """
        an = anc.shape[0]
        # 变量的意义
        assigned_idx = assign_anchor(lab[:, 1:], anc) # (锚框总数, )每一个锚框对应一个索引值
        #lab是一个二维数组，行数表示真实锚框个数，每一行的第一列存储其类别值，后四列为坐标值。
        #assign_anchor函数返回的是每一个anchor是属于第几个类别的实例，返回索引值。用这个索引来找到其属于哪个类别的实例(第一列中的值表示所属类别)，再把该值赋给cls_labels。最后把后4列的坐标值赋给assigned_bb。
        print("a: ",  assigned_idx.shape)
        print(assigned_idx)
        bbox_mask = ((assigned_idx >= 0).float().unsqueeze(-1)).repeat(1, 4) # (锚框总数, 4)
        print("b: " , bbox_mask.shape)
        print(bbox_mask)

        cls_labels = torch.zeros(an, dtype=torch.long) # 0表示背景
        assigned_bb = torch.zeros((an, 4), dtype=torch.float32) # 所有anchor对应的bb坐标
        for i in range(an):
            bb_idx = assigned_idx[i]
            if bb_idx >= 0: # 即非背景
                cls_labels[i] = lab[bb_idx, 0].long().item() + 1 #lab[bb_idx, 0]表示第bb_idx行第0列，即正好是二维数组结构中某一生成锚框所对应的真实标注锚框(行数)的类别值(第0列)  注意要加一。
                #这一步其实就是要为生成的锚框添加类别标签，需要用到的就是一开始真实标注好的边界框。通过交并比来使一个生成锚框对应一个最相似的真实边界框。
                assigned_bb[i, :] = lab[bb_idx, 1:] #把真实标注好的边界框的坐标值赋给与其对应的某一锚框，为下一步计算锚框相对于真实边界框的偏移量做准备。
        
        # 如何计算偏移量
        #以像素点为中心生成的锚框是anc变量,实际真实打好坐标标签的锚框是assigned_bb变量。
        #可以这样想，我们想比较以像素点为中心生成的锚框anc和与其对应最相近的真实边界框(交并比值接近1)之间的偏移量，那么需要知道生成锚框anc的坐标和真实边界框的坐标。anc的坐标一开始是设定好的，将其转化成(center_x, center_y, w, h)该形式并赋给center_anc变量；与生成anc对应最相似的真实边界框的坐标已经赋值给了assigned_bb变量(上边代码)，其数据结构是二维数组，行对应每一个生成的锚框，列对应每一个真实标注好的边界框的的坐标。
        center_anc = xy_to_cxcy(anc) # (center_x, center_y, w, h)
        center_assigned_bb = xy_to_cxcy(assigned_bb)
        
        #根据中心点坐标计算xy方向上的offset和wh方向上的offset
        offset_xy = 10.0 * (center_assigned_bb[:, :2] - center_anc[:, :2]) / center_anc[:, 2:]
        offset_wh = 5.0 * torch.log(eps + center_assigned_bb[:, 2:] / center_anc[:, 2:])
        offset = torch.cat([offset_xy, offset_wh], dim = 1) * bbox_mask # (锚框总数, 4) 4(x,y,w,h)

        return offset.view(-1), bbox_mask.view(-1), cls_labels
    # 组合输出 
    # 主函数部分 把每一个batch(bn)分成一张一张的图片输入到MultiBoxTarget_one函数中来处理每一张
    batch_offset = []
    batch_mask = []
    batch_cls_labels = []
    for b in range(bn):
        #MultiBoxPrior函数生成的anchor形状：(1, num_anchors, 4).
        offset, bbox_mask, cls_labels = MultiBoxTarget_one(anchor[0, :, :], label[b, :, :])
        
        batch_offset.append(offset)
        batch_mask.append(bbox_mask)
        batch_cls_labels.append(cls_labels)
    #stack函数 默认dim=0，增加指定维度
    #比如上面offset列表中有10个元素，stack后形状变成(10,1),即10个anchor和每个anchor对应的offset值
    #其他的变量同理，最后返回一个包含这三个变量的列表
    bbox_offset = torch.stack(batch_offset) 
    bbox_mask = torch.stack(batch_mask)
    cls_labels = torch.stack(batch_cls_labels)
    
    return [bbox_offset, bbox_mask, cls_labels]

8、我们通过unsqueeze函数为锚框和真实边界框添加样本维。

#我们在上边定义的例子anchors是2行5列的，ground_truth是5行4列的（往上找，有代码的）
#而MultiBoxTarget函数接受的anchor和label是三维的，所以要增加维度
labels = MultiBoxTarget(anchors.unsqueeze(dim=0),ground_truth.unsqueeze(dim=0))
'''
返回值
a:  torch.Size([5])
tensor([-1,  0,  1, -1,  1]) 
b:  torch.Size([5, 4])
tensor([[0., 0., 0., 0.],
        [1., 1., 1., 1.],
        [1., 1., 1., 1.],
        [0., 0., 0., 0.],
        [1., 1., 1., 1.]])
'''

同样结合该图来理解上边代码的返回值：

• a是assigned_idx，在实例中返回的a是含有5个元素的列表，其中-1代表未被分配，0表示第0个类别，1表示第一个类别。列表中的索引值则表示当前是第几个生成锚框，如上例图（第0号锚框未分配实例，第1号锚框是第0个实例/类别，第3号锚框由于和第4号锚框对于cat框的交并比相比之下小一些，所以3号锚框未分配，第4号锚框是第1个实例）。
• b是bbox_mask，不属于实例(是背景)就是0，属于实例就为1。可以看到b矩阵和a数组是对应的。

9、返回的结果里有3项，均为Tensor。第三项表示为锚框标注的类别。

 '''
    MultiBoxTarget Function  Returns:
        列表, [bbox_offset, bbox_mask, cls_labels]
        bbox_offset: 每个锚框的标注偏移量，形状为(bn，锚框总数*4) 
        bbox_mask: 形状同bbox_offset, 每个锚框的掩码, 一一对应上面的偏移量, 负类锚框(背景)对应的掩码均为0, 正类锚框的掩码均为1
        cls_labels: 每个锚框的标注类别, 其中0表示为背景, 形状为(bn，锚框总数)
'''
    
labels[2]
# Out: tensor([[0, 1, 2, 0, 2]])     # cls_labels ：背景、dog、cat、背景、cat

我们根据锚框与真实边界框在图像中的位置来分析这些标注的类别。首先，在所有的“锚框—真实边界框”的配对中，锚框A4与猫的真实边界框的交并比最大，因此锚框A4的类别标注为猫。不考虑锚框A4或猫的真实边界框，在剩余的“锚框—真实边界框”的配对中，最大交并比的配对为锚框A1和狗的真实边界框，因此锚框A1的类别标注为狗。

接下来遍历未标注的剩余3个锚框：与锚框A0交并比最大的真实边界框的类别为狗，但交并比小于阈值（默认为0.5），因此类别标注为背景；与锚框A2交并比最大的真实边界框的类别为猫，且交并比大于阈值，因此类别标注为猫；与锚框A3交并比最大的真实边界框的类别为猫，但交并比小于阈值，因此类别标注为背景。

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

labels[1]
'''
out：tensor([[0., 0., 0., 0., 1., 1., 1., 1., 1., 1., 1., 1., 0., 0., 0., 0., 1., 1.,
         1., 1.]]) 
其实就是上边代码中的b，4个为一组
'''

返回的第一项是为每个锚框标注的四个偏移量，其中负类锚框的偏移量标注为0。

labels[0]
'''
out:tensor([[-0.0000e+00, -0.0000e+00, -0.0000e+00, -0.0000e+00,  1.4000e+00,
          1.0000e+01,  2.5940e+00,  7.1754e+00, -1.2000e+00,  2.6882e-01,
          1.6824e+00, -1.5655e+00, -0.0000e+00, -0.0000e+00, -0.0000e+00,
         -0.0000e+00, -5.7143e-01, -1.0000e+00,  4.1723e-06,  6.2582e-01]])
还是4个为一组，0代表负类锚框(背景)，有数字的代表正类锚框(某一类别)
'''

10、输出预测边界框

在模型预测阶段，我们先为图像生成多个锚框，并为这些锚框一一预测类别和偏移量。随后，我们根据锚框及其预测偏移量得到预测边界框。当锚框数量较多时，同一个目标上可能会输出较多相似的预测边界框。为了使结果更加简洁，我们可以移除相似的预测边界框。常用的方法叫作非极大值抑制（non-maximum suppression，NMS）。

我们来描述一下非极大值抑制的工作原理。对于一个预测边界框B，模型会计算各个类别的预测概率。设其中最大的预测概率为p，该概率所对应的类别即B的预测类别。我们也将p称为预测边界框B的置信度。在同一图像上，我们将预测类别非背景的预测边界框按置信度从高到低排序，得到列表L。从L中选取置信度最高的预测边界框B1作为基准，将所有与B1的交并比大于某阈值的非基准预测边界框从L中移除（这样可以移除交并比高的很靠近B1的锚框，从而可以保留交并比低远离B1的锚框）。这里的阈值是预先设定的超参数。此时，L保留了置信度最高的预测边界框并移除了与其相似的其他预测边界框。 接下来，从L中选取置信度第二高的预测边界框B2作为基准，将所有与B2的交并比大于某阈值的非基准预测边界框从L中移除。重复这一过程，直到L中所有的预测边界框都曾作为基准。此时L中任意一对预测边界框的交并比都小于阈值。最终，输出列表L中的所有预测边界框。

下面来看一个具体的例子。先构造4个锚框。简单起见，我们假设预测偏移量全是0：预测边界框即锚框。最后，我们构造每个类别的预测概率。

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.0] * (4 * len(anchors)))
cls_probs = torch.tensor([[0., 0., 0., 0.,],  # 背景的预测概率
                          [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'])

效果如下图：

思考：假如输入已经与了一个训练好的模型，它为我们的每一个锚框都标记了一个置信度，对于一幅有两个狗的图片，若我们的思路是只保存狗这一类别中置信度最大的一个，该类别其它的置信度的锚框都舍弃的话，这样我们在图片中只能检测到一个框。解决该问题的办法就是第10节第二段下划线附近描述的方法（设阈值来分别跟置信度最高的预测边界框相比较，比较方式为IoU）

11、下面我们实现MultiBoxDetection函数来执行非极大值抑制。

#nametuple是tuple的高级形式，同样初始化后也不可以改变。
# tuple是只能通过索引值(0,1,2...)来访问值  nametuple则可以通过名字来索引值，可以看成是字典
from collections import namedtuple
Pred_BB_Info = namedtuple("Pred_BB_Info", ["index", "class_id", "confidence", "xyxy"])
#Pred_BB_Info是nametuple类型的变量                                   置信度     anchor
def non_max_suppression(bb_info_list, nms_threshold = 0.5): #小于0.5保留
    """
    非极大抑制处理预测的边界框
    Args:
        bb_info_list: Pred_BB_Info的列表, 包含预测类别、置信度等信息 (冗余的待删除一些边界框的锚框)
        nms_threshold: 阈值
    Returns:
        output: Pred_BB_Info的列表, 只保留过滤后的边界框信息
    """
    output = []
    # 先根据置信度从高到低排序
    sorted_bb_info_list = sorted(bb_info_list, key = lambda x: x.confidence, reverse=True)
    
    # 循环遍历删除冗余输出  （按置信度从大到小遍历每一个框）
    while len(sorted_bb_info_list) != 0:
        best = sorted_bb_info_list.pop(0) #pop(0)移除列表中的第一个元素,并返回该元素的值
        output.append(best)
        
        if len(sorted_bb_info_list) == 0:
            break

        bb_xyxy = []
        for bb in sorted_bb_info_list: #取出当前回合最大置信度的框之后，把剩余的框组合成一个列表
            bb_xyxy.append(bb.xyxy)
        #计算当前回合最大置信度的框与其余所有框的交并比，来看它们之间的相似性。
        iou = compute_jaccard(torch.tensor([best.xyxy]), 
                              torch.tensor(bb_xyxy))[0] # shape: (len(sorted_bb_info_list), )
        
        n = len(sorted_bb_info_list)
        sorted_bb_info_list = [sorted_bb_info_list[i] for i in range(n) if iou[i] <= nms_threshold]
    return output
#MultiBoxDetection是一个总的生成阈值框的函数，是在训练好的模型之后的。
def MultiBoxDetection(cls_prob, loc_pred, anchor, nms_threshold = 0.5):
    """
    # 按照「9.4.1. 生成多个锚框」所讲的实现, anchor表示成归一化(xmin, ymin, xmax, ymax).
    https://zh.d2l.ai/chapter_computer-vision/anchor.html
    Args:
        cls_prob: 经过softmax后得到的各个锚框的预测概率, shape:(bn, 预测总类别数+1, 锚框个数)
        loc_pred: 预测的各个锚框的偏移量, shape:(bn, 锚框个数*4)
        anchor: MultiBoxPrior输出的默认锚框, shape: (1, 锚框个数, 4)
        nms_threshold: 非极大抑制中的阈值
    Returns:  (以预测锚框为目标的且经过非极大值抑制筛选过的锚框)
        所有锚框的信息, shape: (bn, 锚框个数, 6)
        每个锚框信息由[class_id, confidence, xmin, ymin, xmax, ymax]表示
        class_id=-1 表示背景或在非极大值抑制中被移除了
    """
    assert len(cls_prob.shape) == 3 and len(loc_pred.shape) == 2 and len(anchor.shape) == 3
    bn = cls_prob.shape[0] #bn batch_number
    
    def MultiBoxDetection_one(c_p, l_p, anc, nms_threshold = 0.5):
        """
        MultiBoxDetection的辅助函数, 处理batch中的一个
        Args:
            c_p: (预测总类别数+1, 锚框个数)
            l_p: (锚框个数*4, )
            anc: (锚框个数, 4)
            nms_threshold: 非极大抑制中的阈值
        Return:
            output: (锚框个数, 6)
        """
        pred_bb_num = c_p.shape[1] #预测数据第一维，锚框的个数
        anc = (anc + l_p.view(pred_bb_num, 4)).detach().cpu().numpy() # 加上偏移量
        
        confidence, class_id = torch.max(c_p, 0)
        confidence = confidence.detach().cpu().numpy()
        class_id = class_id.detach().cpu().numpy()
        
        pred_bb_info = [Pred_BB_Info(
                            index = i,
                            class_id = class_id[i] - 1, # 正类label从0开始
                            confidence = confidence[i],
                            xyxy=[*anc[i]]) # xyxy是个列表
                        for i in range(pred_bb_num)] #此列表是非极大值抑制函数的输入，使用for循环每次输入Pre_BB_Info的nametuple类型结构
        
        # 正类的index 列表中已经删除了我们不需要的锚框
        obj_bb_idx = [bb.index for bb in non_max_suppression(pred_bb_info, nms_threshold)]
        
        output = []
        for bb in pred_bb_info:
            output.append([
                (bb.class_id if bb.index in obj_bb_idx else -1.0),
                bb.confidence,
                *bb.xyxy
            ])
            
        return torch.tensor(output) # shape: (锚框个数, 6)  6：类别、置信度、anchor
    
    batch_output = []
    for b in range(bn):
        batch_output.append(MultiBoxDetection_one(cls_prob[b], loc_pred[b], anchor[0], nms_threshold))
    
    return torch.stack(batch_output)

然后我们运行MultiBoxDetection函数（如下代码）并设阈值为0.5。这里为输入都增加了样本维。我们看到，返回的结果的形状为(批量大小, 锚框个数, 6)。其中每一行的6个元素代表同一个预测边界框的输出信息。第一个元素是索引从0开始计数的预测类别（0为狗，1为猫），其中-1表示背景或在非极大值抑制中被移除。第二个元素是预测边界框的置信度。剩余的4个元素分别是预测边界框左上角的x和y轴坐标以及右下角的x和y轴坐标（值域在0到1之间）。

output = MultiBoxDetection(
    cls_probs.unsqueeze(dim=0), offset_preds.unsqueeze(dim=0),
    anchors.unsqueeze(dim=0), nms_threshold=0.5)
output
'''
tensor([[[ 0.0000,  0.9000,  0.1000,  0.0800,  0.5200,  0.9200],
         [-1.0000,  0.8000,  0.0800,  0.2000,  0.5600,  0.9500],
         [-1.0000,  0.7000,  0.1500,  0.3000,  0.6200,  0.9100],
         [ 1.0000,  0.9000,  0.5500,  0.2000,  0.9000,  0.8800]]])
'''

fig = d2l.plt.imshow(img)
for i in output[0].detach().cpu().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)

最终想得到的效果：

实践中，我们可以在执行非极大值抑制前将置信度较低的预测边界框移除，从而减小非极大值抑制的计算量。我们还可以筛选非极大值抑制的输出，例如，只保留其中置信度较高的结果作为最终输出。

小结

• 以每个像素为中心，生成多个大小和宽高比不同的锚框。
• 交并比是两个边界框相交面积与相并面积之比。
• 在训练集中，为每个锚框标注两类标签：一是锚框所含目标的类别；二是真实边界框相对锚框的偏移量。
• 预测时，可以使用非极大值抑制来移除相似的预测边界框，从而令结果简洁。

补充：对于锚框的理解还可以参考这篇blog