数据预处理–对输入数据生成锚框
对于目标检测任务，要识别图片中的物体，目前一般较为常用的做法依旧是，先对需要识别的图片划分出锚框，根据锚框圈出的像素去训练预测它的所属类，所以我们的数据预处理首要任务就是对图片划分出多个锚框
%matplotlib inline
import torch
from d2l import torch as d2l
torch.set_printoptions(2) # 精简输出精度
生成多个锚框
假设输入图像的高度为，宽度为。我们以图像的每个像素为中心生成不同形状的锚框：缩放比为
s
∈
(
0
,
1
]
s\in (0, 1]
s∈(0,1]，宽高比为
r
>
0
r > 0
r>0。那么锚框的高度和宽度分别为
h
s
r
hs\sqrt{r}
hsr和
h
s
/
r
hs/ \sqrt{r}
hs/r。当中心位置给定时，它的宽高是确定的。
在SSD模型中，我们会为图片的每一个像素点生成不同形状的锚框，我们会设置许多不同的缩放比(scale)取值
s
1
,
…
,
s
n
s_1,\dots,s_n
s1,…,sn和许多不同的宽高比取值
r
1
,
…
,
r
m
r_1,\dots,r_m
r1,…,rm。所以对于一张输入的图像会生成
w
h
n
m
whnm
whnm个锚框，这计算量过于巨大。所以在实践中只考虑分别以
s
1
,
r
1
s_1,r_1
s1,r1为基准，即
s
1
s_1
s1与所有不同的宽高比做组合，
r
1
r_1
r1与所有不同的缩放比做组合。
也就是说，最后，对与一个单一的像素为中心生成的锚框数量为
n
m
−
1
n_m-1
nm−1，整个图像共生成
w
h
(
n
+
m
−
1
)
wh(n+m-1)
wh(n+m−1)个锚框。
下面函数multibox_prior将实现一张图片所有锚框的生成。
#@save
def multibox_prior(data, sizes, ratios):
"""生成以每个像素为中心具有不同形状的锚框"""
# data:[batch_size, channel, width, heigth]
# 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轴上缩放步长
# 生成锚框的所有中心点
# 例如是对于[0, 0]位置的像素点，我们将锚框中心移至[0.5, 0.5]，即像素点的中心，再乘缩放步长
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和h是根据公式计算而来，但是只做了缩放比与宽高比之间的计算，没有乘高宽，是因为对于高宽的计算即使乘上
# wh,也需要和像素点中心的计算一样，乘上缩放步长，结果就是下面的代码
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来获得半高和半宽
# 经过torch.stack[4, 5]，经过转置后[5, 4]
# anchor_manipulations:[5*in_height * in_width, 4]
anchor_manipulations = torch.stack((-w, -h, w, h)).T.repeat(
in_height * in_width, 1) / 2
# 每个中心点都将有“boxes_per_pixel”个锚框，
# 所以生成含所有锚框中心的网格，重复了“boxes_per_pixel”次
# 经过torch.stack后[in_height * in_width, 4]
# 经过.repeat_interleave后[5*in_height * in_width, 4]，该方法会把每个元素都复制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
# 最后得到的位置信息是[x_左上, y_左上, x_右下, y_右下]
return output.unsqueeze(0)
对于上述代码，有两处较有疑问，一处是shift_y, shift_x = torch.meshgrid(center_h, center_w, indexing='ij') shift_y, shift_x = shift_y.reshape(-1), shift_x.reshape(-1)
另一处是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:])))
对于前者，我们要了解torch.meshgrid的用法，对于SSD模型对每个像素都生成锚框，则对于每一个center_h都要与所有的center_w匹配。要实现这一点最好的就是torch.meshgrid方法，生成一个网格。然后再将其展平。下面有一个例子：
a = torch.tensor([1, 2, 3])
b = torch.tensor([4, 5, 6])
print(a)
print(b)
tensor([1, 2, 3])
tensor([4, 5, 6])
d, c = torch.meshgrid(b, a)
print(c)
print(d)
tensor([[1, 2, 3],
[1, 2, 3],
[1, 2, 3]])
tensor([[4, 4, 4],
[5, 5, 5],
[6, 6, 6]])
对于torch.meshgrid(b, a)默认为indexing='ij'行优先，输出形状为(h, w)它的逻辑是生成两个h为size(a)的长度，w为size(b)的tensor，c中每行重复a的值，d中每行重复b的值，形成二维网格坐标
对于后者为什么w的计算后面又乘上了in_height / in_width，因为按照我们的公式计算出来的高宽比为
w
r
h
\frac{wr}{h}
hwr，而不是
r
r
r，因此程序中(*in_height / in_width)操作就是将锚框宽高比限制为
r
r
r。而且代码中
w
w
w和
h
h
h的计算并没有乘上height和width，是因为锚框的高宽我们本来就是要再乘上缩放步长的（即steps_h和steps_w），缩放步长刚好与height*width相抵消。
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])
boxes = Y.reshape(h, w, 5, 4)
boxes[250, 250, 0, :]
tensor([0.06, 0.07, 0.63, 0.82])
#@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))
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'])
交并比(IoU)
我们希望某个锚框“较好地”覆盖了图像中的狗。 如果已知目标的真实边界框，那么这里的“好”该如何如何量化呢？ 直观地说，可以衡量锚框和真实边界框之间的相似性。杰卡德系数（Jaccard）可以衡量两组之间的相似性。给定集合 ( A ) 和 ( B ) (\mathcal{A})和(\mathcal{B}) (A)和(B)，他们的杰卡德系数是他们交集的大小除以他们并集的大小：
( A , B ) = ∣ A ∩ B ∣ ∣ A ∪ B ∣ (\mathcal{A},\mathcal{B}) = \frac{\left|\mathcal{A} \cap \mathcal{B}\right|}{\left| \mathcal{A} \cup \mathcal{B}\right|} (A,B)=∣A∪B∣∣A∩B∣
事实上，我们可以将任何边界框的像素区域视为一组像素。通 过这种方式，我们可以通过其像素集的杰卡德系数来测量两个边界框的相似性。对于两个边界框，它们的杰卡德系数通常称为交并比（intersection over union，IoU），即两个边界框相交面积与相并面积之比，如下图所示。交并比的取值范围在0和1之间：0表示两个边界框无重合像素，1表示两个边界框完全重合。
接下来部分将使用交并比来衡量锚框和真实边界框之间、以及不同锚框之间的相似度。 给定两个锚框或边界框的列表，以下box_iou函数将在这两个列表中计算它们成对的交并比。
#@save
def box_iou(boxes1, boxes2):
"""计算两个锚框或边界框列表中成对的交并比"""
# (x_右上-x_左下) * (y_右上-y_左下)
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
上面代码中较难理解的是对inter_upperlefts和inter_lowerrights的生成，其中boxes1[:, None, :2]是为了为boxes1增加一个维度(从[boxes1的数量, 2]->[boxes1的数量, 1, 2])，因为最终我们想要得到这两个对象的形状是(boxes1的数量,boxes2的数量,2)，所以在boxes1增加一个维度后，再与boxes2计算时就会触发广播机制，每一个boxes1里的锚框都会与boxes2所有的锚框做一次运算。
在训练数据中标记锚框
在训练集中，我们将每个锚框视为一个训练样本。 为了训练目标检测模型，我们需要每个锚框的类别（class）和偏移量（offset）标签，其中前者是与锚框相关的对象的类别，后者是真实边界框相对于锚框的偏移量。 在预测时，我们为每个图像生成多个锚框，预测所有锚框的类别和偏移量，根据预测的偏移量调整它们的位置以获得预测的边界框，最后只输出符合特定条件的预测边界框。
目标检测训练集带有真实边界框的位置及其包围物体类别的标签。 要标记任何生成的锚框，我们可以参考分配到的最接近此锚框的真实边界框的位置和类别标签。 下文将介绍一个算法，它能够把最接近的真实边界框分配给锚框。
将真实边界框分配给锚框
给定图像，假设锚框是 ( A 1 , A 2 , … , A n a ) (A_1, A_2, \ldots, A_{n_a}) (A1,A2,…,Ana)，真实边界框是 ( B 1 , B 2 , … , B n b ) (B_1, B_2, \ldots, B_{n_b}) (B1,B2,…,Bnb)，其中 ( n a ≥ n b ) (n_a \geq n_b) (na≥nb)。 让我们定义一个矩阵 ( X ∈ R n a × n b ) (\mathbf{X} \in \mathbb{R}^{n_a \times n_b}) (X∈Rna×nb)，其中第 i i i行、第 j j j列的元素 x i j x_{ij} xij是锚框 A i A_i Ai和真实边界框 B j B_j Bj的IoU。 该算法包含以下步骤。
在矩阵 X \mathbf{X} X中找到最大的元素，并将它的行索引和列索引分别表示为 i 1 i_1 i1和 j 1 j_1 j1。然后将真实边界框 B j 1 B_{j_1} Bj1分配给锚框 A i 1 A_{i_1} Ai1。这很直观，因为 A i 1 A_{i_1} Ai1和 B j 1 B_{j_1} Bj1是所有锚框和真实边界框配对中最相近的。在第一个分配完成后，丢弃矩阵中 i 1 t h {i_1}^\mathrm{th} i1th行和 j 1 t h {j_1}^\mathrm{th} j1th列中的所有元素。
在矩阵 X \mathbf{X} X中找到剩余元素中最大的元素，并将它的行索引和列索引分别表示为 i 2 i_2 i2和 j 2 j_2 j2。我们将真实边界框 B j 2 B_{j_2} Bj2分配给锚框 A i 2 A_{i_2} Ai2，并丢弃矩阵中 i 2 t h {i_2}^\mathrm{th} i2th行和 j 2 t h {j_2}^\mathrm{th} j2th列中的所有元素。
此时，矩阵 X \mathbf{X} X中两行和两列中的元素已被丢弃。我们继续，直到丢弃掉矩阵 X \mathbf{X} X中 n b n_b nb列中的所有元素。此时已经为这 n b n_b nb个锚框各自分配了一个真实边界框。
只遍历剩下的 n a − n b n_a - n_b na−nb个锚框。例如，给定任何锚框 A i A_i Ai，在矩阵 X \mathbf{X} X的第 i t h i^\mathrm{th} ith行中找到与 A i A_i Ai的IoU最大的真实边界框 B j B_j Bj，只有当此IoU大于预定义的阈值时，才将 B j B_j Bj分配给 A i A_i Ai。
下面用一个具体的例子来说明上述算法。 如 图13.4.2（左）所示，假设矩阵 X \mathbf{X} X中的最大值为 x 23 x_{23} x23，我们将真实边界框 B 3 B_3 B3分配给锚框 A 2 A_2 A2。 然后，我们丢弃矩阵第2行和第3列中的所有元素，在剩余元素（阴影区域）中找到最大的 x 71 x_{71} x71，然后将真实边界框 B 1 B_1 B1分配给锚框 A 7 A_7 A7。 接下来，如 图13.4.2（中）所示，丢弃矩阵第7行和第1列中的所有元素，在剩余元素（阴影区域）中找到最大的 x 54 x_{54} x54，然后将真实边界框 B 4 B_4 B4分配给锚框 A 5 A_5 A5。 最后，如 图13.4.2（右）所示，丢弃矩阵第5行和第4列中的所有元素，在剩余元素（阴影区域）中找到最大的 x 92 x_{92} x92，然后将真实边界框 B 2 B_2 B2分配给锚框 A 9 A_9 A9。 之后，我们只需要遍历剩余的锚框 A 1 , A 3 , A 4 , A 6 , A 8 A_1, A_3, A_4, A_6, A_8 A1,A3,A4,A6,A8，然后根据阈值确定是否为它们分配真实边界框。
此算法在下面的assign_anchor_to_bbox函数中实现。
#@save
def assign_anchor_to_bbox(ground_truth, anchors, device, iou_threshold=0.5):
"""将最接近的真实边界框分配给锚框"""
# num_anchors：锚框数量
# num_gt_boxes：真实边界框数量
num_anchors, num_gt_boxes = anchors.shape[0], ground_truth.shape[0]
# 位于第i行和第j列的元素x_ij是锚框i和真实边界框j的IoU
# jaccard:[num_anchors, num_gt_boxes]
jaccard = box_iou(anchors, ground_truth)
# 对于每个锚框，分配的真实边界框的张量
# anchors_bbox_map:[num_anchors,]里面每个值初始化为-1，表示一开始全都未分配真实边界框
anchors_bbox_map = torch.full((num_anchors,), -1, dtype=torch.long,
device=device)
# 根据阈值，决定是否分配真实边界框
# 按dim=1的维度找到每一行iou的最大值及其对应的索引
# max_ious:[num_anchors,]；indices:[num_anchors,]
# indices里面的值是真实边界框的索引
max_ious, indices = torch.max(jaccard, dim=1)
# max_ious >= iou_threshold将max_ious中所有小于阈值的值置为False，大于等于的置为True
# anc_i：max_ious >= iou_threshold的索引
anc_i = torch.nonzero(max_ious >= iou_threshold).reshape(-1)
# box_i：为max_ious >= iou_threshold的锚框得到对应的真实边界框索引
box_j = indices[max_ious >= iou_threshold]
anchors_bbox_map[anc_i] = box_j
# 下面两个变量用于清除被选中x_ij所在行列的所有值
col_discard = torch.full((num_anchors,), -1)
row_discard = torch.full((num_gt_boxes,), -1)
# 上面的代码是将所有锚框中各自对真实边界框的iou值的最大值，只要该最大值大于阈值，就为其赋予一个最大值对应的真实框，也就是说一个
# 真实框可能会有多个锚框，但也有可能出现某个真是边界框没有任何一个锚框的最大值是它，也就是该真实边界框没有锚框。
# 下面的for循环保证了任何一个真实边界框都至少有一个锚框与其对应，即使该锚框对它的iou值小于阈值。
for _ in range(num_gt_boxes):
# 对于torch.argmax方法，若不加dim参数，会将操作对象扁平化处理，即将其展平为一维向量，在返回最大值在一维上的索引
max_idx = torch.argmax(jaccard)
# box_idx：列索引--真实边界框索引
# anc_idx：行索引--锚框索引
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
经过上面的代码处理，每一个真实边界框都至少有一个锚框与其对应。可能会有多个锚框对应同一个真实边界框，但一个锚框只会对应一个真实边界框
标记类别和偏移量
我们可以为每个锚框标记类别和偏移量了。假设一个锚框
A
A
A被分配了一个真实边界框
B
B
B。一方面，锚框
A
A
A的类别将会被标记与
B
B
B相同，另一方面，锚框
A
A
A的偏移量将根据
B
B
B和
A
A
A中心坐标的的相对位置以及这两个框的相对大小进行标记。鉴于数据集内不同的框的位置和大小不同，我们可以对那些相对位置和大小进行变换，使其获得分布更均匀且易于拟合的偏移量。
给定框
A
A
A和
B
B
B，中心坐标分别为
(
x
a
,
y
a
)
(x_a,y_a)
(xa,ya)和
(
x
b
,
y
b
)
(x_b,y_b)
(xb,yb)，宽度分别为
w
a
w_a
wa和
w
b
w_b
wb，高度分别为
h
a
h_a
ha和
h
b
h_b
hb，可以将
A
A
A的偏移量标记为：
(
x
b
−
x
a
w
a
−
μ
x
σ
x
,
y
b
−
y
a
h
a
−
μ
y
σ
y
,
log
w
b
w
a
−
μ
w
σ
w
,
log
h
b
h
a
−
μ
h
σ
h
)
\left( \begin{matrix} \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} \end{matrix} \right)
(σxwaxb−xa−μx,σyhayb−ya−μy,σwlogwawb−μw,σhloghahb−μh)
其中常量的默认值为
μ
x
=
μ
y
=
μ
w
=
μ
h
=
0
\mu_x=\mu_y=\mu_w=\mu_h=0
μx=μy=μw=μh=0，
σ
x
=
σ
y
=
0.1
\sigma_x=\sigma_y=0.1
σx=σy=0.1，
σ
w
=
σ
h
=
0.2
\sigma_w=\sigma_h=0.2
σw=σ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
如果一个锚框没有被分配真实边界框，我们只需将锚框的类别标记为背景（background）。背景类别的锚框通常被称为负类锚框，其余的被称为正类锚框。我们使用真实边界框（labels参数）实现以下multibox_target函数，来标记锚框的类别和偏移量（anchors参数）。此函数将背景类别的索引设置为零，然后将新类别的整数索引递增一。
#@save
def multibox_target(anchors, labels):
"""使用真实边界框标记锚框"""
# anchors:[1, 锚框数, 位置信息]
# labels:[batch_size, 真实边阶框数, 类别+位置信息]
# 这里将anchors的第一个维度进行压缩，因为我们每一张图片的size应该相同，所以生成的初始锚框数量一样
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)
# 将anchors_bbox_map中大于0的化为1，小于0的化为0，size:[num_anchors,]
# 经过.unsqueeze(-1)，size:[num_anchors,1]
# 经过.repeat(1, 4)第一维重复一次，第二维重复4次，size:[num_anchors,4]
# 之所以列维度重复四次，是为了与offset相乘，将未被分配真实边界框的锚框位置信息化为0，表示为背景
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:存放分配到真实边界框的锚框索引
indices_true = torch.nonzero(anchors_bbox_map >= 0)
# bb_idx:存放锚框所得到真实边界框的索引
bb_idx = anchors_bbox_map[indices_true]
# 这里之所以对label+1是因为我们希望将背景的label设为0，所以其他的真实类别就依次递增1
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)
一个例子
下面通过一个具体的例子来说明锚框标签。我们已经为加载图像中的狗和猫定义了真实边界框，其中第一个元素是类别（0代表狗，1代表猫），其余四个元素是左上角和右下角的 ( x , y ) (x,y) (x,y)轴坐标（范围介于0和1之间）。我们还构建了五个锚框，用左上角和右下角的坐标进行标记： A 0 , … , A 4 A_0,\dots,A_4 A0,…,A4（索引从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']);
使用上面定义的multibox_target函数，我们可以根据狗和猫的真实边界框，标注这些锚框的分类和偏移量。 在这个例子中，背景、狗和猫的类索引分别为0、1和2。 下面我们为锚框和真实边界框样本添加一个维度。调用multibox_target函数，看一下输出结果
labels = multibox_target(anchors.unsqueeze(dim=0),
ground_truth.unsqueeze(dim=0))
返回的结果中有三个元素，都是张量格式。第三个元素包含标记的输入锚框的类别。
让我们根据图像中的锚框和真实边界框的位置来分析下面返回的类别标签。首先，在所有的锚框和真实边界框配对中，锚框 A 4 A_4 A4与猫的真实边界框的IoU是最大的。因此， A 4 A_4 A4的类别被标记为猫。去除包含 A 4 A_4 A4或猫的真实边界框的配对，在剩下的配对中，锚框 A 1 A_1 A1和狗的真实边界框有最大的IoU。 因此， A 1 A_1 A1的类别被标记为狗。 接下来，我们需要遍历剩下的三个未标记的锚框： A 0 A_0 A0、 A 2 A_2 A2和 A 3 A_3 A3。对于 A 0 A_0 A0，与其拥有最大IoU的真实边界框的类别是狗，但IoU低于预定义的阈值（0.5），因此该类别被标记为背景；对于 A 2 A_2 A2，与其拥有最大IoU的真实边界框的类别是猫，IoU超过阈值，所以类别被标记为猫；对于 A 3 A_3 A3，与其拥有最大IoU的真实边界框的类别是猫，但值低于阈值，因此该类别被标记为背景。
labels[2]
tensor([[0, 1, 2, 0, 2]])
返回的第二个元素是掩码（mask）变量，形状为（批量大小，锚框数的四倍）。 掩码变量中的元素与每个锚框的4个偏移量一一对应。 由于我们不关心对背景的检测，负类的偏移量不应影响目标函数。 通过元素乘法，掩码变量中的零将在计算目标函数之前过滤掉负类偏移量。
labels[1]
tensor([[0., 0., 0., 0., 1., 1., 1., 1., 1., 1., 1., 1., 0., 0., 0., 0., 1., 1.,
1., 1.]])
返回的第一个元素包含了为每个锚框标记的四个偏移值。 请注意，负类锚框的偏移量被标记为零。
labels[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]])
后处理–对输出结果锚框进行处理
运用非极大值抑制预测边界框(NMS)，因为可能会有多个锚框预测一个真实边界框，我们希望对于真实边界框只需要一个预测锚框来预测它就好。
在预测时，我们先为图像生成多个锚框，再为这些锚框一一预测类别和偏移量。 一个预测好的边界框则根据其中某个带有预测偏移量的锚框而生成。 下面我们实现了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
当有许多锚框时，可能会输出许多相似的具有明显重叠的预测边界框，都围绕着同一目标。 为了简化输出，我们可以使用非极大值抑制（non-maximum suppression，NMS）合并属于同一目标的类似的预测边界框。
以下是非极大值抑制的工作原理。 对于一个预测边界框
B
B
B，目标检测模型会计算每个类别的预测概率。假设最大的预测概率为
p
p
p，则该概率所对应的类
B
B
B
即为预测的类别。 具体来说，我们将
p
p
p称为预测边界框
B
B
B的置信度（confidence）。在同一张图像中，所有预测的非背景边界框都按置信度降序排序，以生成列表
L
L
L。然后我们通过以下步骤操作排序列表
L
L
L。
-
从 L L L中选取置信度最高的预测边界框 B 1 B_1 B1作为基准，然后将所有与 B 1 B_1 B1的IoU超过预定阈值 ϵ \epsilon ϵ的非基准预测边界框从 L L L中移除。这时 L L L保留了置信度最高的预测边界框，去除了与其太过相似的其他预测边界框。简而言之，那些具有非极大值置信度的边界框被抑制了。
-
从 L L L中选取置信度第二高的预测边界框 B 2 B_2 B2作为又一个基准，然后将所有与 B 2 B_2 B2的IoU大于 ϵ \epsilon ϵ的非基准预测边界框从 L L L中移除。
-
重复上述过程，直到 L L L中的所有预测边界框都曾被用作基准。此时， L L L中任意一对预测边界框的IoU都小于阈值 ϵ \epsilon ϵ；因此，没有一对边界框过于相似。
-
输出列表 L L L中的所有预测边界框。
以下nms函数按降序对置信度进行排序并返回其索引。
#@save
def nms(boxes, scores, iou_threshold):
"""对预测边界框的置信度进行排序"""
# boxes:[num_anchors, 位置信息]
# scores:[num_anchors, 置信度]，这里的置信度可以理解为锚框对其所匹配真实边界框类别的预测准确度
# 对置信度进行降序，并返回从大到小的索引
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
iou = box_iou(boxes[i, :].reshape(-1, 4),
boxes[B[1:], :].reshape(-1, 4)).reshape(-1)
# iou <= iou_threshold将iou小于阈值的设为TRUE，大于的设为FALSE
# 返回小于阈值的索引，表示要将它们保留，而大于阈值值的则意味着与最大置信度锚框过于接近，很可能表述了同一个真实边界框
# 所以剔除
inds = torch.nonzero(iou <= iou_threshold).reshape(-1)
B = B[inds + 1]
return torch.tensor(keep, device=boxes.device)
上面代码的B = B[inds + 1]有一个+1的操作，是因为，我们本来就是那B中的第一个值与后面的所有值做计算，所以我们的inds实际上相对于B的索引往前移动了一个位置，所以要将那个1加回来。
我们定义以下multibox_detection函数来将非极大值抑制应用于预测边界框。 这里的实现有点复杂，请不要担心。我们将在实现之后，马上用一个具体的例子来展示它是如何工作的。
#@save
def multibox_detection(cls_probs, offset_preds, anchors, nms_threshold=0.5,
pos_threshold=0.009999999):
"""使用非极大值抑制来预测边界框"""
# cls_probs:[batch_size, 真实类别数， 锚框数(存放对类别的预测置信度)]
# offset_preds:[batch_size, 锚框数, offset_value]
# 注意这里的锚框都是经过上面对所有像素而生成的锚框处理后留下来的，用于预测的锚框
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)
# 实际我们在前面拿到锚框之后需要对锚框里的内容做预测，看他是属于哪个类别，所以通过softmax函数，每个锚框都会对所有类别有一个
# 预测值，所以这里要通过torch.max()方法得到锚框最大的预测类别，因为一开始为真实边界框分配锚框是就没有考虑到背景，也不需要对
# 背景做出预测，所以不考虑我们的锚框可能会预测出背景。
conf, class_id = torch.max(cls_prob[1:], 0) # 这里cls_prob[1:]表示只对真实类别预测，不对背景做预测
# predicted_bb得到预测的锚框
predicted_bb = offset_inverse(anchors, offset_pred)
# 通过nms函数得到保留的锚框
keep = nms(predicted_bb, conf, nms_threshold)
# 找到所有的non_keep索引，并将类设置为背景
# 从28-35行代码实际上实现了将分配了真实边界框的锚框放在前面，并存储对应预测出来的类别，将背景放在后面，并将其赋值为0
# 最后得到的class_id是与[keep, 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]
# 获取与上面得到的class_id一一对应的预测值和预测锚框
conf, predicted_bb = conf[all_id_sorted], predicted_bb[all_id_sorted]
# pos_threshold是一个用于非背景预测的阈值
# 小于阈值的设为TRUE，大于阈值的设为FALSE
below_min_idx = (conf < pos_threshold)
# 我们在上面已经将non_keep的位置设为了-1，这里之所以还有这样的操作，是因为对于部分锚框它对所有类别的预测都很小，即使他在nms
# 算法中保留下来，我们依旧认为其是背景，将其设为-1
class_id[below_min_idx] = -1
# 将被设置为背景的锚框的背景预测值设置为1 - conf[below_min_idx]，这样可以表示它为背景的概率比较大
conf[below_min_idx] = 1 - conf[below_min_idx]
# pre_info:[num_anchors, class_id+conf+predicted_bb]
pred_info = torch.cat((class_id.unsqueeze(1),
conf.unsqueeze(1),
predicted_bb), dim=1)
# 处理好了一张图片，将其加入到out中
out.append(pred_info)
return torch.stack(out)
一个例子
现在让我们将上述算法应用到一个带有四个锚框的具体示例中。为简单起见，我们假设预测的偏移量都是零，这意味着预测的边界框即是锚框。对于背景、狗和猫其中的每个类，我们还定义了它的预测概率。
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。 请注意，我们在示例的张量输入中添加了维度。
我们可以看到返回结果的形状是（批量大小，锚框的数量，6）。最内层维度中的六个元素提供了同一预测边界框的输出信息。第一个元素是预测的类索引，从0开始（0代表狗，1代表猫），值-1表示背景或在非极大值抑制中被移除了。第二个元素是预测的边界框的置信度。其余四个元素分别是预测边界框左上角和右下角的
(
x
,
y
)
(x,y)
(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
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类别（背景）的预测边界框后，我们可以输出由非极大值抑制保存的最终预测边界框。删除-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)
扫一扫
2142
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
