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 boxescfg.TRAIN.HAS_RPN = Truecfg.TRAIN.BBOX_REG = False  # applies only to Fast R-CNN bbox regressioncfg.TRAIN.PROPOSAL_METHOD = 'gt'cfg.TRAIN.IMS_PER_BATCH = 1print '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 modelfor i in model_paths[:-1]:os.remove(i)rpn_model_path = model_paths[-1]# Send final model path through the multiprocessing queuequeue.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-flycfg.TRAIN.PROPOSAL_METHOD = 'rpn'   # use pre-computed RPN proposals insteadcfg.TRAIN.IMS_PER_BATCH = 2print '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-CNNmodel_paths = train_net(solver, roidb, output_dir,pretrained_model=init_model,max_iters=max_iters)# Cleanup all but the final modelfor i in model_paths[:-1]:os.remove(i)fast_rcnn_model_path = model_paths[-1]# Send Fast R-CNN model path over the multiprocessing queuequeue.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_fileroidb = 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 roidbgt_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 VOCformat."""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 difficultnon_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_objsnum_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 areaseg_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-basedx1 = float(bbox.find('xmin').text) - 1y1 = float(bbox.find('ymin').text) - 1x2 = float(bbox.find('xmax').text) - 1y2 = float(bbox.find('ymax').text) - 1cls = self._class_to_ind[obj.find('name').text.lower().strip()]boxes[ix, :] = [x1, y1, x2, y2]gt_classes[ix] = clsoverlaps[ix, cls] = 1.0seg_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 roidbdef _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堆叠在一起，进行合并。@staticmethoddef 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."""  # 其实还有rpnroidb = 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 RoIoverlaps = entry['max_overlaps']# find boxes with sufficient overlapfg_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 existvalid = len(fg_inds) > 0 or len(bg_inds) > 0return validnum = 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 weuse 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_dirif (cfg.TRAIN.HAS_RPN and cfg.TRAIN.BBOX_REG andcfg.TRAIN.BBOX_NORMALIZE_TARGETS):# RPN can only use precomputed normalization because there are no# fixed statistics to compute a prioriassert 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) > 0assert '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_overlapsnum_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 valuesmeans = 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)^2class_counts = np.zeros((num_classes, 1)) + cfg.EPSsums = 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.sizesums[cls, :] += targets[cls_inds, 1:].sum(axis=0)squared_sums[cls, :] += \(targets[cls_inds, 1:] ** 2).sum(axis=0)means = sums / class_countsstds = np.sqrt(squared_sums / class_counts - means ** 2)print 'bbox target means:'print meansprint means[1:, :].mean(axis=0) # ignore bg classprint 'bbox target stdevs:'print stdsprint stds[1:, :].mean(axis=0) # ignore bg class# Normalize targetsif 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 ROIsgt_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的IoUex_gt_overlaps = bbox_overlaps(# 变数据格式为floatnp.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,元素数值代表两者的IoUgt_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]  #第一个元素是labeltargets[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 = roidbself._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 existsdef cleanup():print 'Terminating BlobFetcher'self._prefetch_process.terminate()self._prefetch_process.join()import atexitatexit.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 YAMLlayer_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 channelsidx = 0top[idx].reshape(cfg.TRAIN.IMS_PER_BATCH, 3,         # 对于rpn，data的规模为1*3*600*1000 ，对于fast rcnn，2*3*600*1000max(cfg.TRAIN.SCALES), cfg.TRAIN.MAX_SIZE)self._name_to_top_map['data'] = idxidx += 1if 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 += 1top[idx].reshape(1, 4)     self._name_to_top_map['gt_boxes'] = idx  #设置gt_boxes每行的规模是1*4 idx += 1else: # 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 backgroundtop[idx].reshape(1)self._name_to_top_map['labels'] = idx  #设置labels每行的规模是1，分别取自[0, ..., K]，0为背景，其他是前景idx += 1if cfg.TRAIN.BBOX_REG: # 同样对于fast rcnn，默认设为true# bbox_targets blob: R bounding-box regression targets with 4# targets per classtop[idx].reshape(1, self._num_classes * 4)     #设置bbox_targets每行的规模是1*（_num_classes * 4），也即是1*84self._name_to_top_map['bbox_targets'] = idxidx += 1# bbox_inside_weights blob: At most 4 targets per roi are active;# thisbinary vector sepcifies the subset of active targetstop[idx].reshape(1, self._num_classes * 4)self._name_to_top_map['bbox_inside_weights'] = idx #设置bbox_inside_weights每行的规模是1*（_num_classes * 4），也即是1*84idx += 1top[idx].reshape(1, self._num_classes * 4)     #bbox_outside_weights每行的规模是1*（_num_classes * 4），也即是1*84self._name_to_top_map['bbox_outside_weights'] = idxidx += 1print 'RoiDataLayer: name_to_top:', self._name_to_top_mapassert 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 blobstop[top_ind].reshape(*(blob.shape))# Copy data into net's input blobstop[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 aseparate 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_BATCHreturn 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）.有点矛盾啊？