Faster-RCNN代码解读6：主要文件解读-中
Faster-RCNN代码解读6：主要文件解读-中
前言
因为最近打算尝试一下Faster-RCNN的复现，不要多想，我还没有厉害到可以一个人复现所有代码。所以，是参考别人的代码，进行自己的解读。
代码来自于B站的UP主（大佬666），其把代码都放到了GitHub上了，我把链接都放到下面了（应该不算侵权吧，毕竟代码都开源了_）：
b站链接：https://www.bilibili.com/video/BV1of4y1m7nj/?vd_source=afeab8b555e5eb1bfa1e7f267262cbf2
GitHub链接：https://github.com/WZMIAOMIAO/deep-learning-for-image-processing
目的
其实UP主已经做了很好的视频讲解了他的代码，只是有时候我还是喜欢阅读博客来学习，另外视频很长，6个小时，我看的时候容易睡着_，所以才打算写博客记录一下学习笔记。
目前完成的内容
第一篇：VOC数据集详细介绍
第二篇：Faster-RCNN代码解读2：快速上手使用
第三篇：Faster-RCNN代码解读3：制作自己的数据加载器
第四篇：Faster-RCNN代码解读4：辅助文件解读
第五篇： Faster-RCNN代码解读5：主要文件解读-上
第六篇： Faster-RCNN代码解读6：主要文件解读-中（本文）
目录结构
文章目录
-
- Faster-RCNN代码解读6：主要文件解读-中
-
- 1. 前言：
- 2. faster_rcnn_framework.py文件解读：
-
- 2.1 FasterRCNNBase类：
- 2.2 TwoMLPHead类：
- 2.3 FastRCNNPredictor类：
- 2.4 FasterRCNN类：
- 2.5 小结：
- 3. roi_head.py文件解读：
-
- 3.1 RoIHeads类：
- 3.2 fastrcnn_loss函数：
- 4. 总结：
1. 前言：
之前讲解了network_files文件夹下的transform.py \ boxes.py \ image_list.py文件，这篇文章继续讲解该文件夹下的内容，主要涉及的文件：
faster_rcnn_framework.py
roi_head.py
首先，放张图片，是作者根据代码来画的Faster-RCNN细节图。读过论文的朋友都知道，在论文中并没有详细的给出Faster-RCNN架构图，只是给了一张粗略的图片。
另外，在解读之前，我想补充一点：作者给出了不同的训练网络，比如mobilenet、res50+fpn，其中fpn表示引入不同的特征层。而为了方便代码的统一，作者一般会用一个索引字典来存储相关变量，而mobilenet只有一个特征层，所以只有一个值；而res50+fpn有多个特征层，所以字典有多个值。
关于这一点，你在读代码的时候会发现很多地方都出现了的。
2. faster_rcnn_framework.py文件解读：
这个文件的主要内容就是Faster-RCNN的架构实现。下面来一一讲解里面的类和实现思路。
2.1 FasterRCNNBase类：
这个类是Faster-RCNN的基础，里面主要有两个方法，一是初始化方法，二是前向传播方法。其主要实现了Faster-RCNN整体的正向传播定义。
__init__方法：
初始化一些变量。
输入参数：
| 参数 | 意义 |
|---|---|
| backbone | 特征提取网络模型 |
| rpn | rpn模型 |
| roi_heads | roi pooling和后面的部分 |
| transform | 变换操作 |
该方法具体内容就是将传入参数变为类变量：
self.transform = transform # 预处理方法
self.backbone = backbone # 骨干CNN架构网络
self.rpn = rpn # RPN网络
self.roi_heads = roi_heads # ROI_Head部分
forward方法：
前向传播方法。
传入参数：
| 参数 | 意义 |
|---|---|
| images | 需要处理的图像，batch |
| targets | target参数，一个列表，里面的每一个值都是字典，一个字典就是我们自定义数据加载器的target |
首先，判断是否为训练模式，如果为训练模式，target不能为空：
# 判断是否为训练模式，如果为训练模式，target不能为空
if self.training and targets is None:
raise ValueError("In training mode, targets should be passed")
接着，把boxes值（此时的为真实的值）提取出来并检测数据是否存在问题：
# 如果是训练模式
if self.training:
# 保存target不是空的
assert targets is not None
# 对于targets列表中的每一个target
for target in targets: # 进一步判断传入的target的boxes参数是否符合规定
boxes = target["boxes"]
# 是否为tensor
if isinstance(boxes, torch.Tensor):
# boxes维度判断，必须为【N，4】，N表示一章图片中有N个对象，4为坐标
if len(boxes.shape) != 2 or boxes.shape[-1] != 4:
raise ValueError("Expected target boxes to be a tensor"
"of shape [N, 4], got {:}.".format(
boxes.shape))
else:
raise ValueError("Expected target boxes to be of type "
"Tensor, got {:}.".format(type(boxes)))
然后，获取图像原始尺寸；
# 定义一个空列表,后面的内容torch.jit.annotate是指明这个列表里面的值为啥形式，必须满足这个条件才可以存储进来
original_image_sizes = torch.jit.annotate(List[Tuple[int, int]], [])
# 获取图像的原始尺寸
for img in images:
val = img.shape[-2:]
assert len(val) == 2 # 防止输入的是个一维向量
original_image_sizes.append((val[0], val[1]))
接着，对图像和图像对应的target进行预处理：
# 对图像进行预处理：需要归一化、resize处理（限制图像最小和最大尺度）
images, targets = self.transform(images, targets)
然后，就是将图像作为输入数据，按照Faster-RCNN架构顺序调用相关方法（即先送入backbone，，其输出特征图；接着利用特征图生成建议框；接着就是ROI Pooling以及后面的分类、回归等操作）：
features = self.backbone(images.tensors) # 将图像输入backbone得到特征图
if isinstance(features, torch.Tensor): # 若只在一层特征层上预测，将feature放入有序字典中，并编号为‘0’
features = OrderedDict([('0', features)]) # 若在多层特征层上预测，传入的就是一个有序字典
# 将特征层以及标注target信息传入rpn中
# proposals: List[Tensor], Tensor_shape: [num_proposals, 4],
# 每个proposals是绝对坐标，且为(x1, y1, x2, y2)格式
proposals, proposal_losses = self.rpn(images, features, targets)
# 将rpn生成的数据以及标注target信息传入fast rcnn后半部分
detections, detector_losses = self.roi_heads(features, proposals, images.image_sizes, targets)
# 对网络的预测结果进行后处理（主要将bboxes还原到原图像尺度上）
detections = self.transform.postprocess(detections, images.image_sizes, original_image_sizes)
最后，不要忘记把损失值保存一下，方便后期画图：
# 损失保存一下，后期画图用
losses = {}
losses.update(detector_losses)
losses.update(proposal_losses)
2.2 TwoMLPHead类：
这个方法定义的就是下图对应的区域：
__init__方法：
传入的参数：
| 参数 | 意义 |
|---|---|
| in_channels | ROI pooling后的输入通道个数 |
| representation_size | FC1 和 FC2的通道数/神经元数目 |
该方法内部的代码也很简单，就是定义了fc1 和 fc2：
self.fc6 = nn.Linear(in_channels, representation_size)
self.fc7 = nn.Linear(representation_size, representation_size)
forward方法：
前向传播方法。首先，需要实现flatten展平操作，然后再用全连接层前向传播即可：
# 展平
x = x.flatten(start_dim=1)
# 前向传播，不要忘记relu激活函数
x = F.relu(self.fc6(x))
x = F.relu(self.fc7(x))
2.3 FastRCNNPredictor类：
这个类定义的就是下图对应的区域：
__init__方法：
传入的参数：
| 参数 | 意义 |
|---|---|
| in_channels | 输入的通道个数 |
| num_classes | 类别个数，包括背景 |
这个方法内容很简单，就是定义两个全连接层，只是注意这两个的输出通道个数如何定义的：
self.cls_score = nn.Linear(in_channels, num_classes)
self.bbox_pred = nn.Linear(in_channels, num_classes * 4)
在这里，分类全连接层输出通道数肯定是类别个数，而回归全连接层输出个数为4*类别个数，是因为每个类别的边界框坐标都有四个。
forward方法：
前向传播方法很简单，具体内容看代码注释：
# 如果输入数据为4维的，即【batch，channel，w，h】
# 说明之前的处理有问题，报错
# 但是一般情况下不会进入该判断
if x.dim() == 4:
assert list(x.shape[2:]) == [1, 1]
# 展平处理
# 其实并不需要，其实之前的全连接层已经展平过了
x = x.flatten(start_dim=1)
# 预测
scores = self.cls_score(x)
bbox_deltas = self.bbox_pred(x)
2.4 FasterRCNN类：
这个类继承自FasterRCNNBase类，主要实现了Faster-RCNN的参数初始化部分。
其定义了一个方法，即__init__。首先，看看它的参数（）：
| 参数 | 意义 |
|---|---|
| backbone | CNN架构 |
| num_classes | 类别个数，包括背景，采用VOC数据集为21 |
| min_size 与 max_size | 预处理resize时限制的最小尺寸与最大尺寸 |
| image_mean 与 image_std | 预处理normalize时使用的均值和方差 |
| rpn_anchor_generator | 通过后面的RPN方法定义的，用于生成anchors |
| rpn_head | 也是后面RPN定义的，是RPN的部分结构 |
| rpn_pre_nms_top_n_train 与 rpn_pre_nms_top_n_test | rpn中在nms处理前保留的proposal数(根据score) |
| rpn_post_nms_top_n_train 与 rpn_post_nms_top_n_test | rpn中在nms处理后保留的proposal数，主要针对的是FPN网络，每层都2000个，叠加起来超过上万个，于是使用nms保持2000个 |
| rpn_nms_thresh | rpn中进行nms处理时使用的iou阈值 |
| rpn_fg_iou_thresh 与 rpn_bg_iou_thresh | rpn计算损失时，采集正负样本设置的阈值 |
| rpn_batch_size_per_image 与 rpn_positive_fraction | rpn计算损失时采样的样本数，以及正样本占总样本的比例 |
| box_roi_pool | 下面图片对应的1区域 |
| box_head | 下面图片对应的2区域 |
| box_predictor | 下面图片对应的3区域 |
| box_score_thresh | 移除低目标概率的阈值 |
| box_nms_thresh | fast rcnn中进行nms处理的阈值 |
| box_detections_per_img | 对预测结果根据score排序取前100个目标 |
| box_fg_iou_thresh 与 box_bg_iou_thresh | fast rcnn计算误差时，采集正负样本设置的阈值 |
| box_batch_size_per_image 与 box_positive_fraction | fast rcnn计算误差时采样的样本数，以及正样本占所有样本的比例 |
其函数内容如下：
首先，判断backbone是否有输出通道属性，目的是防止backbone设置错误：
# backbone是否有out_channels属性，即输出通道数
if not hasattr(backbone, "out_channels"):
raise ValueError(
"backbone should contain an attribute out_channels"
"specifying the number of output channels (assumed to be the"
"same for all the levels"
)
接着，还是判断传入的参数是否存在问题：
# 进行一些判断
assert isinstance(rpn_anchor_generator, (AnchorsGenerator, type(None))) # 是否为我们自己定义的AnchorsGenerator类，如果为None，后面再创建
assert isinstance(box_roi_pool, (MultiScaleRoIAlign, type(None))) # 是否有ROI Pooling
# 如果num_classes不为空
if num_classes is not None:
# 那么，说明num_classes是我们自己定义的，那么box_predictor也要有定义
if box_predictor is not None:
raise ValueError("num_classes should be None when box_predictor "
"is specified")
else:
if box_predictor is None:
raise ValueError("num_classes should not be None when box_predictor "
"is not specified")
然后，判断rpn_anchor_generator是否为空，对于train_mobilenetv2.py而言不为空，但是对于但是train_res50_fpn.py为空，因此需要针对该情况创建：
# 预测特征层的channels
out_channels = backbone.out_channels
# train_mobilenetv2.py文件已经定义了rpn_anchor_generator，但是train_res50_fpn.py没有定义
# 若anchor生成器为空，则自动生成针对resnet50_fpn的anchor生成器
if rpn_anchor_generator is None:
# res50 + fpn 有五个特征层，因此传入的anchor_size参数，需要变为五个元组
# 不同的特征层进行不同的尺度处理
anchor_sizes = ((32,), (64,), (128,), (256,), (512,))
aspect_ratios = ((0.5, 1.0, 2.0),) * len(anchor_sizes)
rpn_anchor_generator = AnchorsGenerator(
anchor_sizes, aspect_ratios
)
后面，就是继续初始化一些变量并将一些构件进行组合方便后期使用，我就不细说了，把内容写在了注释上：
# 由于一般不会传rpn_head参数，所以需要创建
# 生成RPN通过滑动窗口预测网络部分
if rpn_head is None:
rpn_head = RPNHead(
out_channels, rpn_anchor_generator.num_anchors_per_location()[0]
)
# 默认rpn_pre_nms_top_n_train = 2000, rpn_pre_nms_top_n_test = 1000,
# 默认rpn_post_nms_top_n_train = 2000, rpn_post_nms_top_n_test = 1000,
# 生成两个字典
rpn_pre_nms_top_n = dict(training=rpn_pre_nms_top_n_train, testing=rpn_pre_nms_top_n_test)
rpn_post_nms_top_n = dict(training=rpn_post_nms_top_n_train, testing=rpn_post_nms_top_n_test)
# 定义整个RPN框架，具体的实现在后面讲解
rpn = RegionProposalNetwork(
rpn_anchor_generator, rpn_head,
rpn_fg_iou_thresh, rpn_bg_iou_thresh,
rpn_batch_size_per_image, rpn_positive_fraction,
rpn_pre_nms_top_n, rpn_post_nms_top_n, rpn_nms_thresh,
score_thresh=rpn_score_thresh)
# Multi-scale RoIAlign pooling
# 如果我们用了res+fpn，是多个（5个）特征层，因此需要专门设定ROI Pooling
# 但是，官方实现的时候，没有加上最后一层，因此总共为4层
if box_roi_pool is None:
box_roi_pool = MultiScaleRoIAlign(
featmap_names=['0', '1', '2', '3'], # 在哪些特征层进行roi pooling
output_size=[7, 7],
sampling_ratio=2)
# fast RCNN中roi pooling后的展平处理两个全连接层部分
# 定义
if box_head is None:
resolution = box_roi_pool.output_size[0] # 默认等于7
representation_size = 1024
# 这个类上面讲解过了
box_head = TwoMLPHead(
out_channels * resolution ** 2,
representation_size
)
# 在box_head的输出上预测部分
if box_predictor is None:
representation_size = 1024
# 这个类上面讲解过了
box_predictor = FastRCNNPredictor(
representation_size,
num_classes)
# 将roi pooling, box_head以及box_predictor结合在一起： 方便定义处理方法和前向传播方法
# 见下面3.1讲解
roi_heads = RoIHeads(
# box
box_roi_pool, box_head, box_predictor,
box_fg_iou_thresh, box_bg_iou_thresh, # 0.5 0.5
box_batch_size_per_image, box_positive_fraction, # 512 0.25
bbox_reg_weights,
box_score_thresh, box_nms_thresh, box_detections_per_img) # 0.05 0.5 100
# 预处理的图像均值和方差定义
if image_mean is None:
image_mean = [0.485, 0.456, 0.406]
if image_std is None:
image_std = [0.229, 0.224, 0.225]
# 对数据进行标准化，缩放，打包成batch等处理部分
transform = GeneralizedRCNNTransform(min_size, max_size, image_mean, image_std)
说明：
在上面的代码中，其实有一个函数实现了ROI Pooling，就是：
# Multi-scale RoIAlign pooling
# 如果我们用了res+fpn，是多个（5个）特征层，因此需要专门设定ROI Pooling
# 但是，官方实现的时候，没有加上最后一层，因此总共为4层
if box_roi_pool is None:
box_roi_pool = MultiScaleRoIAlign(
featmap_names=['0', '1', '2', '3'], # 在哪些特征层进行roi pooling
output_size=[7, 7],
sampling_ratio=2)
我之所以专门提出它，是因为作者并没有单独再去实现ROI pooling方法了。作者给出了解释：MultiScaleRoIAlign方法是torchvision官方实现的，并且已经封装好了，所以没有办法看到源码。但是网上仍然有许多相关的实现方法，感兴趣的可以取看看。
2.5 小结：
faster_rcnn_framework.py文件是该项目中非常重要的文件之一。当阅读完该文件代码后，我们可以知道：该文件实现了将Faster-RCNN的各个组件串联一起的功能。
比如，在network_files文件夹下，主要实现了rpn框架、预处理方法、ROI pooling及其后面流程组成的roi_head框架等功能，而faster_rcnn_framework.py就是将这些串起来了，构成了一个完整的Faster-RCNN。
如果上面有一些代码你没有弄明白，可以多看一遍，或者自己取调试代码，弄清变量含义。
3. roi_head.py文件解读：
3.1 RoIHeads类：
上面2.4小节第一次出现RoIHeads类，这个类的作用就是把下图框起来的部分结合在一起来处理：
__init__方法：
首先，看看传入的参数：
| 参数 | 意义 |
|---|---|
| box_roi_pool | 上图中的ROIPpooling |
| box_head | 上图中的TwoMLPHead |
| box_predictor | 上图中的FastRCNNPredictor |
| fg_iou_thresh 与 bg_iou_thresh | 正负样本划分阈值，都为0.5 |
| batch_size_per_image 与 positive_fraction | 样本总数与正负样本比例 |
| score_thresh 与 nms_thresh 与 detection_per_img | 三个阈值，值分别为0.05，0.5，100 |
这里说明一下上面参数中的detection_per_img参数，其默认值为100。表示一张图片前100个score值最大的对象，之所以设置为100个，是因为一般图像并没有100个对象，因此设置100个可以让大部分图片的对象都包含在内。
初始化方法的内容就是初始化一些对象，其中有几个对象是文件det_utils.py中的，这些对象的具体内容会在下一篇讲解。
初始化方法很简单，看下面的注释即可：
# 将iou方法赋予给box_similarity
self.box_similarity = box_ops.box_iou
# det_utils.Matcher作用是划分正负样本
self.proposal_matcher = det_utils.Matcher(
fg_iou_thresh, # default: 0.5
bg_iou_thresh, # default: 0.5
allow_low_quality_matches=False)
# BalancedPositiveNegativeSampler 作用是将划分好正负样本的proposal进行采样
self.fg_bg_sampler = det_utils.BalancedPositiveNegativeSampler(
batch_size_per_image, # default: 512
positive_fraction) # default: 0.25
# 超参数，后面用的时候再说
if bbox_reg_weights is None:
bbox_reg_weights = (10., 10., 5., 5.)
#
self.box_coder = det_utils.BoxCoder(bbox_reg_weights)
# 简单的赋值操作 / 初始化变量
self.box_roi_pool = box_roi_pool # Multi-scale RoIAlign pooling
self.box_head = box_head # TwoMLPHead
self.box_predictor = box_predictor # FastRCNNPredictor
self.score_thresh = score_thresh # default: 0.05
self.nms_thresh = nms_thresh # default: 0.5
self.detection_per_img = detection_per_img # default: 100
forward方法：
下面以前向传播方法为路径，遇到新方法就讲解新方法的内容（新方法补充在下面）。
首先，看看forward方法的参数：
| 参数 | 意义 |
|---|---|
| features | 图像特征层 |
| proposals | rpn输出的proposal值，格式为List[Tensor[N, 4]] |
| image_shapes | 预处理后的图像尺寸信息 |
| targets | 图像对应的target信息（真实值） |
代码内容如下：
首先，检测target内部的值是否符合要求：
# 检查targets的数据类型是否正确
if targets is not None:
for t in targets:
floating_point_types = (torch.float, torch.double, torch.half)
assert t["boxes"].dtype in floating_point_types, "target boxes must of float type"
assert t["labels"].dtype == torch.int64, "target labels must of int64 type"
接着，判断是否为训练模式，如果为训练模式，则需要对proposal进行处理（划分正负样本，统计对应gt的标签以及边界框回归信息等），否则就不需要：（方法select_training_samples见后面）
if self.training:
# 划分正负样本，统计对应gt的标签以及边界框回归信息
# 因为传入的proposal 2000个，但是我们只需要512个，所以需要进行采样
proposals, labels, regression_targets = self.select_training_samples(proposals, targets)
else:
labels = None
regression_targets = None
通过上面的方法，我们就获取到了proposal、label、anchor回归参数。接着，我们需要进行ROI Pooling操作：
# 将采集样本通过Multi-scale RoIAlign pooling层，即输出的大小都相同
# box_features_shape: [num_proposals, channel, height, width] = 【1024，256，7，7】 （2张图片=512*2=1024）
box_features = self.box_roi_pool(features, proposals, image_shapes)
然后，通过两个全连接层：
# 通过roi_pooling后的两层全连接层
# box_features_shape: [num_proposals, representation_size] = 【1024，1024】 后一个1024是全连接层的输出个数
box_features = self.box_head(box_features)
进行最后的回归和分类操作：
# 接着分别预测目标类别和边界框回归参数，这就是我们的预测结果
class_logits, box_regression = self.box_predictor(box_features)
# class_logits = 【1024，21】
# box_regression = 【1024，84】 ，81 = 21*4 ， 每个类别都有四个坐标值
最后，如果是训练模式，需要计入损失；如果不是，则需要进行后处理操作显示预测结果：
# 定义result格式
result = torch.jit.annotate(List[Dict[str, torch.Tensor]], [])
# 定义损失函数空字典
losses = {}
if self.training:
# 如果是训练模式，需要计算损失
assert labels is not None and regression_targets is not None
loss_classifier, loss_box_reg = fastrcnn_loss(
class_logits, box_regression, labels, regression_targets)
# 把损失添加一下
losses = {
"loss_classifier": loss_classifier,
"loss_box_reg": loss_box_reg
}
else:
# 如果是验证，不需要计算损失
# 直接对预测结果进行后处理： 低概率筛选，nms处理
boxes, scores, labels = self.postprocess_detections(class_logits, box_regression, proposals, image_shapes)
# 获取个数
num_images = len(boxes)
# 将值传入result参数值返回
for i in range(num_images):
result.append(
{
"boxes": boxes[i],
"labels": labels[i],
"scores": scores[i],
}
)
后处理方法见后面。
elect_training_samples方法：
这个方法的作用是：划分正负样本，统计对应gt的标签以及边界框回归信息。
首先，传入的参数：
| 参数 | 意义 |
|---|---|
| proposals | rpn预测的boxes，2000个 |
| targets | 真实图像的信息 |
代码内容如下：
首先，检测数据是否正常并获取一些基本值：
# 检查target数据是否为空
self.check_targets(targets)
# 如果不加这句，jit.script会不通过(看不懂)
assert targets is not None
# 获取proposal的类型和设备信息
dtype = proposals[0].dtype
device = proposals[0].device
# 获取标注好的真实boxes以及labels信息
gt_boxes = [t["boxes"].to(dtype) for t in targets]
gt_labels = [t["labels"] for t in targets]
由于正例的proposal很少，所以作者把真实样本框的值也加入了其中：（add_gt_proposals方法见后面）
# 将gt_boxes拼接到proposal后面
proposals = self.add_gt_proposals(proposals, gt_boxes)
然后，为计算每个proposal与对应的真实框的iou，并划分正负样本（该流程由方法assign_targets_to_proposals实现，见后面）：
# 为每个proposal匹配对应的gt_box，并划分到正负样本中
matched_idxs, labels = self.assign_targets_to_proposals(proposals, gt_boxes, gt_labels)
划分完正负样本后，就是按照给定的参数进行正负样本采样：（方法subsample见后面）
# 按给定数量和比例采样正负样本
sampled_inds = self.subsample(labels)
采样完成后，就是去获取正负样本和其对应的标签，并利用anchor和真实框进行回归：
# 遍历每张图像
for img_id in range(num_images):
# 获取每张图像的正负样本索引
img_sampled_inds = sampled_inds[img_id]
# 获取对应 正负 样本的proposals信息
proposals[img_id] = proposals[img_id][img_sampled_inds]
# 获取对应 正负 样本的真实类别信息
labels[img_id] = labels[img_id][img_sampled_inds]
# 获取对应 正负 样本的gt索引信息
matched_idxs[img_id] = matched_idxs[img_id][img_sampled_inds]
# 获取图像的gt box
gt_boxes_in_image = gt_boxes[img_id]
# 如果gt box个数为0
if gt_boxes_in_image.numel() == 0:
# 给它一个0值
gt_boxes_in_image = torch.zeros((1, 4), dtype=dtype, device=device)
# 获取对应正负样本的gt box信息
# matched_idxs[img_id] = gt box的索引
# gt_boxes_in_image[matched_idxs[img_id]] 将索引对应的值提取出来
# matched_gt_boxes就为[512,4]，坐标信息
matched_gt_boxes.append(gt_boxes_in_image[matched_idxs[img_id]])
# 根据gt和proposal计算边框回归参数（针对gt的），真实的回归
regression_targets = self.box_coder.encode(matched_gt_boxes, proposals)
return proposals, labels, regression_targets
我们知道，这里作者定义的采集512个正负样本，那么可以在调试代码的时候验证一下输出，如下图所示：
另外，不要忘记，每个变量其实都是batch，因此具体的结构为[batch,512,4]：
add_gt_proposals方法：
该方法的作用：将gt_boxes拼接到proposal后面。
传入的参数：
| 参数 | 意义 |
|---|---|
| proposals | 一个batch中每张图像rpn预测的boxes |
| gt_boxes | 一个batch中每张图像对应的真实目标边界框 |
该方法的实现很简单，就是直接遍历拼接即可：
# 直接遍历拼接
# 目的： 增加正样本个数
proposals = [
torch.cat((proposal, gt_box))
for proposal, gt_box in zip(proposals, gt_boxes)
]
为了让大家更直观的观测其值的变化，可以对代码进行调试，首先，运行前后的proposal变量shape：
而该方法的作用是把真实框加入其中，那么看看真实框的shape是不是[1,4]即可验证函数作用：
assign_targets_to_proposals方法：
该方法的作用就是：为每个proposal匹配对应的gt_box，并划分到正负样本中。
传入的参数：
| 参数 | 意义 |
|---|---|
| proposals | rpn输出的proposals值 |
| gt_boxes | 真实框的坐标信息 |
| gt_labels | 真实框的类别信息 |
代码的具体内容可以看注释：
# 定义两个空列表，待会用于存储值
matched_idxs = []
labels = []
# 遍历每张图像的proposals, gt_boxes, gt_labels信息
for proposals_in_image, gt_boxes_in_image, gt_labels_in_image in zip(proposals, gt_boxes, gt_labels):
# 该张图像中没有gt框，即这个图像里面没有任何一个对象，一般情况下不会发生
if gt_boxes_in_image.numel() == 0:
# 对上面这种情况做出一定的处理： 可以跳过不看
# 具体来说，就是用0值填充
device = proposals_in_image.device
clamped_matched_idxs_in_image = torch.zeros(
(proposals_in_image.shape[0],), dtype=torch.int64, device=device
)
labels_in_image = torch.zeros(
(proposals_in_image.shape[0],), dtype=torch.int64, device=device
)
else:
# 有对象的情况下
# 计算proposal与每个gt_box的iou重合度
match_quality_matrix = box_ops.box_iou(gt_boxes_in_image, proposals_in_image)
# 计算proposal与每个gt_box匹配的iou最大值，并记录索引，
# iou < low_threshold索引值为 -1， low_threshold <= iou < high_threshold索引值为 -2
# 其中-2的值就是忽略的样本，-1的值就是负例样本
matched_idxs_in_image = self.proposal_matcher(match_quality_matrix)
# 限制最小值，防止匹配标签时出现越界的情况
# 注意-1, -2对应的gt索引会调整到0,获取的标签类别为第0个gt的类别（实际上并不是）,后续会进一步处理
clamped_matched_idxs_in_image = matched_idxs_in_image.clamp(min=0)
# 获取proposal匹配到的gt对应标签
labels_in_image = gt_labels_in_image[clamped_matched_idxs_in_image]
labels_in_image = labels_in_image.to(dtype=torch.int64)
# 将gt索引为-1的类别设置为0，即背景，负样本
bg_inds = matched_idxs_in_image == self.proposal_matcher.BELOW_LOW_THRESHOLD # -1
labels_in_image[bg_inds] = 0
# 将gt索引为-2的类别设置为-1, 即废弃样本
ignore_inds = matched_idxs_in_image == self.proposal_matcher.BETWEEN_THRESHOLDS # -2
labels_in_image[ignore_inds] = -1 # -1 is ignored by sampler
# 将处理完的值添加至列表中并返回
matched_idxs.append(clamped_matched_idxs_in_image)
labels.append(labels_in_image)
subsample方法：
该方法的就是按照给定的参数进行样本的采样。
代码内容很简单（只大致看下意思）：
# 使用fg_bg_sampler进行采集正样本和负样本，返回其对应的索引值
sampled_pos_inds, sampled_neg_inds = self.fg_bg_sampler(labels)
# 定义一个空列表
sampled_inds = []
# 遍历每张图片的正负样本索引
for img_idx, (pos_inds_img, neg_inds_img) in enumerate(zip(sampled_pos_inds, sampled_neg_inds)):
# 记录所有采集样本索引（包括正样本和负样本）： pos_inds_img | neg_inds_img 中的 | 是或操作
img_sampled_inds = torch.where(pos_inds_img | neg_inds_img)[0]
sampled_inds.append(img_sampled_inds)
postprocess_detections方法：
该方法的作用是进行后处理。后处理的内容包括：
（1）根据proposal以及预测的回归参数计算出最终bbox坐标
（2）对预测类别结果进行softmax处理
（3）裁剪预测的boxes信息，将越界的坐标调整到图片边界上
（4）移除所有背景信息
（5）移除低概率目标
（6）移除小尺寸目标
（7）执行nms处理，并按scores进行排序
（8）根据scores排序返回前topk个目标
首先，传入的参数：
| 参数 | 意义 |
|---|---|
| class_logits | 网络预测类别概率信息 |
| box_regression | 网络预测的边界框回归参数 |
| proposals | rpn输出的proposal |
| image_shapes | 打包成batch前每张图像的宽高 |
这个方法的整体思路很简单，但是很多方法涉及到另外一个文件det_utls.py，我会在下一篇中解读。这里只需要了解这个方法在干嘛即可：
# 获取设备
device = class_logits.device
# 预测目标类别数
num_classes = class_logits.shape[-1]
# 获取每张图像的预测bbox数量
boxes_per_image = [boxes_in_image.shape[0] for boxes_in_image in proposals]
# 根据proposal以及预测的回归参数计算出最终bbox坐标
pred_boxes = self.box_coder.decode(box_regression, proposals)
# 对预测类别结果进行softmax处理
pred_scores = F.softmax(class_logits, -1)
# 根据每张图像的预测bbox数量分割结果
pred_boxes_list = pred_boxes.split(boxes_per_image, 0)
pred_scores_list = pred_scores.split(boxes_per_image, 0)
# 定义一些变量
all_boxes = []
all_scores = []
all_labels = []
# 遍历每张图像预测信息
for boxes, scores, image_shape in zip(pred_boxes_list, pred_scores_list, image_shapes):
# 裁剪预测的boxes信息，将越界的坐标调整到图片边界上
boxes = box_ops.clip_boxes_to_image(boxes, image_shape)
# create labels for each prediction
labels = torch.arange(num_classes, device=device)
labels = labels.view(1, -1).expand_as(scores)
# 移除索引为0的所有信息（0代表背景）
boxes = boxes[:, 1:]
scores = scores[:, 1:]
labels = labels[:, 1:]
# batch everything, by making every class prediction be a separate instance
boxes = boxes.reshape(-1, 4)
scores = scores.reshape(-1)
labels = labels.reshape(-1)
# 移除低概率目标，self.scores_thresh=0.05
# gt: Computes input > other element-wise.
inds = torch.where(torch.gt(scores, self.score_thresh))[0]
boxes, scores, labels = boxes[inds], scores[inds], labels[inds]
# 移除小目标
keep = box_ops.remove_small_boxes(boxes, min_size=1.)
boxes, scores, labels = boxes[keep], scores[keep], labels[keep]
# 执行nms处理，执行后的结果会按照scores从大到小进行排序返回
keep = box_ops.batched_nms(boxes, scores, labels, self.nms_thresh)
# 获取scores排在前topk个预测目标
keep = keep[:self.detection_per_img]
boxes, scores, labels = boxes[keep], scores[keep], labels[keep]
# 将处理后的值加入变量中
all_boxes.append(boxes)
all_scores.append(scores)
all_labels.append(labels)
return all_boxes, all_scores, all_labels
3.2 fastrcnn_loss函数：
该函数的作用是计算faster-rcnn的损失值。
首先，传入的参数为：
| 参数 | 意义 |
|---|---|
| class_logits | 预测类别概率信息，shape=[num_anchors, num_classes] |
| box_regression | 预测边目标界框回归信息 |
| labels | 真实类别信息 |
| regression_targets | 真实目标边界框信息 |
其实这个函数的定义就是按照**Faster-RCNN损失函数定义来定义的，**为方便理解，我把faster-rcnn的损失函数放在这里：
而，函数代码内容如下，详细见注释：
# 思路： 分别计算回归损失和分类损失
# 将值进行拼接
# label=【batch，512】 ---》 label = 【1024】，此时batch=2
labels = torch.cat(labels, dim=0)
# regression_targets=【2，512，4】 ---》 【1024，4】
regression_targets = torch.cat(regression_targets, dim=0)
# 计算类别损失信息：交叉熵损失
# class_logits = 【1024，21】
classification_loss = F.cross_entropy(class_logits, labels)
# 计算预测框的回归损失：只有正样本才有意义
# 返回标签类别大于0的索引
sampled_pos_inds_subset = torch.where(torch.gt(labels, 0))[0]
# 返回标签类别大于0位置的类别信息
labels_pos = labels[sampled_pos_inds_subset]
# shape=[num_proposal, num_classes]
# N 1024 ；classes 21
N, num_classes = class_logits.shape
# reshape前=【1024，84】 --》 【1024，21，4】
box_regression = box_regression.reshape(N, -1, 4)
# 计算边界框损失信息
box_loss = det_utils.smooth_l1_loss(
# 获取指定索引proposal的指定类别box信息
box_regression[sampled_pos_inds_subset, labels_pos],
regression_targets[sampled_pos_inds_subset],
beta=1 / 9,
size_average=False,
) / labels.numel()
4. 总结：
本篇主要介绍了Faster-RCNN的架构的大致实现流程，和ROI Pooling以及后面的部分的详细实现过程。