Faster-RCNN Pytorch实现的minibatch包装

实际上faster-rcnn对于输入的图片是有resize操作的，在resize的图片基础上提取feature map，而后generate一定数量的RoI。

我想首先去掉这个resize的操作，对每张图都是在原始图片基础上进行识别，所以要找到它到底在哪里resize了图片。

直接搜 grep 'resize' ./lib/ -r

./lib/crnn/utils.py: v.data.resize_(data.size()).copy_(data)
./lib/model/config.py:# Option to set if max-pooling is appended after crop_and_resize.
./lib/model/config.py:# if true, the region will be resized to a square of 2xPOOLING_SIZE,
./lib/model/config.py:# resized to a square of POOLING_SIZE
./lib/model/test.py: im = cv2.resize(im_orig, None, None, fx=im_scale, fy=im_scale,
./lib/nets/network.py:from scipy.misc import imresize
./lib/nets/network.py: image = imresize(image[0], self._im_info[:2] / self._im_info[2])
./lib/utils/blob.py: im = cv2.resize(im, None, None, fx=im_scale, fy=im_scale,

这里在training过程中应当是调用了./lib/utils/blob.py，

该文件包含了两个函数：

 def im_list_to_blob(ims):
   """Convert a list of images into a network input.
   Assumes images are already prepared (means subtracted, BGR order, ...).
   """
   max_shape = np.array([im.shape for im in ims]).max(axis=0)
   num_images = len(ims)
   blob = np.zeros((num_images, max_shape[0], max_shape[1], 3),
                   dtype=np.float32)
   for i in range(num_images):
     im = ims[i]
     blob[i, 0:im.shape[0], 0:im.shape[1], :] = im

   return blob

 def prep_im_for_blob(im, pixel_means, target_size, max_size):
   """Mean subtract and scale an image for use in a blob."""
   im = im.astype(np.float32, copy=False)
   im -= pixel_means
   im_shape = im.shape
   im_size_min = np.min(im_shape[0:2])
   im_size_max = np.max(im_shape[0:2])
   im_scale = float(target_size) / float(im_size_min)
   # Prevent the biggest axis from being more than MAX_SIZE
   if np.round(im_scale * im_size_max) > max_size:
     im_scale = float(max_size) / float(im_size_max)
   im = cv2.resize(im, None, None, fx=im_scale, fy=im_scale,
                   interpolation=cv2.INTER_LINEAR)

   return im, im_scale

而这两个函数都是在./lib/roi_data_layer/minibatch.py 下被调用的。

而该文件也定义了两个函数，其中get_minibatch() 调用了另一个子函数_get_image_blob()。

 def get_minibatch(roidb, num_classes):
   """Given a roidb, construct a minibatch sampled from it."""
   num_images = len(roidb)
   # Sample random scales to use for each image in this batch
   random_scale_inds = npr.randint(0, high=len(cfg.TRAIN.SCALES),
                   size=num_images)
   assert(cfg.TRAIN.BATCH_SIZE % num_images == 0), \
     'num_images ({}) must divide BATCH_SIZE ({})'. \
     format(num_images, cfg.TRAIN.BATCH_SIZE)

   # Get the input image blob, formatted for caffe
   im_blob, im_scales = _get_image_blob(roidb, random_scale_inds)

   blobs = {'data': im_blob}

   assert len(im_scales) == 1, "Single batch only"
   assert len(roidb) == 1, "Single batch only"

   # gt boxes: (x1, y1, x2, y2, cls)
   if cfg.TRAIN.USE_ALL_GT:
     # Include all ground truth boxes
     gt_inds = np.where(roidb[0]['gt_classes'] != 0)[0]
   else:
     # For the COCO ground truth boxes, exclude the ones that are ''iscrowd''
     gt_inds = np.where(roidb[0]['gt_classes'] != 0 & np.all(roidb[0]['gt_overlaps'].toarray() > -1.0, axis=1))[0]
   gt_boxes = np.empty((len(gt_inds), 5), dtype=np.float32)
   gt_boxes[:, 0:4] = roidb[0]['boxes'][gt_inds, :] * im_scales[0]
   gt_boxes[:, 4] = roidb[0]['gt_classes'][gt_inds]
   blobs['gt_boxes'] = gt_boxes
   blobs['im_info'] = np.array(
     [im_blob.shape[1], im_blob.shape[2], im_scales[0]],
     dtype=np.float32)

   return blobs

 def _get_image_blob(roidb, scale_inds):
   """Builds an input blob from the images in the roidb at the specified
   scales.
   """
   num_images = len(roidb)
   processed_ims = []
   im_scales = []
   for i in range(num_images):
     im = cv2.imread(roidb[i]['image'])
     if roidb[i]['flipped']:
       im = im[:, ::-1, :]
     target_size = cfg.TRAIN.SCALES[scale_inds[i]]
     im, im_scale = prep_im_for_blob(im, cfg.PIXEL_MEANS, target_size,
                     cfg.TRAIN.MAX_SIZE)
     im_scales.append(im_scale)
     processed_ims.append(im)

   # Create a blob to hold the input images
   blob = im_list_to_blob(processed_ims)

   return blob, im_scales

get_minibatch()又是被./lib/roi_data_layer/layer.py中的类RoIDataLayer的一个方法forward()中调用的另一个方法_get_next_minibatch()调用的。

至此，由于RoIDataLayer类在类Network中被调用，终于把这些都接起来了。

faster-RCNN的代码实在是冗杂，来来回回定义了很多完全可以用一个函数实现的很多很多个函数。我佛了！