Faster RCNN pascal_voc.py

主要定义了一个pascal_voc类，在类的内部定义了它的一些属性和方法。

def _init_(self, image_set, year, devkit_path=None) 构造器方法

def __init__(self, image_set, year, devkit_path=None):
imdb.__init__(self, 'voc_' + year + '_' + image_set)
self._year = year
self._image_set = image_set
# print '~~~~~~~~~~~~~~~~~~~PASCAL_VOC OBJECT _image_set: {}'.format(self._image_set) # trainval
self._devkit_path = self._get_default_path() if devkit_path is None \
else devkit_path
self._data_path = os.path.join(self._devkit_path, 'VOC' + self._year)
self._classes = ('__background__', # always index 0
'aeroplane', 'bicycle', 'bird', 'boat',
'bottle', 'bus', 'car', 'cat', 'chair',
'cow', 'diningtable', 'dog', 'horse',
'motorbike', 'person', 'pottedplant',
'sheep', 'sofa', 'train', 'tvmonitor')
self._class_to_ind = dict(zip(self.classes, xrange(self.num_classes)))
self._image_ext = '.jpg'
self._image_index = self._load_image_set_index()
# Default to roidb handler
# self.selective_search_roidb是一个函数对象，把这个函数对象付给_roidb_handler属性
self._roidb_handler = self.selective_search_roidb
self._salt = str(uuid.uuid4())
self._comp_id = 'comp4'

# PASCAL specific config options
self.config = {'cleanup'     : True,
'use_salt'    : True,
'use_diff'    : False,
'matlab_eval' : False,
'rpn_file'    : None,
'min_size'    : 2}

assert os.path.exists(self._devkit_path), \
'VOCdevkit path does not exist: {}'.format(self._devkit_path)
assert os.path.exists(self._data_path), \
'Path does not exist: {}'.format(self._data_path)

def gt_roidb(self) 以’gt’ 方法生成roidb 。其中会调用_load_pascal_annotation方法从下载的数据文件annotation中载入图像的ground-truth信息。

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

def _load_pascal_annotation(self, index) 从XML文件载入图像信息，而且是ground-truth信息，比如boxes

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为 num_objs * K 的数组， K表示总共的类别数， num_objs表示当前这张图片中box的个数
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
# 从anatation直接载入图像的信息，因为本身就是ground-truth , 所以overlap直接设为1
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}

def rpn_roidb(self)： 以‘rpn’ 方法生成roidb。先调用gt_roidb生成gt_roidb, 然后调用_load_rpn_roidb载入rpn_roidb， 最后调用其父类的静态方法imdb.merge_roidbs将两者合并，即对于最后生成的roidb中每一张图像中，即包含gt_roidb中的box等信息，也包含rpn_roidb 中的box等信息。

def rpn_roidb(self):
if int(self._year) == 2007 or self._image_set != 'test':
gt_roidb = self.gt_roidb()
# 求取rpn_roidb需要以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) 调用父类方法create_roidb_from_box_list 从box_list 中读取每张图像的boxes

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:
# 读取rpn_file里的box，形成box_list; box_list为一个列表，每张图像对应其中的一个元素，
# 所以box_list 的大小要与gt_roidb 相同
box_list = cPickle.load(f)
return self.create_roidb_from_box_list(box_list, gt_roidb)

def create_roidb_from_box_list(self, box_list, gt_roidb)： 从box_list 中读取每张图像的boxes

def create_roidb_from_box_list(self, box_list, gt_roidb):

# box_list 的大小要与gt_roidb 相同， 并且各图像一一对应
assert len(box_list) == self.num_images, \
'Number of boxes must match number of ground-truth images'
roidb = []
for i in xrange(self.num_images):
# 遍历每张图像， 当前图像中box的个数
boxes = box_list[i]
# 当前这张图像中的box个数
num_boxes = boxes.shape[0]
# overlaps的shape始终为：num_boxes × num_classes 。
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']
# 计算当前图像的rpn_file中记录的boxes与gtboxes的IOU overlap， 返回的gt_overlaps的
#shape为 num_boxes × num_gtboxes， 后面要对gt_overlaps求max和argmax
gt_overlaps = bbox_overlaps(boxes.astype(np.float),
gt_boxes.astype(np.float))
# 对gt_overlaps 求argmax 和 max
argmaxes = gt_overlaps.argmax(axis=1)
maxes = gt_overlaps.max(axis=1)
# 返回 maxes > 0的位置信息
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 为一个全0一维数组（这是为什么？？？？）
'gt_classes' : np.zeros((num_boxes,), dtype=np.int32),
# 最终还是将shape为num_boxes × num_classes 的数组进行存储， 所以，以‘rpn’方法生成的
#rpn_roidb中的gt_overlaps是rpn_file中的box与gt_roidb中box的overlap，而不像
#gt_roidb()方法生成的gt_roidb中的gt_overlaps全部为1.0
'gt_overlaps' : overlaps,
'flipped' : False,
'seg_areas' : np.zeros((num_boxes,), dtype=np.float32),
})
return roidb