chenyuntc/simple-faster-r-cnn的代码详细讲解

这里是faster-r-cnn论文原文+翻译: csdn翻译
这里是陈云实现的faster-r-cnn代码链接: github
这里是陈云在知乎的讲解和一些问题问答: 知乎

整体的模型框架和作用作者已经介绍的很详细了，我就不再从整体的大框架讲解，但是遇到代码部分的细分我会再解说一次，水平有限，如有错误，还请指正。

data

data/voc_dataset.py

// An highlighted block
import os
import xml.etree.ElementTree as ET    //ET类是专门用来解析标注xml文件的，语法简单，十分易用
import numpy as np
from .util import read_image


class VOCBboxDataset: //读取voc数据集 实现魔术方法__getitem__（以便pytorch的DataLoader读取数据集） 返回其中一张的 图片img:numpy矩阵
                        标签label: 0-19 标注框box:（[ymin,xmin,ymax,xmax]） 是否难以标注difficult: 0 or 1
                        一张图片可以有多个box(R,4)和label(R,)和difficult(R,) 那么将返回多维numpy数组形式
                        如果要训练自己的数据集 那么请修改这里的魔术方法读取自己的数据集


    def __init__(self, data_dir, split='trainval',      
                 use_difficult=False, return_difficult=False,
                 ):   //参数datadir由utils.config的voc_data_dir而来，是数据集存放的地址  
                        use_difficult：表示是否启用难识别 图片标注的时候，比如我们要识别自行车，图片中有一堆自行车，
                        我们没办法一个一个的标记出来，这时会用到difficult 一般来说训练不启用difficult 测试会用到
                        return_difficult：是否返回difficult
        id_list_file = os.path.join(
            data_dir, 'ImageSets/Main/{0}.txt'.format(split))        
      //id_list_file =data_dir/ImageSets/Main/trainval.txt' 这个txt文本中 每行是图片数据的名字（不带后缀如.jpg后缀） 
        
        self.ids = [id_.strip() for id_ in open(id_list_file)]  //类表解析：读取上面的txt 按行读取后装入一个列表
        self.data_dir = data_dir
        self.use_difficult = use_difficult
        self.return_difficult = return_difficult
        self.label_names = VOC_BBOX_LABEL_NAMES  //在最下面，是voc数据集所有物体name的tuple

    def __len__(self):
        return len(self.ids)  //数据集的数量 就是ids列表的长度

    def get_example(self, i):  //魔术方法：从数据集列表ids中 选取一个进行xml解析
        id_ = self.ids[i]     //列表中选取一个数据
        anno = ET.parse(
            os.path.join(self.data_dir, 'Annotations', id_ + '.xml')) //找到名字对应的xml 用ET进行解析
        bbox = list()
        label = list()
        difficult = list()
        for obj in anno.findall('object'):      //找到所有标注的object 
            
            if not self.use_difficult and int(obj.find('difficult').text) == 1:
                continue  //当没有启用difficult 但是我们找到了标注的difficult物体（标注值为1） 跳过这个object
                           .text方法是获取xml标签里的内容 比如obj.find('difficult')=<difficult>1<difficult/>
                           obj.find('difficult').text = 1 （string类型数据 要转成int）

            difficult.append(int(obj.find('difficult').text)) 
            bndbox_anno = obj.find('bndbox')   //找到标注框boundbox
            bbox.append([
                int(bndbox_anno.find(tag).text) - 1
                for tag in ('ymin', 'xmin', 'ymax', 'xmax')])  //列表解析：[ymin,xmin,ymax,xmax] 减一是为了让像素的索引从0开始
            name = obj.find('name').text.lower().strip()  //name标注的对应VOC_BBOX_LABEL_NAMES中的一个
            label.append(VOC_BBOX_LABEL_NAMES.index(name))  //label就是VOC_BBOX_LABEL_NAME中name的索引 范围0-19
        
        bbox = np.stack(bbox).astype(np.float32)  //将box从list转成np.float32类型
        label = np.stack(label).astype(np.int32)  //label是 np.int32类型
        difficult = np.array(difficult, dtype=np.bool).astype(np.uint8)  
        //由于pytorch不支持np.bool 我们要将difficult 转成np.bool后再转成unint8
        
        img_file = os.path.join(self.data_dir, 'JPEGImages', id_ + '.jpg') //获得id_对应图片的完整路径
        img = read_image(img_file, color=True) //调用data/util 中的read_image方法 读取图片数据
        
        return img, bbox, label, difficult    

    __getitem__ = get_example  //魔术方法 上面写的get_example


VOC_BBOX_LABEL_NAMES = (
    'aeroplane',
    'bicycle',
    'bird',
    'boat',
    'bottle',
    'bus',
    'car',
    'cat',
    'chair',
    'cow',
    'diningtable',
    'dog',
    'horse',
    'motorbike',
    'person',
    'pottedplant',
    'sheep',
    'sofa',
    'train',
    'tvmonitor')

trainval.txt 记事本打开是这样的 其实暗藏/n换行符 是000005/n 000007/n 000009/n…

标注xml大概是这样的（与原xml有删减） object是物体 name是物体名字 bndbox是标注框 difficult 0或1（难识别）

data/util.py

import numpy as np
from PIL import Image
import random

def read_image(path, dtype=np.float32, color=True):   //根据path读取图片 转化成np矩阵返回
    f = Image.open(path)   //PIL的Image方法 读取img文件
    try:
        if color:    //默认都是彩色图三通道 
            img = f.convert('RGB')  
        else:
            img = f.convert('P')  //灰度矩阵
        img = np.asarray(img, dtype=dtype)  //转换为np.float32矩阵
    finally:
        if hasattr(f, 'close'): //关闭文件
            f.close()   

    if img.ndim == 2:  //灰度图像 
        # reshape (H, W) -> (1, H, W)
        return img[np.newaxis]
    else:
        # transpose (H, W, C) -> (C, H, W)
        return img.transpose((2, 0, 1))  //Image读取的是H W C格式 转成 C H W 以便pytorch利用


def resize_bbox(bbox, in_size, out_size): //bbox:一张图片中 R个标注box(ymin,xmin,ymax,xmax) shape:(R,4)
                                            insize:(height，width) outsize:你想要的(height，width)  
                                            当我们resize图片后 也应当resize_box 此函数单独使用没有意义
    bbox = bbox.copy()
    y_scale = float(out_size[0]) / in_size[0]   //垂直y缩放倍数
    x_scale = float(out_size[1]) / in_size[1]   //水平x缩放倍数
    bbox[:, 0] = y_scale * bbox[:, 0]           //new ymin
    bbox[:, 2] = y_scale * bbox[:, 2]           //new xmin
    bbox[:, 1] = x_scale * bbox[:, 1]           //new ymax
    bbox[:, 3] = x_scale * bbox[:, 3]           //new xmax
    return bbox


def flip_bbox(bbox, size, y_flip=False, x_flip=False):  //数据增强部分 如果翻转了图片 那么bbox标注框也应该翻转
                                                         此函数就是bbox的翻转 单独使用没有意义
    H, W = size    //bbox:一张图片中 R个标注的box(ymin,xmin,ymax,xmax) shape:(R,4)  输入图片的size:(height，width) 
    bbox = bbox.copy()  
    if y_flip:  //垂直翻转
        y_max = H - bbox[:, 0]   //H-ymin
        y_min = H - bbox[:, 2]   //H-ymax
        bbox[:, 0] = y_min       //ymin = H-ymin 垂直翻转
        bbox[:, 2] = y_max       //y_max = H-ymax 垂直翻转
    if x_flip: //水平翻转  同理
        x_max = W - bbox[:, 1]
        x_min = W - bbox[:, 3]
        bbox[:, 1] = x_min
        bbox[:, 3] = x_max
    return bbox  //翻转后的box


def crop_bbox(
        bbox, y_slice=None, x_slice=None,
        allow_outside_center=True, return_param=False):
    pass   //方法对应crop_img  由于我们训练的时候使用的是resize image 这个函数没有用


def _slice_to_bounds(slice_):
    pass //上面crop_bbox用到的函数 此处略过


def translate_bbox(bbox, y_offset=0, x_offset=0):
    pass
    //如果图片用了padding后者cropping 那么对应bbox也要变换 
    由于我们训练的时候使用的是resize image 这个函数没有用


def random_flip(img, y_random=False, x_random=False,  //数据增强 实现图片翻转 img:图片矩阵  y_random:是否使用垂直随机翻
                return_param=False, copy=False):        转，return_param：是否返回翻转状态 一个dict很好懂 copy:是否返回img的副本 
    y_flip, x_flip = False, False   //默认不进行垂直翻转 和水平翻转
    if y_random:  //如果使用随机垂直翻转
        y_flip = random.choice([True, False])  //随机选取T or F 即随机选取翻不翻转
    if x_random:
        x_flip = random.choice([True, False])

    if y_flip:
        img = img[:, ::-1, :]    //图片翻转  C H W   H翻转
    if x_flip:
        img = img[:, :, ::-1]

    if copy:
        img = img.copy()

    if return_param:  //因为我们这里只翻转了图片 保留dict参数是为了翻转box时使用 如果img水平翻转了 
                       那么x_flip=True 我们记录这个参数 以后也应当水平翻转这张图片的所有box R个box
        return img, {'y_flip': y_flip, 'x_flip': x_flip}
    else:
        return img

data/dataset.py

为了不让你对numpy的copy()感到困惑
请参考这篇文章: csdn numpy.copy()

from __future__ import  absolute_import
from __future__ import  division
import torch as t
from data.voc_dataset import VOCBboxDataset
from skimage import transform as sktsf
from torchvision import transforms as tvtsf
from data import util
import numpy as np
from utils.config import opt


def inverse_normalize(img):  //逆标准化图片 以便显示（可视化）的时候使用
    if opt.caffe_pretrain:   //如果模型是caffe预训练的
        img = img + (np.array([122.7717, 115.9465, 102.9801]).reshape(3, 1, 1)) //img加均值  0-255
        caffe没有标准差 reshape是为了numpy的广播机制
        return img[::-1, :, :]  //caffe是 [BGR,H,W]  需要转化成[RGB,H,W]显示
    return (img * 0.225 + 0.45).clip(min=0, max=1) * 255   
    //pytorch预训练的img 范围在0-1  加均值乘以标准差后 需要扩大到0-255  
    clip限定是为了防止超界 下界为0 上界为1 如果超过1就是1 如果小于0就是0 


def pytorch_normalze(img): //pytoch图片标准化  为了让均值为0 标准差为1以便训练 F~（0,1）
    normalize = tvtsf.Normalize(mean=[0.485, 0.456, 0.406],   //pytorch用法 将图片减均值除以标准差
                                std=[0.229, 0.224, 0.225])
    img = normalize(t.from_numpy(img))  //因为Normalize方法只接受tensor对象 将img转化为tensor传入
    return img.numpy()    //将标准化后的img 从tensor转化为numpy


def caffe_normalize(img): //caffe图片标准化 caffe只有均值 没有标准差 F~（0,Σ） 如果你用过caffe发现caffe只有一个mean.binaryproto
    img = img[[2, 1, 0], :, :]  // RGB to BGR  因为如果使用caffe_pretrain，那么整个模型参数都是基于caffe训练的，是bgr的
                                   我们需要把图片变为bgr的进行训练，训练之后再inverse_nomalize还原成rgb通道显示
    img = img * 255  //0-1 to 0-255
    mean = np.array([122.7717, 115.9465, 102.9801]).reshape(3, 1, 1)  
    img = (img - mean).astype(np.float32, copy=True)  //img减均值 返回一个np.float32 img矩阵的副本（-125-125 BGR）
    return img


def preprocess(img, min_size=600, max_size=1000): //输入原始img矩阵 返回取值0-1的，经过resize的，标准化后的img numpy矩阵
                                                   输入img  min_size就是输出图片的短边长最长600（不是要求最小为600）  
                                                   mix_size输出图片长边最长1000  就是要求输出图片一边为600或者一边为1000
    C, H, W = img.shape   
    scale1 = min_size / min(H, W)   //600/短边
    scale2 = max_size / max(H, W)   //1000/长边
    scale = min(scale1, scale2) //比较两个scale 看哪个才是主要影响缩放因子 如果是scale1更小 那么将图片缩放
                                  到600*Z 时 Z不会超过1000 如果scale2是 那么缩放到 Z*1000时 Z不会超过600
                                  通俗一点：长边不能超过1000 短边不能超过600 且 至少有一边是600或1000
    img = img / 255.   //转化为0-1
    img = sktsf.resize(img, (C, H * scale, W * scale), mode='reflect') //根据scale resize img
                                                                         sktsf.resize方法来自skimage的transform
    if opt.caffe_pretrain:  //标准化过程
        normalize = caffe_normalize
    else:
        normalize = pytorch_normalze
    return normalize(img)

//一张图片可能有R个box和label shape:box（R,4） label:（R,） 以后不再提示
class Transform(object): // 接受魔术方法get_example传来的一张图片的原始 img box label 
                           返回resize和normalize后的img 对应处理后的box  以及label(没有处理)

    def __init__(self, min_size=600, max_size=1000):
        self.min_size = min_size
        self.max_size = max_size

    def __call__(self, in_data): 
        img, bbox, label = in_data  
        _, H, W = img.shape
        img = preprocess(img, self.min_size, self.max_size)  //resize img 并进行标准化 输出范围0-1 numpy矩阵
        _, o_H, o_W = img.shape
        scale = o_H / H
        bbox = util.resize_bbox(bbox, (H, W), (o_H, o_W))  //根据resize_img的scale 对box进行同等scale 

        # horizontally flip
        img, params = util.random_flip(  //数据增强 随机水平翻转
            img, x_random=True, return_param=True)
        bbox = util.flip_bbox(  //根据img水平翻转的情况 对box也进行翻转
            bbox, (o_H, o_W), x_flip=params['x_flip'])

        return img, bbox, label, scale


class Dataset: //读取训练数据最大的类 如果你读过pytorch源码 你会发现其实并不用继承dataset类 因为那个类是空 
                 的 只实现了两个pass空方法 getitem和len两个魔术方法 所以我们只要实现这两个方法就不用继承就可以传入DataLoader
    def __init__(self, opt): //opt是传来的参数 来自utils.config 包含了voc_data的路径
        self.opt = opt 
        self.db = VOCBboxDataset(opt.voc_data_dir)
        self.tsf = Transform(opt.min_size, opt.max_size)

    def __getitem__(self, idx):  //实现getitem魔术方法
        ori_img, bbox, label, difficult = self.db.get_example(idx)

        img, bbox, label, scale = self.tsf((ori_img, bbox, label))
        return img.copy(), bbox.copy(), label.copy(), scale

    def __len__(self):  //实现__len__魔术方法 
        return len(self.db)


class TestDataset:  //读取测试数据   split不同从而读取的是test.txt 启用use_difficult 不对图片 box等进行resize等处理
    def __init__(self, opt, split='test', use_difficult=True):
        self.opt = opt
        self.db = VOCBboxDataset(opt.voc_data_dir, split=split, use_difficult=use_difficult)

    def __getitem__(self, idx):
        ori_img, bbox, label, difficult = self.db.get_example(idx)
        img = preprocess(ori_img)
        return img, ori_img.shape[1:], bbox, label, difficult //这里多返回了difficult 和原图ori_img.shape：(h,w) 去掉了c

    def __len__(self):
        return len(self.db)

mics

convet_caffe_pretrain

# code from ruotian luo
# https://github.com/ruotianluo/pytorch-faster-rcnn
import torch
from torch.utils.model_zoo import load_url
from torchvision import models

//作者也说了下载预训练的caffe_pretrain model最后训练效果mAP会高一点，所以我们需要提前运行这个python类
下载预训练的caffe模型参数 如果不提前下载 训练时会自动用pytorch自带的vgg16模型参数 效果稍微差一点

sd = load_url("https://s3-us-west-2.amazonaws.com/jcjohns-models/vgg16-00b39a1b.pth") //下载并加载模型
sd['classifier.0.weight'] = sd['classifier.1.weight']   //将分类器第1层权值给第0层 
sd['classifier.0.bias'] = sd['classifier.1.bias']       //偏置同理
del sd['classifier.1.weight']                           //删除第一层偏置和权重
del sd['classifier.1.bias']

sd['classifier.3.weight'] = sd['classifier.4.weight']
sd['classifier.3.bias'] = sd['classifier.4.bias']
del sd['classifier.4.weight']
del sd['classifier.4.bias']

import  os
# speicify the path to save
if not os.path.exists('checkpoints'):               //如果没有misc/checkpoints这个路径  创建路径保存模型参数
    os.makedirs('checkpoints')
torch.save(sd, "checkpoints/vgg16_caffe.pth")

代码很容易，但是为什么要这样做 我们打印一下网络结构就知道了

上面是pytorch自带的vgg结构 下面是下载的sd网络 前面features是一样的 后面可能由于sd作者原因还是其他原因（我也不知道）导致参数名字与pytorch的vgg16参数名字不一样 所以我们这里需要将参数改名字（因为我们要加载pytorch自带的网络结构 所以参数名称必须与其一致）

train_fast.py

更快的训练模型，由于我们要讲解的 train. py 与这个大同小异，这个训练的轮数更少，改变lr，训练完后统一进行测试而不是训练一轮就测试一次等技法 使得训练更快 我也没有仔细读这个类！

utils

array_tool.py

import torch as t
import numpy as np


def tonumpy(data):     //将数据转化为Numpy
    if isinstance(data, np.ndarray):  //如果是np类型
        return data   //直接返回
    if isinstance(data, t.Tensor):  //是pytorch的tensor
        return data.detach().cpu().numpy()  //将变量从图中分离（使得数据独立，以后你再如何操作都不会对图，对模型产生影响）
        ，如果是gpu类型变成cpu的（cpu类型调用cpu方法没有影响），再转化为numpy数组


def totensor(data, cuda=True):   //将数据转化为cuda或者tensor类型   cuda=True表示转化为cuda类型
    if isinstance(data, np.ndarray):    //如果是numpy类型
        tensor = t.from_numpy(data)    //调用pytorch常用的from_numpy 变成tensor
    if isinstance(data, t.Tensor):    //如果是tensor
        tensor = data.detach()           //隔离变量
    if cuda:                          //需要转化为cuda变量
        tensor = tensor.cuda()
    return tensor


def scalar(data):             //取出数据的值
    if isinstance(data, np.ndarray):             //如果是numpy类型（必须为1个数据 几维都行） 取出这个数据的值        
        return data.reshape(1)[0]       
    if isinstance(data, t.Tensor):             //如果是tensor类型 调用pytorch常用的item方法 取出tensor的值
        return data.item()

_config.py

from pprint import pprint
//参数作者注释很清楚 对模型了解的话都可以看懂
class Config:
    # data
    voc_data_dir = '/home/cy/.chainer/dataset/pfnet/chainercv/voc/VOCdevkit/VOC2007/'
    min_size = 600  # image resize
    max_size = 1000 # image resize
    num_workers = 8   //工作线程数
    test_num_workers = 8
    # sigma for l1_smooth_loss
    rpn_sigma = 3.
    roi_sigma = 1.
    # param for optimizer
    # 0.0005 in origin paper but 0.0001 in tf-faster-rcnn
    weight_decay = 0.0005
    lr_decay = 0.1  # 1e-3 -> 1e-4
    lr = 1e-3
    # visualization
    env = 'faster-rcnn'  # visdom env
    port = 8097  //visdom 端口
    plot_every = 40  # vis every N iter
    # preset
    data = 'voc'
    pretrained_model = 'vgg16'
    # training
    epoch = 14
    use_adam = False # Use Adam optimizer
    use_chainer = False # try match everything as chainer
    use_drop = False # use dropout in RoIHead
    # debug
    debug_file = '/tmp/debugf'
    test_num = 10000
    # model
    load_path = None
    caffe_pretrain = False # use caffe pretrained model instead of torchvision   //建议使用
    caffe_pretrain_path = 'checkpoints/vgg16_caffe.pth'

    def _parse(self, kwargs):    //解析并设置用户设定的参数
        state_dict = self._state_dict()  //读取Config类的所有参数dict{para_name:para_value}
        for k, v in kwargs.items():    //遍历用户传来的dict
            if k not in state_dict:   //遇到未知参数
                raise ValueError('UnKnown Option: "--%s"' % k)
            setattr(self, k, v)   //设置参数

        print('======user config========')
        pprint(self._state_dict())    //打印参数 pprint函数是为了让显示结果更加优美
        print('==========end============')

    def _state_dict(self): //读取Config类的所有参数dict{para_name:para_value}
        return {k: getattr(self, k) for k, _ in Config.__dict__.items() if not k.startswith('_')}
          //字典解析，Config.__dict__.items() 取出类中所有的函数、全局变量以及一些内置的属性
          前面我们设定的都是全局变量（键值对：比如min_size = 600），没有函数，而系统内置属性都是_打头的，
          所以我们要not k.startswith('_')  返回结果dict{para_name0:para_value0，para_name1:para_value1，....}

opt = Config()  //创建config对象

eval_tool.py

from __future__ import division

from collections import defaultdict
import itertools
import numpy as np
import six

from model.utils.bbox_tools import bbox_iou


def eval_detection_voc(
        pred_bboxes, pred_labels, pred_scores, gt_bboxes, gt_labels,
        gt_difficults=None,
        iou_thresh=0.5, use_07_metric=False):
        //根据PASCAL VOC的evaluation code 计算平均精度
        test_num张图片（图片数据来自测试数据testdata）的预测框，标签，分数，和真实的框，标签和分数。
        所有参数都是list len（list）=opt.test_num(default=10000)
        pred_boxes:[(A,4),(B,4),(C,4)....共test_num个] 输入源gt_数据 经过train.predict函数预测出的结果框
        pred_labels[(A,),(B,),(C,)...共test_num个]  pred_scores同pred_labels  
        A,B,C,D是由nms决定的个数，即预测的框个数，不确定。
        gt_bboxes：[(a,4),(b,4)....共test_num个]  a b...是每张图片标注真实框的个数
        gt_labels与gt_difficults同理
        use_07_metric (bool): 是否使用PASCAL VOC 2007 evaluation metric计算平均精度
    
    prec, rec = calc_detection_voc_prec_rec(  //函数算出每个label类的准确率和召回率
        pred_bboxes, pred_labels, pred_scores,
        gt_bboxes, gt_labels, gt_difficults,
        iou_thresh=iou_thresh)
    ap = calc_detection_voc_ap(prec, rec, use_07_metric=use_07_metric) //根据prec和rec 计算ap和map
    return {'ap': ap, 'map': np.nanmean(ap)}


def calc_detection_voc_prec_rec(
        pred_bboxes, pred_labels, pred_scores, gt_bboxes, gt_labels,
        gt_difficults=None,
        iou_thresh=0.5)
    pred_bboxes = iter(pred_bboxes) //生成迭代器
    pred_labels = iter(pred_labels)
    pred_scores = iter(pred_scores)
    gt_bboxes = iter(gt_bboxes)
    gt_labels = iter(gt_labels)
    if gt_difficults is None:  
        gt_difficults = itertools.repeat(None) //itertools.repeat生成一个重复的迭代器 None是每次迭代获得的数据
    else:
        gt_difficults = iter(gt_difficults)

    n_pos = defaultdict(int)  //defaultdict当key不存在时 dict[key]=default(int)=0 default(list)=[] default(dict)={}
    score = defaultdict(list)
    match = defaultdict(list)

    for pred_bbox, pred_label, pred_score, gt_bbox, gt_label, gt_difficult in \
            six.moves.zip(     //遍历每一张图片的box label score
                pred_bboxes, pred_labels, pred_scores,
                gt_bboxes, gt_labels, gt_difficults):

        if gt_difficult is None:
            gt_difficult = np.zeros(gt_bbox.shape[0], dtype=bool) //全部设置为非difficult
        //遍历一张图片中 所有出现的label
        for l in np.unique(np.concatenate((pred_label, gt_label)).astype(int)): //拼接后返回无重复的从小到大排序的一维numpy  
                                                              如[2,3,4,5,6] 并遍历这个一维数组，即遍历这张图片出
                                                              现过的标签数字(gt_label+pred_label)
            pred_mask_l = pred_label == l              //广播pred_mask_l=[eg. T,F,T,T,F,F,F,T..] 所有预测label中等于L的为T 否则F
            pred_bbox_l = pred_bbox[pred_mask_l]       //选出label=L的所有pre_box
            pred_score_l = pred_score[pred_mask_l]     //label=L 对应所有pre_score
            # sort by score
            order = pred_score_l.argsort()[::-1]        //获得score降序排序索引
            pred_bbox_l = pred_bbox_l[order]            //按照分数从高到低 对box进行排序
            pred_score_l = pred_score_l[order]          //对score进行排序

            gt_mask_l = gt_label == l     //广播gt_mask_l =[eg. T,F,T,T,F,F,F,T..]  所有真实label中等于L的为T 否则F
            gt_bbox_l = gt_bbox[gt_mask_l]     //选出label=L的所有box
            gt_difficult_l = gt_difficult[gt_mask_l]   //选出label=L的所有difficult

            n_pos[l] += np.logical_not(gt_difficult_l).sum() //对T,F取反求和 即统计difficult=0的个数
            score[l].extend(pred_score_l)   //score={l:predscore_1,....}  extend是针对list的方法

            if len(pred_bbox_l) == 0: //没有预测的label=L的box 即真实label有L，我们全没有预测到 
                continue  //跳过这张图片 此时没有对match字典操作 之前score[l].extend操作也为空 保持了match和score形状一致
            if len(gt_bbox_l) == 0:  //没有真实的label=L的box 即预测label有L，真实中没有 我们都预测错了
                match[l].extend((0,) * pred_bbox_l.shape[0]) //match{L:[0，0，0，..  n_pred_box个0]} 
                continue //预测错label就是0 已不需要后续操作 跳过此图片
 
            # VOC evaluation follows integer typed bounding boxes.
            //我不太懂这么做的目的，作者给的注释是follows integer typed bounding boxes
              但是只改变了ymax,xmax的值，重要的是这样做并不能转化为整数 pred_bbox和gt_bbox只
              参与了IOU计算且后面没有参与其他计算 有待解答。
            pred_bbox_l = pred_bbox_l.copy()
            pred_bbox_l[:, 2:] += 1   //ymax,xmax +=1
            gt_bbox_l = gt_bbox_l.copy()
            gt_bbox_l[:, 2:] += 1   //ymax,xmax +=1

            iou = bbox_iou(pred_bbox_l, gt_bbox_l) //计算两个box的IOU
            gt_index = iou.argmax(axis=1) //有len(pred_bbox_l)个索引 第i个索引值n表示 gt_box[n]与pred_box[i] IOU最大
            # set -1 if there is no matching ground truth
            gt_index[iou.max(axis=1) < iou_thresh] = -1  //将gt_box与pred_box iou<thresh的索引值置为-1
                                                         即针对每个pred_bbox，与每个gt_bbox IOU的最大值 如果最大值小于阀值则置为-1
                                                         即我们预测的这个box效果并不理想 后续会将index=-1的 matchlabel=0
            del iou

            selec = np.zeros(gt_bbox_l.shape[0], dtype=bool)
            for gt_idx in gt_index: //遍历gt_index索引值
                if gt_idx >= 0:    //即IOU满足条件
                    if gt_difficult_l[gt_idx]: //对应的gt_difficult =1 即困难标识
                        match[l].append(-1)    //match[l]追加一个-1
                    else:  //不是困难标识
                        if not selec[gt_idx]: //没有被选过 select[gt_idx]=0时
                            match[l].append(1)   //match[l]追加一个1
                        else: //对应的gt_box已经被选择过一次 即已经和前面某pred_box IOU最大
                            match[l].append(0)    //match[l]追加一个0
                    selec[gt_idx] = True  //select[gt_idx]=1  置为1，表示已经被选过一次
                else: //不满足IOU>thresh 效果并不理想
                    match[l].append(0)  //match[l]追加一个0
    
    //我们注意到 上面为每个pred_box都打了label 0,1,-1  len(match[l])=len(score[l])=len(pred_bbox_l)
    for iter_ in (   //上面的 six.moves.zip遍历会在某一iter遍历到头后停止，由于pred_bboxes等是全局iter对象，
                       我们此时继续调用next取下一数据，如果有任一数据不为None，那么说明他们的len是不相等的 有悖常理，数据错误
            pred_bboxes, pred_labels, pred_scores,
            gt_bboxes, gt_labels, gt_difficults):
        if next(iter_, None) is not None:      //next(iter,None) 表示调用next 如果已经遍历到头 不抛出异常而是返回None
            raise ValueError('Length of input iterables need to be same.')

    //注：对PR曲线不了解的可以去看一看，跟ROC曲线是有区别的
    n_fg_class = max(n_pos.keys()) + 1  //有n_fg_class个类
    prec = [None] * n_fg_class   //list[None,.....len(n_fg_class)]
    rec = [None] * n_fg_class

    for l in n_pos.keys(): //遍历所有Label
        score_l = np.array(score[l])   //list to np.array
        match_l = np.array(match[l], dtype=np.int8)

        order = score_l.argsort()[::-1]  
        match_l = match_l[order]    //对应match按照 score由大到小排序

        tp = np.cumsum(match_l == 1)   //统计累计 match_1=1的个数
        fp = np.cumsum(match_l == 0)   //统计累计 match_1=0的个数
        //tp eg. [1 2 3 3 4 5 5 6 7 8 8 9 10 11........]
        //fp eg. [0 0 0 0 0 0 0 1 1 1 1 1 1 2 ......]
        # 如果 fp + tp = 0, 那么计算出的prec[l] = nan
        prec[l] = tp / (fp + tp)      //计算准确率
        if n_pos[l] > 0:   //如果n_pos[l] = 0,那么rec[l] =None
            rec[l] = tp / n_pos[l]   //计算召回率

    return prec, rec


def calc_detection_voc_ap(prec, rec, use_07_metric=False):

    n_fg_class = len(prec)
    ap = np.empty(n_fg_class)
    for l in six.moves.range(n_fg_class):  //遍历每个label
        if prec[l] is None or rec[l] is None: //如果为None 则ap置为np.nan
            ap[l] = np.nan
            continue

        
        if use_07_metric: //如果按07分数矩阵计算ap
            # 11 point metric
            ap[l] = 0
            for t in np.arange(0., 1.1, 0.1):  //t=0 0.1 0.2 ....1.0
                if np.sum(rec[l] >= t) == 0:  //这个标签的召回率没有>=t的
                    p = 0
                else:
                    p = np.max(np.nan_to_num(prec[l])[rec[l] >= t]) //p=(rec>=t时 对应index：prec中的最大值)
                                                                      P=（X>t时，X对应的Y:Y的最大值）                                                          
                                                                      np.nan_to_num 是为了让None=0 以便计算
                ap[l] += p / 11    
        else:
            mpre = np.concatenate(([0], np.nan_to_num(prec[l]), [0])) //头尾填0
            mrec = np.concatenate(([0], rec[l], [1]))  //头填0 尾填1
            mpre = np.maximum.accumulate(mpre[::-1])[::-1] //我们知道 我们是按score由高到低排序的 而且我们给box打了label
                                                             0,1,-1   score高时1的概率会大，所以pre是累计降序的
                                                             而rec是累积升序的，那么此时将pre倒序再maxuim.ac
                                                             获得累积最大值，再倒序后 从小到大排序的累积最大值
                                                  
            i = np.where(mrec[1:] != mrec[:-1])[0]   //差位比较，看哪里改变了recall的值 记录Index (x轴)
            # and sum (\Delta recall) * prec
            ap[l] = np.sum((mrec[i + 1] - mrec[i]) * mpre[i + 1])   //差值*mpre_max值 （x轴差值*y_max）

    return ap

vis_tool.py

matplotlib只是一个中间过程 我们利用matplotlib 画一张图片，画所有的bbox和label and score （所有的都在一张图里）最后并不显示，而是将figure转化为numpy数组 CHW 范围0-1 以供visdom显示 visdom是一个可视化的工具库 支持numpy和pytorch
请参考这篇文章: 在PyTorch中使用Visdom可视化工具ptorch.com 和 visdom github: Visdom GitHub

import time

import numpy as np
import matplotlib
import torch as t
import visdom
matplotlib.use('Agg')
from matplotlib import pyplot as plot
# from data.voc_dataset import VOC_BBOX_LABEL_NAMES
//voc标注物体的名字，可以从之前导入，我不知道为什么作者这里又写了一份简写的，可能方便显示吧
VOC_BBOX_LABEL_NAMES = (
    'fly',
    'bike',
    'bird',
    'boat',
    'pin',
    'bus',
    'c',
    'cat',
    'chair',
    'cow',
    'table',
    'dog',
    'horse',
    'moto',
    'p',
    'plant',
    'shep',
    'sofa',
    'train',
    'tv',
)


def vis_image(img, ax=None):   //画图像： img是经过逆标准化0-255的RGB图像，ax是传来的matplotlib.axes.Axis对象 告诉我们画在哪里
    if ax is None:   //如果没有这个对象 创建一个（1,1,1）的
        fig = plot.figure()
        ax = fig.add_subplot(1, 1, 1)
    # CHW -> HWC
    img = img.transpose((1, 2, 0))
    ax.imshow(img.astype(np.uint8)) //matplot支持0-1的图形显示也支持0-255的图形显示 转成uint8是为了告诉它我们的图形是0-255的
    return ax    //返回axis对象后续使用，vis_box会继续调用，在此图片基础上画框等


def vis_bbox(img, bbox, label=None, score=None, ax=None):
    label_names = list(VOC_BBOX_LABEL_NAMES) + ['bg']  //20个物体对象+后景['bg']
    if label is not None and not len(bbox) == len(label): //框个数不等于标签个数
        raise ValueError('The length of label must be same as that of bbox')
    if score is not None and not len(bbox) == len(score):  //框个数不等于分数个数
        raise ValueError('The length of score must be same as that of bbox')
    ax = vis_image(img, ax=ax) //显示图像
    if len(bbox) == 0:  //没有框
        return ax
    for i, bb in enumerate(bbox): //遍历一张图所有框
        xy = (bb[1], bb[0])    //左上角
        height = bb[2] - bb[0]  //高
        width = bb[3] - bb[1]   //宽
        ax.add_patch(plot.Rectangle(        //画矩形 红色 2粗
             xy, width, height, fill=False, edgecolor='red', linewidth=2))
        caption = list()
        if label is not None and label_names is not None:
            lb = label[i]  //此框对应的label
            if not (-1 <= lb < len(label_names)): //超界
                raise ValueError('No corresponding name is given')
            caption.append(label_names[lb]) //物体名字加入caption list
        if score is not None:
            sc = score[i]  //找到此框对应分数
            caption.append('{:.2f}'.format(sc))  //加入caption list

        if len(caption) > 0:
            ax.text(bb[1], bb[0],   //将物体名字 分数 画在框左上角
                    ': '.join(caption),
                    style='italic',
                    bbox={'facecolor': 'white', 'alpha': 0.5, 'pad': 0})
    return ax  //返回axis对象后续被fig4vis调用，将图像转化为numpy数组


def fig2data(fig):  //将matplotlib的figure图像 转化为RGBA形式的Numpy返回
    fig.canvas.draw() //画图，渲染
    w, h = fig.canvas.get_width_height() //得到figure的w,h
    buf = np.fromstring(fig.canvas.tostring_argb(), dtype=np.uint8) //得到numpy形式的 argb图像
    buf.shape = (w, h, 4)   //(w,h,argb)
    buf = np.roll(buf, 3, axis=2)   //(w,h,rgba) 在第二轴水平向右滚动3个距离
    return buf.reshape(h, w, 4)     //(h,w,rgba)


def fig4vis(fig):  //将matplotlib的figure图像 转化为pytorch常用的3通道RGB，CHW 0-1图像
    ax = fig.get_figure()   
    img_data = fig2data(ax).astype(np.int32)
    plot.close()
    return img_data[:, :, :3].transpose((2, 0, 1)) / 255. 
    //(H,W,RGBA)->(H,W,RGB)->(RGB,H,W)即CHW /255->0-1  


def visdom_bbox(*args, **kwargs): //我们要使用的函数 包含上面所有函数调用 传入img box label score 画成一张图像 以numpy形式返回
    fig = vis_bbox(*args, **kwargs)
    data = fig4vis(fig)
    return data

class Visualizer(object):  //Visdom可视化部分
    def __init__(self, env='default', **kwargs):
        self.vis = visdom.Visdom(env=env, use_incoming_socket=False, **kwargs) //visdom对象
        self._vis_kw = kwargs  //参数
        self.index = {}
        self.log_text = ''

    def reinit(self, env='default', **kwargs):
       //可能由于用户要改变kwargs初始化参数 而重新初始化visdom对象
        self.vis = visdom.Visdom(env=env, **kwargs)
        return self

    def plot_many(self, d): //plot
        //参数 d: dict (name,value) i.e. ('loss',0.11)
        for k, v in d.items():
            if v is not None:
                self.plot(k, v) //调用下面的plot函数 画折线图（各种损失折线图，训练map折线图）

    def img_many(self, d):    //参数 d: dict (name,value) i.e. ('loss',0.11)
        for k, v in d.items():
            self.img(k, v)  //调用下面的img函数 画图

    def plot(self, name, y, **kwargs): //画一条直线  title=name
        x = self.index.get(name, 0)
        self.vis.line(Y=np.array([y]), X=np.array([x]),
                      win=name,
                      opts=dict(title=name),
                      update=None if x == 0 else 'append',
                      **kwargs
                      )
        self.index[name] = x + 1

    def img(self, name, img_, **kwargs): //画图片  title=name
        self.vis.images(t.Tensor(img_).cpu().numpy(),
                        win=name,
                        opts=dict(title=name),
                        **kwargs
                        )

    def log(self, info, win='log_text'): //打印log日志  时间+info
        self.log_text += ('[{time}] {info} 
'.format(
            time=time.strftime('%m%d_%H%M%S'), \
            info=info))
        self.vis.text(self.log_text, win)

    def __getattr__(self, name): //按name获得一个属性
        return getattr(self.vis, name)

    def state_dict(self): //返回现有参数 dict
        return {
            'index': self.index,
            'vis_kw': self._vis_kw,
            'log_text': self.log_text,
            'env': self.vis.env
        }

    def load_state_dict(self, d):  //参数 d: dict (name,value) i.e. ('loss',0.11)  初始化参数
        self.vis = visdom.Visdom(env=d.get('env', self.vis.env), **(self.d.get('vis_kw')))
        self.log_text = d.get('log_text', '')
        self.index = d.get('index', dict())
        return self

model

utils

nms

我们知道python 本来就是用c写的，最近刚好看过源码（一切皆对象）由于其本身特性和高级语言等原因，运行速度是一直是一个问题。虽然pytorch是用C加速和CUDA运算，但是NMS这一块需要我们自己写，用python速度很慢，这里作者结合了Cupy cuda编程 和Cython结合，写出了nms. Cupy是numpy的一个加速cuda计算库，可以将Numpy放到gpu计算，Cython则是将python代码编译成C语言，C编译器将.c文件编译链接成pyd拓展模块，这样对象的类型大小在编译时就可以确定，会加速很多。官网是这样说的
A .pyx file is compiled by Cython to a .c file, containing the code of a Python extension module.
The .c file is compiled by a C compiler to a .so file (or .pyd on Windows) which can be import-ed directly into a Python session.
win上生成pyd linux生成.so 动态链接库 可以被python直接导入（实际上好多库的函数都是这么干的…python实在太慢了）

我当时训练完模型，有人要求我用cpu进行预测，所以当时我把gpu部分去掉了 你调试的时候也可以换成cpu代码进行调试

nms cpu python代码: csdn:nms.cpu

build_.py

from distutils.core import setup
from distutils.extension import Extension
from Cython.Distutils import build_ext
//构建动态链接库的代码，Cython标准写法，详见Cython，这里就是将我们写的_nms_gpu_post.pyx变成pyd
或.so文件的过程 所以我们要先运行这个类，运行方法作者也介绍的很清楚了，最终生成pyd or .so链接库 .c是中间文件

ext_modules = [Extension("_nms_gpu_post", ["_nms_gpu_post.pyx"])]
setup(
    name="Hello pyx",
    cmdclass={'build_ext': build_ext},
    ext_modules=ext_modules
)

_nms_gpu_post_py.py

如果环境不允许或其他原因 我们没有使用Cython加速 那么将加载这个python原生函数（慢很多） 代码与_nms_gpu_post.pyx 大同小异 这里不做讲解

non_maximum_suppression.py

非极大值抑制主函数 注：cupy与numpy函数库无太大差异，np.函数 在cp上也都有，用法也一样 只不过一个在gpu计算 一个在本地计算

from __future__ import division
import numpy as np
import cupy as cp
import torch as t
try:
    from ._nms_gpu_post import _nms_gpu_post   //尝试加载pyd
except:     //加载失败 告诉使用者，使用pyd会更快和生成pyd的方法
    import warnings
    warnings.warn('''
    the python code for non_maximum_suppression is about 2x slow
    It is strongly recommended to build cython code: 
    `cd model/utils/nms/; python3 build.py build_ext --inplace''')
    from ._nms_gpu_post_py import _nms_gpu_post   //加载python原生函数

//cupy函数 这里直接使用cuda编程   kernel_name是函数名字，方便调用。code是原生c-cuda-code需要自己编写
函数作用就是让我们自己编写的c cuda code变成一个函数 供我们调用。
@cp.util.memoize(for_each_device=True)
def _load_kernel(kernel_name, code, options=()):
    cp.cuda.runtime.free(0)
    assert isinstance(options, tuple)
    kernel_code = cp.cuda.compile_with_cache(code, options=options)
    return kernel_code.get_function(kernel_name)


def non_maximum_suppression(bbox, thresh, score=None,
                            limit=None):
       //根据传入的box 和score 规定的thresh 计算返回nms处理后选择的box索引（按照分数从高到低排序）
    return _non_maximum_suppression_gpu(bbox, thresh, score, limit)


def _non_maximum_suppression_gpu(bbox, thresh, score=None, limit=None):
    if len(bbox) == 0:                       //没有候选框 直接返回0
        return cp.zeros((0,), dtype=np.int32)

    n_bbox = bbox.shape[0]  //传入box的个数

    if score is not None: //传入了score分数
        order = score.argsort()[::-1].astype(np.int32) //获得按分数降序排列的索引
    else: //没有传入
        order = cp.arange(n_bbox, dtype=np.int32)   // 索引等于 0-(n_box-1)

    sorted_bbox = bbox[order, :]     //将传入框 按分数从高到低排序
    selec, n_selec = _call_nms_kernel(    //调用nms_kernel函数 返回选中的索引（索引是依据sorted_boxed的，也可以说是依据order的）
                                             和 选中框的个数
        sorted_bbox, thresh)
    selec = selec[:n_selec]    
    selec = order[selec]   //根据order取 框真正的索引
    if limit is not None:  //限制返回框个数 参数自己定
        selec = selec[:limit]
    return cp.asnumpy(selec)   //转化为numpy返回  返回的是选择框的索引shape:（N，）

def _call_nms_kernel(bbox, thresh):
    n_bbox = bbox.shape[0]  //框的个数
    threads_per_block = 64       //一个block有多少thread
    col_blocks = np.ceil(n_bbox / threads_per_block).astype(np.int32)   //cuda常用的对齐block操作 保证线程数最小限度全覆盖数据
    blocks = (col_blocks, col_blocks, 1)  //看到这里我有点慌了 因为对齐一个blocks按理说是(n_blocks,1,1) 说明后面要全排列了
    threads = (threads_per_block, 1, 1)    
    mask_dev = cp.zeros((n_bbox * col_blocks,), dtype=np.uint64) //开辟64*n_box*sizeof(np.uint64)的连续内存 置为0 用于存放结果
    bbox = cp.ascontiguousarray(bbox, dtype=np.float32)  //将bbox从numpy转成cupycuda计算 放到连续的内存中以便cuda运算 很重要
    kern = _load_kernel('nms_kernel', _nms_gpu_code)  //加载自己写的c-cuda核函数
    kern(blocks, threads, args=(cp.int32(n_bbox), cp.float32(thresh),  //调用核函数
                                bbox, mask_dev))

    mask_host = mask_dev.get()  //将计算结果从gpu取到本地
    selection, n_selec = _nms_gpu_post(      //调用我们Cython导入的nms函数进行计算
        mask_host, n_bbox, threads_per_block, col_blocks)
    return selection, n_selec


_nms_gpu_code = '''
#define DIVUP(m,n) ((m) / (n) + ((m) % (n) > 0))  //进位除法 保证全线程覆盖数据
int const threadsPerBlock = sizeof(unsigned long long) * 8;

__device__   //将从gpu本地函数进行调用
inline float devIoU(float const *const bbox_a, float const *const bbox_b) {   //计算两个box的IOU 
  float top = max(bbox_a[0], bbox_b[0]);   //重合部分上界
  float bottom = min(bbox_a[2], bbox_b[2]);  //重合部分下界
  float left = max(bbox_a[1], bbox_b[1]);  //重合部分左界
  float right = min(bbox_a[3], bbox_b[3]);  //重合部分右界
  float height = max(bottom - top, 0.f);  //重合部分高
  float width = max(right - left, 0.f);  //重合部分宽
  float area_i = height * width; //重合部分面积
  float area_a = (bbox_a[2] - bbox_a[0]) * (bbox_a[3] - bbox_a[1]);  //box_a 框面积
  float area_b = (bbox_b[2] - bbox_b[0]) * (bbox_b[3] - bbox_b[1]);   //box_b 框面积
  return area_i / (area_a + area_b - area_i);      //IOU
}

extern "C"
__global__    //将从cpu调用 我们调用入口点
void nms_kernel(const int n_bbox, const float thresh,
                const float *dev_bbox,
                unsigned long long *dev_mask) {
  下面我要举例子了因为干讲怕理解不了，我们假设n_bbox=2000
  那么blocks=(32,32,1)  threads=(64,1,1)   我们想象blocks就是32*32的格子 每个格子有64个线程在工作 每个格子互不干扰
  那么传入2000个框时，我们将拥有32*32*64=65536个线程在同时计算 blocks和threads可以让我们寻找到这个线程 就是下面的blockIdx.y
  这个是cuda自行给我们标识的 我们可以直接调用获得当前线程 blockIdx=0-31  blockidy=0-31 threadIdx.x=0-63 
  有了这个你就知道当前线程是哪个了

  const int row_start = blockIdx.y;  
  const int col_start = blockIdx.x;

  const int row_size =
        min(n_bbox - row_start * threadsPerBlock, threadsPerBlock); //保证不越界 限制线程
  const int col_size =
        min(n_bbox - col_start * threadsPerBlock, threadsPerBlock);  //保证不越界  限制线程

  __shared__ float block_bbox[threadsPerBlock * 4];  //一个block的thread共享一片内存 不同block互不影响
  if (threadIdx.x < col_size) {  //threadIdx.x < col_size是保证不越界，这里的目的是将box数据 复制到block_bbox
    block_bbox[threadIdx.x * 4 + 0] =
        dev_bbox[(threadsPerBlock * col_start + threadIdx.x) * 4 + 0];
    block_bbox[threadIdx.x * 4 + 1] =
        dev_bbox[(threadsPerBlock * col_start + threadIdx.x) * 4 + 1];
    block_bbox[threadIdx.x * 4 + 2] =
        dev_bbox[(threadsPerBlock * col_start + threadIdx.x) * 4 + 2];
    block_bbox[threadIdx.x * 4 + 3] =
        dev_bbox[(threadsPerBlock * col_start + threadIdx.x) * 4 + 3];
  }
  __syncthreads(); //等待同步 所有线程必须都干完了才能开始下面的工作

  if (threadIdx.x < row_size) {  //保证不越界
    const int cur_box_idx = threadsPerBlock * row_start + threadIdx.x; //框idx
    const float *cur_box = dev_bbox + cur_box_idx * 4;  //生成框游标索引
    int i = 0;
    unsigned long long t = 0;
    int start = 0;
    if (row_start == col_start) {   //跳过相同数据 自己和自己比IOU
      start = threadIdx.x + 1;
    }
    for (i = start; i < col_size; i++) {
      if (devIoU(cur_box, block_bbox + i * 4) >= thresh) {  //分别计算IOU 如果大于阈值 那么将t的i位置为1
        t |= 1ULL << i;
      }
    }
    const int col_blocks = DIVUP(n_bbox, threadsPerBlock);
    dev_mask[cur_box_idx * col_blocks + col_start] = t;   储存t值
  }
}
'''

我们以n_bbox=2000，继续画图详细讲解一下，cuda代码在干什么吧：

 if (threadIdx.x < col_size) {  
    block_bbox[threadIdx.x * 4 + 0] =
        dev_bbox[(threadsPerBlock * col_start + threadIdx.x) * 4 + 0];
    block_bbox[threadIdx.x * 4 + 1] =
        dev_bbox[(threadsPerBlock * col_start + threadIdx.x) * 4 + 1];
    block_bbox[threadIdx.x * 4 + 2] =
        dev_bbox[(threadsPerBlock * col_start + threadIdx.x) * 4 + 2];
    block_bbox[threadIdx.x * 4 + 3] =
        dev_bbox[(threadsPerBlock * col_start + threadIdx.x) * 4 + 3];
  }

首先这里 threadIdx.x < col_size 是保证不越界，dev_bbox是我们传入的2000个bbox,dev_bbox的索引自然是0-1999， threadsPerBlock(64) * col_start(0-31) + threadIdx.x（0-63）= 0-2047 因为我们要保证线程只能多不能少于数据 所以多的那48个线程访问dev_bbox 就会越界，这就是前面row_size和限制 if(threadIdx.x < col_size)的作用
且注意：这是C语言 我们传入的只是dev_bbox数组的首地址，他会按float类型的指针进行寻址，bbox是（2000，4（ymax,xmax,ymin,xmin的））所以实际上按照dev_bbox的长度是2000*4=8000 寻址对应也要乘以4

由于每个block共享一片内存block_bbox[256]，所以上面的代码干了一件这样的事（设blockIdx.y=y，blockIdx.x=x,threadIdx.x=z）

y=0,x=0时，将我们传入的2000个框 前64个框装入block_bbox
y=0,x=1时，将我们传入的2000个框 再64个框装入block_bbox
直至x=31 把2000个框装完
注意block_bbox是互不干扰的 生存在自己的显存空间里。
y=1,2…31时又将2000个框装了一遍…
相当于对源数据2000个框 复制了32次 想到当时对mask_dev开辟了32*2000的意义了吗 想到我当初说全排列的意义了吗
他是想要2000个框内 每两个不相同的框计算一次IOU 再巧妙的储存下来。

接着下面代码

 if (threadIdx.x < row_size) {  //保证不越界
    const int cur_box_idx = threadsPerBlock * row_start + threadIdx.x; //框idx
    const float *cur_box = dev_bbox + cur_box_idx * 4;  //生成框游标索引
    int i = 0;
    unsigned long long t = 0;
    int start = 0;
    if (row_start == col_start) {   //跳过相同数据 自己和自己比IOU
      start = threadIdx.x + 1;
    }
    for (i = start; i < col_size; i++) {
      if (devIoU(cur_box, block_bbox + i * 4) >= thresh) {  //分别计算IOU 如果大于阈值 那么将t的i位置为1
        t |= 1ULL << i;
      }
    }
    const int col_blocks = DIVUP(n_bbox, threadsPerBlock);
    dev_mask[cur_box_idx * col_blocks + col_start] = t;   储存t值
  }

我们将x,y,z带入 直接看devIoU部分

 if (y == x) {   //跳过相同数据 自己和自己比IOU
      start = z + 1;
    }
  for (i = start; i < col_size; i++) {
      if (devIoU(dev_bbox[4(y*64+z)], dev_bbox[4(x*64+z)+4i]) >= thresh) {  //分别计算IOU 如果大于阈值 那么将t的i位置为1
        t |= 1ULL << i;
      }

现在就很清楚了如果x=y时 start=0时 我们比的就是同一个框自己 所以x=y时 start要等一z+1 向后错一个框
当y=0 x=0时 比的是第0个框和1-63个框的IOU 按1-63位 IOU大于阀值的话，t的1-63位会对应置为1 储存起来
同理y=0,x=1…x=1 y=0…每俩个框计算了一次IOU 当然由于不能重复比 t储存的数据数也会发生变化
只要32*2000个位置就可以储存所有结果 这个结果由于我们是 dev_mask[cur_box_idx * col_blocks + col_start] = t 储存的。
所以后面解析的时候可以清楚的知道哪两个框IOU大于thresh 是易于还原的。

_nms_gpu_post.pyd

上面我们得到了每2个框的IOU值 并巧妙的储存了起来，这里就是选择框的过程了，由于我们巧妙的储存了t，所以这里也会巧妙的把t读取来，完成NMS操作。这里的代码纯属技法问题，如果你熟悉cuda寻址，熟悉一些算法，这里很容易还原算法。这个类的作用就是NMS的作用：选出score最大的框,这个框肯定框柱了一个物体，如果其他与这个IOU大于阀值，那么认为其他框也是框的这个物体，但是score置信度还不行，果断扔掉。再找一个score次高的，循环做下去…就是nms了

cimport numpy as np
from libc.stdint cimport uint64_t
import numpy as np

//根据我们的mask_dev 选出候选框 Cython写法 与python没什么不同 声明一些变量类型而已 Cpython会自动帮我们依据半python代码(pyd)将此pyd编译成.c c编译器会再次编译.c文件生成我们要的动态链接库

def _nms_gpu_post(np.ndarray[np.uint64_t, ndim=1] mask,
                  int n_bbox,
                  int threads_per_block,
                  int col_blocks
                  ):
    cdef:
        int i, j, nblock, index
        uint64_t inblock
        int n_selection = 0
        uint64_t one_ull = 1
        np.ndarray[np.int32_t, ndim=1] selection
        np.ndarray[np.uint64_t, ndim=1] remv

    selection = np.zeros((n_bbox,), dtype=np.int32)
    remv = np.zeros((col_blocks,), dtype=np.uint64)

    for i in range(n_bbox): //遍历2000个框
        nblock = i // threads_per_block    //nblock 0-31
        inblock = i % threads_per_block    //inblock 0-63

        if not (remv[nblock] & one_ull << inblock): //如果IOU不小于阀值(标注的是一个新的物体)
            selection[n_selection] = i          //记录这个box的index
            n_selection += 1                    //选取框数目+1

            index = i * col_blocks       //index寻址
            for j in range(nblock, col_blocks):   //将对应选中框的所有IOU对应结果存入
                remv[j] |= mask[index + j]
    return selection, n_selection

由于我们传入的box都是按score排序好的，所以该算法可以实现。
首先我们会进入if not语句中，记录第一个score最大的框，下面for j的循环就是找出所有与第一个框的IOU记录
赋值给remv 下面就是依次判断第二个框第三个框是否与第一个框IOU大于阀值 移一位就是一个框的IOU记录
如果大于阀值则继续下一个for i循环 小于阀值认定是不同的框，由于其分数最高 所以记录在selection中 再找出与此框的所有IOU记录继续遍历…

bbox_tools.py

import numpy as np
import numpy as xp

import six
from six import __init__

def bbox2loc(src_bbox, dst_bbox):
  //给定两个框 返回源框到目标框变换的loc 这原论文中说的很详细
   
   height = src_bbox[:, 2] - src_bbox[:, 0]    //源框高
   width = src_bbox[:, 3] - src_bbox[:, 1]    //源框宽
   ctr_y = src_bbox[:, 0] + 0.5 * height        //矩中心y坐标
   ctr_x = src_bbox[:, 1] + 0.5 * width        //矩中心x坐标

   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

   eps = xp.finfo(height.dtype).eps    //防止数据错误
   height = xp.maximum(height, eps)
   width = xp.maximum(width, eps)

   dy = (base_ctr_y - ctr_y) / height      //按论文计算dy dx dh dw
   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

def loc2bbox(src_bbox, loc):
   //给定源框和loc 反向计算目标框 还原方法 与bbox2loc对应

   if src_bbox.shape[0] == 0:
       return xp.zeros((0, 4), dtype=loc.dtype)

   src_bbox = src_bbox.astype(src_bbox.dtype, copy=False)

   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

   dy = loc[:, 0::4]
   dx = loc[:, 1::4]
   dh = loc[:, 2::4]
   dw = loc[:, 3::4]

   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




def bbox_iou(bbox_a, bbox_b):
   //计算两个框的IOU值 我们在cuda计算时已经见过了 但是这个方法的bbox_a与bbox_b可以是多维数组的(X,4)(Y,4)
     则返回的结果也是多维的结果（X,Y）
   
   //防止数据错误
   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)
   return area_i / (area_a[:, None] + area_b - area_i)


def __test():
   pass


if __name__ == '__main__':
   __test()


def generate_anchor_base(base_size=16, ratios=[0.5, 1, 2],
                        anchor_scales=[8, 16, 32]):
 
  //生成Anocher 论文中介绍的很清楚了，要在feature map每个点生成9种不同size和长宽比的box
  这里只是生成最基本的Anchorbase 还没有在feature map上滑动
  
   py = base_size / 2.      #y中点
   px = base_size / 2.      #x中点

   anchor_base = np.zeros((len(ratios) * len(anchor_scales), 4),       //shape=(3*3,4)
                          dtype=np.float32)
   for i in six.moves.range(len(ratios)):             //9个box(ymax,xmax,ymin,xmin) 共36个参数
       for j in six.moves.range(len(anchor_scales)):
           h = base_size * anchor_scales[j] * np.sqrt(ratios[i])
           w = base_size * anchor_scales[j] * np.sqrt(1. / ratios[i])
           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

creator_tool.py

import numpy as np
import cupy as cp

from model.utils.bbox_tools import bbox2loc, bbox_iou, loc2bbox
from model.utils.nms import non_maximum_suppression

//从ProposalCreator生成的Rois中 这里是选取正负样本共n_sample个（这里是128）为了后续放入RoiPooling后
卷积全连接进行（20+1）类的分类损失计算FC21和21x4的box位置损失计算FC84 我们规定与真实gt_box框 IOU>0.5为正样本
0.5<IOU<0.1为负样本

class ProposalTargetCreator(object):
   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
                ):
       self.n_sample = n_sample   //要选取的样本数
       self.pos_ratio = pos_ratio   //正样本率
       self.pos_iou_thresh = pos_iou_thresh   //正样本iou阀值
       self.neg_iou_thresh_hi = neg_iou_thresh_hi    //负样本iou最高阀值
       self.neg_iou_thresh_lo = neg_iou_thresh_lo  # NOTE:default 0.1 in py-faster-rcnn 负样本iou最低阀值

   def __call__(self, roi, bbox, label,     //输入 N个ROI （N，4）   真实标注的bbox（R,4）,真实的label（R，）
                loc_normalize_mean=(0., 0., 0., 0.),  //loc均值
                loc_normalize_std=(0.1, 0.1, 0.2, 0.2)):  //loc标准差
       
       n_bbox, _ = bbox.shape   //bbox个数
       roi = np.concatenate((roi, bbox), axis=0)     //（N，4）to (N+R,4）  R是真实框个数 N是ROI个数

       pos_roi_per_image = np.round(self.n_sample * self.pos_ratio)    //正样本数 四舍五入
       iou = bbox_iou(roi, bbox)   //计算IOU
       gt_assignment = iou.argmax(axis=1)   //最大值索引，gt_assighment[i]=j  表示第i个roi 与第j个bbox的IOU最大
       max_iou = iou.max(axis=1)  //对应上面索引的最大值
       gt_roi_label = label[gt_assignment] + 1  //      所有roi对应IOU最大的真实gt_box的label   一一对应
                                                         [0, n_fg_class - 1] to [1, n_fg_class]   0是背景剩下n_fg_class个前景

       pos_index = np.where(max_iou >= self.pos_iou_thresh)[0]     //选择IOU大于阀值的索引
       pos_roi_per_this_image = int(min(pos_roi_per_image, pos_index.size))   //如果得到索引个数大于设定 则变为设定个数
       if pos_index.size > 0:
           pos_index = np.random.choice(          //随机选取pos_roi_per_this_image个 
               pos_index, size=pos_roi_per_this_image, replace=False)
       
       neg_index = np.where((max_iou < self.neg_iou_thresh_hi) &   //IOU小于设定的索引 为负样本
                            (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)

       keep_index = np.append(pos_index, neg_index)  //所有选取的样本index
       gt_roi_label = gt_roi_label[keep_index]    //对应的label
       gt_roi_label[pos_roi_per_this_image:] = 0  # negative labels --> 0
       sample_roi = roi[keep_index]    //根据keep_index选出对应roi框

       # Compute offsets and scales to match sampled RoIs to the GTs.
       gt_roi_loc = bbox2loc(sample_roi, bbox[gt_assignment[keep_index]])  //计算我们取样的roi和真实bbox 的loc 便于后面Loss的计算
       gt_roi_loc = ((gt_roi_loc - np.array(loc_normalize_mean, np.float32)  //标准化
                      ) / np.array(loc_normalize_std, np.float32))

       return sample_roi, gt_roi_loc, gt_roi_label

 
 //从20000多个Anchor中 选择正负样本128共256个进行  对anchor进行9*2(前，后景)的分类任务 9*4(ymax,xmax,ymin,xmin)个位置回归任务 
  规定IOU最高为正 IOU>0.7为正样本，IOU<0.3为负样本 只计算前景损失
class AnchorTargetCreator(object):
  
   def __init__(self,
                n_sample=256,
                pos_iou_thresh=0.7, neg_iou_thresh=0.3,
                pos_ratio=0.5):
       self.n_sample = n_sample
       self.pos_iou_thresh = pos_iou_thresh
       self.neg_iou_thresh = neg_iou_thresh
       self.pos_ratio = pos_ratio

   def __call__(self, bbox, anchor, img_size):
       
       img_H, img_W = img_size //图片高 宽

       n_anchor = len(anchor)  //anchor个数
       inside_index = _get_inside_index(anchor, img_H, img_W)  //将超出图片边界的anchor过滤 返回在界内的anchor索引
       anchor = anchor[inside_index]   //选择界内的anchor
       argmax_ious, label = self._create_label(   //根据真实bbox  给anchor创建标签label 并返回标签对应的[(iou最大值的gt_box)的index]
           inside_index, anchor, bbox)
       
       loc = bbox2loc(anchor, bbox[argmax_ious])  //计算anchor和自己对应IOU最大的gt_bbox的损失

       label = _unmap(label, n_anchor, inside_index, fill=-1)  //将label数据 置于原来总anchor的位置，并将其余没选出的位置置为-1
       loc = _unmap(loc, n_anchor, inside_index, fill=0)   //将loc数据 置于原来总anchor的位置，并将其余没选出的位置置为0
       return loc, label

   def _create_label(self, inside_index, anchor, bbox):
       # label: 1 is positive, 0 is negative, -1 is dont care
       label = np.empty((len(inside_index),), dtype=np.int32)   //len(边界内的anochor)
       label.fill(-1)

       argmax_ious, max_ious, gt_argmax_ious = \     //见函数
           self._calc_ious(anchor, bbox, inside_index)

       # assign negative labels first so that positive labels can clobber them
       label[max_ious < self.neg_iou_thresh] = 0  //将IOU小于阀值的置为1
       label[gt_argmax_ious] = 1  //将于gt_box IOU最大的anchor label置为1
       label[max_ious >= self.pos_iou_thresh] = 1  //IOU大于阀值的置为1

       n_pos = int(self.pos_ratio * self.n_sample)  //我们要的正样本数
       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  //没选中的置为-1 dont care

       n_neg = self.n_sample - np.sum(label == 1)  //我们要的负样本数
       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

       return argmax_ious, label   

   def _calc_ious(self, anchor, bbox, inside_index):
      
       ious = bbox_iou(anchor, bbox)  //计算IOU 
       argmax_ious = ious.argmax(axis=1)   //argmax_ious[i]=j 表示第i个anchor与第j个bbox IOU值最大
       max_ious = ious[np.arange(len(inside_index)), argmax_ious]     //max_ious[i]=j 表示第i个anchor与对应gt_box IOU的最大值是 j
       gt_argmax_ious = ious.argmax(axis=0)   //gt_argmax_ious[i]=j 表示第i个bbox与第j个anchor IOU值最大
       gt_max_ious = ious[gt_argmax_ious, np.arange(ious.shape[1])]   //max_ious[i]=j 表示第i个gt_bbox与对应anchor IOU的最大值是 j
       gt_argmax_ious = np.where(ious == gt_max_ious)[0]            //是一个索引gt_argmax_ious[a,b,c,d,e] 表示第a个anchor与对应box IOU
                                                                    值最大，其中a<=b<=c<=d<=e    即表示我们将要选出的框的索引 表示a这个anchor和某个bbox IOU最大
                                                                    这已经够了，我们要选他，并不关心他与哪个框最大。所以为什么不取  
                                                                       gt_argmax_ious = ious.argmax(axis=0) 的结果呢，因为他没有把等值算上，比如
                                                                       第二个box与 第20个anchor和第300个anchor IOU最大都是0.9 前面的运算只会选择第20个anchor
                                                                       而不会选择300                                                            
                                                           
       return argmax_ious, max_ious, gt_argmax_ious


def _unmap(data, count, index, fill=0):
 
   if len(data.shape) == 1:     //1维array
       ret = np.empty((count,), dtype=data.dtype)    
       ret.fill(fill)             //填满fill
       ret[index] = data     //索引处换为数据
   else:  //维度对齐
       ret = np.empty((count,) + data.shape[1:], dtype=data.dtype)     //根据data的shape创建 np.array
       ret.fill(fill)   //填满fill
       ret[index, :] = data   //索引处换为数据
   return ret


def _get_inside_index(anchor, H, W):
 //返回anchor在图片内（不超出边界）的anchor索引
   index_inside = np.where(
       (anchor[:, 0] >= 0) &
       (anchor[:, 1] >= 0) &
       (anchor[:, 2] <= H) &
       (anchor[:, 3] <= W)
   )[0]
   return index_inside



//计算所有anchor是前景的概率，选择概率大的12000（训练）/6000（测试）个 修正位置参数，获得ROIS 再经过NMS后
选择2000/300 个为真正的ROIS 输出（2000/300,R）的ROIS

class ProposalCreator:
  

   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
                ):
       self.parent_model = parent_model
       self.nms_thresh = nms_thresh
       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

   def __call__(self, loc, score,  //传入，预测的loc补偿，score分数，featuremap的所有anchor 
                anchor, img_size, scale=1.):
       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

      //anchor调整位置后获得roi
       roi = loc2bbox(anchor, loc)

      //限制调整后得到的roi候选框在图片内(防止越界）
       roi[:, slice(0, 4, 2)] = np.clip(         //    0<ymax,ymin<H  小于0部分变为0 大于H部分变为H
           roi[:, slice(0, 4, 2)], 0, img_size[0])
       roi[:, slice(1, 4, 2)] = np.clip(               //    0<xmax,xmin<W  小于0部分变为0 大于W部分变为W
           roi[:, slice(1, 4, 2)], 0, img_size[1])
     
       min_size = self.min_size * scale   //threshold 框最小阀值，去除比较小的rois框
       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]

       order = score.ravel().argsort()[::-1] //分数由高到低排序
       if n_pre_nms > 0:     //进入nms前 我们想保留的ROIS个数
           order = order[:n_pre_nms]
       roi = roi[order, :]
      
       keep = non_maximum_suppression(   //NMS
           cp.ascontiguousarray(cp.asarray(roi)),
           thresh=self.nms_thresh)
       if n_post_nms > 0:         //我们想保留的nms后ROIS的个数
           keep = keep[:n_post_nms]
       roi = roi[keep]
       return roi

ROI_POOLING2D的函数，作者用cuda写了一遍，嫌弃chainer和pytorch自带的pooling2d函数运行的慢…
这里只解释向前过程forward。backward代码因为作者想证明自己写的代码正确，将自己forward后的结果，backward后的梯度与chainer的进行比较 都相同则说明自己写的没问题…

roi_cupy.py

kernel_forward = '''
 extern "C"
 __global__ void roi_forward(const float* const bottom_data,const float* const bottom_rois,
             float* top_data, int* argmax_data,
             const double spatial_scale,const int channels,const int height, 
             const int width, const int pooled_height, 
             const int pooled_width,const int NN
 ){
//第一个参数bottom_data   feature map首地址    我们卷积之后得到512*H/16*W/16的 featuremap
  第二个参数bottom_rois     是rois的首地址（N,5） N是rois的个数128  (第一列表示featuremap_batch中的索引，即该rois对应哪个featuremap，
  由于作者只实现了batch_size=1 所以这个没有用，其余四列表示其余的左上角和右下角坐标)
  //第三个参数 第四个参数  两个都是我们开辟的(128,512（通道）,7（outh）,7（outw）) 大小的用来储存结果的地址
  // spatial_scale:原图和feature map的比例 这里是1/16 ,const int channels:512,const int height: feature map H, 
             const int width:feature map W, const int pooled_height: pooling后H  论文是7, 
             const int pooled_width  pooling后W  论文是7, const int NN：值数为128*512*7*7 防止寻址越界


  
 int idx = blockIdx.x * blockDim.x + threadIdx.x;   //cuda一维最常用寻址 能包含(128,512,7,7)大小的所有线程id
 if(idx>=NN)  //超出rois数据范围 返回
     return;
 //由于我们要pooling成7x7的，每一次遍历就是找出7*7=49中  1*1的区域内最大值进行最大池化操作 所以每49个线程 进行1个roi的1个通道的池化  每7*7*512个线程pooling一个roi  共128*512*7*7个线程 记录这些池化值
 
 const int pw = idx % pooled_width;   
 const int ph = (idx / pooled_width) % pooled_height;
 const int c = (idx / pooled_width / pooled_height) % channels;   //当前通道
 int num = idx / pooled_width / pooled_height / channels;  //当前rois个数
 const int roi_batch_ind = bottom_rois[num * 5 + 0];   //图像标签
 const int roi_start_w = round(bottom_rois[num * 5 + 1] * spatial_scale);  //xmin
 const int roi_start_h = round(bottom_rois[num * 5 + 2] * spatial_scale);  //ymin
 const int roi_end_w = round(bottom_rois[num * 5 + 3] * spatial_scale);  //xmax
 const int roi_end_h = round(bottom_rois[num * 5 + 4] * spatial_scale);   //ymax
 // Force malformed ROIs to be 1x1
 const int roi_width = max(roi_end_w - roi_start_w + 1, 1);     //witdh   至少为1
 const int roi_height = max(roi_end_h - roi_start_h + 1, 1);   //height  至少为1
 const float bin_size_h = static_cast<float>(roi_height)                     //  float: height/7
                 / static_cast<float>(pooled_height);
 const float bin_size_w = static_cast<float>(roi_width)                   //   float: width/7
                 / static_cast<float>(pooled_width);

 int hstart = static_cast<int>(floor(static_cast<float>(ph)                //  height/7 * ph 向下取整
                                 * bin_size_h));
     int wstart = static_cast<int>(floor(static_cast<float>(pw)        // width/7 * pw 向下取整
                                 * bin_size_w));
 int hend = static_cast<int>(ceil(static_cast<float>(ph + 1)    //width/7 *(ph+1) 向下取整
                             * bin_size_h));
     int wend = static_cast<int>(ceil(static_cast<float>(pw + 1)   // width/7 * （pw+1) 向下取整
                             * bin_size_w));

 // Add roi offsets and clip to input boundaries  保证不越界 
 hstart = min(max(hstart + roi_start_h, 0), height);  
 hend = min(max(hend + roi_start_h, 0), height);
 wstart = min(max(wstart + roi_start_w, 0), width);
 wend = min(max(wend + roi_start_w, 0), width);
 bool is_empty = (hend <= hstart) || (wend <= wstart);  //没有结果

 // 空roipooling记位0
 float maxval = is_empty ? 0 : -1E+37;
 // If nothing is pooled, argmax=-1 causes nothing to be backprop'd
 int maxidx = -1;
 const int data_offset = (roi_batch_ind * channels + c) * height * width;  //roi对应的feature map  
 for (int h = hstart; h < hend; ++h) {                       //遍历7x7的其中一个1x1区域找出最大值 进行最大池化操作
     for (int w = wstart; w < wend; ++w) {
         int bottom_index = h * width + w;
         if (bottom_data[data_offset + bottom_index] > maxval) {
             maxval = bottom_data[data_offset + bottom_index];
             maxidx = bottom_index;
         }
     }
 }
 top_data[idx]=maxval;   //记录最大值和
 argmax_data[idx]=maxidx; //此最大值在feature map中的index
 }

faster_rcnn.py

from __future__ import  absolute_import
from __future__ import division
import torch as t
import numpy as np
import cupy as cp
from utils import array_tool as at
from model.utils.bbox_tools import loc2bbox
from model.utils.nms import non_maximum_suppression

from torch import nn
from data.dataset import preprocess
from torch.nn import functional as F
from utils.config import opt


def nograd(f): //取消所有tensor的梯度 预测时加快程序运行
 def new_f(*args,**kwargs):
     with t.no_grad():
        return f(*args,**kwargs)
 return new_f

class FasterRCNN(nn.Module):
 
 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__()
     self.extractor = extractor
     self.rpn = rpn
     self.head = head

     # mean and std
     self.loc_normalize_mean = loc_normalize_mean
     self.loc_normalize_std = loc_normalize_std
     self.use_preset('evaluate')

 @property           //装饰器 get方法
 def n_class(self):
     # Total number of classes including the background.
     return self.head.n_class

 def forward(self, x, scale=1.):  //向前过程
 
     img_size = x.shape[2:]  //h,w
     h = self.extractor(x)    //feature map
     rpn_locs, rpn_scores, rois, roi_indices, anchor = \                   //送入rpn 
         self.rpn(h, img_size, scale)
     roi_cls_locs, roi_scores = self.head(     //送入 roi_head
         h, rois, roi_indices)
     return roi_cls_locs, roi_scores, rois, roi_indices

 def use_preset(self, preset):
    //在预测可视化的时候会对score阀值要求高一点 显示效果更好
     if preset == 'visualize':
         self.nms_thresh = 0.3
         self.score_thresh = 0.7
         //在进行模型评估的时候会将score阀值置的很低
     elif preset == 'evaluate':
         self.nms_thresh = 0.3
         self.score_thresh = 0.05
     else:
         raise ValueError('preset must be visualize or evaluate')

 def _suppress(self, raw_cls_bbox, raw_prob):  //由predict调用 预测时对每类候选框进行阀值和Nms操作
     bbox = list()
     label = list()
     score = list()
     // 从1开始 0是背景 
     for l in range(1, self.n_class):  //遍历20个前景
         cls_bbox_l = raw_cls_bbox.reshape((-1, self.n_class, 4))[:, l, :]    //取出第L类的box
         prob_l = raw_prob[:, l]   //取出第L类的prob
         mask = prob_l > self.score_thresh   //大于阀值
         cls_bbox_l = cls_bbox_l[mask]   //保留大于阀值的box
         prob_l = prob_l[mask]  //保留大于阀值的prob
         keep = non_maximum_suppression(       //nms
             cp.array(cls_bbox_l), self.nms_thresh, prob_l)
         keep = cp.asnumpy(keep) //经过nms后保留的index
         bbox.append(cls_bbox_l[keep])    //加入预测框
         # The labels are in [0, self.n_class - 2].
         label.append((l - 1) * np.ones((len(keep),))) //加入label
         score.append(prob_l[keep]) //加入prob
     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

  //预测函数，预测图片的框和分数，标签并返回  取消变量梯度，加快计算
 @nograd //装饰器 取消梯度
 def predict(self, imgs,sizes=None,visualize=False):
     
     self.eval()     //取消BN和dropout
     if visualize:
         self.use_preset('visualize')
         prepared_imgs = list()
         sizes = list()
         for img in imgs:
             size = img.shape[1:]
             img = preprocess(at.tonumpy(img)) //预处理
             prepared_imgs.append(img)
             sizes.append(size)
     else:
          prepared_imgs = imgs 
     bboxes = list()
     labels = list()
     scores = list()
     for img, size in zip(prepared_imgs, sizes): //遍历我们要预测的每张图片
         img = at.totensor(img[None]).float()   #1 C H W
         scale = img.shape[3] / size[1]          
         roi_cls_loc, roi_scores, rois, _ = self(img, scale=scale)  //进入forward 向前计算
         roi_score = roi_scores.data
         roi_cls_loc = roi_cls_loc.data
         roi = at.totensor(rois) / scale   //对应resize前真实图片的roi

         mean = t.Tensor(self.loc_normalize_mean).cuda(). \  //均值repeat n_class
             repeat(self.n_class)[None]
         std = t.Tensor(self.loc_normalize_std).cuda(). \  //标准差repeat n_class
             repeat(self.n_class)[None]

         roi_cls_loc = (roi_cls_loc * std + mean)  //还原roi_cls_loc   shape:(R,84）
         roi_cls_loc = roi_cls_loc.view(-1, self.n_class, 4)    //shape(R,21,4)
         roi = roi.view(-1, 1, 4).expand_as(roi_cls_loc)  //roi(R,4) to (R,21,4)
         cls_bbox = loc2bbox(at.tonumpy(roi).reshape((-1, 4)),   //修正roi  //shape(21R,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)  //shape(R,84)
         # 防止越界 box 超出真实img
         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 = at.tonumpy(F.softmax(at.totensor(roi_score), dim=1)) //softmax score

         raw_cls_bbox = at.tonumpy(cls_bbox)
         raw_prob = at.tonumpy(prob)

         bbox, label, score = self._suppress(raw_cls_bbox, raw_prob) //对box按n_class进行阀值保留和Nms操作 得到真正预测后的预测框
         bboxes.append(bbox)
         labels.append(label)
         scores.append(score)

     self.use_preset('evaluate')    
     self.train()  //启用BN和dropout
     return bboxes, labels, scores

 def get_optimizer(self):
    //返回optimizer
     lr = opt.lr
     params = []
     for key, value in dict(self.named_parameters()).items():
         if value.requires_grad:  //需要梯度
             if 'bias' in key: //有偏置的参数lr*2
                 params += [{'params': [value], 'lr': lr * 2, 'weight_decay': 0}]
             else:  //学习速率衰减
                 params += [{'params': [value], 'lr': lr, 'weight_decay': opt.weight_decay}]
     if opt.use_adam: //Adam优化
         self.optimizer = t.optim.Adam(params)
     else: //SGD
         self.optimizer = t.optim.SGD(params, momentum=0.9)
     return self.optimizer

 def scale_lr(self, decay=0.1): //学习速率衰减
     for param_group in self.optimizer.param_groups:
         param_group['lr'] *= decay
     return self.optimizer

faster_rcnn.py

faster_rcnn_vgg16.py
from __future__ import  absolute_import
import torch as t
from torch import nn
from torchvision.models import vgg16
from model.region_proposal_network import RegionProposalNetwork
from model.faster_rcnn import FasterRCNN
from model.roi_module import RoIPooling2D
from utils import array_tool as at
from utils.config import opt


def decom_vgg16():

   if opt.caffe_pretrain: //加载caffepretrain参数
       model = vgg16(pretrained=False)
       if not opt.load_path:
           model.load_state_dict(t.load(opt.caffe_pretrain_path))
   else:
       model = vgg16(not opt.load_path)  //加载pytorch pretrain参数

   features = list(model.features)[:30]  //除去最后最大池化
   classifier = model.classifier   //Linear ReLu Dropout

   classifier = list(classifier)
   del classifier[6]   //删除最后一个全连接层
   if not opt.use_drop:  //不使用dropout 删除两个dropout层
       del classifier[5]
       del classifier[2]
   classifier = nn.Sequential(*classifier)  //新的classifier

   # 冻结前四个卷积层的参数 加快训练速度 不需要求梯度不用BP过程
   for layer in features[:10]:  
       for p in layer.parameters():
           p.requires_grad = False

   return nn.Sequential(*features), classifier


class FasterRCNNVGG16(FasterRCNN):
   
   def __init__(self,
                n_fg_class=20,
                ratios=[0.5, 1, 2],
                anchor_scales=[8, 16, 32]
                ):
                
       extractor, classifier = decom_vgg16()

       rpn = RegionProposalNetwork(
           512, 512,
           ratios=ratios,
           anchor_scales=anchor_scales,
           feat_stride=self.feat_stride,
       )

       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,
       )


class VGG16RoIHead(nn.Module):


   def __init__(self, n_class, roi_size, spatial_scale,
                classifier):
       # n_class includes the background
       super(VGG16RoIHead, self).__init__()

       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)

       self.n_class = n_class
       self.roi_size = roi_size
       self.spatial_scale = spatial_scale
       self.roi = RoIPooling2D(self.roi_size, self.roi_size, self.spatial_scale)

   def forward(self, x, rois, roi_indices):
  
       roi_indices = at.totensor(roi_indices).float()   //shape(128,)
       rois = at.totensor(rois).float()   //shape(128,4)
       indices_and_rois = t.cat([roi_indices[:, None], rois], dim=1)   //shape(128,5)
       xy_indices_and_rois = indices_and_rois[:, [0, 2, 1, 4, 3]]    /index ymin xmin ymax xmax TO index xmin ymin xmax ymax
       indices_and_rois =  xy_indices_and_rois.contiguous()  //返回连续内存的数据 以便放入cuda

       pool = self.roi(x, indices_and_rois) //roipooling return:(128,512,7,7)
       pool = pool.view(pool.size(0), -1)  //(128,25088) 正好与VGG16的全连接层连接
       fc7 = self.classifier(pool)      
       roi_cls_locs = self.cls_loc(fc7)   
       roi_scores = self.score(fc7) 
       return roi_cls_locs, roi_scores


def normal_init(m, mean, stddev, truncated=False): //正态分布初始化参数
  
   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_()

region_proposal_network.py

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


class RegionProposalNetwork(nn.Module):

  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(),
  ):
      super(RegionProposalNetwork, self).__init__()
      self.anchor_base = generate_anchor_base(      
          anchor_scales=anchor_scales, ratios=ratios)
      self.feat_stride = feat_stride
      self.proposal_layer = ProposalCreator(self, **proposal_creator_params)
      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)

  def forward(self, x, img_size, scale=1.):
      
      n, _, hh, ww = x.shape     //feature map
      anchor = _enumerate_shifted_anchor(     //利用base_anchor 在featuremap上滑动 生成所有的9*hh*ww的Anchor
          np.array(self.anchor_base),
          self.feat_stride, hh, ww)

      n_anchor = anchor.shape[0] // (hh * ww)    //1个pix有多少个anchor=9
      h = F.relu(self.conv1(x))  //第一个卷积层+relu

      rpn_locs = self.loc(h) //四个位置的cls  shape(1, A:36,H,W)   HW:feature_map   A：4*9（1个像素9anchor）
      rpn_locs = rpn_locs.permute(0, 2, 3, 1).contiguous().view(n, -1, 4)        //(1, A:36,H,W,) to (1,H,W,A) to (1,HW9,4)
      rpn_scores = self.score(h)  // 卷积结果(1,2*9,H,W)
      rpn_scores = rpn_scores.permute(0, 2, 3, 1).contiguous() //（1,H,W,2*9）
      rpn_softmax_scores = F.softmax(rpn_scores.view(n, hh, ww, n_anchor, 2), dim=4)  //(1,H,W,9,2)按二分类进行softmax
      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)  //rpn分数

      rois = list()
      roi_indices = list()
      for i in range(n): //batchsize=n=1
          roi = self.proposal_layer(  //调用Proposal Creator 得到roi
              rpn_locs[i].cpu().data.numpy(),
              rpn_fg_scores[i].cpu().data.numpy(),
              anchor, img_size,
              scale=scale)
          batch_index = i * np.ones((len(roi),), dtype=np.int32) //这里是标注roi对于batch的索引 batch=1  所以没有作用
          rois.append(roi)
          roi_indices.append(batch_index)

      rois = np.concatenate(rois, axis=0)
      roi_indices = np.concatenate(roi_indices, axis=0)
      return rpn_locs, rpn_scores, rois, roi_indices, anchor


def _enumerate_shifted_anchor(anchor_base, feat_stride, height, width):

  import numpy as xp
  shift_y = xp.arange(0, height * feat_stride, feat_stride)  //因为down sample了16倍 在featuremap移动一个相当于原图移动16
  shift_x = xp.arange(0, width * feat_stride, feat_stride)  //同理
  shift_x, shift_y = xp.meshgrid(shift_x, shift_y) //生成网格点坐标矩阵 如果你用matlab那么这函数应该挺熟悉，就是生成
                                                                              shift_x与shift_y组成的矩形中所有的点(含边缘) 点间隔feat_stride=16  结果的shift_x y按位置组成一个坐标   
  shift = xp.stack((shift_y.ravel(), shift_x.ravel(),  //将y,x平铺后组合，生成shape(K,4) = (K,(y,x)(y,x)）的shift 
                    shift_y.ravel(), shift_x.ravel()), axis=1)

  A = anchor_base.shape[0]  //1个点对应A(9)个anchor
  K = shift.shape[0]  //共K个点
  anchor = anchor_base.reshape((1, A, 4)) + \                                  //anchor=(1,A,4) + (K,1,4)   根据广播将进行K和A的全排列 生成(K,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):
     //pytorch版本


def normal_init(m, mean, stddev, truncated=False): //正态初始化参数

  if truncated:
      m.weight.data.normal_().fmod_(2).mul_(stddev).add_(mean)  
  else:
      m.weight.data.normal_(mean, stddev)
      m.bias.data.zero_()
  

roi_module.py

from collections import namedtuple
from string import Template
import cupy, torch
import cupy as cp
import torch as t
from torch.autograd import Function
from model.utils.roi_cupy import kernel_backward, kernel_forward

Stream = namedtuple('Stream', ['ptr'])  


@cupy.util.memoize(for_each_device=True)  //nms中见过，加载code
def load_kernel(kernel_name, code, **kwargs):
    cp.cuda.runtime.free(0)
    code = Template(code).substitute(**kwargs)
    kernel_code = cupy.cuda.compile_with_cache(code)
    return kernel_code.get_function(kernel_name)


CUDA_NUM_THREADS = 1024


def GET_BLOCKS(N, K=CUDA_NUM_THREADS):  //全覆盖计算 向上取整除
    return (N + K - 1) // K


class RoI(Function):
    def __init__(self, outh, outw, spatial_scale):
        self.forward_fn = load_kernel('roi_forward', kernel_forward)
        self.backward_fn = load_kernel('roi_backward', kernel_backward)
        self.outh, self.outw, self.spatial_scale = outh, outw, spatial_scale

    def forward(self, x, rois):  //向前传播过程
        x = x.contiguous()  //连续内存
        rois = rois.contiguous()  //连续内存
        self.in_size = B, C, H, W = x.size()  //featuremap
        self.N = N = rois.size(0)
        output = t.zeros(N, C, self.outh, self.outw).cuda()  //储存roipooling结果
        self.argmax_data = t.zeros(N, C, self.outh, self.outw).int().cuda()   //储存maxdata在featuremap中的索引结果
        self.rois = rois
        args = [x.data_ptr(), rois.data_ptr(),
                output.data_ptr(),
                self.argmax_data.data_ptr(),
                self.spatial_scale, C, H, W,
                self.outh, self.outw,
                output.numel()]
        stream = Stream(ptr=torch.cuda.current_stream().cuda_stream)
        self.forward_fn(args=args,
                        block=(CUDA_NUM_THREADS, 1, 1),
                        grid=(GET_BLOCKS(output.numel()), 1, 1),
                        stream=stream)
        return output

    def backward(self, grad_output): //反向传播过程 为了验证cuda code正确性
        grad_output = grad_output.contiguous()
        B, C, H, W = self.in_size
        grad_input = t.zeros(self.in_size).cuda()
        stream = Stream(ptr=torch.cuda.current_stream().cuda_stream)
        args = [grad_output.data_ptr(),
                self.argmax_data.data_ptr(),
                self.rois.data_ptr(),
                grad_input.data_ptr(),
                self.N, self.spatial_scale, C, H, W, self.outh, self.outw,
                grad_input.numel()]
        self.backward_fn(args=args,
                         block=(CUDA_NUM_THREADS, 1, 1),
                         grid=(GET_BLOCKS(grad_input.numel()), 1, 1),
                         stream=stream
                         )
        return grad_input, None


class RoIPooling2D(t.nn.Module):

    def __init__(self, outh, outw, spatial_scale):
        super(RoIPooling2D, self).__init__()
        self.RoI = RoI(outh, outw, spatial_scale)

    def forward(self, x, rois):
        return self.RoI(x, rois)


def test_roi_module(): //测试写的roi

    B, N, C, H, W, PH, PW = 2, 8, 4, 32, 32, 7, 7   //生成测试数据
    bottom_data = t.randn(B, C, H, W).cuda()
    bottom_rois = t.randn(N, 5)
    bottom_rois[:int(N / 2), 0] = 0
    bottom_rois[int(N / 2):, 0] = 1
    bottom_rois[:, 1:] = (t.rand(N, 4) * 100).float()
    bottom_rois = bottom_rois.cuda()
    spatial_scale = 1. / 16
    outh, outw = PH, PW

    # pytorch version
    module = RoIPooling2D(outh, outw, spatial_scale) 
    x = bottom_data.requires_grad_()  
    rois = bottom_rois.detach()

    output = module(x, rois)
    output.sum().backward() 

    def t2c(variable): //tensor to cupy
        npa = variable.data.cpu().numpy()
        return cp.array(npa)

    def test_eq(variable, array, info): //判断结果是否相等
        cc = cp.asnumpy(array)
        neq = (cc != variable.data.cpu().numpy())
        assert neq.sum() == 0, 'test failed: %s' % info

    # chainer version,if you're going to run this
    # pip install chainer 
    import chainer.functions as F
    from chainer import Variable
    x_cn = Variable(t2c(x))  //pytorch to cupy to chainer

    o_cn = F.roi_pooling_2d(x_cn, t2c(rois), outh, outw, spatial_scale) //chainer roi_pooling
    test_eq(output, o_cn.array, 'forward')
    F.sum(o_cn).backward()   
    test_eq(x.grad, x_cn.grad, 'backward')
    print('test pass') //测试成功

trainer_.py

from __future__ import  absolute_import
import os
from collections import namedtuple
import time
from torch.nn import functional as F
from model.utils.creator_tool import AnchorTargetCreator, ProposalTargetCreator

from torch import nn
import torch as t
from utils import array_tool as at
from utils.vis_tool import Visualizer

from utils.config import opt
from torchnet.meter import ConfusionMeter, AverageValueMeter

LossTuple = namedtuple('LossTuple',  //看名字很好理解，作用就是储存这几个loss
                       ['rpn_loc_loss',
                        'rpn_cls_loss',
                        'roi_loc_loss',
                        'roi_cls_loss',
                        'total_loss'
                        ])


class FasterRCNNTrainer(nn.Module):

    def __init__(self, faster_rcnn):
        super(FasterRCNNTrainer, self).__init__()

        self.faster_rcnn = faster_rcnn
        self.rpn_sigma = opt.rpn_sigma
        self.roi_sigma = opt.roi_sigma
        self.anchor_target_creator = AnchorTargetCreator()
        self.proposal_target_creator = ProposalTargetCreator()
        self.loc_normalize_mean = faster_rcnn.loc_normalize_mean
        self.loc_normalize_std = faster_rcnn.loc_normalize_std
        self.optimizer = self.faster_rcnn.get_optimizer()
        self.rpn_cm = ConfusionMeter(2)  //前后景误差矩阵  小彩蛋:这个方法的源码...classification拼错了
        self.roi_cm = ConfusionMeter(21)  //21分类误差矩阵
        self.meters = {k: AverageValueMeter() for k in LossTuple._fields}  //字典解析，平均loss AverageValueMeter会自动求均值

    def forward(self, imgs, bboxes, labels, scale)://训练过程中的向前过程，是最大的forward类 读这个函数可以了解faster-r-cnn的过程
       
        n = bboxes.shape[0]
        if n != 1:
            raise ValueError('Currently only batch size 1 is supported.')

        _, _, H, W = imgs.shape
        img_size = (H, W)

        features = self.faster_rcnn.extractor(imgs)  //生成featuremap

        rpn_locs, rpn_scores, rois, roi_indices, anchor = \  
            self.faster_rcnn.rpn(features, img_size, scale)

        # Since batch size is one, convert variables to singular form
        bbox = bboxes[0]
        label = labels[0]
        rpn_score = rpn_scores[0]
        rpn_loc = rpn_locs[0]
        roi = rois

        # Sample RoIs and forward
        # it's fine to break the computation graph of rois, 
        # consider them as constant input
        sample_roi, gt_roi_loc, gt_roi_label = self.proposal_target_creator(
            roi,
            at.tonumpy(bbox),
            at.tonumpy(label),
            self.loc_normalize_mean,
            self.loc_normalize_std)
        # NOTE it's all zero because now it only support for batch=1 now
        sample_roi_index = t.zeros(len(sample_roi))
        roi_cls_loc, roi_score = self.faster_rcnn.head(
            features,
            sample_roi,
            sample_roi_index)

        # ------------------ RPN losses -------------------#
        gt_rpn_loc, gt_rpn_label = self.anchor_target_creator(
            at.tonumpy(bbox),
            anchor,
            img_size)
        gt_rpn_label = at.totensor(gt_rpn_label).long()
        gt_rpn_loc = at.totensor(gt_rpn_loc)
        rpn_loc_loss = _fast_rcnn_loc_loss(  //rpn loc损失
            rpn_loc,
            gt_rpn_loc,
            gt_rpn_label.data,
            self.rpn_sigma)

        # NOTE: default value of ignore_index is -100 ...
        rpn_cls_loss = F.cross_entropy(rpn_score, gt_rpn_label.cuda(), ignore_index=-1)  //交叉熵损失
        _gt_rpn_label = gt_rpn_label[gt_rpn_label > -1]
        _rpn_score = at.tonumpy(rpn_score)[at.tonumpy(gt_rpn_label) > -1]
        self.rpn_cm.add(at.totensor(_rpn_score, False), _gt_rpn_label.data.long())

        # ------------------ ROI losses (fast rcnn loss) -------------------#
        n_sample = roi_cls_loc.shape[0]
        roi_cls_loc = roi_cls_loc.view(n_sample, -1, 4)
        roi_loc = roi_cls_loc[t.arange(0, n_sample).long().cuda(), \
                              at.totensor(gt_roi_label).long()]
        gt_roi_label = at.totensor(gt_roi_label).long()
        gt_roi_loc = at.totensor(gt_roi_loc)

        roi_loc_loss = _fast_rcnn_loc_loss( //roi loc损失
            roi_loc.contiguous(),
            gt_roi_loc,
            gt_roi_label.data,
            self.roi_sigma)

        roi_cls_loss = nn.CrossEntropyLoss()(roi_score, gt_roi_label.cuda()) //交叉熵损失

        self.roi_cm.add(at.totensor(roi_score, False), gt_roi_label.data.long())

        losses = [rpn_loc_loss, rpn_cls_loss, roi_loc_loss, roi_cls_loss]
        losses = losses + [sum(losses)]

        return LossTuple(*losses)

    def train_step(self, imgs, bboxes, labels, scale): //整个模型的一个step 从0梯度到向前过程，误差反向传播更新参数的过程
        self.optimizer.zero_grad() 
        losses = self.forward(imgs, bboxes, labels, scale)
        losses.total_loss.backward()
        self.optimizer.step()
        self.update_meters(losses)
        return losses

    def save(self, save_optimizer=False, save_path=None, **kwargs): //保存模型参数和config

        save_dict = dict()

        save_dict['model'] = self.faster_rcnn.state_dict()
        save_dict['config'] = opt._state_dict()
        save_dict['other_info'] = kwargs

        if save_optimizer: //保存优化器参数
            save_dict['optimizer'] = self.optimizer.state_dict()

        if save_path is None: //未指定保存地址
            timestr = time.strftime('%m%d%H%M')  //保存在checkpoints/时间戳命名
            save_path = 'checkpoints/fasterrcnn_%s' % timestr
            for k_, v_ in kwargs.items():
                save_path += '_%s' % v_

        save_dir = os.path.dirname(save_path)
        if not os.path.exists(save_dir):
            os.makedirs(save_dir)

        t.save(save_dict, save_path)

    def load(self, path, load_optimizer=True, parse_opt=False, ): //加载模型参数
        state_dict = t.load(path)
        if 'model' in state_dict:
            self.faster_rcnn.load_state_dict(state_dict['model'])
        else:  # legacy way, for backward compatibility
            self.faster_rcnn.load_state_dict(state_dict)
            return self
        if parse_opt:
            opt._parse(state_dict['config'])
        if 'optimizer' in state_dict and load_optimizer:
            self.optimizer.load_state_dict(state_dict['optimizer'])
        return self

    def update_meters(self, losses): //更新average loss
        loss_d = {k: at.scalar(v) for k, v in losses._asdict().items()}
        for key, meter in self.meters.items():
            meter.add(loss_d[key])

    def reset_meters(self): //重置meters 
        for key, meter in self.meters.items():
            meter.reset()
        self.roi_cm.reset()
        self.rpn_cm.reset()

    def get_meter_data(self): //返回meter中的值
        return {k: v.value()[0] for k, v in self.meters.items()}


def _smooth_l1_loss(x, t, in_weight, sigma): //按照论文写得loss
    sigma2 = sigma ** 2
    diff = in_weight * (x - t)
    abs_diff = diff.abs()
    flag = (abs_diff.data < (1. / sigma2)).float()
    y = (flag * (sigma2 / 2.) * (diff ** 2) +
         (1 - flag) * (abs_diff - 0.5 / sigma2))
    return y.sum()


def _fast_rcnn_loc_loss(pred_loc, gt_loc, gt_label, sigma): //按照论文写得loss
    in_weight = t.zeros(gt_loc.shape).cuda()
    # Localization loss is calculated only for positive rois.
    # NOTE:  unlike origin implementation, 
    # we don't need inside_weight and outside_weight, they can calculate by gt_label
    in_weight[(gt_label > 0).view(-1, 1).expand_as(in_weight).cuda()] = 1
    loc_loss = _smooth_l1_loss(pred_loc, gt_loc, in_weight.detach(), sigma)
    # Normalize by total number of negtive and positive rois.
    loc_loss /= ((gt_label >= 0).sum().float()) # ignore gt_label==-1 for rpn_loss
    return loc_loss

train_.py

训练类 这里是程序入口

from __future__ import  absolute_import
# though cupy is not used but without this line, it raise errors...
import cupy as cp
import os

import ipdb
import matplotlib
from tqdm import tqdm

from utils.config import opt
from data.dataset import Dataset, TestDataset, inverse_normalize
from model import FasterRCNNVGG16
from torch.utils import data as data_
from trainer import FasterRCNNTrainer
from utils import array_tool as at
from utils.vis_tool import visdom_bbox
from utils.eval_tool import eval_detection_voc
import resource
rlimit = resource.getrlimit(resource.RLIMIT_NOFILE)
resource.setrlimit(resource.RLIMIT_NOFILE, (20480, rlimit[1]))
//resource is a Unix specific package which is why it worked for Linux, but raised an error when trying to use it in Windows.

matplotlib.use('agg')


def eval(dataloader, faster_rcnn, test_num=10000): //从testdata中 选择10000个进行 ap map计算
    pred_bboxes, pred_labels, pred_scores = list(), list(), list()
    gt_bboxes, gt_labels, gt_difficults = list(), list(), list()
    for ii, (imgs, sizes, gt_bboxes_, gt_labels_, gt_difficults_) in tqdm(enumerate(dataloader)):
        sizes = [sizes[0][0].item(), sizes[1][0].item()]
        pred_bboxes_, pred_labels_, pred_scores_ = faster_rcnn.predict(imgs, [sizes])
        gt_bboxes += list(gt_bboxes_.numpy())
        gt_labels += list(gt_labels_.numpy())
        gt_difficults += list(gt_difficults_.numpy())
        pred_bboxes += pred_bboxes_
        pred_labels += pred_labels_
        pred_scores += pred_scores_
        if ii == test_num: break

    result = eval_detection_voc(
        pred_bboxes, pred_labels, pred_scores,
        gt_bboxes, gt_labels, gt_difficults,
        use_07_metric=True)
    return result


def train(**kwargs):
    opt._parse(kwargs)

    dataset = Dataset(opt)
    print('load data')
    dataloader = data_.DataLoader(dataset, \
                                  batch_size=1, \
                                  shuffle=True, \
                                  # pin_memory=True,
                                  num_workers=opt.num_workers)
    testset = TestDataset(opt)
    test_dataloader = data_.DataLoader(testset,
                                       batch_size=1,
                                       num_workers=opt.test_num_workers,
                                       shuffle=False, \
                                       pin_memory=True
                                       )
    faster_rcnn = FasterRCNNVGG16()
    print('model construct completed')
    trainer = FasterRCNNTrainer(faster_rcnn).cuda()
    if opt.load_path: //加载模型继续训练 或predict
        trainer.load(opt.load_path)
        print('load pretrained model from %s' % opt.load_path)
    trainer.vis.text(dataset.db.label_names, win='labels')
    best_map = 0
    lr_ = opt.lr 
    for epoch in range(opt.epoch):
        trainer.reset_meters()  //每个epoch将meters重置
        for ii, (img, bbox_, label_, scale) in tqdm(enumerate(dataloader)):
            scale = at.scalar(scale)
            img, bbox, label = img.cuda().float(), bbox_.cuda(), label_.cuda()
            trainer.train_step(img, bbox, label, scale)

            if (ii + 1) % opt.plot_every == 0: //训练每多少个img 打印一次结果
                if os.path.exists(opt.debug_file):
                    ipdb.set_trace()

                # plot loss
                trainer.vis.plot_many(trainer.get_meter_data()) //plot所有av_loss

                # plot groud truth bboxes
                ori_img_ = inverse_normalize(at.tonumpy(img[0]))
                gt_img = visdom_bbox(ori_img_,
                                     at.tonumpy(bbox_[0]),
                                     at.tonumpy(label_[0]))
                trainer.vis.img('gt_img', gt_img)

                # plot predicti bboxes
                _bboxes, _labels, _scores = trainer.faster_rcnn.predict([ori_img_], visualize=True)
                pred_img = visdom_bbox(ori_img_,
                                       at.tonumpy(_bboxes[0]),
                                       at.tonumpy(_labels[0]).reshape(-1),
                                       at.tonumpy(_scores[0]))
                trainer.vis.img('pred_img', pred_img)

                # rpn confusion matrix(meter)
                trainer.vis.text(str(trainer.rpn_cm.value().tolist()), win='rpn_cm')
                # roi confusion matrix
                trainer.vis.img('roi_cm', at.totensor(trainer.roi_cm.conf, False).float())
        eval_result = eval(test_dataloader, faster_rcnn, test_num=opt.test_num)
        trainer.vis.plot('test_map', eval_result['map'])
        lr_ = trainer.faster_rcnn.optimizer.param_groups[0]['lr']
        log_info = 'lr:{}, map:{},loss:{}'.format(str(lr_),
                                                  str(eval_result['map']),
                                                  str(trainer.get_meter_data()))
        trainer.vis.log(log_info)

        if eval_result['map'] > best_map: //记录best_map
            best_map = eval_result['map']
            best_path = trainer.save(best_map=best_map)
        if epoch == 9:  //加载best_map继续训练
            trainer.load(best_path)
            trainer.faster_rcnn.scale_lr(opt.lr_decay)
            lr_ = lr_ * opt.lr_decay

        if epoch == 13: 
            break


if __name__ == '__main__':
    import fire

    fire.Fire() //入口 方便运行调试各个函数

有些地方解释的不合理或者不正确请自行判断，结合原作者的注释学习效率更佳。
整个模型的过程就是：batch=1
读取数据gt_boxl label img difficult只在eval的时候会用于计算ap和map img 要经过resize和标准化 flip增强 对应box也要做同等操作. img被送入卷积生成feature map down sampling了16倍。然后我们将feature resize后的imgshape resize scale送入rpn 按照论文在feature map上进行滑动生成anchor 将featuremap送入卷积网络 得到每个anchor的loc(4) 和score(前后景) 根据score 我们选取前景概率大的6000个anchor 将这6000个anchor的位置用loc修正 送入Nms后 选择300个成为ROIS
然后将300个ROIS 与GT_BOX 进行IOU计算 如果某个roi和(对应IOU最大的gt_box)的IOU大于某个阀值 我们将其设定为正样本 他的label也就置为gt_box的label+1 如果小于某阀值 认定为背景 label=0。共选取正负样本共128个 计算这128个roi和对应gt_box（IOU最大）的loc（只计算正样本） 这时我们得到了128个roi roi的label和 128个roi的loc
然后我们将得到的128个roi和feature送入ROIhead 根据featuremap(512) 将roi roi_pooling到7x7 得到7x7x128x512的结果 平铺送入vgg16的全连接层 （巧妙利用权值共享） 得到这张图片 每个类的cls修正 和属于每个类的score
另外我们根据anchor和gt_bbox 的IOU 随机选择>0.7的设置为正样本 <0.3的为负样本 共256个anchor 计算256个anchor和对应gt_box（IOU最大）的 loc （只计算正样本） 返回256个anchor在所有anchor中的位置 和对应loc label
按论文公式进行loss计算 反向传播更新参数
predict预测的时候选出300个ROIS时，将ROIS全部送入ROIhead 得到这300个rois的每个类的cls修正和每个类的score
利用300个rois 和每个类cls修正 进行广播 得到300个每个类的修正后的rois 利用score和rois 进行每个类的nms操作 选出候选框 即我们预测的候选框 score经过softmax后就是这个框的prob 接着就是可视化的过程了