【目标检测】Faster RCNN代码实现——（2）

一、项目总览

二、model文件夹

2.1 faster_rcnn.py

  本py文件用于构建Faster RCNN模型的基类，子类重写该类中的方法或新增方法，来定义想要的模型。

from __future__ import  absolute_import
from __future__ import division
import torch as t
import numpy as np
from utils import array_tool as at
from model.utils.bbox_tools import loc2bbox
from torchvision.ops import nms
from torch import nn
from data.dataset import preprocess
from torch.nn import functional as F
from utils.config import opt
'''本py文件为Faster RCNN模型的基类，其他子类对该类的方法进行重写'''
def nograd(f):
    def new_f(*args,**kwargs):
        with t.no_grad():
           return f(*args,**kwargs)
    return new_f
'''Faster RCNN类：所有类（Faster R-CNNvgg16）的基类。一些基础属性和方法的定义，子类重写这些方法'''
class FasterRCNN(nn.Module):
    """
    3个网络阶段构成了Faster R-CNN.
        1.Feature extraction: 输入图像提取共享的特征图
        2.Region Proposal Networks: 使用共享特征图，产生目标的ROI
        3.Localization and Classification Heads:使用共享特征图及提案ROI进行目标的分类和位置精修
    Args:
        extractor (nn.Module): 一个获取BCHW图像数组并返回特征图的模块。
        rpn (nn.Module): 具有与以下接口相同的模块`model.region_proposal_network.RegionProposalNetwork`
        head (nn.Module): 一个采用BCHW变量，RoI和RoI的批次索引的模块。 这将返回与类相关的位置和类分数。
        loc_normalize_mean (tuple of four floats):位置估计值的平均值。
        loc_normalize_std (tupler of four floats): 位置预测值的标准差。
    """
    '''__init__()函数：初始化函数'''
    def __init__(self, extractor, rpn, head,loc_normalize_mean = (0., 0., 0., 0.),loc_normalize_std = (0.1, 0.1, 0.2, 0.2)):

        super(FasterRCNN, self).__init__()
        '''(1)特征提取器'''
        self.extractor = extractor
        '''(2)RPN网络'''
        self.rpn = rpn
        '''(3)头部网络'''
        self.head = head

        '''4.位置预测的均值和标准差设定'''
        self.loc_normalize_mean = loc_normalize_mean#loc_normalize_mean = (0., 0., 0., 0.)
        self.loc_normalize_std = loc_normalize_std#loc_normalize_std = (0.1, 0.1, 0.2, 0.2)

        '''5.nms_thresh、score_thresh阈值的设定'''
        self.use_preset('evaluate')

    '''n_class()函数：总类别的数量（包含背景类）'''
    @property
    def n_class(self):
        return self.head.n_class
    '''forward()函数：FasterRCNN的前向传播，输入为调整后的图像，返回roi_cls_locs（头部预测）, roi_scores（头部预测）, rois（RPN生成）, roi_indices（RPN生成）'''
    def forward(self, x, scale=1.):
        """
        `scale`：RPN使用scale来确定选择小目标的阈值，这无论他们的置信度如何，都会被拒绝
        `N`：批量的大小  Classes=背景+`L`类
        Args:
            x (autograd.Variable): 4D 图像变量
            scale (float): 在预处理期间应用于原始图像的缩放比例。
        Returns:
            返回下面列出的四个值的元组。
             roi_cls_locs：候选ROI的偏移和缩放 。形状`(R', (L + 1) \\times 4)`. `R'：批量图片产生的ROI的总数。R_i第i个图片产生的ROI
             roi_scores: 候选ROI的类预测 shape `(R', L + 1)`.`L` 除去背景类的类别数量
             rois: RoIs proposed by RPN.  shape (R', 4)`.
             roi_indices : 批量图片产生的ROI的索引 shape`(R',)`.
        """
        img_size = x.shape[2:]#图像的大小H, W。x=(C, H, W)

        '''(1)提取x的特征图：x为调整后的图像'''
        h = self.extractor(x)

        '''(2)RPN网络生成ROI'''
        rpn_locs, rpn_scores, rois, roi_indices, anchor = self.rpn(h, img_size, scale)#输入：调整后图像的特征图、调整后图像尺寸、图像的调整尺度

        '''(3)头部，生成 roi_cls_locs, roi_scores'''
        roi_cls_locs, roi_scores = self.head(h, rois, roi_indices)#输入：调整后图像的特征图、roi坐标 （x,y,x,y）、roi的索引

        return roi_cls_locs, roi_scores, rois, roi_indices

    '''use_preset()函数：根据'visualize', 'evaluate'，设置nms_thresh及score_thresh值'''
    def use_preset(self, preset):
        """Args: preset： ({'visualize', 'evaluate'): """
        if preset == 'visualize':
            self.nms_thresh = 0.3
            self.score_thresh = 0.7
        elif preset == 'evaluate':
            self.nms_thresh = 0.3
            self.score_thresh = 0.05
        else:
            raise ValueError('preset must be visualize or evaluate')

    '''_suppress（）函数：对网络head的预测结果，进行非极大值抑制等后处理操作，得到最终的网络检测结果'''
    def _suppress(self, raw_cls_bbox, raw_prob):

        bbox = list()
        label = list()
        score = list()
        for l in range(1, self.n_class):#跳过类别0，因为是背景类
            cls_bbox_l = raw_cls_bbox.reshape((-1, self.n_class, 4))[:, l, :]
            prob_l = raw_prob[:, l]
            mask = prob_l > self.score_thresh
            cls_bbox_l = cls_bbox_l[mask]
            prob_l = prob_l[mask]
            keep = nms(cls_bbox_l, prob_l,self.nms_thresh)
            # import ipdb;ipdb.set_trace()
            # keep = cp.asnumpy(keep)
            bbox.append(cls_bbox_l[keep].cpu().numpy())
            # The labels are in [0, self.n_class - 2].
            label.append((l - 1) * np.ones((len(keep),)))
            score.append(prob_l[keep].cpu().numpy())
        bbox = np.concatenate(bbox, axis=0).astype(np.float32)
        label = np.concatenate(label, axis=0).astype(np.int32)
        score = np.concatenate(score, axis=0).astype(np.float32)
        return bbox, label, score

    '''predict（）函数：使用模型，进行目标的检测。返回bboxes, labels, scores'''
    @nograd
    def predict(self, imgs,sizes=None,visualize=False):
        """从某张图像中检测目标
        Args:
            imgs (iterable of numpy.ndarray): images数组.所有图像都是CHW和RGB格式，值的范围为0-255
        Returns:返回一个元组，元组的每个元素为一个列表,`(bboxes, labels, scores)`.
           bboxes: 浮点数组列表。hape`(R, 4)`代表 R 一张图像中的边界框的数量，每个边界框(y_{min}, x_{min}, y_{max}, x_{max}
           labels: 整型数组列表 shape (R,)`.每个值代表边界框的类别。值的取值范围为`[0, L - 1]`L是前景类别的数量
           scores: 浮点数组列表。 :math:`(R,)`每个值代表预测置信度
        """
        '''（1）设置模型为测试模式：不进行梯度的更新'''
        self.eval()

        '''(2) 加载并处理图片'''
        if visualize:
            self.use_preset('visualize')#设置nms_thresh及score_thresh值
            prepared_imgs = list()
            sizes = list()
            for img in imgs:
                size = img.shape[1:]#读取原图的大小
                img = preprocess(at.tonumpy(img))#调整图像的大小、值的范围。返回调整大小后的img数组，归一化值的范围为-1~1
                prepared_imgs.append(img)#将调整后的图片加入列表
                sizes.append(size)#将原始图片尺寸
        else:
             prepared_imgs = imgs
        
        '''(3)执行检测'''
        bboxes = list()
        labels = list()
        scores = list()
        for img, size in zip(prepared_imgs, sizes):

            img = at.totensor(img[None]).float()
            
            '''1.获取图片的缩放尺度'''
            # 原始图片的缩放因子scale，因为原始图像经过大小等的调整，这个缩放因子scale在ProposalCreator 筛选roi时有用到，即将所有候选框按这个缩放因子映射回原图，
            # 超出原图边框的趋于将被截断。
            scale = img.shape[3] / size[1]
            
            '''2.图片执行forward：得到头部分支的预测roi_cls_loc, roi_scores, rois, _'''
            roi_cls_loc, roi_scores, rois, _ = self(img, scale=scale)#调用FasterRCNN的前向传播函数：返回roi_cls_locs, roi_scores, rois, roi_indices
            # We are assuming that batch size is 1.
            roi_score = roi_scores.data
            roi_cls_loc = roi_cls_loc.data
            
            roi = at.totensor(rois) / scale

            # 把预测边界框转换为图像坐标中的边界框。预测边界框是网络输入图像的预测，将其转换为适合原图像的尺寸
            mean = t.Tensor(self.loc_normalize_mean).cuda(). repeat(self.n_class)[None]
            std = t.Tensor(self.loc_normalize_std).cuda().repeat(self.n_class)[None]
            roi_cls_loc = (roi_cls_loc * std + mean)
            roi_cls_loc = roi_cls_loc.view(-1, self.n_class, 4)
            roi = roi.view(-1, 1, 4).expand_as(roi_cls_loc)

            '''3.解码roi_cls_loc:变为实际坐标（y，x，y,x），而不是偏移量'''
            #将网络预测关于anchor box的偏移解码为边界框的直接坐标：（y，x，y,x）,roi是参考框，roi_cls_loc是相对于roi的偏移
            cls_bbox = loc2bbox(at.tonumpy(roi).reshape((-1, 4)),at.tonumpy(roi_cls_loc).reshape((-1, 4)))
            cls_bbox = at.totensor(cls_bbox)
            cls_bbox = cls_bbox.view(-1, self.n_class * 4)

            '''4.将超出图像的边界框区域进行裁剪'''
            cls_bbox[:, 0::2] = (cls_bbox[:, 0::2]).clamp(min=0, max=size[0])
            cls_bbox[:, 1::2] = (cls_bbox[:, 1::2]).clamp(min=0, max=size[1])

            prob = (F.softmax(at.totensor(roi_score), dim=1))
            
            '''5.得到真正的检测结果：'''
            # predict函数是对网络RoIhead网络输出的预处理
            # 函数_suppress将得到真正的预测结果。
            bbox, label, score = self._suppress(cls_bbox, prob)
            bboxes.append(bbox)
            labels.append(label)
            scores.append(score)

        self.use_preset('evaluate')
        self.train()
        return bboxes, labels, scores

    '''get_optimizer()函数：返回模型的优化器optimizer'''
    def get_optimizer(self):
        """返回优化器，如果自定义了优化器，则优化器被重写"""
        lr = opt.lr
        params = []

        '''网络层的学习率、权重衰减'''
        for key, value in dict(self.named_parameters()).items():
            if value.requires_grad:
                if 'bias' in key:
                    params += [{'params': [value], 'lr': lr * 2, 'weight_decay': 0}]
                else:
                    params += [{'params': [value], 'lr': lr, 'weight_decay': opt.weight_decay}]

        '''优化算法'''
        if opt.use_adam:
            self.optimizer = t.optim.Adam(params)
        else:
            self.optimizer = t.optim.SGD(params, momentum=0.9)
        return self.optimizer
    '''scale_lr()函数：用于调整网络层的学习率'''
    def scale_lr(self, decay=0.1):
        for param_group in self.optimizer.param_groups:
            param_group['lr'] *= decay
        return self.optimizer

2.1 faster_rcnn_vgg16.py

  本py文件定义了faster_rcnn_vgg16类，该类重写了faster_rcnn类。

from __future__ import  absolute_import
import torch as t
import torch
from torch import nn
# from torchvision.models import vgg16
from torchvision.ops import RoIPool
from model.region_proposal_network import RegionProposalNetwork
from model.faster_rcnn import FasterRCNN
from utils import array_tool as at
from utils.config import opt
'''基于VGG-16的Faster R-CNN。本类是FasterRCNN的子类'''

###################################################新增代码：decom_vgg16()中调用##############################################################
cfgs = {'A': [64, 'M', 128, 'M', 256, 256, 'M', 512, 512, 'M', 512, 512, 'M'],
    'B': [64, 64, 'M', 128, 128, 'M', 256, 256, 'M', 512, 512, 'M', 512, 512, 'M'],
    'D': [64, 64, 'M', 128, 128, 'M', 256, 256, 256, 'M', 512, 512, 512, 'M', 512, 512, 512, 'M'],
    'E': [64, 64, 'M', 128, 128, 'M', 256, 256, 256, 256, 'M', 512, 512, 512, 512, 'M', 512, 512, 512, 512, 'M'],
}
from torchvision.models import VGG
def make_layers(cfg, batch_norm=False):
    layers = []
    in_channels = 3
    for v in cfg:
        if v == 'M':
            layers += [nn.MaxPool2d(kernel_size=2, stride=2)]
        else:
            conv2d = nn.Conv2d(in_channels, v, kernel_size=3, padding=1)
            if batch_norm:
                layers += [conv2d, nn.BatchNorm2d(v), nn.ReLU(inplace=True)]
            else:
                layers += [conv2d, nn.ReLU(inplace=True)]
            in_channels = v
    return nn.Sequential(*layers)
def vgg16(pretrained=False, progress=True, **kwargs):
    return _vgg('vgg16', 'D', False, pretrained, progress, **kwargs)
def _vgg(arch, cfg, batch_norm, pretrained, progress, **kwargs):
    if pretrained:
        kwargs['init_weights'] = False
    model = VGG(make_layers(cfgs[cfg], batch_norm=batch_norm), **kwargs)
    if pretrained:
        model.load_state_dict(torch.load(r'D:\Project\PaperProject\simple-faster-rcnn-pytorch\weight\vgg16-397923af.pth'))
    return model
###################################################新增代码：decom_vgg16()中调用##############################################################

''' FasterRCNNVGG16类：父类为FasterRCNN，此类用于构建FasterRCNNVGG16网络结构'''
class FasterRCNNVGG16(FasterRCNN):
    """基于VGG-16的Faster R-CNN。父类是FasterRCNN的子类"""
    feat_stride = 16  # vgg16的 conv5输出的下采样步长
    '''__init__()函数：初始化函数'''
    def __init__(self, n_fg_class=20,ratios=[0.5, 1, 2],anchor_scales=[8, 16, 32]):
        '''
         n_fg_class (int): 包含背景类的数据集类的数量
        ratios (list of floats):anchors的宽和高比
        anchor_scales (list of numbers): anchors的面积。这些面积将是“ anchor_scales”中元素的平方与参考窗口原始面积的乘积。
        '''
        '''（1）主干网络:特征提取网络，调整后的vgg16'''
        extractor, classifier = decom_vgg16()

        '''(2)RPN网络:返回RPN预测的 rpn_locs（相对于anchor box的偏移，（t_y，t_x,t_h,t_w））、
            rpn_scores（rpn的前景类分数）、
            rois（经过筛选后的rpn,格式为y,x,y,x）、roi的索引，
            anchor box'''
        rpn = RegionProposalNetwork(512, 512,ratios=ratios,anchor_scales=anchor_scales,feat_stride=self.feat_stride,)
        #h, img_size, scale

        '''(3)头部网络：得到网络预测：roi_cls_locs（边界框坐标，4维）, roi_scores（各种类别分数，num_cls维）'''
        head = VGG16RoIHead(n_class=n_fg_class + 1,roi_size=7,spatial_scale=(1. / self.feat_stride), classifier=classifier )
        super(FasterRCNNVGG16, self).__init__(extractor, rpn,head,)


'''decom_vgg16（）函数：构建vgg16网络(Faster RCNN的特征提取网络)。返回nn.Sequential(*features), classifier'''
def decom_vgg16():
 
    '''（1）加载预训练 模型结构、权重'''
    # caffe_pretrain = False  # use caffe pretrained model instead of torchvision
    # caffe_pretrain_path = 'checkpoints/vgg16_caffe.pth'
    if opt.caffe_pretrain:
        model = vgg16(pretrained=False)
        if not opt.load_path:
            model.load_state_dict(t.load(opt.caffe_pretrain_path))
    else:
        # opt.load_path= None
        model = vgg16(not opt.load_path)#加载torchvision内的vgg16模型及权重
    #print(model)#打印VGG16分类网络

    '''(2)预训练模型 结构调整：调整vgg16网络使其适应于本项目'''
    #VGG16模型有两部分：features，classifier。
    #1.features保持不变
    features = list(model.features)[:30]
    #2.classifier层，删除最后一个分类层和其中包含的dropout层
    classifier = model.classifier
    classifier = list(classifier)
    del classifier[6]
    if not opt.use_drop:#删除dropout层
        del classifier[5]
        del classifier[2]
    classifier = nn.Sequential(*classifier)
    '''(3)固定某些层的参数，不训练'''
    # freeze top4 conv
    for layer in features[:10]:#features共计30层，固定其10层不训练
        for p in layer.parameters():
            p.requires_grad = False
    return nn.Sequential(*features), classifier

'''VGG16RoIHead类：Faster RCNN的头部，得到网络预测：roi_cls_locs（边界框坐标，4维）, roi_scores（各种类别分数，num_cls维）'''
class VGG16RoIHead(nn.Module):
    """基于给定的RoI 的特征图输出位置和类别。
    Args:
        n_class (int): 包含背景类别的总类别的数量
        roi_size (int): 经过RoI-pooling作用后的特征图的高和宽.
        spatial_scale (float): roi调整的尺度
        classifier (nn.Module): 从vgg16移植的两层线性层
    """
    '''__init__()函数：初始化函数'''
    def __init__(self, n_class, roi_size, spatial_scale,classifier):
        super(VGG16RoIHead, self).__init__()
        '''特征提取网络的classifier网络层'''
        self.classifier = classifier
        
        '''构建头部网络的线性层：定位层和分类层（线性层），并初始化权重参数'''
        self.cls_loc = nn.Linear(4096, n_class * 4)
        self.score = nn.Linear(4096, n_class)
        normal_init(self.cls_loc, 0, 0.001)
        normal_init(self.score, 0, 0.01)
        
        '''包含背景的类别数量、ROI调整后的大小（通过roi pooling）、ROI调整的尺度'''
        self.n_class = n_class
        self.roi_size = roi_size
        self.spatial_scale = spatial_scale
        
        '''构建RoIPool层'''
        self.roi = RoIPool( (self.roi_size, self.roi_size),self.spatial_scale)

    '''forward()函数:前向传播'''
    def forward(self, x, rois, roi_indices):
        """ `N` batches.
        Args:
            x (Variable): 调整后的图片产生的特征图
            rois (Tensor): ROI边界框的坐标. 这个数组是批量所有图片的ROI 。shape : `(R', 4)`. `R_i` 第i张图片的ROI
            roi_indices (Tensor): 一维数组，是ROI在批量中图片的索引shape :math:`(R',)`，每个值指示批量的哪张图片
        """
        #from utils import array_tool as at
        '''(1)拼接roi_indices、 rois得到indices_and_rois：rois坐标为（y,x,y,x）'''
        #totensor()函数：将其他类型的数据转化为tensor类型，并迁移到cuda
        roi_indices = at.totensor(roi_indices).float()
        rois = at.totensor(rois).float()
        
        indices_and_rois = t.cat([roi_indices[:, None], rois], dim=1)

        '''(2)ROI由（y,x,y,x）转换为（x,y,x,y）格式，得到indices_and_rois'''
        xy_indices_and_rois = indices_and_rois[:, [0, 2, 1, 4, 3]]
        indices_and_rois =  xy_indices_and_rois.contiguous()

        '''(3)RoIPool后的ROI特征图：'''
        pool = self.roi(x, indices_and_rois)
        pool = pool.view(pool.size(0), -1)

        '''(4)定位和分类层作用于ROI特征图，得到检测位置及检测类别'''
        fc7 = self.classifier(pool)
        roi_cls_locs = self.cls_loc(fc7)
        roi_scores = self.score(fc7)

        return roi_cls_locs, roi_scores

'''normal_init（）函数：网络层权重的初始化'''
def normal_init(m, mean, stddev, truncated=False):
    # x is a parameter
    if truncated:
        m.weight.data.normal_().fmod_(2).mul_(stddev).add_(mean)  # not a perfect approximation
    else:
        m.weight.data.normal_(mean, stddev)
        m.bias.data.zero_()

2.3 region_proposal_network.py

  本py文件构建faster Rcnn的RPN网络，返回RPN预测的 rpn_locs（相对于anchor box的偏移，（t_y，t_x,t_h,t_w））、rpn_scores（rpn的前景类分数）、rois（经过筛选后的rpn,格式为y,x,y,x）、roi的索引，anchor box

import numpy as np
from torch.nn import functional as F
import torch as t
from torch import nn
from model.utils.bbox_tools import generate_anchor_base
from model.utils.creator_tool import ProposalCreator

'''RegionProposalNetwork类：构建RPN网络.返回RPN预测的 rpn_locs（相对于anchor box的偏移，（t_y，t_x,t_h,t_w））、rpn_scores（rpn的前景类分数）、rois（经过筛选后的rpn,格式为y,x,y,x）、roi的索引，anchor box'''
class RegionProposalNetwork(nn.Module):
    """利用从图像中提取的特征，在“对象”周围产生类不可知的边界框。
    Args:
        in_channels (int): 输入通道数
        mid_channels (int): 中间张量的通道大小。
        ratios (list of floats): anchor的宽度与高度之比。
        anchor_scales (list of numbers): anchor的面积。这些面积是`anchor_scales`中元素的平方与参考窗口原始区域的乘积。
        feat_stride (int): 从图像中提取的特征的下采样步幅大小。
        initialW (callable): 初始化权重值.
        proposal_creator_params (dict): Key valued paramters for
            :class:`model.utils.creator_tools.ProposalCreator`.
    """
    ''' __init_()函数：属性以及方法的初始化函数'''
    def __init__(self, in_channels=512, mid_channels=512, ratios=[0.5, 1, 2],
                 anchor_scales=[8, 16, 32], feat_stride=16,proposal_creator_params=dict()):
        #ratios=[0.5, 1, 2],anchor_scales=[8, 16, 32]
        super(RegionProposalNetwork, self).__init__()

        '''生成一组先验base anchors(y_{min}, x_{min}, y_{max}, x_{max})，共9个，这组anchors在特征图上滑动，产生先验anchor box。 '''
        self.anchor_base = generate_anchor_base(anchor_scales=anchor_scales, ratios=ratios)

        self.feat_stride = feat_stride
        '''产生ROI，作为头部网络的输入 （ROI：（y，x，y,x））：ROI，是经过NMS等筛选处理后的rpn预测框'''
        self.proposal_layer = ProposalCreator(self, **proposal_creator_params)


        '''构建RPN网络：参数使用normal_init初始化'''
        #一组先验anchor的数量
        n_anchor = self.anchor_base.shape[0]
        self.conv1 = nn.Conv2d(in_channels, mid_channels, 3, 1, 1)
        self.score = nn.Conv2d(mid_channels, n_anchor * 2, 1, 1, 0)
        self.loc = nn.Conv2d(mid_channels, n_anchor * 4, 1, 1, 0)
        normal_init(self.conv1, 0, 0.01)
        normal_init(self.score, 0, 0.01)
        normal_init(self.loc, 0, 0.01)

    '''forward（）函数：RPN网络的前向传播。输入为来自特征提取网络的特征图'''
    def forward(self, x, img_size, scale=1.):#h, img_size, scale
        """
        Args:
            x (~torch.autograd.Variable): 特征图 shape :`(N, C, H, W)`. `N` 批量大小  `C` 输入的通道数 `H` and `W` 特征图的宽和高
            img_size (tuple of ints):网络输入图像的（`height, width`）
            scale (float): 网络输入图像相对于原始图像的缩放尺度
        Returns: (~torch.autograd.Variable, ~torch.autograd.Variable, array, array, array):
           元组包含以下5个值：
                rpn_locs:网络预测边界框相对于anchor box的偏移  shape:`(N, H W A, 4)`.`A` 每个特征图单元的anchor的数量
                rpn_scores : anchor box的前景类的分数 shape  : `(N, H W A, 2)`.`A` 每个特征图单元的anchor的数量
                rois : ROI边界框的坐标，shape `(R', 4)`坐标（y，x，y,x）.`R_i` 代表第i张图片预测的ROI
                roi_indices : RoI对应的图片索引的数组。 shape：（R'，）`。
                anchor :anchor box的坐标.shape  : (H W A, 4)`，其中坐标为（y,x,y,x）.
        """
        '''特征图的高、宽'''
        n, _, hh, ww = x.shape

        '''(1)为特征图产生anchor box（y,x,y,x）'''
        anchor = _enumerate_shifted_anchor(np.array(self.anchor_base),self.feat_stride, hh, ww)#参数

        '''(2)为特征图，生成RPN预测：位置rpn_locs(n, -1, 4)、前景类分数预测 rpn_scores(n, -1, 2)'''

        n_anchor = anchor.shape[0] // (hh * ww)
        '''1.网络边界框坐标预测，坐标为相对于anchor box的偏移量（t_y，t_x,t_h,t_w）'''
        h = F.relu(self.conv1(x))
        rpn_locs = self.loc(h)
        rpn_locs = rpn_locs.permute(0, 2, 3, 1).contiguous().view(n, -1, 4)

        '''2.网络边界框前景类分数预测：经过softmax处理'''
        rpn_scores = self.score(h)
        rpn_scores = rpn_scores.permute(0, 2, 3, 1).contiguous()
        rpn_softmax_scores = F.softmax(rpn_scores.view(n, hh, ww, n_anchor, 2), dim=4)
        rpn_fg_scores = rpn_softmax_scores[:, :, :, :, 1].contiguous()
        rpn_fg_scores = rpn_fg_scores.view(n, -1)
        rpn_scores = rpn_scores.view(n, -1, 2)


        rois = list()
        roi_indices = list()
        for i in range(n):#遍历批量中的每个图片
            '''(3)为第i张图片产生ROI（y，x，y,x）：这些ROI，是经过NMS等处理后的rpn预测框'''
            roi = self.proposal_layer(rpn_locs[i].cpu().data.numpy(),rpn_fg_scores[i].cpu().data.numpy(),anchor, img_size,scale=scale)
            #输入参数：rpn位置预测、rpn前景类分数预测、anchor box、调整后的图像的尺寸、图像的缩放因子

            '''(4)将第i张图片的ROI添加到rois列表，并将batch_index的索引号设置为i'''
            batch_index = i * np.ones((len(roi),), dtype=np.int32)
            rois.append(roi)
            roi_indices.append(batch_index)

        rois = np.concatenate(rois, axis=0)
        roi_indices = np.concatenate(roi_indices, axis=0)
        
        '''(5)返回 rpn_locs（相对于anchor box的偏移，（t_y，t_x,t_h,t_w））、rpn_scores（rpn的前景类分数）、rois（经过筛选后的rpn,格式为y,x,y,x）、roi的索引，anchor box'''
        return rpn_locs, rpn_scores, rois, roi_indices, anchor

'''_enumerate_shifted_anchor()函数：使用一组先验anchor_base为特征图产生anchor box'''
def _enumerate_shifted_anchor(anchor_base, feat_stride, height, width):
    #将Aanchor_base（1，A，4）添加到单元格（图像块）K移位（K，1，4）中以获得移位后的 anchor（K，A，4），形状调整为（K * A，4）

    import numpy as xp
    '''（1）将图像划分为 网格（网格包含：feat_stride*feat_stride 个网格单元）'''
    shift_y = xp.arange(0, height * feat_stride, feat_stride)
    shift_x = xp.arange(0, width * feat_stride, feat_stride)
    shift_x, shift_y = xp.meshgrid(shift_x, shift_y)
    shift = xp.stack((shift_y.ravel(), shift_x.ravel(),shift_y.ravel(), shift_x.ravel()), axis=1)

    '''（2）将先验base anchor分配给每个网格单元，最终得到特征图的所有anchor box的坐标'''
    A = anchor_base.shape[0]
    K = shift.shape[0]
    anchor = anchor_base.reshape((1, A, 4)) +  shift.reshape((1, K, 4)).transpose((1, 0, 2))
    anchor = anchor.reshape((K * A, 4)).astype(np.float32)
    return anchor
'''同上作用'''
def _enumerate_shifted_anchor_torch(anchor_base, feat_stride, height, width):
    import torch as t
    shift_y = t.arange(0, height * feat_stride, feat_stride)
    shift_x = t.arange(0, width * feat_stride, feat_stride)
    shift_x, shift_y = np.meshgrid(shift_x, shift_y)
    shift = np.stack((shift_y.ravel(), shift_x.ravel(), shift_y.ravel(), shift_x.ravel()), axis=1)

    A = anchor_base.shape[0]
    K = shift.shape[0]
    anchor = anchor_base.reshape((1, A, 4)) + shift.reshape((1, K, 4)).transpose((1, 0, 2))
    anchor = anchor.reshape((K * A, 4)).astype(np.float32)
    return anchor

'''normal_init()函数：权重初始化函数'''
def normal_init(m, mean, stddev, truncated=False):
    """"""
    # m为网络层，
    if truncated:
        m.weight.data.normal_().fmod_(2).mul_(stddev).add_(mean)  # not a perfect approximation
    else:
        m.weight.data.normal_(mean, stddev)
        m.bias.data.zero_()

2.4 bbbox_tools.py

import numpy as np
import numpy as xp
import six
from six import __init__

'''loc2bbox()函数：例将网络预测关于anchor box的偏移（t_y，t_x,t_h,t_w），解码为直接坐标：（y，x，y,x）。返回值和输入值相同的形状 '''
def loc2bbox(src_bbox, loc):
    """
    给定网络预测的边界框rpn框（相对于anchor box偏移`t_y, t_x, t_h, t_w` ）计算它的坐标公式为：
        hat{g}_y = p_h t_y + p_y`
        hat{g}_x = p_w t_x + p_x`
        hat{g}_h = p_h \\exp(t_x)`
        hat{g}_w = p_w \\exp(t_w)`
    Args:
        src_bbox (array): anchor box坐标。shape:math:`(R, 4)`坐标形式为：`p_{ymin}, p_{xmin}, p_{ymax}, p_{xmax}`.
        loc (array):loc):  loc为网络预测的边界框，这些边界框是相对于anchor box的偏移,坐标形式为：`t_y, t_x, t_h, t_w`.
        src_bbox, loc两者的形状相同
    Returns:数组，解码后的边界框坐标shap:`(R, 4)`.
    """
    if src_bbox.shape[0] == 0:
        return xp.zeros((0, 4), dtype=loc.dtype)

    src_bbox = src_bbox.astype(src_bbox.dtype, copy=False)
    '''（1）anchor box的w、h、y,x'''
    src_height = src_bbox[:, 2] - src_bbox[:, 0]
    src_width = src_bbox[:, 3] - src_bbox[:, 1]
    src_ctr_y = src_bbox[:, 0] + 0.5 * src_height
    src_ctr_x = src_bbox[:, 1] + 0.5 * src_width
    '''(2)预测框相对于anchor box的偏移dy，dx ，dh，dw'''
    dy = loc[:, 0::4]
    dx = loc[:, 1::4]
    dh = loc[:, 2::4]
    dw = loc[:, 3::4]

    '''(3)解码预测框坐标：返回解码后的预测边界框（y，x，y,x）'''
    ctr_y = dy * src_height[:, xp.newaxis] + src_ctr_y[:, xp.newaxis]
    ctr_x = dx * src_width[:, xp.newaxis] + src_ctr_x[:, xp.newaxis]
    h = xp.exp(dh) * src_height[:, xp.newaxis]
    w = xp.exp(dw) * src_width[:, xp.newaxis]

    dst_bbox = xp.zeros(loc.shape, dtype=loc.dtype)
    dst_bbox[:, 0::4] = ctr_y - 0.5 * h
    dst_bbox[:, 1::4] = ctr_x - 0.5 * w
    dst_bbox[:, 2::4] = ctr_y + 0.5 * h
    dst_bbox[:, 3::4] = ctr_x + 0.5 * w

    return dst_bbox

'''bbox2loc（）函数：例计算anchor box相对于真值框的偏移（t_y, t_x, t_h, t_w）'''
def bbox2loc(src_bbox, dst_bbox):
    """例：给定anchor box，计算相对于真值框的偏移量和缩放比例。以将anchor框与真值框匹配。

    调整后的anchor框：(y, x，p_h, p_w`）
    规范化后的真值框：（`g_y, g_x` `g_h, g_w`,）
    偏移和缩放比例为：（t_y, t_x, t_h, t_w` ）计算公式为：
                `t_y = \\frac{(g_y - p_y)} {p_h}`
                `t_x = \\frac{(g_x - p_x)} {p_w}`
                `t_h = \\log(\\frac{g_h} {p_h})`
                `t_w = \\log(\\frac{g_w} {p_w})`
    Args:
        src_bbox (array): anchor框，形状为`(R, 4)`.R代表anchor框的数量，格式为（`p_{ymin}, p_{xmin}, p_{ymax}, p_{xmax}`.）
        dst_bbox (array): 真值框。形状为(R, 4) 坐标格式为`g_{ymin}, g_{xmin}, g_{ymax}, g_{xmax}`.

    Returns:anchor相对于真值框的偏移shape`(R, 4)`.（`t_y, t_x, t_h, t_w`.）
    """
    '''(1)RPN网络产生的anchor box为(y_{min}, x_{min}, y_{max}, x_{max})形式，将其转换为(y, x，p_h, p_w`）'''
    height = src_bbox[:, 2] - src_bbox[:, 0]
    width = src_bbox[:, 3] - src_bbox[:, 1]
    ctr_y = src_bbox[:, 0] + 0.5 * height
    ctr_x = src_bbox[:, 1] + 0.5 * width
    '''(2)真值框的坐标为(y_{min}, x_{min}, y_{max}, x_{max})形式，将其转换为(y, x，p_h, p_w`）'''
    base_height = dst_bbox[:, 2] - dst_bbox[:, 0]
    base_width = dst_bbox[:, 3] - dst_bbox[:, 1]
    base_ctr_y = dst_bbox[:, 0] + 0.5 * base_height
    base_ctr_x = dst_bbox[:, 1] + 0.5 * base_width

    '''(3)计算anchor box 相对于真值框的偏移（t_y, t_x, t_h, t_w）'''
    eps = xp.finfo(height.dtype).eps
    height = xp.maximum(height, eps)
    width = xp.maximum(width, eps)

    dy = (base_ctr_y - ctr_y) / height
    dx = (base_ctr_x - ctr_x) / width
    dh = xp.log(base_height / height)
    dw = xp.log(base_width / width)
    
    loc = xp.vstack((dy, dx, dh, dw)).transpose()
    return loc

'''bbox_iou()函数：返回IOU值矩阵。计算两组边界框的IOU值矩阵'''
def bbox_iou(bbox_a, bbox_b):
    """
    Args:
        bbox_a (array):形状：`(N, 4)`.N为框的数量
        bbox_b (array):形状：`(K, 4)`.N为框的数量
    Returns:数组，形状为`(N, K)`.
    """
    if bbox_a.shape[1] != 4 or bbox_b.shape[1] != 4:
        raise IndexError
    '''相交区域的左上和右下坐标'''
    tl = xp.maximum(bbox_a[:, None, :2], bbox_b[:, :2])
    br = xp.minimum(bbox_a[:, None, 2:], bbox_b[:, 2:])
    
    '''相交面积'''
    area_i = xp.prod(br - tl, axis=2) * (tl < br).all(axis=2)
    
    area_a = xp.prod(bbox_a[:, 2:] - bbox_a[:, :2], axis=1)
    area_b = xp.prod(bbox_b[:, 2:] - bbox_b[:, :2], axis=1)
    '''iou值矩阵'''
    return area_i / (area_a[:, None] + area_b - area_i)


def __test():
    pass

if __name__ == '__main__':
    __test()

'''generate_anchor_base：一组先验 base anchors，这组anchors在特征图上滑动，为特征图产生先验anchor box。(y_{min}, x_{min}, y_{max}, x_{max}) '''
def generate_anchor_base(base_size=16, ratios=[0.5, 1, 2],anchor_scales=[8, 16, 32]):
    """产生按给定宽高比缩放和修改的anchor。
    例如果scale是`8`，ratio是`0.25`，则基本窗口的宽度和高度被`8`拉伸。高度减半，宽度加倍。
    Args:
        base_size (number): 参考窗口的宽和高.
        ratios (list of floats): anchor宽高比的比率
        anchor_scales (list of numbers): anchor的面积
            这些面积将是“ anchor_scales”中元素的平方与参考窗口原始面积的乘积。
    Returns: ~numpy.ndarray。shape：`(R, 4)`.每个anchor的坐标为`(y_{min}, x_{min}, y_{max}, x_{max})`

    """
    '''(1)参考窗口的宽和高'''
    py = base_size / 2.#8
    px = base_size / 2.#8

    '''(2)每个位置的anchor的数量（一组anchors的数量）'''
    anchor_base = np.zeros((len(ratios) * len(anchor_scales), 4),dtype=np.float32)#shape=[9,4]

    '''(3)每个anchor的坐标。这些anchor框以（0,0）为中心'''
    for i in six.moves.range(len(ratios)):
        for j in six.moves.range(len(anchor_scales)):
            #anchor的宽和高'''，例 ratios=0.5,anchor_scales=8时，h=8*8*根下0.5=45.25,w=8*8*根下0.75=90.5
            h = base_size * anchor_scales[j] * np.sqrt(ratios[i])
            w = base_size * anchor_scales[j] * np.sqrt(1. / ratios[i])

            '''anchor的坐标(y_{min}, x_{min}, y_{max}, x_{max}），'''
            index = i * len(anchor_scales) + j
            anchor_base[index, 0] = py - h / 2.
            anchor_base[index, 1] = px - w / 2.
            anchor_base[index, 2] = py + h / 2.
            anchor_base[index, 3] = px + w / 2.
    return anchor_base

2.5 creator_tools.py

import numpy as np
import torch
from torchvision.ops import nms
from model.utils.bbox_tools import bbox2loc, bbox_iou, loc2bbox

''' ProposalTargetCreator类：采样ROI，返回sample_roi, gt_roi_loc, gt_roi_label.既采样后的ROI、ROI相对于真值框的偏移（t_y, t_x, t_h, t_w）、ROI的类标签索引'''
class ProposalTargetCreator(object):
    """把真值框分配给ROI
    Args:
        n_sample (int): 采样ROI的数量
        pos_ratio (float): 标记为前景的区域的分数。
        pos_iou_thresh (float): RoI被视为前景的IoU阈值。
        neg_iou_thresh_hi (float): RoI被视为背景：如果IOU 在 [`neg_iou_thresh_hi`,`neg_iou_thresh_hi`).范围
        neg_iou_thresh_lo (float): RoI被视为背景：如果IOU 在 [`neg_iou_thresh_hi`,`neg_iou_thresh_hi`).范围
    """
    '''__init__（）函数：初始化函数，用于定义一些参数、阈值等'''
    def __init__(self,n_sample=128,pos_ratio=0.25, pos_iou_thresh=0.5, neg_iou_thresh_hi=0.5, neg_iou_thresh_lo=0.0):
        #采样后的ROI的数量
        self.n_sample = n_sample
        self.pos_ratio = pos_ratio
        self.pos_iou_thresh = pos_iou_thresh
        self.neg_iou_thresh_hi = neg_iou_thresh_hi
        self.neg_iou_thresh_lo = neg_iou_thresh_lo  # NOTE:default 0.1 in py-faster-rcnn
        
    '''__call__()函数：采样ROI，返回采样后的ROI、ROI相对于真值框的偏移（t_y, t_x, t_h, t_w）、ROI的类标签索引'''
    def __call__(self, roi, bbox, label,loc_normalize_mean=(0., 0., 0., 0.),loc_normalize_std=(0.1, 0.1, 0.2, 0.2)):
        """Assigns ground truth to sampled proposals.
        Args:
            roi (array): RoIs.shape :(R, 4)`
            bbox (array): 真值框的坐标。shape : (R', 4)`.
            label (array):真值框的标签.  shape :`(R',)`.值的范围为[0, L - 1]`, L为前景类的数量
            loc_normalize_mean (tuple of four floats):标准化后边界框坐标的均值
            loc_normalize_std (tupler of four floats): 边界框坐标的标准方差
        Returns:(array, array, array):
             sample_roi : 采样的ROI数量 。shape  :`(S, 4)`.`S` 采样RoIs的总数量=n_sample`.
             gt_roi_loc :采样的RoI相对于与真值框的偏移和尺度   shape  :`(S, 4)`.
             gt_roi_label: 采样的ROI的标签.  shape   :`(S,)`.取值范围`[0, L]`.   0 代表背景

        """
        '''(1)计算ROI与真值框的IOU值矩阵：iou'''
        #真值框的数量
        n_bbox, _ = bbox.shape
        roi = np.concatenate((roi, bbox), axis=0)#按轴axis连接array组成一个新的array
        pos_roi_per_image = np.round(self.n_sample * self.pos_ratio)

        iou = bbox_iou(roi, bbox)

        '''(2)每个ROI匹配的  真值框的索引（gt_assignment）、两者之间的IOU值（max_iou）、类标签索引（gt_roi_label）'''
        gt_assignment = iou.argmax(axis=1)#行中最大值的索引
        max_iou = iou.max(axis=1)#行中最大IOU值
        # Offset range of classes from [0, n_fg_class - 1] to [1, n_fg_class].
        gt_roi_label = label[gt_assignment] + 1#0代表背景

        '''(3)采样前景RoI,返回前景roi的索引pos_index:  IoU>>pos_iou_thresh ,数量为pos_roi_per_this_image'''
        pos_index = np.where(max_iou >= self.pos_iou_thresh)[0]
        pos_roi_per_this_image = int(min(pos_roi_per_image, pos_index.size))#每张图片应该保留的前景ROI数量
        if pos_index.size > 0:
            pos_index = np.random.choice( pos_index, size=pos_roi_per_this_image, replace=False)
        '''(4)采样背景ROI，返回背景roi的索引neg_index：IoU值范围在[neg_iou_thresh_lo, neg_iou_thresh_hi)'，数量为=neg_roi_per_this_image'''
        neg_index = np.where((max_iou < self.neg_iou_thresh_hi) &(max_iou >= self.neg_iou_thresh_lo))[0]
        neg_roi_per_this_image = self.n_sample - pos_roi_per_this_image
        neg_roi_per_this_image = int(min(neg_roi_per_this_image,neg_index.size))
        if neg_index.size > 0:
            neg_index = np.random.choice(neg_index, size=neg_roi_per_this_image, replace=False)

        '''(5)最终采样保留的ROI的索引（pos_index, neg_index）'''
        keep_index = np.append(pos_index, neg_index)
        '''(6)采样后的ROI的坐标sample_roi、类标签索引gt_roi_label，'''
        gt_roi_label = gt_roi_label[keep_index]
        gt_roi_label[pos_roi_per_this_image:] = 0  # 背景ROI的类标签索引为0

        sample_roi = roi[keep_index]

        '''(7)计算采样ROI与其匹配的真值框的 偏移（t_y, t_x, t_h, t_w）'''
        # Compute offsets and scales to match sampled RoIs to the GTs.
        gt_roi_loc = bbox2loc(sample_roi, bbox[gt_assignment[keep_index]])
        gt_roi_loc = ((gt_roi_loc - np.array(loc_normalize_mean, np.float32)) / np.array(loc_normalize_std, np.float32))
        #返回采样后的ROI，ROI相对于真值框的偏移（t_y, t_x, t_h, t_w）、ROI的类标签索引
        return sample_roi, gt_roi_loc, gt_roi_label
    
    
'''AnchorTargetCreator类：构建anchor box相对于匹配的真值框的偏移（t_y, t_x, t_h, t_w）、anchor的标签（0，-1,1）、'''
class AnchorTargetCreator(object):
    """将真值边界框分配给 anchor。用于训练RPN网络
     把anchor匹配给真值框的偏移量和比例尺，都使用的编码方案`model.utils.bbox_tools.bbox2loc`计算
    """
    ''' __init__()函数：初始化函数，设置采样anchor的总数量、正负anchor的阈值、正anchor占总anchor的比例'''
    def __init__(self,n_sample=256,pos_iou_thresh=0.7, neg_iou_thresh=0.3,pos_ratio=0.5):
        '''
        n_sample (int): The number of regions to produce.
        pos_iou_thresh (float): IoU高于此阈值的anchor为正。
        neg_iou_thresh (float): IoU低于此阈值的anchor为负。
        pos_ratio (float): 采样anchor中正anchor的比率。'''
        self.n_sample = n_sample
        self.pos_iou_thresh = pos_iou_thresh
        self.neg_iou_thresh = neg_iou_thresh
        self.pos_ratio = pos_ratio
    '''__call__（）函数：返回anchor box相对于真值框的偏移（t_y, t_x, t_h, t_w）、anchor box的标签(1=positive, 0=negative, -1=ignore)'''
    def __call__(self, bbox, anchor, img_size):
        """将真值框分配给采样anchor子集。
        Args:
            bbox (array): 真值框的坐标. shape `(R, 4)`.`R` 真值框数量
            anchor (array): 图片中所有anchor box的坐标. shape `(S, 4)`.`S` anchor的数量
            img_size (tuple of ints):经过调整后的图像的宽和高
        Returns: (array, array):
            loc: anchor box相对于真值框的偏移和缩放shape :`(S, 4)`.
            label: 带有值的anchor box标签(1=positive, 0=negative, -1=ignore)`.shape：`(S,)`.
        """
        '''(1)经过调整的图像的大小、anchor box的数量'''
        img_H, img_W = img_size
        n_anchor = len(anchor)

        '''(2)获取完全在图像内部的anchor box及anchor box的索引'''
        #index_inside:获取完全位于图像内部的anchor的索引。
        inside_index = _get_inside_index(anchor, img_H, img_W)
        #anchor：提取完全位于图像内部的anchor（anchor的坐标）
        anchor = anchor[inside_index]

        '''(3)每个anchor box最大iou对应的真实框索引、每个anchor box的标签数组label(1=positive, 0=negative, -1=ignore)'''
        argmax_ious, label = self._create_label(inside_index, anchor, bbox)

        '''(4)计算anchor box相对于匹配的真值框的偏移（t_y, t_x, t_h, t_w）:anchor box和真值框的坐标都是（x,y,x,y）形式'''
        loc = bbox2loc(anchor, bbox[argmax_ious])

        '''(6)将anchor的标签既anchor相对于真值框的偏移，映射到所有anchor中：因为初始label、loc的计算都是对完全包含在图像中的anchor进行的，有一部分anchor可能有些区域在图像外部'''
        label = _unmap(label, n_anchor, inside_index, fill=-1)#anchor的标签、anchor的数量、完全在图像内部的anchor索引
        loc = _unmap(loc, n_anchor, inside_index, fill=0)

        return loc, label
    
    
    '''_create_label()函数：返回每个anchor box最大iou对应的真实框索引、每个anchor box的标签数组label(1=positive, 0=negative, -1=ignore)、'''
    def _create_label(self, inside_index, anchor, bbox):
        '''
        inside_index:完全位于图像内部的anchor box的索引
        anchor:完全位于图像内部的anchor box（anchor的坐标）
        bbox：真值框
        '''
        '''(1)创建anchor的lable数组:数组初始值为-1'''
        label = np.empty((len(inside_index),), dtype=np.int32)
        label.fill(-1)

        '''(2)每个anchor box最大iou对应的真实框索引（argmax_ious）、每个anchor box最大iou值（max_ious）、每个真值框最大iou的anchor box索引'''
        argmax_ious, max_ious, gt_argmax_ious = self._calc_ious(anchor, bbox, inside_index)

        '''(3)给anchor box设置标签(1=positive, 0=negative, -1=ignore)：根据max_iou是否高于阈值'''
        # 负标签：首先分配负标签，以便正标签可以掩盖它们
        label[max_ious < self.neg_iou_thresh] = 0

        #正标签：
        #1.最大iou值对应的anchor设为正anchor
        label[gt_argmax_ious] = 1
        # 2.iou值高于阈值的anchor设为正anchor
        label[max_ious >= self.pos_iou_thresh] = 1

        '''(4)采样正anchor box：没有被采样的正anchor box标签label相应位置设置为-1'''
        #需要保留的正anchor的数量
        n_pos = int(self.pos_ratio * self.n_sample)
        #正anchor的索引
        pos_index = np.where(label == 1)[0]
        if len(pos_index) > n_pos:
            disable_index = np.random.choice(pos_index, size=(len(pos_index) - n_pos), replace=False)
            label[disable_index] = -1

        '''(5)采样负anchor box：'''
        #需要保留的负anchor的数量
        n_neg = self.n_sample - np.sum(label == 1)
        #负anchor的索引
        neg_index = np.where(label == 0)[0]
        if len(neg_index) > n_neg:
            disable_index = np.random.choice(
                neg_index, size=(len(neg_index) - n_neg), replace=False)
            label[disable_index] = -1

        '''返回：每个anchor box最大iou对应的真实框索引、每个anchor box的标签数组label（标记anchor为正、负anchor） '''
        return argmax_ious, label
    
    '''_calc_ious（）函数：返回每个anchor box最大iou对应的真实框索引（argmax_ious）、每个anchor box最大iou值（max_ious）、每个真值框最大iou的anchor box索引'''
    def _calc_ious(self, anchor, bbox, inside_index):
        ''' '''
        '''1.计算真值框和anchor的iou值矩阵。形状为【anchor数量，真值框数量】'''
        ious = bbox_iou(anchor, bbox)

        '''2.每个anchor box最大iou的对应的真实框索引'''
        argmax_ious = ious.argmax(axis=1)#
        '''3.每个anchor box最大iou值'''
        max_ious = ious[np.arange(len(inside_index)), argmax_ious]#每个先验框对应的拥有最大iou的真实框的iou值
        '''4.每个真值框最大iou的anchor box索引'''
        gt_argmax_ious = ious.argmax(axis=0)#
        gt_max_ious = ious[gt_argmax_ious, np.arange(ious.shape[1])]
        gt_argmax_ious = np.where(ious == gt_max_ious)[0] # 每个真实框对应的先验框最大的iou

        return argmax_ious, max_ious, gt_argmax_ious
    
'''_unmap()函数：将anchor的标签（anchor的标签只包含完全在图像的anchor）映射到所有的anchor中'''
def _unmap(data, count, index, fill=0):
    # Unmap a subset of item (data) back to the original set of items (of size count)
    '''参数：完全在图像内部的anchor的标签、图像中所有anchor的数量、完全在图像内部的anchor索引'''
    if len(data.shape) == 1:
        ret = np.empty((count,), dtype=data.dtype)
        ret.fill(fill)
        ret[index] = data
    else:
        ret = np.empty((count,) + data.shape[1:], dtype=data.dtype)
        ret.fill(fill)
        ret[index, :] = data
    return ret

'''_get_inside_index()函数：获取完全位于图像内部的anchor box的索引。index_inside'''
def _get_inside_index(anchor, H, W):
    # 计算完全位于指定大小图像内部的anchor索引。
    index_inside = np.where(
        (anchor[:, 0] >= 0) &
        (anchor[:, 1] >= 0) &
        (anchor[:, 2] <= H) &
        (anchor[:, 3] <= W)
    )[0]
    return index_inside

'''ProposalCreator类：RPN网络生成ROI（感兴趣区域，用于后续的头部网络的检测（y，x，y,x））。既经过非极大值抑制等后处理操作后的RPN网络产生的rpn框 '''
class ProposalCreator:
    """为特征图生成提案框
   `__call__` 通过估计边界框相对于anchor的偏移量来输出对象检测提案（ROI）。
    此类使用参数来控制传递给NMS并在NMS之后保留的边界框的数量。如果参数为负，则使用提供的所有边界框或保留NMS返回的所有边界框。
    """
    '''__init__()函数：初始化函数，设置一些阈值、nms相关的参数'''
    def __init__(self,parent_model,nms_thresh=0.7, n_train_pre_nms=12000, n_train_post_nms=2000,n_test_pre_nms=6000,n_test_post_nms=300,min_size=16):
        '''
         nms_thresh (float): NMS.阈值
        n_train_pre_nms (int):在训练模式下，传递到NMS之前要保留的得分最高的边界框的数量。
        n_train_post_nms (int): 在训练模式下，传递到NMS后要保留的得分最高的边界框的数量。
        n_test_pre_nms (int): 在测试模式下，传递到NMS之前要保留的得分最高的边界框的数量。
        n_test_post_nms (int): 在测试模式下，传递到NMS后要保留的得分最高的边界框的数量。
        force_cpu_nms (bool): `True`代表在CPU模式下应用NMS 。`False`：False：根据输入类型选择NMS模式
        min_size (int): 用于根据边界框的大小确定丢弃边界框的阈值的参数。
        '''
        '''(1)模式、nms阈值'''
        self.parent_model = parent_model
        self.nms_thresh = nms_thresh

        '''（2）不同模式下，nms处理前和nms后保留的边界框的数量'''
        self.n_train_pre_nms = n_train_pre_nms
        self.n_train_post_nms = n_train_post_nms

        self.n_test_pre_nms = n_test_pre_nms
        self.n_test_post_nms = n_test_post_nms

        self.min_size = min_size
        
    '''__call__()函数：返回ROI框（用于输入到后续头部网络），这些ROI框，是对RPN预测框的筛选后的结果'''
    def __call__(self, loc, score , anchor, img_size, scale=1.):# rpn位置预测、rpn前景类分数预测、anchor box、调整后的图像的尺寸、图像的缩放因子
        """
        Args:
            loc (array):网络预测的相对于anchor box的偏移 shape `(R, 4)`.偏移的坐标（t_y，t_x,t_h,t_w），R为先验 anchor的总数量=特征图的宽*高*每个位置先验anchor的数量（9）
            score (array): anchor为前景的预测概率 shape:(R,)`.
            anchor (array): anchor  box的坐标. shape:`(R, 4)`.
            img_size (tuple of ints): （调整后的）图像的宽和高
            scale (float):从文件读取图像后，用于缩放图像的缩放因子。

        Returns:提案框的坐标数组。shape:`(S, 4)`.:`S` 在测试模式下少于n_test_post_nms在训练模式下少于n_train_post_nms。
        """
        # 测试模式下faster_rcnn.eval()，self.traing = False
        '''（1）不同训练模式下参数的设定：设置nms前、nms后保留的框的数量'''
        if self.parent_model.training:
            n_pre_nms = self.n_train_pre_nms
            n_post_nms = self.n_train_post_nms
        else:
            n_pre_nms = self.n_test_pre_nms
            n_post_nms = self.n_test_post_nms

        '''(2)网络预测边界框解码，返回rpn框的坐标（y，x，y,x）：之前RPN的预测坐标为相对于anchor box的偏移，解码为坐标（y，x，y,x），将坐标超出图片的边界进行裁剪'''
        roi = loc2bbox(anchor, loc)# loc为rpn产生的框，是相对于anchor box的偏移（t_y，t_x,t_h,t_w）
        #对预测边界框的坐标进行处理
        # clip（数组，最小值，最大值）：将数组中的元素限制在a_min, a_max之间，大于a_max的就使得它等于 a_max，小于a_min,的就使得它等于a_min
        roi[:, slice(0, 4, 2)] = np.clip(roi[:, slice(0, 4, 2)], 0, img_size[0])
        roi[:, slice(1, 4, 2)] = np.clip(roi[:, slice(1, 4, 2)], 0, img_size[1])

        '''(3)去除宽和高不满足阈值的rpn框：得到筛选后的网络预测边界框（roi）和边界框的前景类分数（score）'''
        # 删除高度或宽度<阈值的预测框。scale为缩放原图像的缩放因子。
        min_size = self.min_size * scale
        #预测框的高和宽：
        hs = roi[:, 2] - roi[:, 0]
        ws = roi[:, 3] - roi[:, 1]
        keep = np.where((hs >= min_size) & (ws >= min_size))[0]
        roi = roi[keep, :]
        score = score[keep]

        # Sort all (proposal, score) pairs by score from highest to lowest.
        # Take top pre_nms_topN (e.g. 6000).
        '''（4）非极大值抑制前，保留n_pre_nm个rpn预测框(前景类分数最大的前n_pre_nm个rpn框) '''
        #对边界框的前景类分数进行排序，保留前n_pre_nms个边界框
        order = score.ravel().argsort()[::-1]
        if n_pre_nms > 0:
            order = order[:n_pre_nms]
        roi = roi[order, :]
        score = score[order]

        # Apply nms (e.g. threshold = 0.7).
        # Take after_nms_topN (e.g. 300).

        '''(5)非极大值抑制'''
        keep = nms( torch.from_numpy(roi).cuda(),torch.from_numpy(score).cuda(),self.nms_thresh)

        '''(6)非极大值抑制后保留的n_post_nms个rpn预测框——最终ROI'''
        if n_post_nms > 0:
            keep = keep[:n_post_nms]
        roi = roi[keep.cpu().numpy()]

        return roi#返回ROI（输入到头部网络的rpn框，坐标为y，x，y，x格式）