13.4.0 头文件
import torch
from d2l import torch as d2l
from matplotlib import pyplot as plt
d2l.set_figsize()
torch.set_printoptions(2) # 精简输出精度
# 宽高比r是指锚框的宽高比与图像的宽高比之比，即 w' / h' = w / h * r
# 缩放比s是指图像尺寸缩放因子，即 w'h' / whs^2
# 两者联立之后就可以得到锚框宽度为 w’ = ws × sqrt(r)，锚框高度为 h’ = hs / sqrt(r)
# w’‘ = s × sqrt(r)为归一化之后的锚框宽度
# h’‘ = s / sqrt(r)为归一化之后的锚框高度
13.4.1 获取图像中每个像素的所有锚框的归一化坐标
def multibox_prior(data, sizes, ratios):
# 输入：
# data:一个批量的图像
# sizes:所有的缩放比
# ratios:所有的宽高比
# 输出：
# output.unsqueeze(0):一批图像中每个像素的所有锚框的归一化坐标（左上x坐标，左上y坐标，右下x坐标，右下y坐标），坐标以图像左上角为原点 形状为(批量大小,像素点个数,坐标)
# 功能：
# 一批图像中每个像素的所有锚框的归一化坐标（左上x坐标，左上y坐标，右下x坐标，右下y坐标）
# in_height为图像的行数，in_width为图像的列数
in_height, in_width = data.shape[-2:]
# device为图像所在的设备（CPU）、num_sizes为缩放比的个数、num_ratios为长宽比的个数
device, num_sizes, num_ratios = data.device, len(sizes), len(ratios)
# boxes_per_pixel为以同一像素为中心的锚框数量
boxes_per_pixel = (num_sizes + num_ratios - 1)
# 把缩放比转换成张量
size_tensor = torch.tensor(sizes, device=device)
# 把宽高比转换成张量
ratio_tensor = torch.tensor(ratios, device=device)
# 像素的高宽均为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中存放了所有锚点的归一化列坐标（线聚成面）
shift_y, shift_x = torch.meshgrid(center_h, center_w, indexing='ij')
shift_y, shift_x = shift_y.reshape(-1), shift_x.reshape(-1)
# 将所有缩放比和高宽比进行组合的话，会生成大量的锚框，因此实践中只考虑第一个缩放比和第一个高宽比的组合，这样以同一个像素为中心的锚框的数量就是（缩放比个数+高宽比个数-1），整个图像中的锚框数量就是（行数×列数×（缩放比个数+高宽比个数-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.stack((-w, -h, w, h)).T / 2 为一个像素点的锚框集合，每个锚框的形式为（坐上x坐标，坐上y坐标，右下x坐标，右下y坐标）（坐标位置以锚点为原点，而且经过了归一化）
# 生成一个图像中所有像素的锚框，而且每个锚框的表示形式均以自己的锚点为中心
anchor_manipulations = torch.stack((-w, -h, w, h)).T.repeat(in_height * in_width, 1) / 2
# 生成并返回一个图像中每个像素的所有锚框（左上x坐标，左上y坐标，右下x坐标，右下y坐标），坐标以图像左上角为原点，而且经过了归一化
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)
# 读入图像dog_cat.jpg，形状为（行数578，列数1032，通道数3）
img = d2l.plt.imread('../img/catdog.jpg')
h, w = img.shape[:2]
print(h, w)
# 输出：
# 578 1032
# 随机生成一个批量的图像，批量大小为1，图像通道数为3，行数578，列数1032
X = torch.rand(size=(1, 3, h, w))
# sizes为缩放比，ratio为宽高比
# 返回图像X中每个像素的所有锚框（左上x坐标，左上y坐标，右下x坐标，右下y坐标），坐标以图像左上角为原点，而且经过了归一化
Y = multibox_prior(X, sizes=[0.75, 0.5, 0.25], ratios=[1, 2, 0.5])
print(Y.shape)
# 输出：
# torch.Size([1, 2982480, 4]) 2982480为这个图像中锚框的总数（图像中锚框的总数 = 图像中像素数 × 每个像素的锚框数） 4为每个锚框的坐上和右下两个坐标
# 查看第一个像素的第一个锚框
print(Y[0][0])
# 输出：
# tensor([-0.21, -0.37, 0.21, 0.38])
# 将锚框集合组织成（行数，列数，每个像素点的锚框数，锚框坐标）
boxes = Y.reshape(h, w, 5, 4)
# 第250行第250列像素的第0个锚框
print(boxes[250, 250, 0, :])
# 输出：
# tensor([0.03, 0.06, 0.45, 0.81])
13.4.2 在图像上画出锚框或边界框,并显示相应的文本
def show_bboxes(axes, bboxes, labels=None, colors=None):
# 输入：
# axes:要绘图的画布
# bboxes:锚框的非归一化坐标
# labels:锚框的标签
# colors:锚框的颜色
# 输出：
# 无
# 功能：
# 在图像上画出锚框或边界框,并显示相应的文本
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:每个锚框对应的标签
labels = _make_list(labels)
# colors：每个锚框对应的颜色
colors = _make_list(colors, ['b', 'g', 'r', 'm', 'c'])
for i, bbox in enumerate(bboxes):
color = colors[i % len(colors)]
# 把锚框的（左上(x, y), 右下(x, y)）坐标转换为（中心(x, y), 宽x, 高y）坐标，同时设置锚框颜色
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'
# 在锚框上画出标签框
# rect.xy[0], rect.xy[1]为放置标签框的位置，ha为水平对齐方式，va为垂直对齐方式，fontsize为字体大小，color为字体颜色，labels[i]为标签框中的标签内容
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))
# bbox_scale：（行数，列数，行数，列数），后续用来计算每个锚框的实际坐标（未归一化坐标）
bbox_scale = torch.tensor((w, h, w, h))
fig = d2l.plt.imshow(img)
# 画出（250，250）像素点处的所有锚框和标签框
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'])
plt.show()
13.4.3 根据真实边界框,计算出每个锚框的分类和偏移量
def box_iou(boxes1, boxes2):
# 输入：
# boxes1:锚框的归一化坐标集合，形状为（锚框集合数，坐标）
# boxes2:真实边界框的归一化坐标集合，（不包括真实边界框的类别信息），形状为（真实边界框集合数，坐标）
# 输出：
# 锚框集合中每个锚框与真实边界框中每个真实边界框之间的交并比，形状为（锚框集合数，真实边界框集合数）
# 功能：
# 计算锚框集合中每个锚框与真实边界框中每个真实边界框之间的交并比，形状为（锚框集合数，真实边界框集合数）
# 定义一个lambda表达式，用来计算锚框或者真实边界框的归一化面积
box_area = lambda boxes: ((boxes[:, 2] - boxes[:, 0]) * (boxes[:, 3] - boxes[:, 1]))
# 计算锚框集合中每个锚框的归一化面积
areas1 = box_area(boxes1)
# 计算真实边界框集合中每个真实边界框的归一化面积
areas2 = box_area(boxes2)
# 计算锚框集合中每个锚框与真实边界框中每个真实边界框之间交集的左上角归一化坐标，形状为（锚框集合数，真实边界框集合数，坐标）
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_areas = inters[:, :, 0] * inters[:, :, 1]
# 计算锚框集合中每个锚框与真实边界框中每个真实边界框之间并集的归一化面积，形状为（锚框集合数，真实边界框集合数）
union_areas = areas1[:, None] + areas2 - inter_areas
# 计算并返回锚框集合中每个锚框与真实边界框中每个真实边界框之间的交并比，形状为（锚框集合数，真实边界框集合数）
return inter_areas / union_areas
def assign_anchor_to_bbox(ground_truth, anchors, device, iou_threshold=0.5):
# 输入：
# anchors:锚框的归一化坐标集合，形状为（锚框集合数，坐标）
# ground_truth:真实边界框的归一化坐标集合，（不包括真实边界框的类别信息），形状为（真实边界框集合数，坐标）
# device：设备
# iou_threshold：交并比阈值
# 输出：
# 返回锚框集合中的每个锚框和相应的真实边界框的映射关系
# 功能：
# 建立锚框和真实边界框的映射关系
# num_anchors为锚框的个数，num_gt_boxes为真实边界框的个数
num_anchors, num_gt_boxes = anchors.shape[0], ground_truth.shape[0]
# 计算锚框集合中每个锚框与真实边界框中每个真实边界框之间的交并比，形状为（锚框集合数，真实边界框集合数）
jaccard = box_iou(anchors, ground_truth)
# 创建一个映射表，用来存放每个锚框对应的真实边界框编号，初始时都为-1，形状为（锚框集合数）
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 >= iou_threshold).reshape(-1)
box_j = indices[max_ious >= iou_threshold]
# 将锚框和真实边界框的对应关系存入到anchors_bbox_map映射表中
anchors_bbox_map[anc_i] = box_j
col_discard = torch.full((num_anchors,), -1)
row_discard = torch.full((num_gt_boxes,), -1)
for _ in range(num_gt_boxes):
# 计算交并比矩阵中最大值的编号（拉成一维后得到的索引）
max_idx = torch.argmax(jaccard)
# print(max_idx)
# 计算这个最大值所在的列，即真实边界框的编号
box_idx = (max_idx % num_gt_boxes).long()
# 计算这个最大值所在的行，即锚框的编号
anc_idx = (max_idx / num_gt_boxes).long()
# 建立这个最大值对应锚框和真实边界框的映射关系
anchors_bbox_map[anc_idx] = box_idx
# 将最大值所在列和所在行的所有交并比赋值为-1
jaccard[:, box_idx] = col_discard
jaccard[anc_idx, :] = row_discard
# 返回每个锚框和其相应的真实边界框的映射关系
return anchors_bbox_map
def offset_boxes(anchors, assigned_bb, eps=1e-6):
# 输入：
# anchors:锚框的归一化坐标集合，形状为（锚框集合数，坐标）
# assigned_bb:锚框对应的真实边界框的归一化坐标，对于类型为背景的坐标设为[0, 0, 0, 0]
# 输出：
# 返回每个锚框相对于其对应的真实边界框的中心点xy偏移量和宽高wh的偏移量
# 功能：
# 计算每个锚框相对于其对应的真实边界框的中心点xy偏移量和宽高wh的偏移量
# 把锚框的（左上(x,y),右下(x,y)）坐标转换为（中心(x,y),宽x,高y）坐标
c_anc = d2l.box_corner_to_center(anchors)
# 把锚框对应的真实边界框的（左上(x,y),右下(x,y)）坐标转换为（中心(x,y),宽x,高y）坐标
c_assigned_bb = d2l.box_corner_to_center(assigned_bb)
# 计算并返回每个锚框相对于其对应的真实边界框的中心点xy偏移量和宽高wh的偏移量
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
def multibox_target(anchors, labels):
# 输入：
# anchors:锚框的归一化坐标集合，形状为（锚框集合数，坐标）
# labels:真实边界框的归一化坐标集合，（包括真实边界框的类别信息），形状为（真实边界框集合数，类别+坐标）
# 输出：
# bbox_offset：每个锚框相对真实边界框的中心点xy偏移量和宽高wh的偏移量（将类别为背景的偏移量置零）
# bbox_mask：每个锚框对应的真实边界框是背景还是非背景，为0表示背景，为1表示非背景
# class_labels：锚框和真实边界框的映射关系，0为背景，非背景依序递增
#
# 功能：
# 获取锚框与相应真实边界框的中心点xy偏移量和宽高偏移量，以及锚框和真实边界框的映射关系
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, :, :]
# 建立锚框和真实边界框的映射关系（-1表示背景）
anchors_bbox_map = assign_anchor_to_bbox(label[:, 1:], anchors, device)
# 将背景与非背景区分开来，为背景的锚框用-1表示，为非背景的锚框用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 = torch.nonzero(anchors_bbox_map >= 0)
# 相应真实边界框为非背景的锚框缩所对应真实边界框的编号
bb_idx = anchors_bbox_map[indices_true]
# 将锚框和真实边界框的映射关系全部加1
class_labels[indices_true] = label[bb_idx, 0].long() + 1
# 锚框对应的真实边界框的归一化坐标，对于类型为背景的坐标设为[0,0,0,0]
assigned_bb[indices_true] = label[bb_idx, 1:]
# 计算每个锚框相对于其对应的真实边界框的中心点xy偏移量和宽高wh的偏移量,并且将类别为背景的偏移量置零
offset = offset_boxes(anchors, assigned_bb) * bbox_mask # (逐元素相乘，不是矩阵乘法)
# 存储每个锚框相对于本批次的真实边界框的中心点xy偏移量和宽高wh的偏移量（将类别为背景的偏移量置零）
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)
# ground_truth：图像中的真实边界框，包括两个，第一个是狗，第二个是猫，每个边界框的形式为（类别，左上x，左上y，右下x，右下y），类别0为狗，类别1为y，坐标已经归一化
ground_truth = torch.tensor([[0, 0.1, 0.08, 0.52, 0.92],[1, 0.55, 0.2, 0.9, 0.88]])
# 定义五个锚框，分别为A0、A1、A2、A3、A4 每个锚框的形式为（左上x，左上y，右下x，右下y），坐标已经归一化
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']);
plt.show()
# 获取锚框与相应真实边界框的中心点xy偏移量和宽高偏移量，背景和非背景mask，锚框和真实边界框的映射关系
labels = multibox_target(anchors.unsqueeze(dim=0),ground_truth.unsqueeze(dim=0))
# 锚框与相应真实边界框的中心点xy偏移量和宽高wh偏移量(元素个数为锚框数×xywh四个偏移量)
print(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]])
# 背景和非背景mask,掩码矩阵中的元素与每个锚框的4个偏移量一一对应
print(labels[1])
# 输出:
# tensor([[0., 0., 0., 0., 1., 1.,
# 1., 1., 1., 1., 1., 1.,
# 0., 0., 0., 0., 1., 1.,
# 1., 1.]])
# 锚框和真实边界框的映射关系(0表示这个锚框框中的是背景,1表示这个锚框框中的是类别1(边界框1),2表示这个锚框框中的是类别2(边界框2))
print(labels[2])
# 输出:
# tensor([[0, 1, 2, 0, 2]])
13.4.4 使用非极大值抑制来抑制一些不好的边界框
def offset_inverse(anchors, offset_preds):
# 输入：
# anchors:锚框的归一化坐标集合，形状为（锚框集合数，坐标）
# offset_preds:每个锚框的预测偏移量
# 输出：
# predicted_bbox：预测边界框归一化坐标集合,形状为（锚框集合数，坐标）
#
# 功能：
# 根据锚框的归一化坐标集合和每个锚框的预测偏移量,计算预测边界框归一化坐标集合
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
def nms(boxes, scores, iou_threshold):
# 输入：
# boxes：预测边界框归一化坐标集合,形状为(预测边界框的个数,坐标)
# scores:每个预测边界框的最大置信度(每个预测框在所有类别上都有一个概率值,这个概率值被称为置信度,最大的置信度就是其中最大的概率值),形状为(预测边界框的个数)
# iou_threshold:交并比阈值
# 输出：
# torch.tensor(keep, device=boxes.device):返回相互之间交并比都小于iou_threshold阈值的边界框的编号(在boxes中的下标)
#
# 功能：
# 在预测边界框集合中,丢弃存在相互重叠而且概率值较小的边界框
# 将所有预测边界框的编号根据最大置信度降序排序,排序之后,B中的第一个元素就是具有最大置信度的预测边界框编号
B = torch.argsort(scores, dim=-1, descending=True)
# 用来保存筛选之后的预测边界框,这些边界框相互之间的交并比都小于阈值
keep = [] # 保留预测边界框的指标
while B.numel() > 0:
# 取当前置信度最高的预测边界框作为基准边界框B1,B1的编号为i
i = B[0]
# 把基准边界框作为筛选之后的结果保留下来
keep.append(i)
# 如果只剩1个预测边界框,将其作为筛选之后的结果保留下来之后就返回
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)
def multibox_detection(cls_probs, offset_preds, anchors, nms_threshold=0.5, pos_threshold=0.009999999):
# 输入：
# cls_probs：每个锚框在每个类别上的预测概率,形状为(批量大小,类别数,锚框数),三个类别分别为:背景、狗、猫
# offset_preds:每个锚框的四维预测偏移量,形状为(批量大小,锚框数,四维预测偏移量)
# anchors:锚框集合的归一化坐标,形状为(批量大小,锚框数,四维归一化坐标)
# nms_threshold:边界框丢弃阈值
# pos_threshold:前景背景分割阈值
# 输出：
# torch.stack(out):返回所有的边界框的类别、置信度、边界框四维坐标(其中有效的边界框在前,无效边界框在后,无效边界框的类别被置为-1)
# 功能：根据锚框集合以及相应的预测偏移量来计算预测边界框,并将其中重叠的边界框抑制(类别标为-1),
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_prob, offset_pred = cls_probs[i], offset_preds[i].reshape(-1, 4)
# 定义class_id为每个锚框最可能属于的类别(在哪个类别上的预测概率最大,就最可能属于哪个类别)(类别编号不包括背景,非背景的类别编号从0开始)
# 定义conf为每个锚框在所有类别上预测概率的最大值(即最可能属于类别的概率,也是这个锚框的置信度)
conf, class_id = torch.max(cls_prob[1:], 0)
# 根据锚框的归一化坐标集合和每个锚框的预测偏移量, 计算相应的预测边界框归一化坐标集合
predicted_bb = offset_inverse(anchors, offset_pred)
# 对于得到的所有预测边界框,将之两两组合,如果交并比大于了阈值nms_threshold,则将概率较小者丢弃,直到剩余的边界框中两两之间的交并比都小于阈值nms_threshold,剩余的边界框就是最终得到的边界框
keep = nms(predicted_bb, conf, nms_threshold)
# 找到被nms丢弃的有重叠而且概率较小的边界框
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]
# 将置信度小于前背景分割阈值的边界框的类别设置为背景,并更新置信度
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)
# 返回所有的边界框的类别、置信度、边界框四维坐标(其中有效的边界框在前,无效边界框在后,无效边界框的类别被置为-1)
return torch.stack(out)
# 偏移量的逆变换,正变换是根据锚框和真实边界框生成偏移量,逆变换是由锚框和偏移量生成预测边界框
# 从众多的预测边界框中,挑选出合适的框
# 定义锚框集合,集合中包含四个锚框的四位归一化坐标,坐标形式为（左上x，左上y，右下x，右下y）,形状为(锚框数,四维坐标)
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]]) # 猫的预测概率
# 读入图像catdog.jpg
fig = d2l.plt.imshow(img)
# bbox_scale：图像尺寸,形状为（图像行数，图像列数，图像行数，图像列数），用来计算每个框的（非归一化坐标）
# 画出锚框和每个锚框对应的标签框
show_bboxes(fig.axes, anchors * bbox_scale,['dog=0.9', 'dog=0.8', 'dog=0.7', 'cat=0.9'])
plt.show()
# 根据锚框集合以及相应的预测偏移量来计算预测边界框,并将其中重叠而且概率值较小的边界框抑制(类别标为-1),返回所有的边界框的类别、置信度、边界框四维坐标(其中有效的边界框在前,无效边界框在后)
output = multibox_detection(cls_probs.unsqueeze(dim=0), offset_preds.unsqueeze(dim=0), anchors.unsqueeze(dim=0), nms_threshold=0.5)
print(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]]])
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)
plt.show()
本小节完整代码如下
import torch
from d2l import torch as d2l
from matplotlib import pyplot as plt
d2l.set_figsize()
torch.set_printoptions(2) # 精简输出精度
# 宽高比r是指锚框的宽高比与图像的宽高比之比，即 w' / h' = w / h * r
# 缩放比s是指图像尺寸缩放因子，即 w'h' / whs^2
# 两者联立之后就可以得到锚框宽度为 w’ = ws × sqrt(r)，锚框高度为 h’ = hs / sqrt(r)
# w’‘ = s × sqrt(r)为归一化之后的锚框宽度
# h’‘ = s / sqrt(r)为归一化之后的锚框高度
# ------------------------------获取图像中每个像素的所有锚框的归一化坐标------------------------------------
def multibox_prior(data, sizes, ratios):
# 输入：
# data:一个批量的图像
# sizes:所有的缩放比
# ratios:所有的宽高比
# 输出：
# output.unsqueeze(0):一批图像中每个像素的所有锚框的归一化坐标（左上x坐标，左上y坐标，右下x坐标，右下y坐标），坐标以图像左上角为原点 形状为(批量大小,像素点个数,坐标)
# 功能：
# 一批图像中每个像素的所有锚框的归一化坐标（左上x坐标，左上y坐标，右下x坐标，右下y坐标）
# in_height为图像的行数，in_width为图像的列数
in_height, in_width = data.shape[-2:]
# device为图像所在的设备（CPU）、num_sizes为缩放比的个数、num_ratios为长宽比的个数
device, num_sizes, num_ratios = data.device, len(sizes), len(ratios)
# boxes_per_pixel为以同一像素为中心的锚框数量
boxes_per_pixel = (num_sizes + num_ratios - 1)
# 把缩放比转换成张量
size_tensor = torch.tensor(sizes, device=device)
# 把宽高比转换成张量
ratio_tensor = torch.tensor(ratios, device=device)
# 像素的高宽均为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中存放了所有锚点的归一化列坐标（线聚成面）
shift_y, shift_x = torch.meshgrid(center_h, center_w, indexing='ij')
shift_y, shift_x = shift_y.reshape(-1), shift_x.reshape(-1)
# 将所有缩放比和高宽比进行组合的话，会生成大量的锚框，因此实践中只考虑第一个缩放比和第一个高宽比的组合，这样以同一个像素为中心的锚框的数量就是（缩放比个数+高宽比个数-1），整个图像中的锚框数量就是（行数×列数×（缩放比个数+高宽比个数-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.stack((-w, -h, w, h)).T / 2 为一个像素点的锚框集合，每个锚框的形式为（坐上x坐标，坐上y坐标，右下x坐标，右下y坐标）（坐标位置以锚点为原点，而且经过了归一化）
# 生成一个图像中所有像素的锚框，而且每个锚框的表示形式均以自己的锚点为中心
anchor_manipulations = torch.stack((-w, -h, w, h)).T.repeat(in_height * in_width, 1) / 2
# 生成并返回一个图像中每个像素的所有锚框（左上x坐标，左上y坐标，右下x坐标，右下y坐标），坐标以图像左上角为原点，而且经过了归一化
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)
# 读入图像dog_cat.jpg，形状为（行数578，列数1032，通道数3）
img = d2l.plt.imread('../img/catdog.jpg')
h, w = img.shape[:2]
print(h, w)
# 输出：
# 578 1032
# 随机生成一个批量的图像，批量大小为1，图像通道数为3，行数578，列数1032
X = torch.rand(size=(1, 3, h, w))
# sizes为缩放比，ratio为宽高比
# 返回图像X中每个像素的所有锚框（左上x坐标，左上y坐标，右下x坐标，右下y坐标），坐标以图像左上角为原点，而且经过了归一化
Y = multibox_prior(X, sizes=[0.75, 0.5, 0.25], ratios=[1, 2, 0.5])
print(Y.shape)
# 输出：
# torch.Size([1, 2982480, 4]) 2982480为这个图像中锚框的总数（图像中锚框的总数 = 图像中像素数 × 每个像素的锚框数） 4为每个锚框的坐上和右下两个坐标
# 查看第一个像素的第一个锚框
print(Y[0][0])
# 输出：
# tensor([-0.21, -0.37, 0.21, 0.38])
# 将锚框集合组织成（行数，列数，每个像素点的锚框数，锚框坐标）
boxes = Y.reshape(h, w, 5, 4)
# 第250行第250列像素的第0个锚框
print(boxes[250, 250, 0, :])
# 输出：
# tensor([0.03, 0.06, 0.45, 0.81])
# ------------------------------在图像上画出锚框或边界框,并显示相应的文本------------------------------------
def show_bboxes(axes, bboxes, labels=None, colors=None):
# 输入：
# axes:要绘图的画布
# bboxes:锚框的非归一化坐标
# labels:锚框的标签
# colors:锚框的颜色
# 输出：
# 无
# 功能：
# 在图像上画出锚框或边界框,并显示相应的文本
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:每个锚框对应的标签
labels = _make_list(labels)
# colors：每个锚框对应的颜色
colors = _make_list(colors, ['b', 'g', 'r', 'm', 'c'])
for i, bbox in enumerate(bboxes):
color = colors[i % len(colors)]
# 把锚框的（左上(x, y), 右下(x, y)）坐标转换为（中心(x, y), 宽x, 高y）坐标，同时设置锚框颜色
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'
# 在锚框上画出标签框
# rect.xy[0], rect.xy[1]为放置标签框的位置，ha为水平对齐方式，va为垂直对齐方式，fontsize为字体大小，color为字体颜色，labels[i]为标签框中的标签内容
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))
# bbox_scale：（行数，列数，行数，列数），后续用来计算每个锚框的实际坐标（未归一化坐标）
bbox_scale = torch.tensor((w, h, w, h))
fig = d2l.plt.imshow(img)
# 画出（250，250）像素点处的所有锚框和标签框
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'])
plt.show()
# ------------------------------根据真实边界框,计算出每个锚框的分类和偏移量------------------------------------
def box_iou(boxes1, boxes2):
# 输入：
# boxes1:锚框的归一化坐标集合，形状为（锚框集合数，坐标）
# boxes2:真实边界框的归一化坐标集合，（不包括真实边界框的类别信息），形状为（真实边界框集合数，坐标）
# 输出：
# 锚框集合中每个锚框与真实边界框中每个真实边界框之间的交并比，形状为（锚框集合数，真实边界框集合数）
# 功能：
# 计算锚框集合中每个锚框与真实边界框中每个真实边界框之间的交并比，形状为（锚框集合数，真实边界框集合数）
# 定义一个lambda表达式，用来计算锚框或者真实边界框的归一化面积
box_area = lambda boxes: ((boxes[:, 2] - boxes[:, 0]) * (boxes[:, 3] - boxes[:, 1]))
# 计算锚框集合中每个锚框的归一化面积
areas1 = box_area(boxes1)
# 计算真实边界框集合中每个真实边界框的归一化面积
areas2 = box_area(boxes2)
# 计算锚框集合中每个锚框与真实边界框中每个真实边界框之间交集的左上角归一化坐标，形状为（锚框集合数，真实边界框集合数，坐标）
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_areas = inters[:, :, 0] * inters[:, :, 1]
# 计算锚框集合中每个锚框与真实边界框中每个真实边界框之间并集的归一化面积，形状为（锚框集合数，真实边界框集合数）
union_areas = areas1[:, None] + areas2 - inter_areas
# 计算并返回锚框集合中每个锚框与真实边界框中每个真实边界框之间的交并比，形状为（锚框集合数，真实边界框集合数）
return inter_areas / union_areas
def assign_anchor_to_bbox(ground_truth, anchors, device, iou_threshold=0.5):
# 输入：
# anchors:锚框的归一化坐标集合，形状为（锚框集合数，坐标）
# ground_truth:真实边界框的归一化坐标集合，（不包括真实边界框的类别信息），形状为（真实边界框集合数，坐标）
# device：设备
# iou_threshold：交并比阈值
# 输出：
# 返回锚框集合中的每个锚框和相应的真实边界框的映射关系
# 功能：
# 建立锚框和真实边界框的映射关系
# num_anchors为锚框的个数，num_gt_boxes为真实边界框的个数
num_anchors, num_gt_boxes = anchors.shape[0], ground_truth.shape[0]
# 计算锚框集合中每个锚框与真实边界框中每个真实边界框之间的交并比，形状为（锚框集合数，真实边界框集合数）
jaccard = box_iou(anchors, ground_truth)
# 创建一个映射表，用来存放每个锚框对应的真实边界框编号，初始时都为-1，形状为（锚框集合数）
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 >= iou_threshold).reshape(-1)
box_j = indices[max_ious >= iou_threshold]
# 将锚框和真实边界框的对应关系存入到anchors_bbox_map映射表中
anchors_bbox_map[anc_i] = box_j
col_discard = torch.full((num_anchors,), -1)
row_discard = torch.full((num_gt_boxes,), -1)
for _ in range(num_gt_boxes):
# 计算交并比矩阵中最大值的编号（拉成一维后得到的索引）
max_idx = torch.argmax(jaccard)
# print(max_idx)
# 计算这个最大值所在的列，即真实边界框的编号
box_idx = (max_idx % num_gt_boxes).long()
# 计算这个最大值所在的行，即锚框的编号
anc_idx = (max_idx / num_gt_boxes).long()
# 建立这个最大值对应锚框和真实边界框的映射关系
anchors_bbox_map[anc_idx] = box_idx
# 将最大值所在列和所在行的所有交并比赋值为-1
jaccard[:, box_idx] = col_discard
jaccard[anc_idx, :] = row_discard
# 返回每个锚框和其相应的真实边界框的映射关系
return anchors_bbox_map
def offset_boxes(anchors, assigned_bb, eps=1e-6):
# 输入：
# anchors:锚框的归一化坐标集合，形状为（锚框集合数，坐标）
# assigned_bb:锚框对应的真实边界框的归一化坐标，对于类型为背景的坐标设为[0, 0, 0, 0]
# 输出：
# 返回每个锚框相对于其对应的真实边界框的中心点xy偏移量和宽高wh的偏移量
# 功能：
# 计算每个锚框相对于其对应的真实边界框的中心点xy偏移量和宽高wh的偏移量
# 把锚框的（左上(x,y),右下(x,y)）坐标转换为（中心(x,y),宽x,高y）坐标
c_anc = d2l.box_corner_to_center(anchors)
# 把锚框对应的真实边界框的（左上(x,y),右下(x,y)）坐标转换为（中心(x,y),宽x,高y）坐标
c_assigned_bb = d2l.box_corner_to_center(assigned_bb)
# 计算并返回每个锚框相对于其对应的真实边界框的中心点xy偏移量和宽高wh的偏移量
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
def multibox_target(anchors, labels):
# 输入：
# anchors:锚框的归一化坐标集合，形状为（锚框集合数，坐标）
# labels:真实边界框的归一化坐标集合，（包括真实边界框的类别信息），形状为（真实边界框集合数，类别+坐标）
# 输出：
# bbox_offset：每个锚框相对真实边界框的中心点xy偏移量和宽高wh的偏移量（将类别为背景的偏移量置零）
# bbox_mask：每个锚框对应的真实边界框是背景还是非背景，为0表示背景，为1表示非背景
# class_labels：锚框和真实边界框的映射关系，0为背景，非背景依序递增
#
# 功能：
# 获取锚框与相应真实边界框的中心点xy偏移量和宽高偏移量，以及锚框和真实边界框的映射关系
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, :, :]
# 建立锚框和真实边界框的映射关系（-1表示背景）
anchors_bbox_map = assign_anchor_to_bbox(label[:, 1:], anchors, device)
# 将背景与非背景区分开来，为背景的锚框用-1表示，为非背景的锚框用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 = torch.nonzero(anchors_bbox_map >= 0)
# 相应真实边界框为非背景的锚框缩所对应真实边界框的编号
bb_idx = anchors_bbox_map[indices_true]
# 将锚框和真实边界框的映射关系全部加1
class_labels[indices_true] = label[bb_idx, 0].long() + 1
# 锚框对应的真实边界框的归一化坐标，对于类型为背景的坐标设为[0,0,0,0]
assigned_bb[indices_true] = label[bb_idx, 1:]
# 计算每个锚框相对于其对应的真实边界框的中心点xy偏移量和宽高wh的偏移量,并且将类别为背景的偏移量置零
offset = offset_boxes(anchors, assigned_bb) * bbox_mask # (逐元素相乘，不是矩阵乘法)
# 存储每个锚框相对于本批次的真实边界框的中心点xy偏移量和宽高wh的偏移量（将类别为背景的偏移量置零）
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)
# ground_truth：图像中的真实边界框，包括两个，第一个是狗，第二个是猫，每个边界框的形式为（类别，左上x，左上y，右下x，右下y），类别0为狗，类别1为y，坐标已经归一化
ground_truth = torch.tensor([[0, 0.1, 0.08, 0.52, 0.92],[1, 0.55, 0.2, 0.9, 0.88]])
# 定义五个锚框，分别为A0、A1、A2、A3、A4 每个锚框的形式为（左上x，左上y，右下x，右下y），坐标已经归一化
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']);
plt.show()
# 获取锚框与相应真实边界框的中心点xy偏移量和宽高偏移量，背景和非背景mask，锚框和真实边界框的映射关系
labels = multibox_target(anchors.unsqueeze(dim=0),ground_truth.unsqueeze(dim=0))
# 锚框与相应真实边界框的中心点xy偏移量和宽高wh偏移量(元素个数为锚框数×xywh四个偏移量)
print(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]])
# 背景和非背景mask,掩码矩阵中的元素与每个锚框的4个偏移量一一对应
print(labels[1])
# 输出:
# tensor([[0., 0., 0., 0., 1., 1.,
# 1., 1., 1., 1., 1., 1.,
# 0., 0., 0., 0., 1., 1.,
# 1., 1.]])
# 锚框和真实边界框的映射关系(0表示这个锚框框中的是背景,1表示这个锚框框中的是类别1(边界框1),2表示这个锚框框中的是类别2(边界框2))
print(labels[2])
# 输出:
# tensor([[0, 1, 2, 0, 2]])
# ------------------------------使用非极大值抑制来抑制一些不好的边界框------------------------------------
def offset_inverse(anchors, offset_preds):
# 输入：
# anchors:锚框的归一化坐标集合，形状为（锚框集合数，坐标）
# offset_preds:每个锚框的预测偏移量
# 输出：
# predicted_bbox：预测边界框归一化坐标集合,形状为（锚框集合数，坐标）
#
# 功能：
# 根据锚框的归一化坐标集合和每个锚框的预测偏移量,计算预测边界框归一化坐标集合
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
def nms(boxes, scores, iou_threshold):
# 输入：
# boxes：预测边界框归一化坐标集合,形状为(预测边界框的个数,坐标)
# scores:每个预测边界框的最大置信度(每个预测框在所有类别上都有一个概率值,这个概率值被称为置信度,最大的置信度就是其中最大的概率值),形状为(预测边界框的个数)
# iou_threshold:交并比阈值
# 输出：
# torch.tensor(keep, device=boxes.device):返回相互之间交并比都小于iou_threshold阈值的边界框的编号(在boxes中的下标)
#
# 功能：
# 在预测边界框集合中,丢弃存在相互重叠而且概率值较小的边界框
# 将所有预测边界框的编号根据最大置信度降序排序,排序之后,B中的第一个元素就是具有最大置信度的预测边界框编号
B = torch.argsort(scores, dim=-1, descending=True)
# 用来保存筛选之后的预测边界框,这些边界框相互之间的交并比都小于阈值
keep = [] # 保留预测边界框的指标
while B.numel() > 0:
# 取当前置信度最高的预测边界框作为基准边界框B1,B1的编号为i
i = B[0]
# 把基准边界框作为筛选之后的结果保留下来
keep.append(i)
# 如果只剩1个预测边界框,将其作为筛选之后的结果保留下来之后就返回
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)
def multibox_detection(cls_probs, offset_preds, anchors, nms_threshold=0.5, pos_threshold=0.009999999):
# 输入：
# cls_probs：每个锚框在每个类别上的预测概率,形状为(批量大小,类别数,锚框数),三个类别分别为:背景、狗、猫
# offset_preds:每个锚框的四维预测偏移量,形状为(批量大小,锚框数,四维预测偏移量)
# anchors:锚框集合的归一化坐标,形状为(批量大小,锚框数,四维归一化坐标)
# nms_threshold:边界框丢弃阈值
# pos_threshold:前景背景分割阈值
# 输出：
# torch.stack(out):返回所有的边界框的类别、置信度、边界框四维坐标(其中有效的边界框在前,无效边界框在后,无效边界框的类别被置为-1)
# 功能：根据锚框集合以及相应的预测偏移量来计算预测边界框,并将其中重叠的边界框抑制(类别标为-1),
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_prob, offset_pred = cls_probs[i], offset_preds[i].reshape(-1, 4)
# 定义class_id为每个锚框最可能属于的类别(在哪个类别上的预测概率最大,就最可能属于哪个类别)(类别编号不包括背景,非背景的类别编号从0开始)
# 定义conf为每个锚框在所有类别上预测概率的最大值(即最可能属于类别的概率,也是这个锚框的置信度)
conf, class_id = torch.max(cls_prob[1:], 0)
# 根据锚框的归一化坐标集合和每个锚框的预测偏移量, 计算相应的预测边界框归一化坐标集合
predicted_bb = offset_inverse(anchors, offset_pred)
# 对于得到的所有预测边界框,将之两两组合,如果交并比大于了阈值nms_threshold,则将概率较小者丢弃,直到剩余的边界框中两两之间的交并比都小于阈值nms_threshold,剩余的边界框就是最终得到的边界框
keep = nms(predicted_bb, conf, nms_threshold)
# 找到被nms丢弃的有重叠而且概率较小的边界框
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]
# 将置信度小于前背景分割阈值的边界框的类别设置为背景,并更新置信度
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)
# 返回所有的边界框的类别、置信度、边界框四维坐标(其中有效的边界框在前,无效边界框在后,无效边界框的类别被置为-1)
return torch.stack(out)
# 偏移量的逆变换,正变换是根据锚框和真实边界框生成偏移量,逆变换是由锚框和偏移量生成预测边界框
# 从众多的预测边界框中,挑选出合适的框
# 定义锚框集合,集合中包含四个锚框的四位归一化坐标,坐标形式为（左上x，左上y，右下x，右下y）,形状为(锚框数,四维坐标)
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]]) # 猫的预测概率
# 读入图像catdog.jpg
fig = d2l.plt.imshow(img)
# bbox_scale：图像尺寸,形状为（图像行数，图像列数，图像行数，图像列数），用来计算每个框的（非归一化坐标）
# 画出锚框和每个锚框对应的标签框
show_bboxes(fig.axes, anchors * bbox_scale,['dog=0.9', 'dog=0.8', 'dog=0.7', 'cat=0.9'])
plt.show()
# 根据锚框集合以及相应的预测偏移量来计算预测边界框,并将其中重叠而且概率值较小的边界框抑制(类别标为-1),返回所有的边界框的类别、置信度、边界框四维坐标(其中有效的边界框在前,无效边界框在后)
output = multibox_detection(cls_probs.unsqueeze(dim=0), offset_preds.unsqueeze(dim=0), anchors.unsqueeze(dim=0), nms_threshold=0.5)
print(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]]])
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)
plt.show()
浙公网安备 33010602011771号