def main(): network_generators = { 'ZF': ZFGenerator } args = parse_args(network_generators.keys()) if args.cfg is not None: cfg_from_file(args.cfg) apollocaffe.set_random_seed(cfg.RNG_SEED) np.random.seed(cfg.RNG_SEED) if args.gpu_id >= 0: apollocaffe.set_device(args.gpu_id) apollocaffe.set_cpp_loglevel(3) train_roidb = None if args.train_imdb is not None: train_imdb = get_imdb(args.train_imdb) train_imdb.set_proposal_method(cfg.TRAIN.PROPOSAL_METHOD) train_roidb = get_training_roidb(train_imdb) test_roidb = None if args.test_imdb is not None: test_imdb = get_imdb(args.test_imdb) test_imdb.set_proposal_method('gt') prepare_roidb(test_imdb) test_roidb = test_imdb.roidb faster_rcnn = FasterRCNN(args, network_generators, train_roidb=train_roidb, test_roidb=test_roidb) faster_rcnn.train() return 0
def get_roidb(imdb_name): imdb = get_imdb(imdb_name) print 'Loaded dataset `{:s}` for training'.format(imdb.name) imdb.set_proposal_method('gt') print 'Set proposal method: {:s}'.format('gt') roidb = get_training_roidb(imdb) return roidb
def get_roidb(imdb_name): 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)) roidb = get_training_roidb(imdb) return roidb
def get_roidb(imdb_name, rpn_file=None, stage_flag=None, roidbs_cache_path=None): # Set input info data = cfg.TRAIN.DATA cache = cfg.TRAIN.CACHE D_INPUT_DIR = cfg.TRAIN.D_INPUT_DIR D_INPUT_FILE = cfg.TRAIN.D_INPUT_FILE D_INPUT_LAB_DIR = cfg.TRAIN.D_INPUT_LAB_DIR D_INPUT_IMG_DIR = cfg.TRAIN.D_INPUT_IMG_DIR print print "data:", data print "cache:", cache if stage_flag: print "stage_flag:", stage_flag print # get imdb imdb = get_imdb(imdb_name, D_INPUT_DIR, D_INPUT_IMG_DIR, \ D_INPUT_LAB_DIR, D_INPUT_FILE, data, cache) print 'Loaded dataset `{:s}` for training'.format(imdb.name) # set roidb handler imdb.set_proposal_method(cfg.TRAIN.PROPOSAL_METHOD) print 'Set proposal method: {:s}'.format(cfg.TRAIN.PROPOSAL_METHOD) # rpn File if rpn_file is not None: imdb.config['rpn_file'] = rpn_file # get roidb roidb = get_training_roidb(imdb, roidbs_cache_path) return roidb, imdb
def get_roidb(imdb_name): 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) roidb = get_training_roidb(imdb) return roidb
def get_roidb(imdb_name, devkit_path, CLASSES): imdb = get_imdb(imdb_name, devkit_path, CLASSES) 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) roidb = get_training_roidb(imdb) return roidb
def train_faster_rcnn(no_pretrained, max_iters): """Train a Faster R-CNN network on a region of interest database.""" # Set pretrained model if no_pretrained: pretrained_model = None else: pretrained_model = osp.join(cfg.DATA_DIR, 'imagenet_models', '{:s}.caffemodel'.format(cfg.MODEL_NAME)) check_if_exist('Pretrained model', pretrained_model) # Change solver if OHEM is used postfix = '' if cfg.TRAIN.USE_OHEM: if cfg.MODEL_NAME != 'VGG16' and \ cfg.MODEL_NAME != 'ResNet101_bn-scale-merged': print('Faster RCNN framework with OHEM does not currently ' 'support model: {:s} (supported models: VGG16, ' 'ResNet101_bn-scale-merged).').format(cfg.MODEL_NAME) sys.exit() else: postfix = '_ohem' # Check if custom anchors exist and copy them to output dir if cfg.CUSTOM_ANCHORS: anchor_file = osp.join(cfg.DATA_DIR, cfg.DATASET_NAME, 'custom_anchor_boxes', '9_anchor_boxes.txt') if not osp.exists(anchor_file): print('Custom anchor boxes `{:s}` does not exist.'.format( anchor_file)) print('Generate custom anchor boxes with ' 'data/data_utils/k_means_anchor_boxes.py') sys.exit() copy(anchor_file, osp.join(cfg.OUTPUT_DIR, '9_anchor_boxes.txt')) # Set solver solver = osp.join(cfg.MODELS_DIR, cfg.DATASET_NAME, cfg.METHOD_NAME, cfg.MODEL_NAME, 'solver{}.prototxt'.format(postfix)) check_if_exist('Solver', solver) # Set up caffe caffe.set_mode_gpu() caffe.set_device(cfg.GPU_ID) # Set imdb imdb_name = '{:s}_train'.format(cfg.DATASET_NAME) 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)) roidb = get_training_roidb(imdb) # Start training train_net(solver, roidb, pretrained_model=pretrained_model, max_iters=max_iters)
def get_roidb(imdb_name): imdb = get_imdb(imdb_name) # get_imdb 来自 lib/datasets/factory.py print 'Loaded dataset `{:s}` for training'.format(imdb.name) imdb.set_proposal_method( cfg.TRAIN.PROPOSAL_METHOD) #!!! 这个地方触发了野性语句, 执行了gt_roidb !!! print 'Set proposal method: {:s}'.format(cfg.TRAIN.PROPOSAL_METHOD) roidb = get_training_roidb(imdb) # 从 imdb 获得 roidb return roidb
def get_roidb(imdb_name): imdb = get_imdb(imdb_name) print 'Loaded dataset `{:s}` for training'.format(imdb.name) # set proposal method 'gt' to make this imdb load annotation imdb.set_proposal_method('gt') roidb = get_training_roidb(imdb) return roidb, imdb
def get_roidb(imdb_name): imdb = get_imdb(imdb_name) print 'Loaded dataset `{:s}` for training'.format(imdb.name) imdb.set_proposal_method( cfg.TRAIN.PROPOSAL_METHOD) # Ashu loads the ground truth print 'Set proposal method: {:s}'.format(cfg.TRAIN.PROPOSAL_METHOD) roidb = get_training_roidb(imdb) return roidb
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
def get_roidb(imdb_name, flag=0): 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) roidb = get_training_roidb(imdb) for rd in roidb: rd['dc_label'] = flag return roidb, imdb
def get_roidb(imdb_name): imdb = get_imdb(imdb_name) # if cfg.DEBUG: # print(imdb.roidb_handler) # time.sleep(10000) 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) roidb = get_training_roidb(imdb) return roidb
def get_roidb(imdb_name): ## return an imdb object 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) ## return list of dicts with keys ('bbox', 'gt_classes', 'gt_overlaps'\ ## , 'flipped', 'seg_areas') roidb = get_training_roidb(imdb) return roidb
def get_roidb(imdb_name): imdb = get_imdb(imdb_name) # set classes of train in interface # no need into pascal_voc to reset self._classes imdb.set_classes(classes) 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) roidb = get_training_roidb(imdb) return roidb
def get_roidb(imdb_name): #imdb = get_imdb(imdb_name) pos = imdb_name.rfind('_') db_name = imdb_name[:pos] split = imdb_name[pos + 1:] imdb = universal(db_name=db_name, split=split, ext=ext) 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) roidb = get_training_roidb(imdb) return roidb
def get_roidb(imdb_name): imdb = get_imdb(imdb_name) print 'Loaded dataset `{:s}` for training'.format(imdb.name) print(cfg.TRAIN) print(cfg.TRAIN['PROPOSAL_METHOD']) #print(cfg.TEST.PROPOSAL_METHOD) #print(cfg.TRAIN.HAS_RPN) #print(cfg.MODELS_DIR) imdb.set_proposal_method(cfg.TRAIN.PROPOSAL_METHOD) print 'Set proposal method: {:s}'.format(cfg.TRAIN.PROPOSAL_METHOD) roidb = get_training_roidb(imdb) return roidb
def get_roidb(imdb_name, rpn_file=None): print 'Requiring dataset `{:s}` for training'.format(imdb_name) 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) num_classes = roidb[0]['gt_overlaps'].shape[1] print "############ num class in get_roidb jg rpn train :", num_classes return roidb, imdb
def get_roidb(imdb_name, mat_folder, pkl_folder): 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 mat_folder is not None: mat_file = os.path.join(cfg.DATA_DIR, mat_folder, imdb_name + '.mat') imdb.config['mat_file'] = mat_file if pkl_folder is not None: pkl_file = pkl_folder + imdb_name + '_proposals.pkl' imdb.config['pkl_file'] = pkl_file roidb = get_training_roidb(imdb) return roidb
def get_roidb(imdb_name, rpn_file=None): """ :param imdb_name: 获取roidb :param rpn_file: 获取imdb :return: imdb 根据imdb_name(默认是"voc_2007_trainval")来获取,这里的imdb对象的获取采用了工厂模式,由\lib\datasets\factory.py生成, 根据年份(2007)与切分的数据集(trainval)返回pascal_voc 对象,pascal_voc与coco都继承于imdb 对象。(\lib\datasets\pascal_voc.py +coco.py) roidb 是通过\lib\faster_rcnn\train.py 中的get_training_roidb来获取的,这个roidb是一个imdb的成员变量,包含了训练集图片中框出的每个 区域。这个函数做了两件事情,一是将原有的roidb中的每张图片进行水平翻转然后添加回roidb中 """ 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
cache_file = os.path.join(cache_path, \ i_database_name + '_train' + '_3CL=' + str(cfg.ThreeClass) + \ '_MULTI_LABEL=' + str(cfg.MULTI_LABEL) + \ '_SOFTMAX=' + str(cfg.MULTI_LABEL_SOFTMAX) + \ '_BLC=' + str(cfg.BALANCED) + \ '_COF=' + str(cfg.BALANCED_COF) + \ '_TT1000=' + str(cfg.TESTTYPE1000) + \ '_solver_roidb.pkl') if os.path.exists(cache_file): with open(cache_file, 'rb') as fid: this_dataset_roidb[i_database_name] = cPickle.load(fid) else: imdb = get_imdb(i_database_name + '_train') print('No cache file spotted. Making one from the scratch') print('Loaded dataset `{:s}`'.format(i_database_name)) this_dataset_roidb[i_database_name] = get_training_roidb( imdb) with open(cache_file, 'wb') as fid: cPickle.dump(this_dataset_roidb, fid, cPickle.HIGHEST_PROTOCOL) print('The precomputed roidb saved to {}'.format( cache_file)) print('The precomputed {} roidb datasets loaded'.\ format(i_database_name)) origin_roidb = [] for i_database_name in ['CFD', 'Fashionista']: origin_roidb.extend(this_dataset_roidb[i_database_name]) print('Generating the hdf5 training data') else: cache_file = os.path.join(cache_path, \
if args.device_id is not None: cfg.GPU_ID = device_id if not args.randomize: # fix the random seeds (numpy and caffe) for reproducibility np.random.seed(cfg.RNG_SEED) # the map from dataset name to the dataset is set and store in the /datasets/factory.py # guess that factory.py should run first imdb = get_imdb(args.imdb_name) print 'Loaded dataset `{:s}` for training'.format(imdb.name) #************************************** # load original images and groundtruth #************************************** roidb = get_training_roidb(imdb) if cfg.DEBUG: for key in roidb[0]: print key # output_dir = get_output_dir(imdb, None) output_dir = "/z/home/chsiyuan/Documents/542FinalProject/experiments/results/train" if not os.path.exists(output_dir): os.makedirs(output_dir) print 'Output will be saved to `{:s}`'.format(output_dir) device_name = '/{}:{:d}'.format(args.device,args.device_id) print device_name network = get_network(args.network_name)
cache_file = os.path.join(cache_path, \ i_database_name + '_train' + '_3CL=' + str(cfg.ThreeClass) + \ '_MULTI_LABEL=' + str(cfg.MULTI_LABEL) + \ '_SOFTMAX=' + str(cfg.MULTI_LABEL_SOFTMAX) + \ '_BLC=' + str(cfg.BALANCED) + \ '_COF=' + str(cfg.BALANCED_COF) + \ '_TT1000=' + str(cfg.TESTTYPE1000) + \ '_solver_roidb.pkl') if os.path.exists(cache_file): with open(cache_file, 'rb') as fid: this_dataset_roidb[i_database_name] = cPickle.load(fid) else: imdb = get_imdb(i_database_name + '_train') print('No cache file spotted. Making one from the scratch') print('Loaded dataset `{:s}`'.format(i_database_name)) this_dataset_roidb[i_database_name] = get_training_roidb(imdb) with open(cache_file, 'wb') as fid: cPickle.dump( this_dataset_roidb, fid, cPickle.HIGHEST_PROTOCOL) print('The precomputed roidb saved to {}'.format(cache_file)) print('The precomputed {} roidb datasets loaded'.\ format(i_database_name)) origin_roidb = [] for i_database_name in ['CFD', 'Fashionista']: origin_roidb.extend(this_dataset_roidb[i_database_name]) print('Generating the hdf5 training data') else: cache_file = os.path.join(cache_path, \ args.imdb_name + '_3CL=' + str(cfg.ThreeClass) + \
def get_roidb(imdb): imdb.set_proposal_method(cfg.TRAIN.PROPOSAL_METHOD) print 'Set proposal method: {:s}'.format(cfg.TRAIN.PROPOSAL_METHOD) roidb = get_training_roidb(imdb) return roidb
elif 'GOOGLENET' in model_name: model_name = 'GOOGLENET' elif 'INCEPTION' in model_name: model_name = 'GOOGLENET_BN' else: raise Exception("This model is not supported. %s" % model_name) cfg.MODEL_NAME = model_name imdb = get_imdb(args.imdb_name, model_to_use, proposal, proposal_file) print 'Loaded dataset `{:s}` for training'.format(imdb.name) # DJDJ #imdb.rpn_train_roidb() roidb = get_training_roidb(imdb, args.model_to_use, args.proposal_file) output_dir = get_output_dir(imdb, None) print 'Output will be saved to `{:s}`'.format(output_dir) train_net(args.solver, imdb.bbox_means, imdb.bbox_stds, roidb, output_dir, proposal_file, pretrained_model=args.pretrained_model, restore=args.restore, max_iters=args.max_iters, model_to_use=model_to_use, proposal=proposal)
def get_roidb(dataset): imdb = get_imdb(dataset) print 'Loaded dataset `{:s}` for training'.format(imdb.name) roidb = get_training_roidb(imdb) return roidb
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, max(cfg.TRAIN.SCALES), cfg.TRAIN.MAX_SIZE) self._name_to_top_map['data'] = idx idx += 1 if cfg.TRAIN.HAS_RPN: top[idx].reshape(1, 3) self._name_to_top_map['im_info'] = idx idx += 1 top[idx].reshape(1, 4) self._name_to_top_map['gt_boxes'] = idx idx += 1 else: # not using RPN # 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) 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 idx += 1 if cfg.TRAIN.BBOX_REG: # bbox_targets blob: R bounding-box regression targets with 4 # targets per class top[idx].reshape(1, self._num_classes * 4) 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 idx += 1 top[idx].reshape(1, self._num_classes * 4) self._name_to_top_map['bbox_outside_weights'] = idx idx += 1 print 'RoiDataLayer: name_to_top:', self._name_to_top_map np.random.seed(cfg.RNG_SEED) imdb = get_imdb('voc_2007_test') roidb = get_training_roidb(imdb) self.set_roidb(roidb) assert len(top) == len(self._name_to_top_map)
os.system('cp {:s} {:s}'.format(stage1_model, dest_path)) print 'done!' print 'stage-1 done!' # =============== stage-2 training fast-rcnn with proposals generated by rpn if current_stage <= 2: print 'start stage-2...' imdb = get_imdb(args.imdb_name) print 'Loaded dataset `{:s}` for training'.format(imdb.name) # Append proposl boxes test_rpn_net.NMS_CONFIG = train_cfg.stage1_nms imdb = test_rpn_net.imdb_append_proposals(train_cfg.stage1.test_net, train_cfg.stage1.model_path.format(imdb.name), imdb, anchors_file) roidb = fast_rcnn_train.get_training_roidb(imdb) output_dir = fast_rcnn_config.get_output_dir(imdb, None) print 'Output will be saved to `{:s}`'.format(output_dir) ### mix anothor dataset if args.mix_imdb_name != None: imdb_mix = get_imdb(args.mix_imdb_name) print 'Loaded dataset `{:s}` for training'.format(imdb_mix.name) imdb_mix = test_rpn_net.imdb_append_proposals(train_cfg.stage1.test_net, train_cfg.stage1.model_path.format(imdb.name), imdb_mix, anchors_file) roidb_mix = fast_rcnn_train.get_training_roidb(imdb_mix) roidb.extend(roidb_mix) ### stage2_model = fast_rcnn_train.train_net(train_cfg.stage2.solver, roidb, output_dir, final_name=imdb.name,
def get_roidb(imdb_name): imdb = get_imdb(imdb_name) print 'Loaded dataset `{:s}` for training'.format(imdb.name) roidb = get_training_roidb(imdb) return roidb
def rpn_evaluate(net, imdb, IoUThresh=0.5, numMaxDets=[200, 500, 1000, 2000], rpn_file=None, score_file=None): """evaluate the performance of region proposals of rpn net writen by Yali Li """ if rpn_file is not None and score_file is not None: f_boxes = open(rpn_file, 'rb') imdb_boxes = cPickle.load(f_boxes) f_scores = open(rpn_file, 'rb') imdb_scores = cPickle.load(f_scores) else: imdb_boxes, imdb_scores = imdb_proposals(net, imdb) imdb.set_proposal_method('gt') roidb = get_training_roidb(imdb) imdb_rank_gt = [[] for _ in xrange(imdb.num_images)] print imdb.num_images for i in xrange(imdb.num_images): # sort by confidence ''' sorted_ind = np.argsort(-imdb_scores[i]) sorted_scores = np.sort(-imdb_scores[i]) BB = imdb_boxes[i][sorted_ind, :] imdb_boxes[i] = BB imdb_scores[i] = sorted_scores ''' # determine if the region proposals overlaps BBGT = roidb[i]['boxes'].reshape(-1, 4) bb = imdb_boxes[i] rank_gt = np.zeros(BBGT.shape[0]) for j in xrange(BBGT.shape[0]): # compute overlaps # intersection ixmin = np.maximum(BBGT[j, 0], bb[:, 0]) iymin = np.maximum(BBGT[j, 1], bb[:, 1]) ixmax = np.minimum(BBGT[j, 2], bb[:, 2]) iymax = np.minimum(BBGT[j, 3], bb[:, 3]) iw = np.maximum(ixmax - ixmin + 1., 0.) ih = np.maximum(iymax - iymin + 1., 0.) inters = iw * ih # union uni = ((bb[:, 2] - bb[:, 0] + 1.) * (bb[:, 3] - bb[:, 1] + 1.) + (BBGT[j, 2] - BBGT[j, 0] + 1.) * (BBGT[j, 3] - BBGT[j, 1] + 1.) - inters) overlaps = inters / uni J = np.where(overlaps >= IoUThresh)[0] if J.size > 0: rank_gt[j] = np.min(J) else: rank_gt[j] = -1 imdb_rank_gt[i] = rank_gt imdb_rank_gt = np.hstack(np.array(imdb_rank_gt)) num_all_gdtruths = len(imdb_rank_gt) num_max_dets = np.max(numMaxDets, axis=0) rec = np.zeros((num_max_dets, 1)) for k in xrange(1, num_max_dets): inds = np.where((imdb_rank_gt >= 0) & (imdb_rank_gt < k))[0] num_inds = len(inds) # print float(num_inds)/num_all_gdtruths rec[k] = float(num_inds) / num_all_gdtruths mAR = np.zeros((len(numMaxDets), 1)) for m in xrange(len(numMaxDets)): mAR[m] = np.mean(rec[:numMaxDets[m]], axis=0) # print "The recall of rpn proposals: " # print numMaxDets # print mAR return mAR.transpose(1, 0)
print 'done!' print 'stage-1 done!' # =============== stage-2 training fast-rcnn with proposals generated by rpn if current_stage <= 2: print 'start stage-2...' imdb = get_imdb(args.imdb_name) print 'Loaded dataset `{:s}` for training'.format(imdb.name) # Append proposl boxes test_rpn_net.NMS_CONFIG = train_cfg.stage1_nms imdb = test_rpn_net.imdb_append_proposals( train_cfg.stage1.test_net, train_cfg.stage1.model_path.format(imdb.name), imdb, anchors_file) roidb = fast_rcnn_train.get_training_roidb(imdb) output_dir = fast_rcnn_config.get_output_dir(imdb, None) print 'Output will be saved to `{:s}`'.format(output_dir) ### mix anothor dataset if args.mix_imdb_name != None: imdb_mix = get_imdb(args.mix_imdb_name) print 'Loaded dataset `{:s}` for training'.format(imdb_mix.name) imdb_mix = test_rpn_net.imdb_append_proposals( train_cfg.stage1.test_net, train_cfg.stage1.model_path.format(imdb.name), imdb_mix, anchors_file) roidb_mix = fast_rcnn_train.get_training_roidb(imdb_mix) roidb.extend(roidb_mix) ###
model_name = 'GOOGLENET4' elif 'GOOGLENET5' in model_name: model_name = 'GOOGLENET5' elif 'GOOGLENET' in model_name: model_name = 'GOOGLENET' elif 'INCEPTION' in model_name: model_name = 'GOOGLENET_BN' else: raise Exception("This model is not supported. %s" % model_name) cfg.MODEL_NAME = model_name imdb = get_imdb(args.imdb_name, model_to_use, proposal, proposal_file) print 'Loaded dataset `{:s}` for training'.format(imdb.name) # DJDJ #imdb.rpn_train_roidb() roidb = get_training_roidb(imdb, args.model_to_use, args.proposal_file) output_dir = get_output_dir(imdb, None) print 'Output will be saved to `{:s}`'.format(output_dir) train_net(args.solver, imdb.bbox_means, imdb.bbox_stds, roidb, output_dir, proposal_file, pretrained_model=args.pretrained_model, restore=args.restore, max_iters=args.max_iters, model_to_use=model_to_use, proposal=proposal)
device_name = '/{}:{:d}'.format(args.device, args.device_id) print device_name if args.device == 'gpu': cfg.USE_GPU_NMS = True cfg.GPU_ID = args.device_id else: cfg.USE_GPU_NMS = False if not args.randomize: # fix the random seeds (numpy and caffe) for reproducibility np.random.seed(cfg.RNG_SEED) target_imdb = get_imdb(args.target_imdb_name) target_imdb.competition_mode(args.comp_mode) print 'Loaded dataset `{:s}` for training'.format(target_imdb.name) target_roidb = get_training_roidb(target_imdb) source_imdb = get_imdb(args.source_imdb_name) source_imdb.competition_mode(args.comp_mode) print 'Loaded dataset `{:s}` for training'.format(source_imdb.name) source_roidb = get_training_roidb(source_imdb) target_network = get_network(args.target_network_name) print 'Use network `{:s}` in training'.format(args.target_network_name) target_vars = tf.get_collection(tf.GraphKeys.GLOBAL_VARIABLES, scope='target') source_network = get_network(args.source_network_name) print 'Use network `{:s}` in training'.format(args.source_network_name) source_vars = tf.get_collection(tf.GraphKeys.GLOBAL_VARIABLES, scope='source')
from datasets.caltech import caltech from datasets.inria import inria import datasets.imdb import caffe import numpy as np import sys if __name__ == '__main__': #set up global variable 'cfg' for train train_solver = sys.path[4] + '/' + 'models/pascal_voc_person/VGG16/solver.prototxt' pretrained_caffemodel = sys.path[4] + '/' + 'data/imagenet_models/VGG16.caffemodel' max_iterations = 4000 train_imdb = inria(train = 1) roidb = get_training_roidb(train_imdb) # set up global varibles for validation validation_network = sys.path[4]+'/'+ 'models/pascal_voc_person/VGG16/test.prototxt' validation_imdb = inria(test = 1) # set up global caffe mode cfg_file = sys.path[4] + '/' + 'models/pascal_voc_person/VGG16/vgg16_faster_rcnn.yml' if 1: train_solver = 'models/pascal_voc_person/VGG16/solver.prototxt' pretrained_caffemodel = 'data/imagenet_models/VGG16.caffemodel' validation_network = 'models/pascal_voc_person/VGG16/test.prototxt' cfg_file = 'models/pascal_voc_person/VGG16/vgg16_faster_rcnn.yml' cfg_from_file(cfg_file)
if args.cfg_file is not None: cfg_from_file(args.cfg_file) if args.set_cfgs is not None: cfg_from_list(args.set_cfgs) print('Using config:') pprint.pprint(cfg) if not args.randomize: # fix the random seeds (numpy and caffe) for reproducibility np.random.seed(cfg.RNG_SEED) caffe.set_random_seed(cfg.RNG_SEED) # set up caffe caffe.set_mode_gpu() if args.gpu_id is not None: caffe.set_device(args.gpu_id) imdb = get_imdb(args.imdb_name) print 'Loaded dataset `{:s}` for training'.format(imdb.name) roidb = get_training_roidb(imdb) output_dir = get_output_dir(imdb, None) print 'Output will be saved to `{:s}`'.format(output_dir) # roidb_s,roidb_w, = weakly_supervised_roidb(roidb) train_net(args.solver, roidb, output_dir, pretrained_model=args.pretrained_model, max_iters=args.max_iters)
caffe.set_mode_gpu() caffe.set_device(cfg.GPU_ID) caffe.init_glog(path_env['caffe_log']) imdb = tsv(args.data, 'train') print 'Loaded dataset `{:s}` for training'.format(imdb.name) #generate training/testing prototxt if not args.skip_genprototxt: gen_prototxt.generate_prototxt(path_env['basemodel'].split('_')[0], imdb.num_images, imdb.num_classes, path_env['output']) imdb.set_proposal_method(cfg.TRAIN.PROPOSAL_METHOD) print 'Set proposal method: {:s}'.format(cfg.TRAIN.PROPOSAL_METHOD) roidb = get_training_roidb(imdb) #imdb.gt_roidb() print '{:d} roidb entries'.format(len(roidb)) train_net(path_env['solver'], roidb, path_env['snapshot'], pretrained_model=path_env['basemodel'], max_iters=args.max_iters) print 'training finished in %s seconds' % (time.time() - start) #get final models labelmap_src = op.join(path_env['data'], "labelmap.txt") net_final = latest_model(path_env['model_pattern']) labelmap_src = op.join(path_env['data'], "labelmap.txt") proto_src = op.join(path_env['output'], "test.prototxt")