以下链接是个人关于mmdetection(Foveabox-目标检测框架)所有见解，如有错误欢迎大家指出，我会第一时间纠正。有兴趣的朋友可以加微信：17575010159 相互讨论技术。若是帮助到了你什么，一定要记得点赞！因为这是对我最大的鼓励。
目标检测00-00：mmdetection(Foveabox为例)-目录-史上最新无死角讲解
前言
在上篇博客中，已经对 mmdet\models\dense_heads\fovea_head.py 中的 FoveaHead 训练过程进行了讲解。但是推理过程还没有进行解析。那么这篇博客我们就来好好的专研一下，其主要的核心就是 FoveaHead 中的 def get_bboxes 函数。
代码注释
关于 FoveaHead 中 get_bboxes 代码，本人注释如下：
def get_targets(self, gt_bbox_list, gt_label_list, featmap_sizes, points):
"""
:param gt_bbox_list: 该个batch所有图像对应的box信息
:param gt_label_list: 该个batch所有图像box对应的cls信息
:param featmap_sizes: 5个特征图大小，默认为[[60,80],[30,40],[15,20],[8,10],[4,5]]
:param points: 包含了5个特征图像素对应的坐标位置
:return:
"""
# 循环 batch_size 次执行self._get_target_single函数，
# 为每张图像生成特征图对应的box，cls标签
label_list, bbox_target_list = multi_apply(
self._get_target_single,
gt_bbox_list,
gt_label_list,
featmap_size_list=featmap_sizes,
point_list=points)
# 把所有特征图对应的label cls进行扁平处理，形状为[b,n]（包含一个batch）
flatten_labels = [
torch.cat([
labels_level_img.flatten() for labels_level_img in labels_level
]) for labels_level in zip(*label_list)
]
# 把所有特征图对应的box进行扁平处理，形状为[b,n,4]包含一个batch）
flatten_bbox_targets = [
torch.cat([
bbox_targets_level_img.reshape(-1, 4)
for bbox_targets_level_img in bbox_targets_level
]) for bbox_targets_level in zip(*bbox_target_list)
]
# [b,n]-->[b*n]
flatten_labels = torch.cat(flatten_labels)
# [b,n,4]-->[b*n,4]
flatten_bbox_targets = torch.cat(flatten_bbox_targets)
return flatten_labels, flatten_bbox_targets
def _get_target_single(self,
gt_bboxes_raw, # 输入图像对应的box
gt_labels_raw, # 输入图像box对应的cls标签
featmap_size_list=None, # 包含5个特征图的大小
point_list=None): # 包含5ge特征图每个像素的坐标
# 获得box的面积（开根号之后的）
gt_areas = torch.sqrt((gt_bboxes_raw[:, 2] - gt_bboxes_raw[:, 0]) *
(gt_bboxes_raw[:, 3] - gt_bboxes_raw[:, 1]))
# 记录一张图片的所有特征的 target label 类别信息
label_list = []
# 记录一张图片的所有特征的 target box 的 tx1，ty1, tx2，ty2,（论文的公式4） 的信息
bbox_target_list = []
# for each pyramid, find the cls and box target
# 为每个金字塔特征生成对应的 target cls，target box
# self.base_edge_list 默认为 [16, 32, 64, 128, 256]，对应论文中的rl
# self.scale_ranges 默认为被覆盖为 ((1, 64), (32, 128), (64, 256), (128, 512), (256, 2048))
# self.strides 默认为被覆盖为[8, 16, 32, 64, 128],
# featmap_size_list 默认形状为为 [[60,80],[30,40],[15,20],[8,10],[4,5]]
for base_len, (lower_bound, upper_bound), stride, featmap_size, \
(y, x) in zip(self.base_edge_list, self.scale_ranges,
self.strides, featmap_size_list, point_list):
# FG cat_id: [0, num_classes -1], BG cat_id: num_classes
# 创建一个featmap_size大小的labels，全部都赋值成背景类
labels = gt_labels_raw.new_zeros(featmap_size) + self.num_classes
# 创建一个featmap_size大小的 box target,
# 形状为(featmap_size[0], featmap_size[1],4)，初始化所有的值填充为1
bbox_targets = gt_bboxes_raw.new(featmap_size[0], featmap_size[1],
4) + 1
# 论文中的scale assignment，缩放分配。也就是一个box，其应该属于那个特征图最合适
# 如果gt_areas在当前金字塔特征的[lower_bound, upper_bound]之间，
# 说明使用该特征图对其进行预测是合理的，一张图片中可能存在多个box，所以hit_indices可能存在多个值
# 并且hit_indices记录的是box的索引
hit_indices = ((gt_areas >= lower_bound) &
(gt_areas <= upper_bound)).nonzero().flatten()
# 如果没有被分配到当前金字塔特征的，则continue继续。表示该特征图不存在 Positivte area（论文Fig3）区域
if len(hit_indices) == 0:
label_list.append(labels)
bbox_target_list.append(torch.log(bbox_targets))
continue
# 把被分贝到当前的特征图的box，按面积进行排序，
_, hit_index_order = torch.sort(-gt_areas[hit_indices])
# 获取通过面积排序之后的索引值
hit_indices = hit_indices[hit_index_order]
# 根据索引值获得box,同时除以stride（因为特征图相对于原图缩小了stride倍，所以要进行坐标变换）
# 这里的stride可以理解为论文中的sl
gt_bboxes = gt_bboxes_raw[hit_indices, :] / stride
# 根据索引值获得box对应的cls类别
gt_labels = gt_labels_raw[hit_indices]
# 获得box宽高的一半数值
half_w = 0.5 * (gt_bboxes[:, 2] - gt_bboxes[:, 0])
half_h = 0.5 * (gt_bboxes[:, 3] - gt_bboxes[:, 1])
# valid fovea area: left, right, top, down
# self.sigma对应论文中的σ，这里的主要是根据该参数，求得论文中特征图对应的Positivte area（论文Fig3），也就是Rpos
# 对应论文中的公式（1）（2）
pos_left = torch.ceil(
gt_bboxes[:, 0] + (1 - self.sigma) * half_w - 0.5).long().\
clamp(0, featmap_size[1] - 1)
pos_right = torch.floor(
gt_bboxes[:, 0] + (1 + self.sigma) * half_w - 0.5).long().\
clamp(0, featmap_size[1] - 1)
pos_top = torch.ceil(
gt_bboxes[:, 1] + (1 - self.sigma) * half_h - 0.5).long().\
clamp(0, featmap_size[0] - 1)
pos_down = torch.floor(
gt_bboxes[:, 1] + (1 + self.sigma) * half_h - 0.5).long().\
clamp(0, featmap_size[0] - 1)
# 循环对每个box的Positivte area进行处理
for px1, py1, px2, py2, label, (gt_x1, gt_y1, gt_x2, gt_y2) in \
zip(pos_left, pos_top, pos_right, pos_down, gt_labels,
gt_bboxes_raw[hit_indices, :]):
# 特征图box的Rpos区域进行标签赋值
labels[py1:py2 + 1, px1:px2 + 1] = label
# 对应论文中的公式(4)，但是大家要注意，这里话没有进行log的计算，
# 也就是其只计算了:[sl(x+0.5) - x']/rl 部分，
# 主要的目的是为了计算box边框坐标到特征图预测像素坐标的偏移值
bbox_targets[py1:py2 + 1, px1:px2 + 1, 0] = \
(stride * x[py1:py2 + 1, px1:px2 + 1] - gt_x1) / base_len
bbox_targets[py1:py2 + 1, px1:px2 + 1, 1] = \
(stride * y[py1:py2 + 1, px1:px2 + 1] - gt_y1) / base_len
bbox_targets[py1:py2 + 1, px1:px2 + 1, 2] = \
(gt_x2 - stride * x[py1:py2 + 1, px1:px2 + 1]) / base_len
bbox_targets[py1:py2 + 1, px1:px2 + 1, 3] = \
(gt_y2 - stride * y[py1:py2 + 1, px1:px2 + 1]) / base_len
# 把范围固定在[1./16，16]之间
bbox_targets = bbox_targets.clamp(min=1. / 16, max=16.)
label_list.append(labels)
# 把剩余的log操作完成，然后添加到bbox_target_list之中
bbox_target_list.append(torch.log(bbox_targets))
return label_list, bbox_target_list
def get_bboxes(self, # 以下的讲解，都以输入图像为 640*480 为例。
cls_scores, # 网络输出的5个金字塔特征对应box概率值（暂时未经过softmax或者sigmod处理）。
bbox_preds, # 网络输出的5个金字塔特征对应的(tx1, ty1, tx2, ty2)
img_metas, # 主要记录了输入图像的路径, 原始大小，当前大小，缩放因子，正则化参数。用于 box 还原处理，
cfg=None, # 本人测试代码时为 None
rescale=None): # 默认为Ture
# 判断长度是否相同，不相同则报错
assert len(cls_scores) == len(bbox_preds)
# 获得金字塔特征的数目，默认为 5
num_levels = len(cls_scores)
# 获得每个金字塔特征的大小，本人实验大小分别为:[(60,80),(30,40),(15,20),(8,10),(4,5)]
featmap_sizes = [featmap.size()[-2:] for featmap in cls_scores]
# 根据特征图大小，获得特征图点的坐标xy。把他理解为网格形式。如特征图最左上角网格的坐标为 x, y = [0.5, 0.5]
# points 为一个链表，包含了5个元素（对应5个金字塔特征），同时每个元素包含两个列表，分别为 x,y 坐标。
points = self.get_points(featmap_sizes,bbox_preds[0].dtype,bbox_preds[0].device,flatten=True)
# 用于保存推算出来的 box 结果
result_list = []
# 循环对每张图片进行处理，len(img_metas)为多少，说明其有多少张图片。
for img_id in range(len(img_metas)):
# detach 表示从当前网络中分离出来，不参与梯度计算，把它作为叶子节点。
# 获得一张图片所有金字塔特征的 cls_score 以及 bbox_preds。
# cls_score = [(num_class,60,80), (num_class,30,40), (num_class,15,20), (num_class,8,10), (num_class,4,5)]
cls_score_list = [
cls_scores[i][img_id].detach() for i in range(num_levels)
]
# cls_score = [(4,60,80), (4,30,40), (4,15,20), (4,8,10), (4,4,5)]
bbox_pred_list = [
bbox_preds[i][img_id].detach() for i in range(num_levels)
]
# 获得当前输入网络图片的形状，这里默认为360,640
img_shape = img_metas[img_id]['img_shape']
# 获得缩放因子，默认为[0.5, 0.5, 0.5, 0.5]
scale_factor = img_metas[img_id]['scale_factor']
# 把预测的 (tx1, ty1, tx2, ty2) 转换为坐标,同时做了 nms 处理（单张图像）。
det_bboxes = self._get_bboxes_single(cls_score_list,
bbox_pred_list, featmap_sizes,
points, img_shape,
scale_factor, cfg, rescale)
result_list.append(det_bboxes)
return result_list
def _get_bboxes_single(self, # cls_scores, bbox_preds 为一张图像所有金字塔特征的 cls_score 以及 bbox_preds。
cls_scores, # [(num_class,60,80), (num_class,30,40), (num_class,15,20), (num_class,8,10), (num_class,4,5)]
bbox_preds, # [(4,60,80), (4,30,40), (4,15,20), (4,8,10), (4,4,5)]
featmap_sizes, # [(60,80),(30,40),(15,20),(8,10),(4,5)]
point_list, # 前面介绍的特征图网格的坐标
img_shape, # 输入网络图像的大小
scale_factor, # 缩放因子，默认为[0.5, 0.5, 0.5, 0.5]
cfg,
rescale=False): #默认为Ture，则把坐标缩放到最原始图像上
# 如果cfg为None，则赋值 self.test_cfg 给cfg
cfg = self.test_cfg if cfg is None else cfg
# 检测长度是否匹配，不匹配则报错。
assert len(cls_scores) == len(bbox_preds) == len(point_list)
# 用于保存转换之后的 box,类别， 以及 box 对应的类别概率值
det_bboxes = []
det_scores = []
# 循环对每个金字塔特征进行处理。
# self.strides，表示论文中的sl，
# self.base_edge_list，默认为 [16, 32, 64, 128, 256]，对应论文中的rl
for cls_score, bbox_pred, featmap_size, stride, base_len, (y, x) \
in zip(cls_scores, bbox_preds, featmap_sizes, self.strides,
self.base_edge_list, point_list):
# 判断宽高是否一致，不一致则报错
assert cls_score.size()[-2:] == bbox_pred.size()[-2:]
# 形状进行改变 [4,h,w] -- > [h,w,4] --> [h*w, 4]
scores = cls_score.permute(1, 2, 0).reshape(
-1, self.cls_out_channels).sigmoid()
# 形状进行改变 [num_class,h,w] -- > [h,w,num_class] --> [h*w, num_class]
# 并且进行了exp操作
bbox_pred = bbox_pred.permute(1, 2, 0).reshape(-1, 4).exp()
# nms_pre 默认值为1000,也就是去1000
nms_pre = cfg.get('nms_pre', -1)
if (nms_pre > 0) and (scores.shape[0] > nms_pre):
# 获得num_class最高的分值 [h*w, num_class] -> [h*w]
max_scores, _ = scores.max(dim=1)
# 获得分值最高的前 nms_pre 个下标
_, topk_inds = max_scores.topk(nms_pre)
# 根据topk_inds下标，取得对应的 box
bbox_pred = bbox_pred[topk_inds, :]
# 取得 topk_inds下标的 scores[h*w, num_class] 的分值，然后再赋值给scores
scores = scores[topk_inds, :]
# 获得 topk_inds 对应的x, y 坐标。
y = y[topk_inds]
x = x[topk_inds]
# 根据论文中的公式计算出 box 在输入图像（640*480）的坐标。
x1 = (stride * x - base_len * bbox_pred[:, 0]).\
clamp(min=0, max=img_shape[1] - 1)
y1 = (stride * y - base_len * bbox_pred[:, 1]).\
clamp(min=0, max=img_shape[0] - 1)
x2 = (stride * x + base_len * bbox_pred[:, 2]).\
clamp(min=0, max=img_shape[1] - 1)
y2 = (stride * y + base_len * bbox_pred[:, 3]).\
clamp(min=0, max=img_shape[0] - 1)
# 把坐标链接起来，转化为(n, x1, y1, x2, y2)的形式
bboxes = torch.stack([x1, y1, x2, y2], -1)
# 把变换之后box坐标，以及对应的类别分值添加到 det_bboxes 与 det_scores 之中。
det_bboxes.append(bboxes)
det_scores.append(scores)
# 把多个金字塔特征得到的 box 坐标，链接起来
det_bboxes = torch.cat(det_bboxes)
# 如果需要，则把图片缩放到最原始的图像上。
if rescale:
det_bboxes /= det_bboxes.new_tensor(scale_factor)
# 把多个金字塔特征得到的 box 类别的得分值链接起来
det_scores = torch.cat(det_scores)
# 把det_scores添加一列，最要是兼容背景类
padding = det_scores.new_zeros(det_scores.shape[0], 1)
# remind that we set FG labels to [0, num_class-1] since mmdet v2.0
# BG cat_id: num_class
det_scores = torch.cat([det_scores, padding], dim=1)
# 进行 nms 处理
det_bboxes, det_labels = multiclass_nms(det_bboxes, det_scores,
cfg.score_thr, cfg.nms,
cfg.max_per_img)
# 处理的结果返回，
# det_bboxes[-1,5], 最后一列表示概率值，
# det_labels 表示 box 对应的 cls 类别。
return det_bboxes, det_labels
结语
我相信大家看了上面的代码，对于模型推理，如何获得原图对应的 box 坐标应该十分清楚了。除了 nms 没有进行详细的讲解之外，其他算讲解比较彻底了。对于 Foveabox 的讲解基本算是完成了。后续我使用该网络进行行人检测，追踪。再进一步联合行人从识别，进行动作识别。链接如下，欢迎大家观看：
781
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
