我们从Python开源项目中，提取了以下50个代码示例，用于说明如何使用fast_rcnn.config.cfg.IS_RPN。
def _get_next_minibatch_inds(self): """Return the roidb indices for the next minibatch.""" if cfg.IS_RPN: 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 else: # sample images db_inds = np.zeros((cfg.TRAIN.IMS_PER_BATCH), dtype=np.int32) i = 0 while (i < cfg.TRAIN.IMS_PER_BATCH): ind = self._perm[self._cur] num_objs = self._roidb[ind]['boxes'].shape[0] if num_objs != 0: db_inds[i] = ind i += 1 self._cur += 1 if self._cur >= len(self._roidb): self._shuffle_roidb_inds() return db_inds
def __init__(self, solver_prototxt, roidb, output_dir, pretrained_model=None): """Initialize the SolverWrapper.""" self.output_dir = output_dir print 'Computing bounding-box regression targets...' if cfg.TRAIN.BBOX_REG: if cfg.IS_RPN: self.bbox_means, self.bbox_stds = gdl_roidb.add_bbox_regression_targets(roidb) else: 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) self.solver.net.layers[0].set_roidb(roidb)
def get_training_roidb(imdb): """Returns a roidb (Region of Interest database) for use in training.""" if cfg.TRAIN.USE_FLIPPED: print 'Appending horizontally-flipped training examples...' imdb.append_flipped_images() print 'done' print 'Preparing training data...' if cfg.IS_RPN: if cfg.IS_MULTISCALE: gdl_roidb.prepare_roidb(imdb) else: rdl_roidb.prepare_roidb(imdb) else: rdl_roidb.prepare_roidb(imdb) print 'done' return imdb.roidb
def _get_blobs(im, rois): """Convert an image and RoIs within that image into network inputs.""" if cfg.IS_RPN: blobs = {'data' : None, 'boxes_grid' : None} blobs['data'], im_scale_factors = _get_image_blob(im) blobs['boxes_grid'] = rois else: blobs = {'data' : None, 'rois' : None} blobs['data'], im_scale_factors = _get_image_blob(im) if cfg.IS_MULTISCALE: if cfg.IS_EXTRAPOLATING: blobs['rois'] = _get_rois_blob(rois, cfg.TEST.SCALES) else: blobs['rois'] = _get_rois_blob(rois, cfg.TEST.SCALES_BASE) else: blobs['rois'] = _get_rois_blob(rois, cfg.TEST.SCALES_BASE) return blobs, im_scale_factors
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_subcategory_exemplar_annotation(index) for index in self.image_index] if cfg.IS_RPN: # print out recall for i in xrange(1, self.num_classes): print '{}: Total number of boxes {:d}'.format(self.classes[i], self._num_boxes_all[i]) print '{}: Number of boxes covered {:d}'.format(self.classes[i], self._num_boxes_covered[i]) print '{}: Recall {:f}'.format(self.classes[i], float(self._num_boxes_covered[i]) / float(self._num_boxes_all[i])) 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 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 + '_' + cfg.SUBCLS_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_kitti_voxel_exemplar_annotation(index) for index in self.image_index] if cfg.IS_RPN: # print out recall for i in xrange(1, self.num_classes): print '{}: Total number of boxes {:d}'.format(self.classes[i], self._num_boxes_all[i]) print '{}: Number of boxes covered {:d}'.format(self.classes[i], self._num_boxes_covered[i]) print '{}: Recall {:f}'.format(self.classes[i], float(self._num_boxes_covered[i]) / float(self._num_boxes_all[i])) 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 __init__(self, image_set, imagenet3d_path=None): datasets.imdb.__init__(self, 'imagenet3d_' + image_set) self._image_set = image_set self._imagenet3d_path = self._get_default_path() if imagenet3d_path is None \ else imagenet3d_path self._data_path = os.path.join(self._imagenet3d_path, 'Images') self._classes = ('__background__', 'aeroplane', 'ashtray', 'backpack', 'basket', \ 'bed', 'bench', 'bicycle', 'blackboard', 'boat', 'bookshelf', 'bottle', 'bucket', \ 'bus', 'cabinet', 'calculator', 'camera', 'can', 'cap', 'car', 'cellphone', 'chair', \ 'clock', 'coffee_maker', 'comb', 'computer', 'cup', 'desk_lamp', 'diningtable', \ 'dishwasher', 'door', 'eraser', 'eyeglasses', 'fan', 'faucet', 'filing_cabinet', \ 'fire_extinguisher', 'fish_tank', 'flashlight', 'fork', 'guitar', 'hair_dryer', \ 'hammer', 'headphone', 'helmet', 'iron', 'jar', 'kettle', 'key', 'keyboard', 'knife', \ 'laptop', 'lighter', 'mailbox', 'microphone', 'microwave', 'motorbike', 'mouse', \ 'paintbrush', 'pan', 'pen', 'pencil', 'piano', 'pillow', 'plate', 'pot', 'printer', \ 'racket', 'refrigerator', 'remote_control', 'rifle', 'road_pole', 'satellite_dish', \ 'scissors', 'screwdriver', 'shoe', 'shovel', 'sign', 'skate', 'skateboard', 'slipper', \ 'sofa', 'speaker', 'spoon', 'stapler', 'stove', 'suitcase', 'teapot', 'telephone', \ 'toaster', 'toilet', 'toothbrush', 'train', 'trash_bin', 'trophy', 'tub', 'tvmonitor', \ 'vending_machine', 'washing_machine', 'watch', 'wheelchair') self._class_to_ind = dict(zip(self.classes, xrange(self.num_classes))) self._image_ext = '.JPEG' self._image_index = self._load_image_set_index() # Default to roidb handler if cfg.IS_RPN: self._roidb_handler = self.gt_roidb else: self._roidb_handler = self.region_proposal_roidb self.config = {'top_k': 100000} # statistics for computing recall self._num_boxes_all = np.zeros(self.num_classes, dtype=np.int) self._num_boxes_covered = np.zeros(self.num_classes, dtype=np.int) self._num_boxes_proposal = 0 assert os.path.exists(self._imagenet3d_path), \ 'imagenet3d path does not exist: {}'.format(self._imagenet3d_path) assert os.path.exists(self._data_path), \ 'Path does not exist: {}'.format(self._data_path)
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 + '_' + cfg.SUBCLS_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_imagenet3d_annotation(index) for index in self.image_index] if cfg.IS_RPN: # print out recall for i in xrange(1, self.num_classes): print '{}: Total number of boxes {:d}'.format(self.classes[i], self._num_boxes_all[i]) print '{}: Number of boxes covered {:d}'.format(self.classes[i], self._num_boxes_covered[i]) print '{}: Recall {:f}'.format(self.classes[i], float(self._num_boxes_covered[i]) / float(self._num_boxes_all[i])) 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 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 + '_' + cfg.SUBCLS_NAME + '_gt_roidb.pkl') cache_file = os.path.join(self.cache_path, self.name + '_' + '_gt_roidb.pkl') # the path is: .../Faster-RCNN_TF/data/cache/building_train_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_building_annotation(index) for index in self.image_index] """if cfg.IS_RPN: # print out recall for i in xrange(1, self.num_classes): print '{}: Total number of boxes {:d}'.format(self.classes[i], self._num_boxes_all[i]) print '{}: Number of boxes covered {:d}'.format(self.classes[i], self._num_boxes_covered[i]) print '{}: Recall {:f}'.format(self.classes[i], float(self._num_boxes_covered[i]) / float(self._num_boxes_all[i]))""" 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 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 + '_' + cfg.SUBCLS_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_pascal3d_voxel_exemplar_annotation(index) for index in self.image_index] if cfg.IS_RPN: # print out recall for i in xrange(1, self.num_classes): print '{}: Total number of boxes {:d}'.format(self.classes[i], self._num_boxes_all[i]) print '{}: Number of boxes covered {:d}'.format(self.classes[i], self._num_boxes_covered[i]) print '{}: Recall {:f}'.format(self.classes[i], float(self._num_boxes_covered[i]) / float(self._num_boxes_all[i])) 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 __init__(self, image_set, building_path=None): datasets.imdb.__init__(self, 'building_' + image_set) self._image_set = image_set # something like 'train', 'val', ... self._building_path = self._get_default_path() if building_path is None \ else building_path # building_path = ... Faster-RCNN_TF/data/building_data self._classes = ('__background__', 'building') self._class_to_ind = dict(zip(self.classes, xrange(self.num_classes))) # {'Building': 1, '__background__': 0} self._image_ext = '.png' self._image_index = self._load_image_set_index() # something like: ['22', '23', '29'] # Default to roidb handler """if cfg.IS_RPN: self._roidb_handler = self.gt_roidb else: self._roidb_handler = self.region_proposal_roidb""" self._roidb_handler = self.gt_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} #################################################################################################################### # ---------------------------------------------------------------------------------------------------------------- #
def gt_roidb(self): """ Return the database of ground-truth regions of interest. """ cache_file = os.path.join(self.cache_path, self.name + '_' + cfg.SUBCLS_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_kitti_voxel_exemplar_annotation(index) for index in self.image_index] if cfg.IS_RPN: # print out recall for i in xrange(1, self.num_classes): print '{}: Total number of boxes {:d}'.format(self.classes[i], self._num_boxes_all[i]) print '{}: Number of boxes covered {:d}'.format(self.classes[i], self._num_boxes_covered[i]) print '{}: Recall {:f}'.format(self.classes[i], float(self._num_boxes_covered[i]) / float(self._num_boxes_all[i])) 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 gt_roidb(self): """ Return the database of ground-truth regions of interest. """ cache_file = os.path.join(self.cache_path, self.name + '_' + cfg.SUBCLS_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_mot_voxel_exemplar_annotation(index) for index in self.image_index] if cfg.IS_RPN: # print out recall for i in xrange(1, self.num_classes): print '{}: Total number of boxes {:d}'.format(self.classes[i], self._num_boxes_all[i]) print '{}: Number of boxes covered {:d}'.format(self.classes[i], self._num_boxes_covered[i]) print '{}: Recall {:f}'.format(self.classes[i], float(self._num_boxes_covered[i]) / float(self._num_boxes_all[i])) 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 __init__(self, image_set, nissan_path=None): datasets.imdb.__init__(self, 'nissan_' + image_set) self._image_set = image_set self._nissan_path = self._get_default_path() if nissan_path is None \ else nissan_path self._data_path = os.path.join(self._nissan_path, 'Images') self._classes = ('__background__', 'Car', 'Pedestrian', 'Cyclist') self._class_to_ind = dict(zip(self.classes, xrange(self.num_classes))) self._image_ext = '.png' self._image_index = self._load_image_set_index() # Default to roidb handler if cfg.IS_RPN: self._roidb_handler = self.gt_roidb else: self._roidb_handler = self.region_proposal_roidb # num of subclasses self._num_subclasses = 227 + 36 + 36 + 1 # load the mapping for subcalss to class filename = os.path.join(self._nissan_path, 'mapping.txt') assert os.path.exists(filename), 'Path does not exist: {}'.format(filename) mapping = np.zeros(self._num_subclasses, dtype=np.int) with open(filename) as f: for line in f: words = line.split() subcls = int(words[0]) mapping[subcls] = self._class_to_ind[words[1]] self._subclass_mapping = mapping self.config = {'top_k': 100000} # statistics for computing recall self._num_boxes_all = np.zeros(self.num_classes, dtype=np.int) self._num_boxes_covered = np.zeros(self.num_classes, dtype=np.int) self._num_boxes_proposal = 0 assert os.path.exists(self._nissan_path), \ 'Nissan path does not exist: {}'.format(self._nissan_path) assert os.path.exists(self._data_path), \ 'Path does not exist: {}'.format(self._data_path)
def __init__(self, image_set, year, pascal_path=None): datasets.imdb.__init__(self, 'voc_' + year + '_' + image_set) self._year = year self._image_set = image_set self._pascal_path = self._get_default_path() if pascal_path is None \ else pascal_path self._data_path = os.path.join(self._pascal_path, 'VOCdevkit' + self._year, '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 if cfg.IS_RPN: self._roidb_handler = self.gt_roidb else: self._roidb_handler = self.region_proposal_roidb # num of subclasses self._num_subclasses = 240 + 1 # load the mapping for subcalss to class filename = os.path.join(self._pascal_path, 'subcategory_exemplars', 'mapping.txt') assert os.path.exists(filename), 'Path does not exist: {}'.format(filename) mapping = np.zeros(self._num_subclasses, dtype=np.int) with open(filename) as f: for line in f: words = line.split() subcls = int(words[0]) mapping[subcls] = self._class_to_ind[words[1]] self._subclass_mapping = mapping # PASCAL specific config options self.config = {'cleanup' : True, 'use_salt' : True, 'top_k' : 2000} # statistics for computing recall self._num_boxes_all = np.zeros(self.num_classes, dtype=np.int) self._num_boxes_covered = np.zeros(self.num_classes, dtype=np.int) self._num_boxes_proposal = 0 assert os.path.exists(self._pascal_path), \ 'PASCAL path does not exist: {}'.format(self._pascal_path) assert os.path.exists(self._data_path), \ 'Path does not exist: {}'.format(self._data_path)
def __init__(self, image_set, nthu_path=None): datasets.imdb.__init__(self, 'nthu_' + image_set) self._image_set = image_set self._nthu_path = self._get_default_path() if nthu_path is None \ else nthu_path self._data_path = os.path.join(self._nthu_path, 'data') self._classes = ('__background__', 'Car', 'Pedestrian', 'Cyclist') 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 if cfg.IS_RPN: self._roidb_handler = self.gt_roidb else: self._roidb_handler = self.region_proposal_roidb # num of subclasses self._num_subclasses = 227 + 36 + 36 + 1 # load the mapping for subcalss to class filename = os.path.join(self._nthu_path, 'mapping.txt') assert os.path.exists(filename), 'Path does not exist: {}'.format(filename) mapping = np.zeros(self._num_subclasses, dtype=np.int) with open(filename) as f: for line in f: words = line.split() subcls = int(words[0]) mapping[subcls] = self._class_to_ind[words[1]] self._subclass_mapping = mapping self.config = {'top_k': 100000} # statistics for computing recall self._num_boxes_all = np.zeros(self.num_classes, dtype=np.int) self._num_boxes_covered = np.zeros(self.num_classes, dtype=np.int) self._num_boxes_proposal = 0 assert os.path.exists(self._nthu_path), \ 'NTHU path does not exist: {}'.format(self._nthu_path) assert os.path.exists(self._data_path), \ 'Path does not exist: {}'.format(self._data_path)
def __init__(self, image_set, pascal3d_path = None): datasets.imdb.__init__(self, 'pascal3d_' + image_set) self._year = '2012' self._image_set = image_set self._pascal3d_path = self._get_default_path() if pascal3d_path is None \ else pascal3d_path self._data_path = os.path.join(self._pascal3d_path, 'VOCdevkit' + self._year, 'VOC' + self._year) self._classes = ('__background__', # always index 0 'aeroplane', 'bicycle', 'boat', 'bottle', 'bus', 'car', 'chair', 'diningtable', 'motorbike', '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 if cfg.IS_RPN: self._roidb_handler = self.gt_roidb else: self._roidb_handler = self.region_proposal_roidb # num of subclasses if cfg.SUBCLS_NAME == 'voxel_exemplars': self._num_subclasses = 337 + 1 elif cfg.SUBCLS_NAME == 'pose_exemplars': self._num_subclasses = 260 + 1 else: assert (1), 'cfg.SUBCLS_NAME not supported!' # load the mapping for subcalss to class filename = os.path.join(self._pascal3d_path, cfg.SUBCLS_NAME, 'mapping.txt') assert os.path.exists(filename), 'Path does not exist: {}'.format(filename) mapping = np.zeros(self._num_subclasses, dtype=np.int) with open(filename) as f: for line in f: words = line.split() subcls = int(words[0]) mapping[subcls] = self._class_to_ind[words[1]] self._subclass_mapping = mapping # PASCAL specific config options self.config = {'cleanup' : True, 'use_salt' : True, 'top_k' : 2000} # statistics for computing recall self._num_boxes_all = np.zeros(self.num_classes, dtype=np.int) self._num_boxes_covered = np.zeros(self.num_classes, dtype=np.int) self._num_boxes_proposal = 0 assert os.path.exists(self._pascal3d_path), \ 'PASCAL3D path does not exist: {}'.format(self._pascal3d_path) assert os.path.exists(self._data_path), \ 'Path does not exist: {}'.format(self._data_path)
def __init__(self, image_set, kitti_path=None): datasets.imdb.__init__(self, 'kitti_' + image_set) self._image_set = image_set self._kitti_path = self._get_default_path() if kitti_path is None \ else kitti_path self._data_path = os.path.join(self._kitti_path, 'data_object_image_2') self._classes = ('__background__', 'Car', 'Pedestrian', 'Cyclist') self._class_to_ind = dict(zip(self.classes, xrange(self.num_classes))) self._image_ext = '.png' self._image_index = self._load_image_set_index() # Default to roidb handler if cfg.IS_RPN: self._roidb_handler = self.gt_roidb else: self._roidb_handler = self.region_proposal_roidb # num of subclasses if image_set == 'train' or image_set == 'val': self._num_subclasses = 125 + 24 + 24 + 1 prefix = 'validation' else: self._num_subclasses = 227 + 36 + 36 + 1 prefix = 'test' # load the mapping for subcalss to class filename = os.path.join(self._kitti_path, cfg.SUBCLS_NAME, prefix, 'mapping.txt') assert os.path.exists(filename), 'Path does not exist: {}'.format(filename) mapping = np.zeros(self._num_subclasses, dtype=np.int) with open(filename) as f: for line in f: words = line.split() subcls = int(words[0]) mapping[subcls] = self._class_to_ind[words[1]] self._subclass_mapping = mapping self.config = {'top_k': 100000} # statistics for computing recall self._num_boxes_all = np.zeros(self.num_classes, dtype=np.int) self._num_boxes_covered = np.zeros(self.num_classes, dtype=np.int) self._num_boxes_proposal = 0 assert os.path.exists(self._kitti_path), \ 'KITTI path does not exist: {}'.format(self._kitti_path) assert os.path.exists(self._data_path), \ 'Path does not exist: {}'.format(self._data_path)
def __init__(self, image_set, seq_name, kitti_tracking_path=None): datasets.imdb.__init__(self, 'kitti_tracking_' + image_set + '_' + seq_name) self._image_set = image_set self._seq_name = seq_name self._kitti_tracking_path = self._get_default_path() if kitti_tracking_path is None \ else kitti_tracking_path self._data_path = os.path.join(self._kitti_tracking_path, image_set, 'image_02') self._classes = ('__background__', 'Car', 'Pedestrian', 'Cyclist') self._class_to_ind = dict(zip(self.classes, xrange(self.num_classes))) self._image_ext = '.png' self._image_index = self._load_image_set_index() # Default to roidb handler if cfg.IS_RPN: self._roidb_handler = self.gt_roidb else: self._roidb_handler = self.region_proposal_roidb # num of subclasses if image_set == 'training' and seq_name != 'trainval': self._num_subclasses = 220 + 1 else: self._num_subclasses = 472 + 1 # load the mapping for subcalss to class if image_set == 'training' and seq_name != 'trainval': filename = os.path.join(self._kitti_tracking_path, 'voxel_exemplars', 'train', 'mapping.txt') else: filename = os.path.join(self._kitti_tracking_path, 'voxel_exemplars', 'trainval', 'mapping.txt') assert os.path.exists(filename), 'Path does not exist: {}'.format(filename) mapping = np.zeros(self._num_subclasses, dtype=np.int) with open(filename) as f: for line in f: words = line.split() subcls = int(words[0]) mapping[subcls] = self._class_to_ind[words[1]] self._subclass_mapping = mapping self.config = {'top_k': 100000} # statistics for computing recall self._num_boxes_all = np.zeros(self.num_classes, dtype=np.int) self._num_boxes_covered = np.zeros(self.num_classes, dtype=np.int) self._num_boxes_proposal = 0 assert os.path.exists(self._kitti_tracking_path), \ 'kitti_tracking path does not exist: {}'.format(self._kitti_tracking_path) assert os.path.exists(self._data_path), \ 'Path does not exist: {}'.format(self._data_path)
