生如蚁,美如神

众里寻她千百度,蓦然回首,那人却在灯火阑珊处

faster rcnn学习之rpn、fast rcnn数据准备说明

在上文《 faster-rcnn系列学习之准备数据》,我们已经介绍了imdb与roidb的一些情况,下面我们准备再继续说一下rpn阶段和fast rcnn阶段的数据准备整个处理流程。

由于这两个阶段的数据准备有些重合,所以放在一起说明。

我们并行地从train_rpn与train_fast_rcnn说起,这两个函数在train_faster_rcnn_alt_opt.py中。

def train_rpn(queue=None, imdb_name=None, init_model=None, solver=None,
              max_iters=None, cfg=None):
    """Train a Region Proposal Network in a separate training process.
    """

    # Not using any proposals, just ground-truth boxes
    cfg.TRAIN.HAS_RPN = True
    cfg.TRAIN.BBOX_REG = False  # applies only to Fast R-CNN bbox regression
    cfg.TRAIN.PROPOSAL_METHOD = 'gt'
    cfg.TRAIN.IMS_PER_BATCH = 1
    print 'Init model: {}'.format(init_model)
    print('Using config:')
    pprint.pprint(cfg)

    import caffe
    _init_caffe(cfg)

    roidb, imdb = get_roidb(imdb_name)
    print 'roidb len: {}'.format(len(roidb))
    output_dir = get_output_dir(imdb)
    print 'Output will be saved to `{:s}`'.format(output_dir)

    model_paths = train_net(solver, roidb, output_dir,
                            pretrained_model=init_model,
                            max_iters=max_iters)
    # Cleanup all but the final model
    for i in model_paths[:-1]:
        os.remove(i)
    rpn_model_path = model_paths[-1]
    # Send final model path through the multiprocessing queue
    queue.put({'model_path': rpn_model_path})

def train_fast_rcnn(queue=None, imdb_name=None, init_model=None, solver=None,
                    max_iters=None, cfg=None, rpn_file=None):
    """Train a Fast R-CNN using proposals generated by an RPN.
    """

    cfg.TRAIN.HAS_RPN = False           # not generating prosals on-the-fly
    cfg.TRAIN.PROPOSAL_METHOD = 'rpn'   # use pre-computed RPN proposals instead
    cfg.TRAIN.IMS_PER_BATCH = 2
    print 'Init model: {}'.format(init_model)
    print 'RPN proposals: {}'.format(rpn_file)
    print('Using config:')
    pprint.pprint(cfg)

    import caffe
    _init_caffe(cfg)

    roidb, imdb = get_roidb(imdb_name, rpn_file=rpn_file)
    output_dir = get_output_dir(imdb)
    print 'Output will be saved to `{:s}`'.format(output_dir)
    # Train Fast R-CNN
    model_paths = train_net(solver, roidb, output_dir,
                            pretrained_model=init_model,
                            max_iters=max_iters)
    # Cleanup all but the final model
    for i in model_paths[:-1]:
        os.remove(i)
    fast_rcnn_model_path = model_paths[-1]
    # Send Fast R-CNN model path over the multiprocessing queue
    queue.put({'model_path': fast_rcnn_model_path})
显然两段代码很相似。很显然,两个子网络都从vgg-16开始训起,自然初始输入是相似的。

但设置不同,rpn:  

 cfg.TRAIN.HAS_RPN = True 

                                 cfg.TRAIN.PROPOSAL_METHOD = 'gt' #使用gt_roidb

                                 cfg.TRAIN.IMS_PER_BATCH = 1

                        而fast rcnn;  

                          cfg.TRAIN.HAS_RPN = False          
    cfg.TRAIN.PROPOSAL_METHOD = 'rpn'   #使用rpn_roidb
      cfg.TRAIN.IMS_PER_BATCH = 2


我们接下来从roidb, imdb = get_roidb(imdb_name)说起。

def get_roidb(imdb_name, rpn_file=None):
    imdb = get_imdb(imdb_name)#通过工厂类获取图片数据库信息
    print 'Loaded dataset `{:s}` for training'.format(imdb.name)
    imdb.set_proposal_method(cfg.TRAIN.PROPOSAL_METHOD)
    print 'Set proposal method: {:s}'.format(cfg.TRAIN.PROPOSAL_METHOD)
    if rpn_file is not None:
        imdb.config['rpn_file'] = rpn_file
    roidb = get_training_roidb(imdb)#获得训练数据
    return roidb, imdb
我们先看这句:
imdb.set_proposal_method(cfg.TRAIN.PROPOSAL_METHOD)

    def set_proposal_method(self, method):
        method = eval('self.' + method + '_roidb') # python中eval是可以具体运行里面的字符串的
        self.roidb_handler = method

对于rpn来说: eval('self.gt_roidb');

对于fast rcnn来说:eval('self.rpn_roidb');eval是python的语法,指运行里面的字符串。这里这两个命令都在pascal_voc.py中。我们逐一来看。

rpn: 

def gt_roidb(self):
        """
        Return the database of ground-truth regions of interest.

        This function loads/saves from/to a cache file to speed up future calls.
        """
        cache_file = os.path.join(self.cache_path, self.name + '_gt_roidb.pkl')
        if os.path.exists(cache_file):
            with open(cache_file, 'rb') as fid:
                roidb = cPickle.load(fid)
            print '{} gt roidb loaded from {}'.format(self.name, cache_file)
            return roidb

        gt_roidb = [self._load_pascal_annotation(index)
                    for index in self.image_index]
        with open(cache_file, 'wb') as fid:
            cPickle.dump(gt_roidb, fid, cPickle.HIGHEST_PROTOCOL)
        print 'wrote gt roidb to {}'.format(cache_file)

        return gt_roidb
 这个函数是pascal_voc对象的核心函数之一,它将返回roidb数据对象。
 首先它会在cache路径下找到以扩展名’.pkl’结尾的缓存,这个文件是通过cPickle工具将roidb序列化存储的。如果该文件存在,那么它会先读取这里的内容,以提高效率(所以如果你换数据集的时候,要先把cache文件给删除,否则会造成错误)。否则它将调用 _load _pascal _annotation这个私有函数加载roidb中的数据,并将其保存在缓存文件中,返回roidb。
def _load_pascal_annotation(self, index):
        """
        Load image and bounding boxes info from XML file in the PASCAL VOC
        format.
        """
        filename = os.path.join(self._data_path, 'Annotations', index + '.xml')
        tree = ET.parse(filename)
        objs = tree.findall('object')
        if not self.config['use_diff']:
            # Exclude the samples labeled as difficult
            non_diff_objs = [
                obj for obj in objs if int(obj.find('difficult').text) == 0]
            # if len(non_diff_objs) != len(objs):
            #     print 'Removed {} difficult objects'.format(
            #         len(objs) - len(non_diff_objs))
            objs = non_diff_objs
        num_objs = len(objs)

        boxes = np.zeros((num_objs, 4), dtype=np.uint16)
        gt_classes = np.zeros((num_objs), dtype=np.int32)
        overlaps = np.zeros((num_objs, self.num_classes), dtype=np.float32)
        # "Seg" area for pascal is just the box area
        seg_areas = np.zeros((num_objs), dtype=np.float32)

        # Load object bounding boxes into a data frame.
        for ix, obj in enumerate(objs):
            bbox = obj.find('bndbox')
            # Make pixel indexes 0-based
            x1 = float(bbox.find('xmin').text) - 1
            y1 = float(bbox.find('ymin').text) - 1
            x2 = float(bbox.find('xmax').text) - 1
            y2 = float(bbox.find('ymax').text) - 1
            cls = self._class_to_ind[obj.find('name').text.lower().strip()]
            boxes[ix, :] = [x1, y1, x2, y2]
            gt_classes[ix] = cls
            overlaps[ix, cls] = 1.0
            seg_areas[ix] = (x2 - x1 + 1) * (y2 - y1 + 1)

        overlaps = scipy.sparse.csr_matrix(overlaps)

        return {'boxes' : boxes,
                'gt_classes': gt_classes,
                'gt_overlaps' : overlaps,
                'flipped' : False,
                'seg_areas' : seg_areas}
该函数根据每个图像的索引,到Annotations这个文件夹下去找相应的xml标注数据,然后加载所有的bounding box对象,并去除所有的“复杂”对象。
xml的解析到此结束,接下来是roidb中的几个类成员的赋值:

  •   boxes 一个二维数组   每一行存储 xmin ymin xmax ymax ,行指的多个box的序号
  •   gt_classes存储了每个box所对应的类索引(类数组在初始化函数中声明)
  •   overlap是一个二维数组,行指box的序号,列共有21列,存储的是0.0或者1.0 ,当box对应的类别时,自然为1.0.这实际上是指对于ground truth box,由于这里的候选框  就是ground truth box,所以自然重叠后为1,而与其他的自然重叠设为0.后来被转成了稀疏矩阵
  •  seg _areas存储着 box的面积
  •  flipped 为false 代表该图片还未被翻转(后来在train.py里会将翻转的图片加进去,用该变量用于区分)
 最后将这些成员变量组装成roidb返回.  总的来说rpn初始阶段载入的roidb是groundtruth box的情况,而且指的是所有图片。
fast rcnn: 

def rpn_roidb(self):
        if int(self._year) == 2007 or self._image_set != 'test':
            gt_roidb = self.gt_roidb()
            rpn_roidb = self._load_rpn_roidb(gt_roidb)
            roidb = imdb.merge_roidbs(gt_roidb, rpn_roidb)
        else:
            roidb = self._load_rpn_roidb(None)

        return roidb

    def _load_rpn_roidb(self, gt_roidb):
        filename = self.config['rpn_file']
        print 'loading {}'.format(filename)
        assert os.path.exists(filename), \
               'rpn data not found at: {}'.format(filename)
        with open(filename, 'rb') as f:
            box_list = cPickle.load(f)
        return self.create_roidb_from_box_list(box_list, gt_roidb)
在经过RPN网络产生了proposal以后,这个函数作用是将这些proposal 的 roi与groudtruth结合起来,变成rpn_roidb.
最后用merge _roidbs将gt_roidb与rpn _roidb合并,输出
载入rpn_roidb的过程首先需要获得rpn的proposal,然后再进行处理。下面看create_roidb_from_box_list
def create_roidb_from_box_list(self, box_list, gt_roidb):
        assert len(box_list) == self.num_images, \
                'Number of boxes must match number of ground-truth images'  # box_list是一个数组,每个元素是一个列表,每个列表指一幅图像中含有的盒子个数
        roidb = []
        for i in xrange(self.num_images):
            boxes = box_list[i]
            num_boxes = boxes.shape[0] # 行为盒子序号,列为盒子坐标 
            overlaps = np.zeros((num_boxes, self.num_classes), dtype=np.float32)

            if gt_roidb is not None and gt_roidb[i]['boxes'].size > 0:
                gt_boxes = gt_roidb[i]['boxes']
                gt_classes = gt_roidb[i]['gt_classes']
                gt_overlaps = bbox_overlaps(boxes.astype(np.float),
                                            gt_boxes.astype(np.float)) 
                argmaxes = gt_overlaps.argmax(axis=1)
                maxes = gt_overlaps.max(axis=1)
                I = np.where(maxes > 0)[0]
                overlaps[I, gt_classes[argmaxes[I]]] = maxes[I]

            overlaps = scipy.sparse.csr_matrix(overlaps)
            roidb.append({
                'boxes' : boxes,
                'gt_classes' : np.zeros((num_boxes,), dtype=np.int32), #为0
                'gt_overlaps' : overlaps,     
                'flipped' : False,
                'seg_areas' : np.zeros((num_boxes,), dtype=np.float32),
            })
        return roidb
 box_list是一个数组,每个元素是一个列表,每个列表指一幅图像中含有的盒子 。gt_roidb自然是rpn训练阶段获得的ground truth 盒子的情况。

 bbox_overlaps:每个proposal的box都与groud-truth的box做一次重合度计算,与anchor _target _layer.py中类似
  overlap = (重合部分面积) / (proposal _box面积 + gt_boxes面积 - 重合部分面积)
 对于每个proposal,选出最大的那个gt _boxes的值所对应的类别,然后填写相应地重叠值,到相应的class index下。

这里fast rcnn生成的roidb,结构与rpn的相同。而gt_overlaps如下:

         0 (背景类)   1      2      。。。。  21
1        0     		0.8    0                 0
2        0     		0      0.6               0
3        0   		0      0                 0   (全0,为背景)
;       ..............................................
n        0    		0      0                 0.8

横坐标是盒子的序号,纵坐标是种类。这里需要知道的是对于每一个盒子,我们记录它的重叠度,考虑是与某一种类的重叠度,而没有记录下与某个ground truth box的重叠度。有可能出现这样的情况,某个图片含有两个猫,而一个候选框与这两只猫的ground truth box的重叠度相同,且最大。那么我们没有必要记住与哪个猫重叠度最大,而只需要知道是与猫重叠度最大。因为这里重叠度仅仅是用来与阈值做比较的。排除掉某些低前景的box. 后面进行box的回归也会出现类似的情况。待后续。

#将一般是两个roidb堆叠在一起,进行合并。
    @staticmethod
    def merge_roidbs(a, b):
        assert len(a) == len(b)
        for i in xrange(len(a)):
            a[i]['boxes'] = np.vstack((a[i]['boxes'], b[i]['boxes'])) # 竖着堆叠
            a[i]['gt_classes'] = np.hstack((a[i]['gt_classes'],          # 横着拉长
                                            b[i]['gt_classes']))
            a[i]['gt_overlaps'] = scipy.sparse.vstack([a[i]['gt_overlaps'],b[i]['gt_overlaps']]) #竖着堆叠
            a[i]['seg_areas'] = np.hstack((a[i]['seg_areas'],
                                           b[i]['seg_areas']))
        return a
最后fast rcnn在训练阶段返回的是含有ground truth box与proposal box的roidb的信息,在测试时仅返回proposal box的roidb的信息。这里参与计算的一定是所有rpn阶段提取的proposals.

get_roidb 中还有最后一步:get_training_roidb。参考http://blog.csdn.net/xiamentingtao/article/details/78449751  ,

对于生成的roidb新增了一些属性。形成了如下信息:


接下来我们再看train_net,他们在train.py中。该程序封装了一个Solver,并且定义了snapshot.并且这里生成了box对应的回归目标。下面我们仔细分析。

def train_net(solver_prototxt, roidb, output_dir,
              pretrained_model=None, max_iters=40000):
    """Train a Fast R-CNN network."""  # 其实还有rpn

    roidb = filter_roidb(roidb)
    sw = SolverWrapper(solver_prototxt, roidb, output_dir,
                       pretrained_model=pretrained_model)

    print 'Solving...'
    model_paths = sw.train_model(max_iters)
    print 'done solving'
    return model_paths
首先过滤掉一些box。

def filter_roidb(roidb):
    """Remove roidb entries that have no usable RoIs."""

    def is_valid(entry): # entry是指一幅图片
        # Valid images have:
        #   (1) At least one foreground RoI OR
        #   (2) At least one background RoI
        overlaps = entry['max_overlaps']
        # find boxes with sufficient overlap
        fg_inds = np.where(overlaps >= cfg.TRAIN.FG_THRESH)[0] #返回所有满足条件的序号列表
        # Select background RoIs as those within [BG_THRESH_LO, BG_THRESH_HI)
        bg_inds = np.where((overlaps < cfg.TRAIN.BG_THRESH_HI) &
                           (overlaps >= cfg.TRAIN.BG_THRESH_LO))[0]
        # image is only valid if such boxes exist
        valid = len(fg_inds) > 0 or len(bg_inds) > 0
        return valid

    num = len(roidb)
    filtered_roidb = [entry for entry in roidb if is_valid(entry)]
    num_after = len(filtered_roidb)
    print 'Filtered {} roidb entries: {} -> {}'.format(num - num_after,
                                                       num, num_after)
    return filtered_roidb
该函数中定义了一个is_valid函数,用于判断roidb中的每个entry(图片)是否合理,合 理定义为至少有一个前景box或背景box。 
对于 rpn,  roidb全是groudtruth时,因为box与对应的类的重合度(overlaps)显然为1,所以不会过滤掉。
如果roidb包含了一些proposal,overlaps在[BG_THRESH_LO, BG_THRESH_HI]之间的都将被认为是背景,大于FG_THRESH才被认为是前景,roidb 至少要有一个前景或背景,否则将被过滤掉。 当然了对于fast rcnn的训练阶段由于包含了ground truth box,自然也不会过滤掉。对于测试阶段就不一定了。其实也很显然,如果都包含了ground truth,自然是应该可以拿来训练的。  (感觉这个函数似乎没用~~~
将没用的roidb过滤掉以后,返回的就是filtered_roidb
接下来在train_net中定义了一个SolverWrapper对象sw,在对象的初始化过程中包含回归目标的求解。

class SolverWrapper(object):
    """A simple wrapper around Caffe's solver.
    This wrapper gives us control over he snapshotting process, which we
    use to unnormalize the learned bounding-box regression weights.
    """

    def __init__(self, solver_prototxt, roidb, output_dir,
                 pretrained_model=None):
        """Initialize the SolverWrapper."""
        self.output_dir = output_dir

        if (cfg.TRAIN.HAS_RPN and cfg.TRAIN.BBOX_REG and
            cfg.TRAIN.BBOX_NORMALIZE_TARGETS):
            # RPN can only use precomputed normalization because there are no
            # fixed statistics to compute a priori
            assert cfg.TRAIN.BBOX_NORMALIZE_TARGETS_PRECOMPUTED
# 计算box回归目标,并且返回各类的偏移均值和方差,
        if cfg.TRAIN.BBOX_REG:
            print 'Computing bounding-box regression targets...'
            self.bbox_means, self.bbox_stds = \
                    rdl_roidb.add_bbox_regression_targets(roidb)
            print 'done'

        self.solver = caffe.SGDSolver(solver_prototxt)
# 预训练参数写入
        if pretrained_model is not None:
            print ('Loading pretrained model '
                   'weights from {:s}').format(pretrained_model)
            self.solver.net.copy_from(pretrained_model)

        self.solver_param = caffe_pb2.SolverParameter()
        with open(solver_prototxt, 'rt') as f:
            pb2.text_format.Merge(f.read(), self.solver_param)
#所有的前面的数据准备工作都是为了这一句话,将roidb设置进去,接下来就正式进入剖析训练过程的部分了。
        self.solver.net.layers[0].set_roidb(roidb)
首先对于rpn来说,cfg.TRAIN.BBOX_REG=false,因此不需要计算各类的偏移均值和方差。这是必然的,因为rpn刚开始是没有anchor的,只有图片和groundtruth box,自然就不需要计算回归目标了,而在fast rcnn阶段才需要。所以如下的操作是针对在rpn提取proposal形成的roidb操作的。而且根据config.py的

设置:

__C.TRAIN.BBOX_NORMALIZE_TARGETS = True
# Deprecated (inside weights)
__C.TRAIN.BBOX_INSIDE_WEIGHTS = (1.0, 1.0, 1.0, 1.0)
# Normalize the targets using "precomputed" (or made up) means and stdevs
# (BBOX_NORMALIZE_TARGETS must also be True)
__C.TRAIN.BBOX_NORMALIZE_TARGETS_PRECOMPUTED = False
__C.TRAIN.BBOX_NORMALIZE_MEANS = (0.0, 0.0, 0.0, 0.0)
__C.TRAIN.BBOX_NORMALIZE_STDS = (0.1, 0.1, 0.2, 0.2)

我们看到其实总的来说有设置归一化,但是由于rpn时cfg.TRAIN.BBOX_REG=false,所以对于rpn阶段,不进行归一化。只有在fast rcnn阶段才进行。

(啰嗦一点,不知道清楚没?)

def add_bbox_regression_targets(roidb):
    """Add information needed to train bounding-box regressors."""
    assert len(roidb) > 0
    assert 'max_classes' in roidb[0], 'Did you call prepare_roidb first?'

    num_images = len(roidb)#这里的个数是rpn提取的所有proposal的个数
    # Infer number of classes from the number of columns in gt_overlaps
    num_classes = roidb[0]['gt_overlaps'].shape[1]
    for im_i in xrange(num_images):
        rois = roidb[im_i]['boxes']
        max_overlaps = roidb[im_i]['max_overlaps']
        max_classes = roidb[im_i]['max_classes']
        roidb[im_i]['bbox_targets'] = \
                _compute_targets(rois, max_overlaps, max_classes)

    if cfg.TRAIN.BBOX_NORMALIZE_TARGETS_PRECOMPUTED:
        # Use fixed / precomputed "means" and "stds" instead of empirical values
        means = np.tile(
                np.array(cfg.TRAIN.BBOX_NORMALIZE_MEANS), (num_classes, 1))
        stds = np.tile(
                np.array(cfg.TRAIN.BBOX_NORMALIZE_STDS), (num_classes, 1))
    else:
        # Compute values needed for means and stds
        # var(x) = E(x^2) - E(x)^2
        class_counts = np.zeros((num_classes, 1)) + cfg.EPS
        sums = np.zeros((num_classes, 4))
        squared_sums = np.zeros((num_classes, 4))
        for im_i in xrange(num_images):
            targets = roidb[im_i]['bbox_targets']
            for cls in xrange(1, num_classes):
                cls_inds = np.where(targets[:, 0] == cls)[0]
                if cls_inds.size > 0:
                    class_counts[cls] += cls_inds.size
                    sums[cls, :] += targets[cls_inds, 1:].sum(axis=0)
                    squared_sums[cls, :] += \
                            (targets[cls_inds, 1:] ** 2).sum(axis=0)

        means = sums / class_counts
        stds = np.sqrt(squared_sums / class_counts - means ** 2)

    print 'bbox target means:'
    print means
    print means[1:, :].mean(axis=0) # ignore bg class
    print 'bbox target stdevs:'
    print stds
    print stds[1:, :].mean(axis=0) # ignore bg class

    # Normalize targets
    if cfg.TRAIN.BBOX_NORMALIZE_TARGETS:
        print "Normalizing targets"
        for im_i in xrange(num_images):
            targets = roidb[im_i]['bbox_targets']
            for cls in xrange(1, num_classes):
                cls_inds = np.where(targets[:, 0] == cls)[0]
                roidb[im_i]['bbox_targets'][cls_inds, 1:] -= means[cls, :]
                roidb[im_i]['bbox_targets'][cls_inds, 1:] /= stds[cls, :]
    else:
        print "NOT normalizing targets"

    # These values will be needed for making predictions
    # (the predicts will need to be unnormalized and uncentered)
    return means.ravel(), stds.ravel()# 返回的是铺平后的向量,也就是由21*4变成了1*(21*4)=1*84

这个函数首先计算了bbox_targets,为roidb增加了一个key:bbox_targets,主要通过函数_compute_targets来实现。而后面则利用rpn阶段提取的所有box的bbox_targets分别计算了各类的偏移均值和方差,shape是num_classes*4,(由于参与计算均值和方差的box显然个数很多,所以大部分的类均应该都可以计算出均值和方差,唯独强调的是这里的box也有可能是

背景,但是我们这里不计算背景类,所以means,和stds的第一行为(0,0,0,0)。

然后使用计算出的均值和方差对bbox_targets进行了归一化。最后返回铺平后的均值和方差。shape也就是由21*4变成了1*(21*4)=1*84

下面我们来看_compute_targets。

这个函数用来计算一张图片的所有box的回归信息。这将直接应用于在后面的回归损失计算。

def _compute_targets(rois, overlaps, labels):  # 参数rois只含有当前图片的box信息
    """Compute bounding-box regression targets for an image."""
    # Indices目录 of ground-truth ROIs
    # ground-truth ROIs
    gt_inds = np.where(overlaps == 1)[0]
    if len(gt_inds) == 0:
        # Bail if the image has no ground-truth ROIs
        # 不存在gt ROI,返回空数组
        return np.zeros((rois.shape[0], 5), dtype=np.float32)
    # Indices of examples for which we try to make predictions
    # BBOX阈值,只有ROI与gt的重叠度大于阈值,这样的ROI才能用作bb回归的训练样本
    ex_inds = np.where(overlaps >= cfg.TRAIN.BBOX_THRESH)[0]

    # Get IoU overlap between each ex ROI and gt ROI
    # 计算ex ROI and gt ROI的IoU
    ex_gt_overlaps = bbox_overlaps(
        # 变数据格式为float
        np.ascontiguousarray(rois[ex_inds, :], dtype=np.float),
        np.ascontiguousarray(rois[gt_inds, :], dtype=np.float))

    # Find which gt ROI each ex ROI has max overlap with:
    # this will be the ex ROI's gt target
    # 这里每一行代表一个ex_roi,列代表gt_roi,元素数值代表两者的IoU
    gt_assignment = ex_gt_overlaps.argmax(axis=1) #按行求最大,返回索引.
    gt_rois = rois[gt_inds[gt_assignment], :]  #每个ex_roi对应的gt_rois,与下面ex_roi数量相同
    ex_rois = rois[ex_inds, :]

    targets = np.zeros((rois.shape[0], 5), dtype=np.float32)
    targets[ex_inds, 0] = labels[ex_inds]  #第一个元素是label
    targets[ex_inds, 1:] = bbox_transform(ex_rois, gt_rois)  #后4个元素是ex_box与gt_box的4个方位的偏移
    return targets

根据前面,在fast rcnn中准备roidb时,已经包含了rpn阶段提取的proposal与ground truth box.而groundtruth roidb的overlaps=1,所以我们可以轻松找到所有的ground truth box.

整个过程怎么找每个box对应的ground truth box呢?实际上就是重新计算了每个box对ground truth box的重合度,然后

寻找重合度最大的对应ground truth.,进而计算偏差,输出的是一个二维数组,横坐标是盒子的序号,纵坐标是5维,第一维是类别,第二维到第五维为偏移。

而且这里实际上所有的ground truth也都参与了与groundtruth box的重合度计算,自然自己与自己的重叠度最大,后面计算回归量时,他们的回归量正好都为0.因此整个

target非0的均是proposal的回归目标。

【注意:】这里参与计算target的是那些最大重叠度>阈值(0.5)的前景proposal.但是整个targets返回的shape却是n*5,其中n为rois的盒子个数,包括了所有的proposal与groundtruth box。没有计算的,target为0.
计算偏移可以参考文档:http://caffecn.cn/?/question/160 王斌_ICT 的pdf文件

这样得到的fast rcnn的roidb的情况如下:

roidb[img_index]包含的key, value
boxes box位置信息,box_num*4的np array (x1,y1,x2,y2)
gt_overlaps 所有box在不同类别的得分,box_num*class_num矩阵
gt_classes 所有box的真实类别,box_num长度的list
flipped 是否翻转
 image 该图片的路径,字符串
width 图片的宽
height  图片的高
max_overlaps 每个box的在所有类别的得分最大值,box_num长度
max_classes 每个box的得分最高所对应的类,box_num长度
bbox_targets 每个box的类别,以及与最接近的gt-box的4个方位偏移
(共5列)(c,tx,ty,tw,th)


接下来预训练的imagenet的参数写入,并且将准备好的roidb送入网络的第一层。 调用layer.py中的set_roidb方法,为网络的第一层(RoIDataLayer)设置roidb同时打乱顺序
这样做是必然的,毕竟类imdb或者pascal_voc的实例中的roidb必须要传到layer中,网络才能继续向前传播;
在RoIDataLayer的foward方法中,就是将RoIDataLayer实例的_roidb拷贝给RoIDataLayer的top blob。

最后我们再来看一下数据准备的最后一步,也就是layer.py的RoIDataLayer类。 明确这里我们向网络层输入的roidb是所有的图片的roidb,且看它如何批处理。

对于rpn,网络的第一层为:

layer {
  name: 'input-data'
  type: 'Python'
  top: 'data'
  top: 'im_info'
  top: 'gt_boxes'
  python_param {
    module: 'roi_data_layer.layer'
    layer: 'RoIDataLayer'
    param_str: "'num_classes': 21"
  }
}
对于fast rcnn,网络的第一层为:

layer {
  name: 'data'
  type: 'Python'
  top: 'data'
  top: 'rois'
  top: 'labels'
  top: 'bbox_targets'
  top: 'bbox_inside_weights'
  top: 'bbox_outside_weights'
  python_param {
    module: 'roi_data_layer.layer'
    layer: 'RoIDataLayer'
    param_str: "'num_classes': 21"
  }
}
首先看set_roidb。
def set_roidb(self, roidb):
        """Set the roidb to be used by this layer during training."""
        self._roidb = roidb
        self._shuffle_roidb_inds()
        if cfg.TRAIN.USE_PREFETCH:
            self._blob_queue = Queue(10)
            self._prefetch_process = BlobFetcher(self._blob_queue,
                                                 self._roidb,
                                                 self._num_classes)
            self._prefetch_process.start()
            # Terminate the child process when the parent exists
            def cleanup():
                print 'Terminating BlobFetcher'
                self._prefetch_process.terminate()
                self._prefetch_process.join()
            import atexit
            atexit.register(cleanup)

首先载入roidb,然后将roidb中长宽比近似的图像放在一起(其实也就2种情况,扁的还是竖的),有利于计算速度,并且随后随机打乱roidbs。至于后面的USE_PREFETCH,config.py设为false,可以先忽略它。

我们接下来重要的是看setup,它将设置批次处理的规模。

  

def setup(self, bottom, top):
        """Setup the RoIDataLayer."""


        # parse the layer parameter string, which must be valid YAML
        layer_params = yaml.load(self.param_str_)


        self._num_classes = layer_params['num_classes']


        self._name_to_top_map = {}


        # data blob: holds a batch of N images, each with 3 channels
        idx = 0
        top[idx].reshape(cfg.TRAIN.IMS_PER_BATCH, 3,         # 对于rpn,data的规模为1*3*600*1000 ,对于fast rcnn,2*3*600*1000
            max(cfg.TRAIN.SCALES), cfg.TRAIN.MAX_SIZE)
        self._name_to_top_map['data'] = idx
        idx += 1


        if cfg.TRAIN.HAS_RPN:  # 对于rpn设置
            top[idx].reshape(1, 3)
            self._name_to_top_map['im_info'] = idx  # 设置im_info每行的规模是1*3,后面可以看到为(h,w,scale)
            idx += 1


            top[idx].reshape(1, 4)     
            self._name_to_top_map['gt_boxes'] = idx  #设置gt_boxes每行的规模是1*4 
            idx += 1
        else: # not using RPN  #对于fast rcnn设置
            # rois blob: holds R regions of interest, each is a 5-tuple
            # (n, x1, y1, x2, y2) specifying an image batch index n and a
            # rectangle (x1, y1, x2, y2)
            top[idx].reshape(1, 5)     # 设置rois每行的规模是1*5,(n, x1, y1, x2, y2) ,n是图片的序号,后面是矩形的坐标
            self._name_to_top_map['rois'] = idx 
            idx += 1


            # labels blob: R categorical labels in [0, ..., K] for K foreground
            # classes plus background
            top[idx].reshape(1)
            self._name_to_top_map['labels'] = idx  #设置labels每行的规模是1,分别取自[0, ..., K],0为背景,其他是前景
            idx += 1


            if cfg.TRAIN.BBOX_REG: # 同样对于fast rcnn,默认设为true
                # bbox_targets blob: R bounding-box regression targets with 4
                # targets per class
                top[idx].reshape(1, self._num_classes * 4)     #设置bbox_targets每行的规模是1*(_num_classes * 4),也即是1*84
                self._name_to_top_map['bbox_targets'] = idx
                idx += 1


                # bbox_inside_weights blob: At most 4 targets per roi are active;
                # thisbinary vector sepcifies the subset of active targets
                top[idx].reshape(1, self._num_classes * 4)
                self._name_to_top_map['bbox_inside_weights'] = idx #设置bbox_inside_weights每行的规模是1*(_num_classes * 4),也即是1*84
                idx += 1


                top[idx].reshape(1, self._num_classes * 4)     #bbox_outside_weights每行的规模是1*(_num_classes * 4),也即是1*84
                self._name_to_top_map['bbox_outside_weights'] = idx
                idx += 1


        print 'RoiDataLayer: name_to_top:', self._name_to_top_map
        assert len(top) == len(self._name_to_top_map)

在这里设置了批次处理的数据规模以及各个top的shape大小。对于rpn,每次处理一张图片,对于fast rcnn,一次处理两张图片。   (  观察 cfg.TRAIN.IMS_PER_BATCH 的大小)

下面我们来看forward,这才开始真正的数据传递。其实我们这时候发现其实在roidb中并没有存储图片的像素值,而只有到了这一步才开始正式读取图片的像素值。

  def forward(self, bottom, top):
        """Get blobs and copy them into this layer's top blob vector."""
        blobs = self._get_next_minibatch()

        for blob_name, blob in blobs.iteritems():
            top_ind = self._name_to_top_map[blob_name]
            # Reshape net's input blobs
            top[top_ind].reshape(*(blob.shape))
            # Copy data into net's input blobs
            top[top_ind].data[...] = blob.astype(np.float32, copy=False)

首先 通过blobs = self._get_next_minibatch()获取一个批次的blob。

 def _get_next_minibatch(self):
        """Return the blobs to be used for the next minibatch.

        If cfg.TRAIN.USE_PREFETCH is True, then blobs will be computed in a
        separate process and made available through self._blob_queue.
        """
        if cfg.TRAIN.USE_PREFETCH:
            return self._blob_queue.get()
        else:
            db_inds = self._get_next_minibatch_inds() #这里包含了一个批次的图片个数
            minibatch_db = [self._roidb[i] for i in db_inds]
            return get_minibatch(minibatch_db, self._num_classes)
下面我们看一下这个函数:
def _get_next_minibatch_inds(self):
        """Return the roidb indices for the next minibatch."""
        if self._cur + cfg.TRAIN.IMS_PER_BATCH >= len(self._roidb):
            self._shuffle_roidb_inds()

        db_inds = self._perm[self._cur:self._cur + cfg.TRAIN.IMS_PER_BATCH]
        self._cur += cfg.TRAIN.IMS_PER_BATCH
        return db_inds

self._cur在打乱roidb排序后设为0,代表当前的图片序号。 这个函数读取一个批次的图片的序号,并返回,并且设置了下一次的起始图片序号( self._cur)

当训练多次,所有的图片都训练完了,将会打乱所有的图片的排序,重新提取序号。这里一个roidb就是代表一张图片。所以有时候会将二者不加区别。

这时一个批次的数据序号准备好了,就可以读取像素值了。且看get_minibatch。这时我们跳到《Faster RCNN minibatch.py解读


总的来说,对于一个minibatch的训练样本来说,这里的所有top都存储了一批量roi的信息(指的是__C.TRAIN.BATCH_SIZE = 128),其中前景与背景box的比为1:3,对于某些符合要求的前景box进行了相应地计算,尤其是回归目标,选出的前景图像除ground truth box以外都是有的,背景类显然没有(也就是全为0)。存储的blob的各key的规模可以参考setup.

最后参与运算的都在bbox_targets ,bbox_inside_weights ,bbox_outside_weights中体现出来(即非0项)。


接下来就是数据的拷贝。至此数据的准备工作结束。数据流的第一层输入完毕。



这里有一个小小的疑问:

1. 在setup中,gt_boxes的规模为1*4,而在_get_next_minibatch返回的blobs中,gt_boxes为1*5,(x1,y1,x2,y2,c).有点矛盾啊?

  



阅读更多
版权声明:本文为博主原创文章,转载请注明原地址。 https://blog.csdn.net/xiamentingtao/article/details/78473105
个人分类: 深度学习
想对作者说点什么? 我来说一句

没有更多推荐了,返回首页

不良信息举报

faster rcnn学习之rpn、fast rcnn数据准备说明

最多只允许输入30个字

加入CSDN,享受更精准的内容推荐,与500万程序员共同成长!
关闭
关闭