目标检测00-10：mmdetection(Foveabox为例)-源码无死角解析（3）-头部网络bbox_head-训练过程
以下链接是个人关于mmdetection(Foveabox-目标检测框架)所有见解，如有错误欢迎大家指出，我会第一时间纠正。有兴趣的朋友可以加微信：a944284742相互讨论技术。若是帮助到了你什么，一定要记得点赞！因为这是对我最大的鼓励。
目标检测00-00：mmdetection(Foveabox为例)-目录-史上最新无死角讲解
前言
通过前面的博客，我们已经知道 Foveabox 是如何构建的，在 mmdet/models/detectors/single_stage.py 中实现，主要包含如下核心部分：
# 根据主干网网络参数构建主干网络
self.backbone = build_backbone(backbone)
# 如果设置了衔接网络，则构件衔接网络
if neck is not None:
self.neck = build_neck(neck)
# 根据配置参数构件头部网络
self.bbox_head = build_head(bbox_head)
经过 self.neck 网络输出的最终结果为一个列表，形状如下如下（假设网络输入图片大小为640x480）：
[(b,256,60,80), (b,256,30,40), (b,256,15,20), (b,256,8,10), (b,256,4,5)]
下面我们就要看看 self.bbox_head ，也就是 mmdet\models\dense_heads\fovea_head.py 中的 FoveaHead 是如何对其进行处理的。
代码注释
该篇博客只讲解其训练过程，所以这里只展示其训练的相关代码注释 （ 稍 微 阅 读 以 下 注 释 即 可 ， 后 面 有 代 码 领 读 ） \color{red}{（稍微阅读以下注释即可，后面有代码领读）} （稍微阅读以下注释即可，后面有代码领读）：
@HEADS.register_module()
class FoveaHead(AnchorFreeHead):
"""FoveaBox: Beyond Anchor-based Object Detector
https://arxiv.org/abs/1904.03797
"""
def __init__(self,
num_classes, # 类别数目
in_channels, # 输入通道数
# 主要用box的分配任务，分配其属于那个金字塔特征图不叫合适，
# 查看该文件内的 _get_target_single 函数有详细的介绍，
base_edge_list=(16, 32, 64, 128, 256), # 对应论文中的rl（可在论文中直接搜索到）
# 用于Scale Assignment的判断，对应论文的[rl/η,rl·η],η默认为2
scale_ranges=((8, 32), (16, 64), (32, 128), (64, 256), (128,512)),
sigma=0.4, # 对论文中的
with_deform=False, # 如果设置为ture，表示使用论文中的 Aligned feature 功能
deform_groups=4,# 默认Aligned为四组，因为有 FPN 特征l1，l2，l3，l4 需要做 Aligned 主力
**kwargs):
self.base_edge_list = base_edge_list # 边缘
self.scale_ranges = scale_ranges # 缩放的范围，默认为((1, 64), (32, 128), (64, 256), (128, 512), (256, 2048))
self.sigma = sigma # 论文中的σ
self.with_deform = with_deform # 如果设置为ture，表示使用可变卷积
self.deform_groups = deform_groups
super().__init__(num_classes, in_channels, **kwargs)
def _init_layers(self): # 重写父类的_init_layers函数
# box branch
super()._init_reg_convs() # 调用父类的_init_reg_convs函数，构建 box branch 分支，得到self.reg_convs
# 在论文中所有的 FPN 特征对应的 box branch 是共享权重的，所以只需要一个box branch分支
self.conv_reg = nn.Conv2d(self.feat_channels, 4, 3, padding=1)
# cls，如果with_deform=True，表示使用变形卷积 DCN 进行Aligned feature操作
if not self.with_deform:
super()._init_cls_convs() # 带哦用父类的_init_cls_convs函数，得到self.cls_convs
self.conv_cls = nn.Conv2d(
self.feat_channels, self.cls_out_channels, 3, padding=1)
# 不使用父类构建的self.cls_convs
else:
self.cls_convs = nn.ModuleList()
self.cls_convs.append(
ConvModule(
self.feat_channels, (self.feat_channels * 4),
3,
stride=1,
padding=1,
conv_cfg=self.conv_cfg,
norm_cfg=self.norm_cfg,
bias=self.norm_cfg is None))
self.cls_convs.append(
ConvModule((self.feat_channels * 4), (self.feat_channels * 4),
1,
stride=1,
padding=0,
conv_cfg=self.conv_cfg,
norm_cfg=self.norm_cfg,
bias=self.norm_cfg is None))
# 构建论文中的 Aligned feature
self.feature_adaption = FeatureAlign(
self.feat_channels,
self.feat_channels,
kernel_size=3,
deform_groups=self.deform_groups)
self.conv_cls = nn.Conv2d(
int(self.feat_channels * 4),
self.cls_out_channels,
3,
padding=1)
def init_weights(self): # 进行权重初始化
super().init_weights()
if self.with_deform:
self.feature_adaption.init_weights()
def forward_single(self, x):
"""
因为 FPN 输出五个金字塔特征图，所以该函数会被执行五次。
假设训练的图片大小为640x480，那么次执行五该函数，其输入x的形状分别为:
[b,256,60,80], [b,256,30,40], [b,256,15,20], [b,256,15,20], [b,256,8,10]， [b,256,4,5]
"""
# 分别把x赋值给cls_feat，reg_feat，
cls_feat = x
reg_feat = x
# 进行一一些列的卷积，然后对 box 进行预测,对应论文中的box branch
for reg_layer in self.reg_convs:
reg_feat = reg_layer(reg_feat)
# 执行五次，形状分别为(假设训练的图片大小为640x480)，其中的4表示的时相对于坐标点的偏移值:
# [b,4,60,80], [b,4,30,40], [b,4,15,20], [b,4,15,20], [b,4,8,10]， [b,4,4,5]
bbox_pred = self.conv_reg(reg_feat)
# 使用 DCN 可变卷积进行论文的 Aligned feature 操作
if self.with_deform:
cls_feat = self.feature_adaption(cls_feat, bbox_pred.exp())
# 对应论文中的 cls branch
for cls_layer in self.cls_convs:
cls_feat = cls_layer(cls_feat)
# 执行五次，形状分别为(假设训练的图片大小为640x480)，:
# [b,num_classes,60,80], [b,num_classes,30,40],
# [b,num_classes,15,20], [b,num_classes,8,10]， [b,num_classes,4,5]
cls_score = self.conv_cls(cls_feat)
return cls_score, bbox_pred
def _get_points_single(self, *args, **kwargs):# 根据特征图的尺寸生成坐标
y, x = super()._get_points_single(*args, **kwargs)
return y + 0.5, x + 0.5
def loss(self,
cls_scores, # 网络预测的cls的结果（包含通过五个FPN 特征图预测的结果），
bbox_preds, # # 网络预测的box的结果（包含通过五个FPN 特征图预测的结果），
gt_bbox_list, # box 的 ground truth，该为一个列表，列表的每一项包含一张图像中的所有box
gt_label_list, # cls 的 ground truth，该为一个列表，列表的每一项包含一张图像中box所属于的类别
img_metas, # 保存了图像的信息，如图像路径，原图大小，缩放后的大小，pad之后的形状，正则化配置，缩放因子等等
gt_bboxes_ignore=None): # 本人调试时为空
# 检测box 和 cls 个数是否相同，不同则报错
assert len(cls_scores) == len(bbox_preds)
# 根据cls_scores的形状，推算出特征图的大小为:[[60,80],[30,40],[15,20],[8,10],[4,5]]
featmap_sizes = [featmap.size()[-2:] for featmap in cls_scores]
# 根据特征图的大小，获得每个特征的坐标，形状为[[60,80],[30,40],[15,20],[8,10],[4,5]] * 2
# 包含了x,y坐标，可以把特征图看着网格，points表示这些网格的坐标
points = self.get_points(featmap_sizes, bbox_preds[0].dtype,
bbox_preds[0].device)
# 获得图片的数目，与batch_size相等
num_imgs = cls_scores[0].size(0)
# ===============处理网络预测的结果=============================
# 循环对cls_scores进行处理，形状由：
# [b,num_classes,60,80], [b,num_classes,30,40],[b,num_classes,15,20], [b,num_classes,8,10]， [b,num_classes,4,5]
# 改变成:
# [b,60,80,num_classes], [b,30,40,num_classes],[b,15,20,num_classes], [b,8,10,num_classes]， [b,4,5,num_classes]
flatten_cls_scores = [
cls_score.permute(0, 2, 3, 1).reshape(-1, self.cls_out_channels)
for cls_score in cls_scores
]
# 同理，[[b,4,60,80]......] --> [[b,60,80,4]......]
flatten_bbox_preds = [
bbox_pred.permute(0, 2, 3, 1).reshape(-1, 4)
for bbox_pred in bbox_preds
]
# 然后把他们垂直连接起来，形状为[-1,num_classes]
flatten_cls_scores = torch.cat(flatten_cls_scores)
# 然后把他们垂直连接起来，形状为[-1,4]
flatten_bbox_preds = torch.cat(flatten_bbox_preds)
# ===============处理获得grund truch=============================
# 把gt_bbox_list，gt_label_list转换成tensor形式，其形状分别为
# [-1,num_classes]，形状为[-1,4], 这里的-1表示随着输入图像的变换而变化
flatten_labels, flatten_bbox_targets = self.get_targets(
gt_bbox_list, gt_label_list, featmap_sizes, points)
# FG cat_id: [0, num_classes -1], BG cat_id: num_classes
# 获得被赋值成Rpos（Fig3的Positive区域）的索引，这里剔除了背景类。即不对背景类进行box的回归优化
pos_inds = (
(flatten_labels >= 0)
& (flatten_labels < self.background_label)).nonzero().view(-1)
# 判断pos_inds的长度
num_pos = len(pos_inds)
# 计算分类的平均loss，使用FocalLoss。
loss_cls = self.loss_cls(
flatten_cls_scores, flatten_labels, avg_factor=num_pos + num_imgs)
# 使用SmoothL1Loss计算box
if num_pos > 0:
# 根据索引，获得网络预测 Rpos（Fig3的Positive区域）的 box 偏移值
pos_bbox_preds = flatten_bbox_preds[pos_inds]
# 根据索引，获得网络预测 Rpos（Fig3的Positive区域）的 box 偏移值
pos_bbox_targets = flatten_bbox_targets[pos_inds]
# Rpos（Fig3的Positive区域）的权重设置为1
pos_weights = pos_bbox_targets.new_zeros(
pos_bbox_targets.size()) + 1.0
# 进行loos计算，
loss_bbox = self.loss_bbox(
pos_bbox_preds,
pos_bbox_targets,
pos_weights,
avg_factor=num_pos)
else:
# 本人在调试过程中，该代码基本没有运行，主要是因为和len(hit_indices) == 0的判断已经重复了
loss_bbox = torch.tensor(
0,
dtype=flatten_bbox_preds.dtype,
device=flatten_bbox_preds.device)
return dict(loss_cls=loss_cls, loss_bbox=loss_bbox)
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 forward_single(self, x)，这个函数是对单个金字塔特征处理的函数，所以其会被调用五次。其中的代码：
# 进行一一些列的卷积，然后对 box 进行预测,对应论文中的box branch
for reg_layer in self.reg_convs:
reg_feat = reg_layer(reg_feat)
# 执行五次，形状分别为(假设训练的图片大小为640x480)，其中的4表示的时相对于坐标点的偏移值:
# [b,4,60,80], [b,4,30,40], [b,4,15,20], [b,4,15,20], [b,4,8,10]， [b,4,4,5]
bbox_pred = self.conv_reg(reg_feat)
对应论文中 Fig. 7 的如下部分（红色框）：
代码：
# 使用 DCN 可变卷积进行论文的 Aligned feature 操作
if self.with_deform:
cls_feat = self.feature_adaption(cls_feat, bbox_pred.exp())
# 对应论文中的 cls branch
for cls_layer in self.cls_convs:
cls_feat = cls_layer(cls_feat)
对应论文中 Fig. 7 的如下部分（红色框）：
这样，我们在网络结构部分就和论文对应起来了。对于 loss 部分注释已经写的比较详细了，这里就不做介绍了。但是大家或许会有一个比较奇怪的点， def loss(…) 这个函数是在哪个地方被调用的呢？我们可以看到 FoveaHead 继承于 AnchorFreeHead，AnchorFreeHead 又继承于 BaseDenseHead。在mmdet\models\dense_heads\base_dense_head.py 文件的 BaseDenseHead 类中，我们可以看到如下代码：
def forward_train(self, x,img_metas, gt_bboxes, gt_labels=None, gt_bboxes_ignore=None,proposal_cfg=None, **kwargs):
outs = self(x)
if gt_labels is None:
loss_inputs = outs + (gt_bboxes, img_metas)
else:
loss_inputs = outs + (gt_bboxes, gt_labels, img_metas)
losses = self.loss(*loss_inputs, gt_bboxes_ignore=gt_bboxes_ignore)
if proposal_cfg is None:
return losses
else:
proposal_list = self.get_bboxes(*outs, img_metas, cfg=proposal_cfg)
return losses, proposal_list
是的，其计算 loss 的函数就是在这个地方被调用的。那么到这里为止，对于 Foveabox 头部网络的训练过程以及算是比较了解了。下篇博客我们去分析，其推理过程又是什么样子的。bbox_head 是如何把推理处理啊的 tx1，ty1, tx2，ty2 转化为坐标的。