下面我和大家一起从训练最开始学习作者如何将原始数据读入并通过RoIDataLayer转化成网络训练所需的数据的总体过程。

训练从./tools/train_net.py开始，进入主函数，我们只关注跟数据有关的模块。

首先是imdb, roidb = combined_roidb(args.imdb_name)语句，传入的参数imdb_name默认是“voc_2007_trainval”，这只是一个数据集的名字而已，进入该文件下的combined_roidb函数，该函数首先有个内部函数get_roidb，下面有调用，进入这函数第一行imdb = get_imdb（imdb_name），这个get_imdb为factory中的函数，细看可以知道get_imdb这个函数通过给数据集的名字返回了该数据集对应的类的对象。

到现在我们可以通过一些变量名知道imdb即影像数据集，roidb即感兴趣区域的数据集，factory即为工厂，它的函数get_imdb根据名字返回数据集对应的类的对象。假如imdb_name为“voc_2007_trainval”，我们可以知道get_imdb返回的是pascal_voc(‘trainval’, ‘2007’)，而进入pascal_voc文件，我们可以看到他是一个继承于imdb类的子类（class pascal_voc(imdb):），在init函数中，我们可以知道该类记录了文件路径目标类别还有影像扩展名等与数据集相关的内容，而父类imdb中则是名字等一般性的内容。

了解了这些内容以后，我们回到combined_roidb函数的get_roidb函数继续往下读，通过get_imdb记录了数据集的路径之类的信息后。get_roidb函数又调用了语句imdb.set_proposal_method(cfg.TRAIN.PROPOSAL_METHOD)，在config.py中我们看到cfg.TRAIN.PROPOSAL_METHOD值是selective_search，但在/experiments/cfgs/faster_rcnn_end2end.yml中它的值是gt，而imdb的set_proposal_method函数里为method = eval('self.' + method + '_roidb')    self.roidb_handler = method其中eval函数把字符串当成表达式求值，从而我们知道下一行调用了gt_roidb函数，进入pascal_voc下的gt_roidb函数，其中关于cache相当于缓存加速未来调用的，可以不管。我们看到该函数核心语句gt_roidb = [self._load_pascal_annotation(index)  for index in self.image_index]在数据集类pascal_voc中我们知道image_index记录的是所有影像名的列表，可以知道对每张影像名调用_load_pascal_annotation，进入该函数一眼可以看到在路径后面加了“Annotations”即可以知道该函数读取的是影像对应存储目标的xml文件。最后返回了“boxes”，“gt_classes”等构成的字典。

随后get_roidb函数调用了get_training_roidb（imdb），进入fast_rcnn下的train.py文件，进入get_training_roidb函数，调用的append_flipped_images函数通过名字可以看出是增加翻转的，可以不管，然后该函数又调用了prepare_roidb，从上面我们已经知道image_index记录的是所有影像名的列表，在roidb.py中prepare_roidb通过循环for i in xrange(len(imdb.image_index))对每张影像在上面gt_roidb函数读取到的内容“gt_overlaps”进行了求最大处理，并记录影像路径还有影像高宽等信息在roidb中并返回，返回的roidb是一个长度与影像数一致的列表。由此知该函数即如函数名所示做准备prepare。

现在回到combined_roidb函数，语句roidbs = [get_roidb(s) for s in imdb_names.split('+')]我们可以知道对于每个数据集返回了带有该数据集信息的imdb和包含每张影像感兴趣区域信息的roidb（包括每张影像点目标和影像宽高等信息），事实上roidb属于imdb。

继续往下看，train_net.py调用了train_net(args.solver, roidb, output_dir,pretrained_model=args.pretrained_model,max_iters=args.max_iters)函数，此函数为fast_rcnn/train.py中的train_net函数该函数首先调用了filter_roidb，如函数名即对roi进行过滤，然后调用了SolverWrapper，即是solver的封装类的对象，在init函数中，开始都是导入网络之类的准备性工作，在最后一句话中，调用了self.solver.net.layers[0].set_roidb(roidb)，这句话很关键，即调用了网络第一层也即是prototxt文件的第一层即RoIDataLayer层的set_roidb函数，把之前读取的roidb对象传进了网络。

到现在我们再来看roidb对象里到底记录了哪些内容呢？包括数据集所有影像的影像路径，所有影像对应的目标，以及宽高等信息。有了这些信息，就可以在RoIDataLayer层的前向传播函数调用get_next_minibatch，该函数首先调用了_get_next_minibatch_inds此批次运行的影像下标，然后获取他们对应的roidb对象后组成列表，传进get_minibatch函数。在RoIDataLayer层中输出为data，im_info和gt_boxes，在get_minibatch函数中，他把所有的输出信息弄成blob以便进行前向传播。data通过roidb的“image”记录的路径信息然后调用opencv的读影像函数进行读取并进行尺度缩放后输出，对应代码为im_blob, im_scales = _get_image_blob(roidb, random_scale_inds)   blobs = {'data': im_blob}，而其余的gt_boxes信息之前已经保存，可以直接将之前的信息保存到对应的blob结构中，最后输出。blobs['gt_boxes'] = gt_boxes   blobs['im_info'] = np.array(  [[im_blob.shape[2], im_blob.shape[3], im_scales[0]]], dtype=np.float32)，最后返回blob，在前向传播中输出top layer。

Faster R-CNN源码阅读之七：Faster R-CNN/lib/rpn_msr/anchor_target_layer_tf.py

1. Faster R-CNN源码阅读之零：写在前面
2. Faster R-CNN源码阅读之一：Faster R-CNN/lib/networks/network.py
3. Faster R-CNN源码阅读之二：Faster R-CNN/lib/networks/factory.py
4. Faster R-CNN源码阅读之三：Faster R-CNN/lib/networks/VGGnet_test.py
5. Faster R-CNN源码阅读之四：Faster R-CNN/lib/rpn_msr/generate_anchors.py
6. Faster R-CNN源码阅读之五：Faster R-CNN/lib/rpn_msr/proposal_layer_tf.py
7. Faster R-CNN源码阅读之六：Faster R-CNN/lib/fast_rcnn/bbox_transform.py
8. Faster R-CNN源码阅读之七：Faster R-CNN/lib/rpn_msr/anchor_target_layer_tf.py
9. Faster R-CNN源码阅读之八：Faster R-CNN/lib/rpn_msr/proposal_target_layer_tf.py
10. Faster R-CNN源码阅读之九：Faster R-CNN/tools/train_net.py
11. Faster R-CNN源码阅读之十：Faster R-CNN/lib/fast_rcnn/train.py
12. Faster R-CNN源码阅读之十一：Faster R-CNN预测demo代码补完
13. Faster R-CNN源码阅读之十二：写在最后

一、介绍
   本demo由Faster R-CNN官方提供，我只是在官方的代码上增加了注释，一方面方便我自己学习，另一方面贴出来和大家一起交流。
   该文件中的函数的主要目的是产生anchors并结合gt boxes（ground truth boxes）给这些anchors进行标记labels（前景还是背景），然后生成这些anchors的权重信息，并产生bbox的RPN网络回归结果目标。

二、代码以及注释

# -*- coding:utf-8 -*-

# --------------------------------------------------------

# Faster R-CNN

# Copyright (c) 2015 Microsoft

# Licensed under The MIT License [see LICENSE for details]

# Written by Ross Girshick and Sean Bell

# --------------------------------------------------------

import os

import yaml

from fast_rcnn.config import cfg

import numpy as np

import numpy.random as npr

from generate_anchors import generate_anchors

from utils.cython_bbox import bbox_overlaps

from fast_rcnn.bbox_transform import bbox_transform

import pdb

DEBUG = False

def anchor_target_layer(rpn_cls_score, gt_boxes, im_info, data, _feat_stride=[16, ], anchor_scales=[4, 8, 16, 32]):

    """

    Assign anchors to ground-truth targets. Produces anchor classification

    labels and bounding-box regression targets.

    """

    # 产生作为基准的若干个anchors，并获取这些anchors的个数。

    _anchors = generate_anchors(scales=np.array(anchor_scales))

    _num_anchors = _anchors.shape[0]

    # if DEBUG代码块仅用作调试时使用，输出某些特定的信息，没有实际的帮助，下同。

    if DEBUG:

        print 'anchors:'

        print _anchors

        print 'anchor shapes:'

        print np.hstack((

            _anchors[:, 2::4] - _anchors[:, 0::4],

            _anchors[:, 3::4] - _anchors[:, 1::4],

        ))

        _counts = cfg.EPS

        _sums = np.zeros((1, 4))

        _squared_sums = np.zeros((1, 4))

        _fg_sum = 0

        _bg_sum = 0

        _count = 0

    # allow boxes to sit over the edge by a small amount

    # 允许boxes（anchors）超过图像实际边界的某个余量，这里设置为0，表示不允许boxes超过图像边界。

    _allowed_border = 0

    # map of shape (..., H, W)

    # height, width = rpn_cls_score.shape[1:3]

    # 获取图像的信息

    im_info = im_info[0]

    # Algorithm:

    #

    # for each (H, W) location i

    #   generate 9 anchor boxes centered on cell i

    #   apply predicted bbox deltas at cell i to each of the 9 anchors

    # filter out-of-image anchors

    # measure GT overlap

    # 算法：

    # 断言，目前版本的算法仅能允许每次feed一张图片

    assert rpn_cls_score.shape[0] == 1, \

        'Only single item batches are supported'

    # map of shape (..., H, W)

    height, width = rpn_cls_score.shape[1:3]

    if DEBUG:

        print 'AnchorTargetLayer: height', height, 'width', width

        print ''

        print 'im_size: ({}, {})'.format(im_info[0], im_info[1])

        print 'scale: {}'.format(im_info[2])

        print 'height, width: ({}, {})'.format(height, width)

        print 'rpn: gt_boxes.shape', gt_boxes.shape

        print 'rpn: gt_boxes', gt_boxes

    # 1. Generate proposals from bbox deltas and shifted anchors

    # 1. 生成所有的加入偏移量之后的anchors，具体过程可以参考proposal_layer_tf.py文件。

    shift_x = np.arange(0, width) * _feat_stride

    shift_y = np.arange(0, height) * _feat_stride

    shift_x, shift_y = np.meshgrid(shift_x, shift_y)

    shifts = np.vstack((shift_x.ravel(), shift_y.ravel(),

                        shift_x.ravel(), shift_y.ravel())).transpose()

    # add A anchors (1, A, 4) to

    # cell K shifts (K, 1, 4) to get

    # shift anchors (K, A, 4)

    # reshape to (K*A, 4) shifted anchors

    A = _num_anchors

    K = shifts.shape[0]

    all_anchors = (_anchors.reshape((1, A, 4)) +

                   shifts.reshape((1, K, 4)).transpose((1, 0, 2)))

    all_anchors = all_anchors.reshape((K * A, 4))

    total_anchors = int(K * A)

    # only keep anchors inside the image

    # 获取所有的边界都在图像边界（加上余量之后）的范围内的anchors的索引。

    inds_inside = np.where(

        (all_anchors[:, 0] >= -_allowed_border) &

        (all_anchors[:, 1] >= -_allowed_border) &

        (all_anchors[:, 2] < im_info[1] + _allowed_border) &  # width

        (all_anchors[:, 3] < im_info[0] + _allowed_border)  # height

    )[0]

    if DEBUG:

        print 'total_anchors', total_anchors

        print 'inds_inside', len(inds_inside)

    # keep only inside anchors

    # 获取上述求得的边界均满足条件的anchors。

    anchors = all_anchors[inds_inside, :]

    if DEBUG:

        print 'anchors.shape', anchors.shape

    # label: 1 is positive, 0 is negative, -1 is don't care

    # 初始化label，1表示正样本，0表示负样本，-1表示不关心。

    # 因此刚开始，我们将所有的label设置为-1。

    labels = np.empty((len(inds_inside),), dtype=np.float32)

    labels.fill(-1)

    # overlaps between the anchors and the gt boxes

    # overlaps (ex, gt)

    # 计算每一个anchor和每一个gt boxes（ground truth boxes）之间的overlap

    # 假设anchors的数目为N，gt boxes的数目为K，

    # 则bbox_overlaps会返回一个shape为[N, K]的数组array，里面依次保存着第i个anchor和第j个gt box之间的IOU。

    overlaps = bbox_overlaps(

        np.ascontiguousarray(anchors, dtype=np.float),

        np.ascontiguousarray(gt_boxes, dtype=np.float))

    # 横向比较，为每一个anchor找到与其拥有最高的IOU的gt box，并返回这些gt box的索引（这里是列索引）。

    argmax_overlaps = overlaps.argmax(axis=1)

    # 保存的是每一个anchor与其拥有最高IOU的gt box的IOU值。

    max_overlaps = overlaps[np.arange(len(inds_inside)), argmax_overlaps]

    # 纵向比较，为每一个gt box找到与其拥有最高的IOU的anchor，并返回这些anchors的索引（这里是行索引）。

    gt_argmax_overlaps = overlaps.argmax(axis=0)

    # 保存的是每一个gt box与其拥有最高IOU的anchor的IOU值。

    # 注意这里gt_argmax_overlaps和np.arange(overlaps.shape[1])的顺序。

    # （个人认为以下的两行代码都更为简便的写法，实际上第二行代码可以省略）

    gt_max_overlaps = overlaps[gt_argmax_overlaps,

                               np.arange(overlaps.shape[1])]

    # 这里按行的顺序获取最大值的索引，本质上是对gt_argmax_overlaps进行从小到大的排序

    gt_argmax_overlaps = np.where(overlaps == gt_max_overlaps)[0]

    if not cfg.TRAIN.RPN_CLOBBER_POSITIVES:

        # assign bg labels first so that positive labels can clobber them

        # 首先对那些小于一定阈值的anchor进行label的赋值，把它们标记为背景anchor（label标记为0）。

        labels[max_overlaps < cfg.TRAIN.RPN_NEGATIVE_OVERLAP] = 0

    # fg label: for each gt, anchor with highest overlap

    # 标记前景anchors的label，与某一个gt box有最高IOU的anchor的label标记为1。

    # 之所以这么做是因为有时候IOU高于某一阈值的anchor不存在，仅考虑使用阈值标记label就会出现错误。

    labels[gt_argmax_overlaps] = 1

    # fg label: above threshold IOU

    # 与某一个gt box的IOU大于某一阈值的anchor的label标记为1。

    labels[max_overlaps >= cfg.TRAIN.RPN_POSITIVE_OVERLAP] = 1

    if cfg.TRAIN.RPN_CLOBBER_POSITIVES:

        # assign bg labels last so that negative labels can clobber positives

        # 最后对背景anchor进行赋值。

        # 和上面的if not cfg.TRAIN.RPN_CLOBBER_POSITIVES代码块功能类似，就是看positive和negative谁比较强。

        # 这两部分的代码在实际过程中只能执行一个。

        # 前一部分代码现将一部分label设置为0，则默认为positive比negative强，因为在前面的两行label赋值代码中有可能anchor的label会从0变成1。

        # 这一部分代码则与前面的if代码块作用相反，默认为negative比positive强，因为在这一部分代码中，可能有已经被标记为1的label会被重新标记为0。

        labels[max_overlaps < cfg.TRAIN.RPN_NEGATIVE_OVERLAP] = 0

    # subsample positive labels if we have too many

    # 如果有过多的正样本label，即过多的前景anchors，随机选择一些，剩下的未被选择的标记为-1。

    # 需要的最大前景数目

    num_fg = int(cfg.TRAIN.RPN_FG_FRACTION * cfg.TRAIN.RPN_BATCHSIZE)

    # 获取label为1即所有前景anchors的索引

    fg_inds = np.where(labels == 1)[0]

    # 如果前景数目过多

    if len(fg_inds) > num_fg:

        # 随机选择一些前景，数目为总前景数目减去所需要的前景数目

        disable_inds = npr.choice(

            fg_inds, size=(len(fg_inds) - num_fg), replace=False)

        # 把这些前景anchors的label变更为-1，表示不关心。

        labels[disable_inds] = -1

    # subsample negative labels if we have too many

    # 如果有过多的背景数目，也是同理筛选一些保留。

    num_bg = cfg.TRAIN.RPN_BATCHSIZE - np.sum(labels == 1)

    bg_inds = np.where(labels == 0)[0]

    if len(bg_inds) > num_bg:

        disable_inds = npr.choice(

            bg_inds, size=(len(bg_inds) - num_bg), replace=False)

        labels[disable_inds] = -1

        # print "was %s inds, disabling %s, now %s inds" % (

        # len(bg_inds), len(disable_inds), np.sum(labels == 0))

    # 创建一个shape为[len(inds_inside), 4]大小的全0数组，用来存储等会生成的anchors的回归目标

    bbox_targets = np.zeros((len(inds_inside), 4), dtype=np.float32)

    # _compute_targets函数返回一个用于anchors回归成targets的包含每个anchor回归值(dx、dy、dw、dh)的array,

    # 形状（(len(inds_inside), 4），即（anchors.shape[0],4）

    # 第二个参数gt_boxes[argmax_overlaps, :]括号内部的取值可以保证每一个anchor都对应于与之拥有最高IOU的gt box。

    # bbox_targets本质上是RPN应该生成的数据，用以bbox的回归操作。即bbox targets是网络在训练的时候需要生成的目标。

    bbox_targets = _compute_targets(anchors, gt_boxes[argmax_overlaps, :])

    # 定义一个全0的(len(inds_inside), 4)二维数组，表示bbox inside weights，并对对应的label为1的bbox inside weights进行赋值

    bbox_inside_weights = np.zeros((len(inds_inside), 4), dtype=np.float32)

    # 这里将对应label为1的bbox inside weights赋值为cfg.TRAIN.RPN_BBOX_INSIDE_WEIGHTS，

    # cfg.TRAIN.RPN_BBOX_INSIDE_WEIGHTS一般是一个长度为4的全有1组成的一维数组。

    bbox_inside_weights[labels == 1, :] = np.array(cfg.TRAIN.RPN_BBOX_INSIDE_WEIGHTS)

    # 定义一个全0的(len(inds_inside), 4)二维数组，表示bbox outside weights。

    bbox_outside_weights = np.zeros((len(inds_inside), 4), dtype=np.float32)

    # cfg.TRAIN.RPN_POSITIVE_WEIGHT一般设为-1

    if cfg.TRAIN.RPN_POSITIVE_WEIGHT < 0:

        # uniform weighting of examples (given non-uniform sampling)

        # 统一的样本（anchors）配置权重方法，else代码块中为非统一样本配置权重方法。

        # 在统一的方法中正样本（anchors）和负样本（anchors）的bbox outside weights均被赋值为正负样本数目之后的倒数。

        # 这一步是获取正负样本（anchors）的总数目（1表示正样本，0表示负样本，-1表示不关心）

        num_examples = np.sum(labels >= 0)

        # 赋值

        positive_weights = np.ones((1, 4)) * 1.0 / num_examples

        negative_weights = np.ones((1, 4)) * 1.0 / num_examples

    else:

        # 保证cfg.TRAIN.RPN_POSITIVE_WEIGHT 在0和1之间

        assert ((cfg.TRAIN.RPN_POSITIVE_WEIGHT > 0) & (cfg.TRAIN.RPN_POSITIVE_WEIGHT < 1))

        # 正样本的权重

        positive_weights = (cfg.TRAIN.RPN_POSITIVE_WEIGHT / np.sum(labels == 1))

        # 负样本的权重

        negative_weights = ((1.0 - cfg.TRAIN.RPN_POSITIVE_WEIGHT) / np.sum(labels == 0))

    # 对正负样本（anchors）的bbox outside weights分别进行赋值。

    bbox_outside_weights[labels == 1, :] = positive_weights

    bbox_outside_weights[labels == 0, :] = negative_weights

    if DEBUG:

        _sums += bbox_targets[labels == 1, :].sum(axis=0)

        _squared_sums += (bbox_targets[labels == 1, :] ** 2).sum(axis=0)

        _counts += np.sum(labels == 1)

        means = _sums / _counts

        stds = np.sqrt(_squared_sums / _counts - means ** 2)

        print 'means:'

        print means

        print 'stdevs:'

        print stds

    # map up to original set of anchors

    # 从获取到存在图片内部的anchors之后，我们一直在对这些anchors进行操作，而剩下的相当多的anchors就被直接忽略掉了，

    # 现在我们需要考虑利用上这一部分anchors。

    # 注：inds_inside变量保存的是存在于图片内部的anchors在生成的全部的anchors中的索引，

    # 而在后续的操作过程中，我们并没有改变提取出来的anchors的顺序，因此这些索引还是和anchors，labels等一一对应。

    # 将剩下的anchors进行label的标注，由于这些anchors并不是全部存在于图片内部，因此这里将他们的label设置为-1，表示不关心。

    # total_anchors是一个整数，表示之前生成的最最原始的anchors的数目。下同

    # inds_inside表示存在于图片内部的anchors在所有原始anchors中的索引。下同

    labels = _unmap(labels, total_anchors, inds_inside, fill=-1)

    # 下面的三行代码也是同理，将那些原始的anchors的信息也添加进去，由于没有经过上面的计算过程，因此这些信息全部被设置为0。

    bbox_targets = _unmap(bbox_targets, total_anchors, inds_inside, fill=0)

    bbox_inside_weights = _unmap(bbox_inside_weights, total_anchors, inds_inside, fill=0)

    bbox_outside_weights = _unmap(bbox_outside_weights, total_anchors, inds_inside, fill=0)

    if DEBUG:

        print 'rpn: max max_overlap', np.max(max_overlaps)

        print 'rpn: num_positive', np.sum(labels == 1)

        print 'rpn: num_negative', np.sum(labels == 0)

        _fg_sum += np.sum(labels == 1)

        _bg_sum += np.sum(labels == 0)

        _count += 1

        print 'rpn: num_positive avg', _fg_sum / _count

        print 'rpn: num_negative avg', _bg_sum / _count

    # labels

    # pdb.set_trace()

    # 在前面anchors的产生过程中可以看出，其本质上也是在特征图上滑窗操作，在每个特征图的点上生成若干个anchors。

    # 这里height，width分别表示特征图的高度和宽度，A表示在每个位置产生的anchors的数目，reshape之后就和特征图上的位置一一对应。

    # 之后transpose(0, 3, 1, 2)，此时最精确信息为width，此时以width信息进行fastest聚类。（？？）

    labels = labels.reshape((1, height, width, A)).transpose(0, 3, 1, 2)

    labels = labels.reshape((1, 1, A * height, width))

    rpn_labels = labels

    # 将以下的三个变量的通道顺序更改为[N, C, H, W]，N为样本维，C表示通道维，H表示height，W表示宽度。

    # 重新给变量命名，并结合上述的rpn_labels一并返回。

    # bbox_targets

    bbox_targets = bbox_targets.reshape((1, height, width, A * 4)).transpose(0, 3, 1, 2)

    rpn_bbox_targets = bbox_targets

    # bbox_inside_weights

    bbox_inside_weights = bbox_inside_weights.reshape((1, height, width, A * 4)).transpose(0, 3, 1, 2)

    # assert bbox_inside_weights.shape[2] == height

    # assert bbox_inside_weights.shape[3] == width

    rpn_bbox_inside_weights = bbox_inside_weights

    # bbox_outside_weights

    bbox_outside_weights = bbox_outside_weights.reshape((1, height, width, A * 4)).transpose(0, 3, 1, 2)

    # assert bbox_outside_weights.shape[2] == height

    # assert bbox_outside_weights.shape[3] == width

    rpn_bbox_outside_weights = bbox_outside_weights

    return rpn_labels, rpn_bbox_targets, rpn_bbox_inside_weights, rpn_bbox_outside_weights

def _unmap(data, count, inds, fill=0):

    """ Unmap a subset of item (data) back to the original set of items (of size count)

    在之前的处理过程中，我们一直在处理存在于图片边界内部的anchors，还有相当多的anchors在图片边界外部或者在图片边界上。

    而这一部分我们直接忽略掉了，现在利用这个函数将他们也进行简单处理，赋予他们所需要的label和weights信息。

    :param data: 该参数有两种形式，一个是图片内部anchors的labels，另一个是图片内部anchors的RPN回归目标以及权重等信息。

                 labels是一个一维数组，其他的都是shape为[N, 4]形状的二维数组。

    :param count:原始anchors的数目，这里包括图片边缘内部的，也包括存在于图片边缘上的和外部的。

    :param inds: 存在于图片边缘内部的anchors在原始anchors序列中的索引，也是一个一维数组。

    :param fill: 默认填充的数值，在图片边缘上的和外部的anchors没有经过前面的计算过程，这些参数只用fill提供的值默认填充。

    :return: 补完之后的信息，这里的信息是所有anchors的信息，包括图片内部的，边界上的和边界外的、

    """

    # 长度为1，表示这里补完的是labels信息

    if len(data.shape) == 1:

        # 定义矩阵。使用fill填充

        ret = np.empty((count,), dtype=np.float32)

        ret.fill(fill)

        # 将图片内部anchors的信息重新赋值给矩阵，位置信息由inds提供。

        ret[inds] = data

    else:

        # 这里补完的是bbox回归目标，权值等信息，和填充labels的过程类似。

        ret = np.empty((count,) + data.shape[1:], dtype=np.float32)

        ret.fill(fill)

        ret[inds, :] = data

    return ret

def _compute_targets(ex_rois, gt_rois):

    """

    Compute bounding-box regression targets for an image.

    :param ex_rois: 待处理的rois，一般是一系列anchors

    :param gt_rois: ground truth boxes, 与每一个ex_rois(anchor)一一对应，每一行都是与当前ex_roi(anchor)其拥有最大IOU的gt box。

    :return:

    """

    # 确保每一个ex_roi都有一个gt box对应

    assert ex_rois.shape[0] == gt_rois.shape[0]

    # anchor长度为4

    assert ex_rois.shape[1] == 4

    # gt box的长度为5，分别表示实际bbox的坐标（4）和类别（1)

    assert gt_rois.shape[1] == 5

    # 分别计算bbox transform，这里只用到了gt box的坐标部分

    return bbox_transform(ex_rois, gt_rois[:, :4]).astype(np.float32, copy=False)