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 __init__(self, name, eval_root=None, det_times_file=None, imdb_name=None): """ :name: name of the detector, used to extract some of the paths """ self._name = name if imdb_name is None: self._imdb_name = 'voc_2007_test' else: self._imdb_name = imdb_name self._imdb = get_imdb(self._imdb_name) self._data_dir = os.path.join(DATA_ROOT_DIR, self._name, self._imdb_name) if eval_root is None: self._eval_root = self._data_dir else: self._eval_root = eval_root if det_times_file is None: self._det_times_file = os.path.join(self._data_dir, 'detections_times.pkl') else: self._det_times_file = det_times_file self.det_cls_img_eval = {} self._conf = None self._tp = None self._fp = None self._npos = None self._allnpos = {}
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 main(args_list): args = parse_args(args_list) print('Called with args:') print(args) 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) cfg.GPU_ID = args.gpu_id print('Using config:') pprint.pprint(cfg) while not os.path.exists(args.caffemodel) and args.wait: print('Waiting for {} to exist...'.format(args.caffemodel)) time.sleep(10) caffe.set_mode_gpu() caffe.set_device(args.gpu_id) net = caffe.Net(args.prototxt, args.caffemodel, caffe.TEST) net.name = os.path.splitext(os.path.basename(args.caffemodel))[0] imdb = get_imdb(args.imdb_name) imdb.competition_mode(args.comp_mode) if not cfg.TEST.HAS_RPN: imdb.set_proposal_method(cfg.TEST.PROPOSAL_METHOD) test_net(net, imdb, max_per_image=args.max_per_image, vis=args.vis)
def combined_roidb(imdb_names, rpn_files=None): 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 if '+' in imdb_names: # Multiple databases e.g. voc_2007_trainval+voc_2012_trainval imdbs_list = imdb_names.split('+') imdb = datasets.imdb.imdb(imdb_names) if rpn_files is None: rpn_files = [None] * len(imdbs_list) assert(len(imdbs_list) == len(rpn_files)) for i, imdb_name in enumerate(imdbs_list): if i == 0: roidb = get_roidb(imdb_name, rpn_files[i]) else: roidb.extend( get_roidb(imdb_name, rpn_files[i]) ) else: # Single database case e.g. voc_2007_trainval roidb = get_roidb(imdb_names, rpn_files) imdb= get_imdb(imdb_names) 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('gt') print 'Set proposal method: {:s}'.format('gt') roidb = get_training_roidb(imdb) return roidb
def test(dataset, output_file): """ Create a pickle file from relations according to annotations in a dataset (VOC 2007) """ imdb = get_imdb(dataset) db_relations = {} rcc_detector = RCC8() for n, image_index in enumerate(imdb.image_index): if n % 10 == 0: print u'Processed: {} / {}'.format(n, len(imdb.image_index)) impath = imdb.image_path_from_index(image_index) # read image img = caffe.io.load_image(impath) # read annotations annotations = imdb._load_pascal_annotation(image_index) # compute RCC8 relation hist, relations, pairs = rcc_detector.get_relations(img, annotations=annotations['gt_classes'], objects=annotations['boxes']) db_relations[image_index] = (hist, relations, pairs) if db_relations: with open(output_file, 'wb') as handle: pickle.dump(db_relations, handle) else: print u'Relations not found!'
def rpn_generate(queue=None, imdb_name=None, rpn_model_path=None, cfg=None, rpn_test_prototxt=None): """Use a trained RPN to generate proposals. """ cfg.TEST.RPN_PRE_NMS_TOP_N = -1 # no pre NMS filtering cfg.TEST.RPN_POST_NMS_TOP_N = 2000 # limit top boxes after NMS print 'RPN model: {}'.format(rpn_model_path) print('Using config:') pprint.pprint(cfg) import caffe _init_caffe(cfg) # NOTE: the matlab implementation computes proposals on flipped images, too. # We compute them on the image once and then flip the already computed # proposals. This might cause a minor loss in mAP (less proposal jittering). imdb = get_imdb(imdb_name) print 'Loaded dataset `{:s}` for proposal generation'.format(imdb.name) # Load RPN and configure output directory rpn_net = caffe.Net(rpn_test_prototxt, rpn_model_path, caffe.TEST) output_dir = get_output_dir(imdb, None) print 'Output will be saved to `{:s}`'.format(output_dir) # Generate proposals on the imdb rpn_proposals = imdb_proposals(rpn_net, imdb) # Write proposals to disk and send the proposal file path through the # multiprocessing queue rpn_net_name = os.path.splitext(os.path.basename(rpn_model_path))[0] rpn_proposals_path = os.path.join( output_dir, rpn_net_name + '_proposals.pkl') with open(rpn_proposals_path, 'wb') as f: cPickle.dump(rpn_proposals, f, cPickle.HIGHEST_PROTOCOL) print 'Wrote RPN proposals to {}'.format(rpn_proposals_path) return {'proposal_path': rpn_proposals_path}
def from_dets(imdb_name, output_dir, args): imdb = get_imdb(imdb_name) imdb.competition_mode(args.comp_mode) imdb.config['matlab_eval'] = args.matlab_eval with open(os.path.join(output_dir, 'detections.pkl'), 'rb') as f: dets = cPickle.load(f) #pose_file = os.path.join(output_dir, 'detections_pose.txt') #with open(pose_file, 'w') as f: # for i in xrange(0, len(dets[0])): # for j in xrange(1, len(dets)): # det = dets[j][i] # for d in det: # f.write("{:d} {:d} {:.1f} {:.1f} {:.1f} {:.1f} {:.3f} {:.3f} {:.3f}\n".format(i, j, # d[0], d[1], d[2], d[3], 15.0*d[4], 15.0*d[5], d[6])) #matlab_cmd = "test_pose_avp('%s');" % (pose_file) #print matlab_cmd #os.system('matlab -nodisplay -r "addpath(\'tools\');%s;quit"' % (matlab_cmd)) if args.apply_nms: print 'Applying NMS to all detections' nms_dets = apply_nms(dets, cfg.TEST.NMS) else: nms_dets = dets print 'Evaluating detections' imdb.evaluate_detections(nms_dets, output_dir)
def combined_roidb(imdb_names, training=True): """ Combine multiple roidbs """ 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...') prepare_roidb(imdb) #ratio_index = rank_roidb_ratio(imdb) print('done') return imdb.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 roidbs = [get_roidb(s) for s in imdb_names.split('+')] roidb = roidbs[0] if len(roidbs) > 1: for r in roidbs[1:]: roidb.extend(r) tmp = get_imdb(imdb_names.split('+')[1]) imdb = datasets.imdb.imdb(imdb_names, tmp.classes) else: imdb = get_imdb(imdb_names) if training: roidb = filter_roidb(roidb) ratio_list, ratio_index = rank_roidb_ratio(roidb) return imdb, roidb, ratio_list, ratio_index
def __init__(self, gts): # DATA_ROOT_PATH = '/home/hinami/rcnn/savedata/frcnn_fc6/caffenet_finetuned/PASCAL2007_trainval' self.DATA_ROOT_PATH = '/home/hinami/work/rcnn/savedata/frcnn_fc6/caffenet_finetuned/PASCAL2007' self.imdb = get_imdb('voc_2007_test') self.svm = LinearSVC(C=0.001, class_weight={1: 2, -1: 1}, intercept_scaling=10.0, verbose=1, penalty='l2', loss='l1', random_state=3, dual=True) self.gts = gts
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 rpn_generate(queue=None, imdb_name=None, rpn_model_path=None, cfg=None, rpn_test_prototxt=None): """Use a trained RPN to generate proposals. """ cfg.TEST.RPN_PRE_NMS_TOP_N = -1 # no pre NMS filtering cfg.TEST.RPN_POST_NMS_TOP_N = 2000 # limit top boxes after NMS print 'RPN model: {}'.format(rpn_model_path) print('Using config:') pprint.pprint(cfg) import caffe _init_caffe(cfg) if '+' in imdb_name: imdbs_list = imdb_name.split('+') imdb = datasets.imdb.imdb(imdb_name) output_dir = get_output_dir(imdb, None) print 'Output will be saved to `{:s}`'.format(output_dir) else: imdbs_list = [imdb_name] output_dir = None # Gets set later for single database case rpn_proposals_path = [None] * len(imdbs_list) for i, imdb_name in enumerate(imdbs_list): # NOTE: the matlab implementation computes proposals on flipped images, too. # We compute them on the image once and then flip the already computed # proposals. This might cause a minor loss in mAP (less proposal jittering). imdb = get_imdb(imdb_name) print 'Loaded dataset `{:s}` for proposal generation'.format(imdb.name) if output_dir is None: output_dir = get_output_dir(imdb, None) print 'Output will be saved to `{:s}`'.format(output_dir) # Load RPN and configure output directory rpn_net = caffe.Net(rpn_test_prototxt, rpn_model_path, caffe.TEST) rpn_net_name = os.path.splitext(os.path.basename(rpn_model_path))[0] rpn_proposals_path[i] = os.path.join( output_dir, rpn_net_name + '_' + imdb_name + '_proposals.pkl') # Check if rpn proposals have already been computed # If so, don't recompute if not os.path.isfile(rpn_proposals_path[i]): # Generate proposals on the imdb rpn_proposals = imdb_proposals(rpn_net, imdb) # Write proposals to disk with open(rpn_proposals_path[i], 'wb') as f: cPickle.dump(rpn_proposals, f, cPickle.HIGHEST_PROTOCOL) print 'Wrote RPN proposals to {}'.format(rpn_proposals_path[i]) else: print "Proposals for " + imdb_name + " exist already." if len(rpn_proposals_path) == 1: rpn_proposals_path = rpn_proposals_path[0] # Send the proposal file path through the # multiprocessing queue queue.put({'proposal_path': rpn_proposals_path})
def from_dets(imdb_name, output_dir, comp_mode): imdb = get_imdb(imdb_name) imdb.competition_mode(comp_mode) with open(os.path.join(output_dir, 'detections.pkl'), 'rb') as f: dets = cPickle.load(f) print 'Applying NMS to all detections' nms_dets = apply_nms(dets, cfg.TEST.NMS) print 'Evaluating detections' imdb.evaluate_detections(nms_dets, output_dir)
def rcnn_demo(i): imdb = get_imdb('voc_2007_test') img = cv2.imread(imdb.image_path_at(i)) rcnn_model = np.load('rcnn_model2.npy').all() rcnn_load_model(rcnn_model, False) # rcnn_model = np.load('rcnn_model.npz')['rcnn_model'].all() # thresh = -1 dets = rcnn_detect(imdb.image_index[i], imdb, rcnn_model) for i in xrange(len(dets)): if isinstance(dets[i], list): continue vis_detections(img, rcnn_model.classes[i], dets[i])
def from_dets(imdb_name, output_dir, args): imdb = get_imdb(imdb_name) imdb.competition_mode(args.comp_mode) imdb.config['matlab_eval'] = args.matlab_eval with open(os.path.join(output_dir, 'detections.pkl'), 'rb') as f: dets = cPickle.load(f) print 'Applying NMS to all detections' cfg.USE_GPU_NMS = False # much faster than GPU NMS for small number of dets nms_dets = apply_nms(dets, cfg.TEST.NMS) print 'Evaluating detections' imdb.evaluate_detections(nms_dets, output_dir)
def combined_roidb(imdb_names): """ Combine multiple roidbs """ 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 roidbs = [get_roidb(s) for s in imdb_names.split('+')] roidb = roidbs[0] if len(roidbs) > 1: for r in roidbs[1:]: roidb.extend(r) tmp = get_imdb(imdb_names.split('+')[1]) imdb = datasets.imdb.imdb(imdb_names, tmp.classes) else: imdb = get_imdb(imdb_names) return imdb, roidb
def from_dets(imdb_name, output_dir, args): imdb = get_imdb(imdb_name) imdb.competition_mode(args.comp_mode) imdb.config['matlab_eval'] = args.matlab_eval with open(os.path.join(output_dir, 'detections.pkl'), 'rb') as f: dets = cPickle.load(f) if args.apply_nms: print('Applying NMS to all detections') nms_dets = apply_nms(dets, cfg.TEST.NMS) else: nms_dets = dets print('Evaluating detections') imdb.evaluate_detections(nms_dets, output_dir)
def combined_roidb(imdb_names): 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 roidbs = [get_roidb(s) for s in imdb_names.split('+')] roidb = roidbs[0] if len(roidbs) > 1: for r in roidbs[1:]: roidb.extend(r) imdb = datasets.imdb(imdb_names) else: imdb = get_imdb(imdb_names) return imdb, roidb
def extractFeatureImdb(self, imdb_name=None, im_list=None): """extracts features of a image database able to do for sublist of images :imdb_name: name of image database, the same as girschick's implementation, to be used with datasets.factory.get_imdb :im_list: gives features with the same order of im_list, if None, then assumes the default order :returns: ndarray of im_list*feature_vector """ if imdb_name is None: imdb_name = self.config['IMDB_NAME'] imdb = get_imdb(imdb_name) self.config['IMDB_NAME'] = imdb_name if im_list is None: im_list = imdb.image_index # check if file already exists, debugging purposes, should add a rerun # feature to it features_file = os.path.join(self.path, imdb_name + '.pkl') self._feature_file = features_file if os.path.exists(features_file): print 'Reading features from file {}'.format(features_file) with open(features_file, 'rb') as f: features = cPickle.load(f) return features print 'computing features for {}'.format(imdb_name) num_images = len(im_list) reporting_freq = np.floor(num_images/10) # extract first image's feature vector to learn more about the # dimensions and then proceed im = imdb.image_path_from_index(im_list[0]) feat = self._extractFeatureImage(im) feat_dimension = len(feat) features = np.empty((len(im_list),feat_dimension)) features[0,:] = feat for i, imindex in enumerate(im_list[1:]): if (i+1)%reporting_freq == 0: print 'computing features for image {}/{}'.format(i+2, num_images) im = imdb.image_path_from_index(imindex) features[i+1, :] = self._extractFeatureImage(im) # save intermediate files print 'saving features to {}'.format(features_file) with open(features_file, 'wb') as f: cPickle.dump(features, f) return features
def combined_roidb(imdb_names): 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 roidbs = [get_roidb(s) for s in imdb_names.split("+")] roidb = roidbs[0] if len(roidbs) > 1: for r in roidbs[1:]: roidb.extend(r) imdb = datasets.imdb.imdb(imdb_names) else: imdb = get_imdb(imdb_names) return imdb, roidb
def combined_roidb(imdb_names): 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 imdb = get_imdb(imdb_names) print 'Loaded dataset `{:s}` for training'.format(imdb.name) roidb = get_roidb(imdb) # roidbs = [get_roidb(s) for s in imdb_names.split('+')] # roidb = roidbs[0] # if len(roidbs) > 1: # for r in roidbs[1:]: # roidb.extend(r) # imdb = datasets.imdb.imdb(imdb_names) # else: # imdb = get_imdb(imdb_names) return imdb, roidb
def from_mats(imdb_name, output_dir): import scipy.io as sio imdb = get_imdb(imdb_name) aps = [] for i, cls in enumerate(imdb.classes[1:]): mat = sio.loadmat(os.path.join(output_dir, cls + '_pr.mat')) ap = mat['ap'][0, 0] * 100 apAuC = mat['ap_auc'][0, 0] * 100 print '!!! {} : {:.1f} {:.1f}'.format(cls, ap, apAuC) aps.append(ap) print '~~~~~~~~~~~~~~~~~~~' print 'Results (from mat files):' for ap in aps: print '{:.1f}'.format(ap) print '{:.1f}'.format(np.array(aps).mean()) print '~~~~~~~~~~~~~~~~~~~'
def combined_roidb(imdb_names): print('===> Start compined_roidb in train_net.py') 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 roidbs = [get_roidb(s) for s in imdb_names.split('+')] roidb = roidbs[0] if len(roidbs) > 1: for r in roidbs[1:]: roidb.extend(r) imdb = datasets.imdb(imdb_names) else: imdb = get_imdb(imdb_names) print('===> Start compined_roidb in train_net.py. done') return imdb, roidb
def main(args): # Combine the default config with # the external config file and the set command if args.cfg is not None: cfg_from_file(args.cfg) if args.set_cfgs is not None: cfg_from_list(args.set_cfgs) cfg.DEBUG = args.debug cfg.GPU_ID = args.gpu_id cfg_print(cfg) # Loading the network caffe.set_mode_gpu() caffe.set_device(args.gpu_id) net = caffe.Net(args.prototxt, args.model, caffe.TEST) # Create the imdb imdb = get_imdb(args.db_name) # Set the network name net.name = args.net_name # Evaluate the network test_net(net, imdb, visualize=args.visualize, no_cache=args.no_cache, output_path=args.out_path)
if args.set_cfgs: cfg_from_list(args.set_cfgs) # Record logs into cfg cfg.LOG.CMD = ' '.join(sys.argv) cfg.LOG.TIME = datetime.datetime.now().strftime('%Y_%m_%d_%H_%M_%S') np.random.seed(int(cfg.RNG_SEED)) if cfg.TENSORBOARD.ENABLE: tb.client = Tensorboard(hostname=cfg.TENSORBOARD.HOSTNAME, port=cfg.TENSORBOARD.PORT) tb.sess = tb.client.create_experiment(cfg.NAME + '_' + cfg.LOG.TIME) if args.train == 'true' or args.train == 'True': # the training entrance # Get training imdb imdb = get_imdb(cfg.TRAIN.DB) roidb = get_training_roidb(imdb) # Redirect stderr output_dir = get_output_dir(imdb.name, cfg.NAME + '_' + cfg.LOG.TIME) f = open(osp.join(output_dir, 'stderr.log'), 'w', 0) os.dup2(f.fileno(), sys.stderr.fileno()) os.dup2(sys.stderr.fileno(), sys.stderr.fileno()) # Edit solver and train prototxts target_sw = osp.join(output_dir, 'solver.prototxt') target_train = osp.join(output_dir, 'train.prototxt') manipulate_solver(cfg.TRAIN.SOLVER, target_sw, train_net=target_train) manipulate_train(cfg.TRAIN.PROTOTXT, target_train)
def combined_roidb(imdb_names, training=True): #dataset name """ Combine multiple roidbs 融合多个roidbs """ def get_training_roidb(imdb): """Returns a roidb (Region of Interest database) for use in training.""" # 如果使用翻转,数据增广 2975张 -> 5950张 if cfg.TRAIN.USE_FLIPPED: print('Appending horizontally-flipped training examples...') imdb.append_flipped_images() # data augment print('done') print('Preparing training data...') # 准备imdb prepare_roidb(imdb) #ratio_index = rank_roidb_ratio(imdb) print('done') return imdb.roidb # 如imdb_name="cityscape_2007_train_s" def get_roidb(imdb_name): # get_imdb 在 factory.py中定义,通过名称获取imdb(image database) # imdb 是数据集标注的实例化对象( !! 例如 imdb = cityscape(train_s, 2007)) imdb = get_imdb( imdb_name ) # return a pascal_voc dataset object get_imdb is from factory which contain all legal dataset object print('Loaded dataset `{:s}` for training'.format( imdb.name)) # 打印数据集的名字 !! 例如 'cityscape_2007_train_s' # cfg.TRAIN.PROPOSAL_METHOD = 'gt' --> 训练方法?? imdb.set_proposal_method(cfg.TRAIN.PROPOSAL_METHOD) print('Set proposal method: {:s}'.format(cfg.TRAIN.PROPOSAL_METHOD)) # 由imdb变为roidb roidb = get_training_roidb(imdb) return roidb # 对字符串进行分割,有的数据集中是多个数据集名用‘+’相连,先分开处理。 # 最终返回GT的roidbs,形式[ 第一种数据集->[{ 第一张图片的字典 },{ 第二张图片的字典 },{...}],第二种数据集-> [{},...],[...]] roidbs = [get_roidb(s) for s in imdb_names.split('+')] roidb = roidbs[0] # 这里因为只有一个数据集,即cityscapes # 如果数据集的个数 > 1 if len(roidbs) > 1: # r是每个roidb列表 for r in roidbs[1:]: # 在第一个数据集的列表中追加(后面数据集的图片标注)字典 roidb.extend(r) tmp = get_imdb(imdb_names.split('+')[1]) # 对第一个数据集???? imdb = datasets.imdb.imdb(imdb_names, tmp.classes) # 数据集合并 else: imdb = get_imdb(imdb_names) # 如果是在训练过程 if training: # 过滤没有目标框的目标 !!对cityscape : 5950张 -> 5932张 roidb = filter_roidb(roidb) # filter samples without bbox ratio_list, ratio_index = rank_roidb_ratio( roidb) # 进行长宽比的排列,排列后的长宽比列表ratio_list & 长宽比的次序ratio_index return imdb, roidb, ratio_list, ratio_index # dataset, roidb dict,ratio_list(0.5,0.5,0.5......2,2,2,), ratio_increase_index(4518,6421,.....)
def get_Imdbs(imdb_names): imdbs = [get_imdb(s) for s in imdb_names.split('+')] for im in imdbs: im.set_proposal_method(cfg.TRAIN.PROPOSAL_METHOD) print 'Set proposal method: {:s}'.format(cfg.TRAIN.PROPOSAL_METHOD) return datasets.imdb.Imdbs(imdbs)
def main(args): 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) # parse gpus gpus = map(int, args.gpus.split(',')) assert len(gpus) >= mpi_size, "Number of GPUs must be >= MPI size" cfg.GPU_ID = gpus[mpi_rank] # parse feature blob names blob_names = args.blob_names.split(',') print('Using config:') pprint.pprint(cfg) while not osp.exists(args.caffemodel) and args.wait: print('Waiting for {} to exist...'.format(args.caffemodel)) time.sleep(10) # load imdb imdb = get_imdb(args.imdb_name) root_dir = imdb._root_dir images_dir = imdb._data_path output_dir = get_output_dir(imdb.name, osp.splitext(osp.basename(args.caffemodel))[0]) if args.eval_only: def _load(fname): fpath = osp.join(output_dir, fname) assert osp.isfile(fpath), "Must have extracted detections and " \ "features first before evaluation" return unpickle(fpath) if mpi_rank == 0: gboxes = _load('gallery_detections.pkl') gfeatures = _load('gallery_features.pkl') pfeatures = _load('probe_features.pkl') else: # setup caffe caffe.mpi_init() caffe.set_mode_gpu() caffe.set_device(cfg.GPU_ID) # 1. Detect and extract features from all the gallery images in the imdb start, end = mpi_dispatch(len(imdb.image_index), mpi_size, mpi_rank) if args.use_gt: net = caffe.Net(args.probe_def, args.caffemodel, caffe.TEST) gboxes, gfeatures = usegt_and_exfeat(net, imdb, start=start, end=end, blob_names=blob_names) else: net = caffe.Net(args.gallery_def, args.caffemodel, caffe.TEST) gboxes, gfeatures = detect_and_exfeat(net, imdb, start=start, end=end, blob_names=blob_names) gboxes = mpi_collect(mpi_comm, mpi_rank, gboxes) gfeatures = mpi_collect(mpi_comm, mpi_rank, gfeatures) del net # to release the cudnn conv static workspace # 2. Only extract features from given probe rois start, end = mpi_dispatch(len(imdb.probes), mpi_size, mpi_rank) net = caffe.Net(args.probe_def, args.caffemodel, caffe.TEST) pfeatures = exfeat(net, imdb.probes, start=start, end=end, blob_names=blob_names) pfeatures = mpi_collect(mpi_comm, mpi_rank, pfeatures) del net # Save if mpi_rank == 0: pickle(gboxes, osp.join(output_dir, 'gallery_detections.pkl')) pickle(gfeatures, osp.join(output_dir, 'gallery_features.pkl')) pickle(pfeatures, osp.join(output_dir, 'probe_features.pkl')) # Evaluate if mpi_rank == 0: imdb.evaluate_detections(gboxes, det_thresh=args.det_thresh) imdb.evaluate_detections(gboxes, det_thresh=args.det_thresh, labeled_only=True) imdb.evaluate_search(gboxes, gfeatures['feat'], pfeatures['feat'], det_thresh=args.det_thresh, gallery_size=args.gallery_size, dump_json=osp.join(output_dir, 'results.json'))
if __name__ == '__main__': args = parse_args() print('Called with args:') print(args) if args.cfg_file is not None: cfg_from_file(args.cfg_file) print('Using config:') pprint.pprint(cfg) weights_filename = os.path.splitext(os.path.basename(args.model))[0] imdb = get_imdb(args.imdb_name) # construct the filenames root = 'data/demo_images/' num = 5 rgb_filenames = [] depth_filenames = [] for i in xrange(num): filename = root + '{:06d}-color.png'.format(i + 1) print filename rgb_filenames.append(filename) filename = root + '{:06d}-depth.png'.format(i + 1) print filename depth_filenames.append(filename) # construct meta data
print('Using config:') pprint(cfg) while not os.path.exists(args.caffemodel) and args.wait: print('Waiting for {} to exist...'.format(args.caffemodel)) time.sleep(10) caffe.set_mode_gpu() caffe.set_device(args.gpu_id) label_set = args.label_set print label_set if label_set != None: label_set = label_set.split(',') imdb = get_imdb(args.imdb_name, dict(label_set = label_set, num_selected = 2)) imdb.competition_mode(args.comp_mode) if not cfg.TEST.HAS_RPN: imdb.set_proposal_method(cfg.TEST.PROPOSAL_METHOD) proto_file = args.prototxt with open(proto_file, 'r') as fp: all_content = fp.read() net_proto = caffe.proto.caffe_pb2.NetParameter() text_format.Merge(all_content, net_proto) all_finded = [layer for layer in net_proto.layer \ if layer.name == 'cls_score'] assert len(all_finded) == 1 all_finded[0].inner_product_param.num_output = len(imdb.classes) all_finded = [layer for layer in net_proto.layer \ if layer.name == 'bbox_pred']
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
exp_name = None # the previous experiment name in TensorBoard # ------------ if rand_seed is not None: np.random.seed(rand_seed) # load config file and get hyperparameters cfg_from_file(cfg_file) lr = cfg.TRAIN.LEARNING_RATE momentum = cfg.TRAIN.MOMENTUM weight_decay = cfg.TRAIN.WEIGHT_DECAY disp_interval = cfg.TRAIN.DISPLAY log_interval = cfg.TRAIN.LOG_IMAGE_ITERS # load imdb and create data later imdb = get_imdb(imdb_name) test_imdb = get_imdb(test_imdb_name) rdl_roidb.prepare_roidb(imdb) roidb = imdb.roidb data_layer = RoIDataLayer(roidb, imdb.num_classes) # Create network and initialize net = WSDDN(classes=imdb.classes, debug=_DEBUG) print(net) network.weights_normal_init(net, dev=0.001) if os.path.exists('pretrained_alexnet.pkl'): pret_net = pkl.load(open('pretrained_alexnet.pkl', 'rb')) else: pret_net = model_zoo.load_url( 'https://download.pytorch.org/models/alexnet-owt-4df8aa71.pth') pkl.dump(pret_net, open('pretrained_alexnet.pkl', 'wb'),
def main(): np.random.seed(5) global args, best_prec1 args = parser.parse_args() args.distributed = args.world_size > 1 # create model print("=> creating model '{}'".format(args.arch)) if args.arch == 'localizer_alexnet': model = localizer_alexnet(pretrained=args.pretrained) criterion = multilabel_loss elif args.arch == 'localizer_alexnet_robust': model = localizer_alexnet_robust(pretrained=args.pretrained) criterion = multilabel_loss_robust print(model) model.features = torch.nn.DataParallel(model.features) model.cuda() # TODO: # define loss function (criterion) and optimizer # criterion = multilabel_loss params = list(model.parameters()) # optimizer = torch.optim.SGD(params[2:], args.lr, # momentum=args.momentum, # weight_decay=args.weight_decay) optimizer = torch.optim.Adam(params[10:], args.lr, weight_decay=args.weight_decay) # optionally resume from a checkpoint if args.resume: if os.path.isfile(args.resume): print("=> loading checkpoint '{}'".format(args.resume)) checkpoint = torch.load(args.resume) args.start_epoch = checkpoint['epoch'] best_prec1 = checkpoint['best_prec1'] model.load_state_dict(checkpoint['state_dict']) optimizer.load_state_dict(checkpoint['optimizer']) print("=> loaded checkpoint '{}' (epoch {})".format( args.resume, checkpoint['epoch'])) else: print("=> no checkpoint found at '{}'".format(args.resume)) cudnn.benchmark = True # Data loading code # TODO: Write code for IMDBDataset in custom.py trainval_imdb = get_imdb('voc_2007_trainval') test_imdb = get_imdb('voc_2007_test') normalize = transforms.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225]) train_dataset = IMDBDataset( trainval_imdb, transforms.Compose([ transforms.Resize((512, 512)), transforms.RandomHorizontalFlip(), transforms.ToTensor(), normalize, ])) train_sampler = None train_loader = torch.utils.data.DataLoader(train_dataset, batch_size=args.batch_size, shuffle=False, num_workers=args.workers, pin_memory=True, sampler=train_sampler) val_loader = torch.utils.data.DataLoader(IMDBDataset( test_imdb, transforms.Compose([ transforms.Resize((384, 384)), transforms.ToTensor(), normalize, ])), batch_size=args.batch_size, shuffle=False, num_workers=args.workers, pin_memory=True) logger = Logger('./tfboard2', name='freeloc_robust') if args.evaluate: validate(val_loader, model, criterion, logger, 0) return # TODO: Create loggers for visdom and tboard # TODO: You can pass the logger objects to train(), make appropriate # modifications to train() for epoch in range(args.start_epoch, args.epochs): adjust_learning_rate(optimizer, epoch) # train for one epoch train(train_loader, model, criterion, optimizer, epoch, logger) # evaluate on validation set if epoch % args.eval_freq == 0 or epoch == args.epochs - 1: m1, m2 = validate(val_loader, model, criterion, logger, epoch) score = m1 * m2 # remember best prec@1 and save checkpoint is_best = score > best_prec1 best_prec1 = max(score, best_prec1) save_checkpoint( { 'epoch': epoch + 1, 'arch': args.arch, 'state_dict': model.state_dict(), 'best_prec1': best_prec1, 'optimizer': optimizer.state_dict(), }, is_best)
scale = blobs['im_info'][0, 2] boxes = blobs_out['rois'][:, 1:].copy() scores = blobs_out['scores'].copy() return boxes, scores cfg.TEST.RPN_PRE_NMS_TOP_N = -1 # no pre NMS filtering cfg.TEST.RPN_POST_NMS_TOP_N = 2000 # limit top boxes after NMS import caffe _init_caffe(cfg) imdb = get_imdb('compcars_trainval') rpn_test_prototxt = os.path.join(cfg.MODELS_DIR, 'ZF', 'faster_rcnn_alt_opt', 'rpn_test.pt') rpn_model_path = './output/faster_rcnn_alt_opt/compcars_trainval/zf_rpn_stage1_iter_80000.caffemodel' # Load RPN and configure output directory rpn_net = caffe.Net(rpn_test_prototxt, rpn_model_path, caffe.TEST) nums = 10 boxes = [[] for _ in xrange(nums)] for i in xrange(nums): im = cv2.imread(imdb.image_path_at(i)) boxes[i], scores = im_proposals(rpn_net, im) im = Image.open(imdb.image_path_at(i))
current_frames) if __name__ == '__main__': cfg_from_file("models/pvanet/cfgs/submit_1019.yml") output_name = "hierarchy" data_name = "tanktruck" classes = CLASS_SETS["coco"] sub_classes = CLASS_SETS["vehicle-types"] prototxt = "models/pvanet/lite/hierachy/v1_test.prototxt" caffemodel = "models/hierarchy/v2/v1_iter_10000.caffemodel" FPS_rate = 1 GPU_ID = 0 imdb = get_imdb(data_name, classes) OUTPUT_DIR = os.path.join(imdb._data_path, "res", output_name) if not os.path.exists(OUTPUT_DIR): os.makedirs(OUTPUT_DIR) if not os.path.isfile(caffemodel): raise IOError(('Caffemodel: {:s} not found').format(caffemodel)) caffe.set_device(GPU_ID) cfg.GPU_ID = GPU_ID net = caffe.Net(prototxt, caffemodel, caffe.TEST) print '\n\nLoaded network {:s}'.format(caffemodel) print("PVANET Loaded") print("Start Detecting") write_testing_results_file(net, imdb, FPS_rate, OUTPUT_DIR, classes)
return sub_cls, sub_score, sub_ind if __name__ == '__main__': cfg_from_file("models/pvanet/cfgs/submit_1019.yml") output_name = "v13-100k" data_name = "Thailand" CLASSES_main = CLASS_SETS["coco"] CLASSES_sub = CLASS_SETS['vehicle-types'] prototxt = "/root/pva-faster-rcnn/models/pvanet/lite/hierachy/v1_test.prototxt" caffemodel = "/root/pva-faster-rcnn/models/hierarchy/v13/v13_iter_100000.caffemodel" FPS_rate = 1 GPU_ID = 2 imdb = get_imdb(data_name, CLASSES_main) OUTPUT_DIR = os.path.join(imdb._data_path, "res", output_name) if not os.path.exists(OUTPUT_DIR): os.makedirs(OUTPUT_DIR) if not os.path.isfile(caffemodel): raise IOError(('Caffemodel: {:s} not found').format(caffemodel)) caffe.set_mode_gpu() caffe.set_device(GPU_ID) cfg.GPU_ID = GPU_ID net = caffe.Net(prototxt, caffemodel, caffe.TEST) print '\n\nLoaded network {:s}'.format(caffemodel) print("PVANET Loaded") print("Start Detecting")
single_scale = True # True: sinle scale test; False: multi scale test test_set = 'coco_2017_val' # 'voc_2007_test' or 'voc_2012_test' or 'coco_2014_minival' or 'coco_2015_test-dev' coco_path = 'models/ResNet/coco/refinedet_resnet101_512x512/' cfg.single_scale_test = single_scale path = coco_path if '320' in path: input_size = 320 else: input_size = 512 caffe.set_mode_gpu() caffe.set_device(GPU_ID) imdb = get_imdb(test_set) imdb.competition_mode(False) if 'coco' in test_set: if single_scale is True: prototxt = path + 'deploy.prototxt' else: prototxt = path + 'multi_test_deploy.prototxt' f = open(prototxt, 'r') for line in f: if 'confidence_threshold' in line: line = line[:-1] cfg.confidence_threshold = float(line.split(' ')[-1]) else: prototxt = path + 'deploy.prototxt' models = ['coco_refinedet_resnet101_512x512_final.caffemodel']
pprint.pprint(cfg) if not args.randomize: # fix the random seeds (numpy) for reproducibility np.random.seed(cfg.RNG_SEED) if args.multi_label == 1: imdb = get_imdb_multi(args.roidb, args.imdb, args.rpndb, args.data_dir, split=0) else: imdb = get_imdb(args.roidb, args.imdb, args.rpndb, args.data_dir, split=0) print 'Loaded imdb `{:s}` for training'.format(args.imdb) print 'Loaded roidb `{:s}` for training'.format(args.roidb) print 'Loaded rpndb `{:s}` for training'.format(args.rpndb) if cfg.TRAIN.USE_FLIPPED: print('appending flipped images') imdb.append_flipped_images() roidb = imdb.roidb print('roidb loaded') # compute bbox target mean and stds if not precomputed if False: print('precomputing target means...') imdb.add_rpn_rois(roidb, make_copy=False) prepare_roidb(roidb)
import os,sys #add library to the system path lib_path = os.path.abspath(os.path.join('lib')) sys.path.append(lib_path) lib_path = os.path.abspath(os.path.join('tools')) sys.path.append(lib_path) import numpy as np import cv2 from utils.transform import calib_to_P,clip3DwithinImage,projectToImage,lidar_to_camera import time from datasets.factory import get_imdb imdb = get_imdb('kitti_trainval') import read_lidar_VOXEL_test as rl root_dir = '/data/RPN/mscnn-master/data/testing'#'/data/RPN/mscnn-master/data/training' velodyne = os.path.join(root_dir, "velodyne/") bird = os.path.join(root_dir, "lidar_pc/") if not os.path.exists(bird):: os.mkdir(bird) t0 = time.time() for ind in xrange(imdb.num_images): filename = velodyne + str(ind).zfill(6) + ".bin" scan = np.fromfile(filename, dtype=np.float32) scan = scan.reshape((-1, 4)) im = cv2.imread(imdb.image_path_at(ind)) img_size = np.array([im.shape[1],im.shape[0]]) calib = imdb.calib_at(ind)
return xset xset = xset + vs[0] if __name__ == '__main__': cfg.TEST.HAS_RPN = True # Use RPN for proposals args = parse_args() if args.model == ' ': raise IOError(('Error: Model not found.\n')) if args.jpg == '': raise IOError(('Error: No image for detection')) imdb = get_imdb(args.imdb) # init session sess = tf.Session(config=tf.ConfigProto(allow_soft_placement=True)) # load network net = get_network(args.demo_net, len(CLASSES)) # load model saver = tf.train.Saver(write_version=tf.train.SaverDef.V1) saver.restore(sess, args.model) #sess.run(tf.initialize_all_variables()) print '\n\nLoaded network {:s}'.format(args.model) # Warmup on a dummy image im = 128 * np.ones((300, 300, 3), dtype=np.uint8)
def main(): device = torch.device("cuda" if torch.cuda.is_available() else "cpu") global args, best_prec1 args = parser.parse_args() args.distributed = args.world_size > 1 # create model print("=> creating model '{}'".format(args.arch)) if args.arch == 'localizer_alexnet': model = localizer_alexnet(pretrained=args.pretrained) elif args.arch == 'localizer_alexnet_robust': model = localizer_alexnet_robust(pretrained=args.pretrained) model.features = torch.nn.DataParallel(model.features) model.cuda() # TODO: # define loss function (criterion) and optimizer optimizer = torch.optim.Adam(model.parameters(), lr=args.lr) criterion = nn.BCEWithLogitsLoss() # optionally resume from a checkpoint if args.resume: if os.path.isfile(args.resume): print("=> loading checkpoint '{}'".format(args.resume)) checkpoint = torch.load(args.resume) args.start_epoch = checkpoint['epoch'] best_prec1 = checkpoint['best_prec1'] model.load_state_dict(checkpoint['state_dict']) optimizer.load_state_dict(checkpoint['optimizer']) print("=> loaded checkpoint '{}' (epoch {})".format( args.resume, checkpoint['epoch'])) else: print("=> no checkpoint found at '{}'".format(args.resume)) cudnn.benchmark = True # Data loading code # TODO: Write code for IMDBDataset in custom.py trainval_imdb = get_imdb('voc_2007_trainval') test_imdb = get_imdb('voc_2007_test') normalize = transforms.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225]) train_dataset = IMDBDataset( trainval_imdb, transforms.Compose([ transforms.Resize((512, 512)), transforms.RandomHorizontalFlip(), transforms.ToTensor(), normalize, ])) train_sampler = None train_loader = torch.utils.data.DataLoader(train_dataset, batch_size=args.batch_size, shuffle=(train_sampler is None), num_workers=args.workers, pin_memory=True, sampler=train_sampler) val_loader = torch.utils.data.DataLoader( IMDBDataset( test_imdb, transforms.Compose([ # transforms.Resize((384, 384)), transforms.Resize((512, 512)), transforms.ToTensor(), normalize, ])), batch_size=args.batch_size, shuffle=False, num_workers=args.workers, pin_memory=True) if args.evaluate: validate(val_loader, model, criterion) return # TODO: Create loggers for visdom and tboard # TODO: You can pass the logger objects to train(), make appropriate # modifications to train() import visdom vis = visdom.Visdom(server='http://localhost', port='8097') from tensorboardX import SummaryWriter logger = SummaryWriter('./runs/q3') for epoch in range(args.start_epoch, args.epochs): adjust_learning_rate(optimizer, epoch) # train for one epoch train(train_loader, model, criterion, optimizer, epoch, logger, vis) # evaluate on validation set if epoch % args.eval_freq == 0 or epoch == args.epochs - 1: m1, m2 = validate(val_loader, model, criterion, epoch, logger, vis) score = m1 * m2 # remember best prec@1 and save checkpoint is_best = score > best_prec1 best_prec1 = max(score, best_prec1) save_checkpoint( { 'epoch': epoch + 1, 'arch': args.arch, 'state_dict': model.state_dict(), 'best_prec1': best_prec1, 'optimizer': optimizer.state_dict(), }, is_best)
def run_single(imid): caffe.set_mode_gpu() caffe.set_device(0) m = h5py.File('/home/zawlin/Dropbox/proj/sg_vrd_meta.h5', 'r', 'core') net = caffe.Net( 'models/sg_vrd/vgg16/faster_rcnn_end2end/test.prototxt', 'output/faster_rcnn_end2end/sg_vrd_2016_train/vgg16_faster_rcnn_iter_80000.caffemodel', caffe.TEST) net2 = caffe.Net( 'models/sg_vrd/vgg16/faster_rcnn_end2end/test.prototxt', 'output/faster_rcnn_end2end/sg_vrd_2016_train/vgg16_faster_rcnn_finetune_iter_95000.caffemodel', caffe.TEST) # net.name = os.path.splitext(os.path.basename(args.caffemodel))[0] net.name = 'sgvrd' imdb = get_imdb('sg_vrd_2016_test') imdb.competition_mode(0) if not cfg.TEST.HAS_RPN: imdb.set_proposal_method(cfg.TEST.PROPOSAL_METHOD) """Test a Fast R-CNN network on an image database.""" num_images = len(imdb.image_index) # all detections are collected into: # all_boxes[cls][image] = N x 5 array of detections in # (x1, y1, x2, y2, score) all_boxes = [[[] for _ in xrange(num_images)] for _ in xrange(imdb.num_classes)] root = 'data/sg_vrd_2016/Data/sg_test_images/' cnt = 0 fpath = root + imid + '.jpg' im_orig = cv2.imread(fpath) if im_orig == None: print fpath cv2.namedWindow('ctrl') cv2.createTrackbar('t1', 'ctrl', 200, 1000, nothing) cv2.createTrackbar('t2', 'ctrl', 200, 1000, nothing) dets1 = detect(im_orig, net, 0.1, imid, m) dets2 = detect(im_orig, net2, 0.1, imid, m) print_text = True while True: im = im_orig.copy() t1 = cv2.getTrackbarPos('t1', 'ctrl') / 1000. t2 = cv2.getTrackbarPos('t2', 'ctrl') / 1000. # t1idx = [] # t2idx = [] t1idx = [2, 10] t2idx = [1, 9] for i in xrange(len(dets1)): #if t1idx != -1 and t1idx!=i: continue if len(t1idx) > 0 and i not in t1idx: continue d = dets1[i] score = d['score'] if score < t1: continue cls_name = d['cls_name'] + '.' + str(i) di = [d['x1'], d['y1'], d['x2'], d['y2']] x, y = int(di[0]), int(di[1]) if x < 10: x = 15 if y < 10: y = 15 if print_text: cv2.putText(im, cls_name, (x, y), cv2.FONT_HERSHEY_COMPLEX, 1, (0, 0, 255), 1) cv2.rectangle(im, (di[0], di[1]), (di[2], di[3]), (0, 0, 255), 1) #print '%s %f %d %d %d %f\n' % (imid, score, di[0], di[1], di[2], di[3]) for i in xrange(len(dets2)): if len(t2idx) > 0 and i not in t2idx: continue d = dets2[i] score = d['score'] if score < t2: continue cls_name = d['cls_name'] + '.' + str(i) di = [d['x1'], d['y1'], d['x2'], d['y2']] x, y = int(di[0]), int(di[1]) if x < 10: x = 15 if y < 10: y = 15 if print_text: cv2.putText(im, cls_name, (x, y), cv2.FONT_HERSHEY_COMPLEX, 1, (0, 0, 255), 1) cv2.rectangle(im, (di[0], di[1]), (di[2], di[3]), (0, 255, 0), 1) #print '%s %f %d %d %d %f\n' % (imid, score, di[0], di[1], di[2], di[3]) cv2.imshow('im', im) c = cv2.waitKey(100) & 0xFF if c == ord('s'): cv2.imwrite('output/results/' + imid + '.jpg', im) print 'written' elif c == ord('b'): print_text = not print_text elif c == ord(' '): break elif c == 27: exit(0)
def combined_roidb(imdb_names, training=True, seen=1): """ Combine multiple roidbs """ def get_training_roidb(imdb, training): """Returns a roidb (Region of Interest database) for use in training.""" if cfg.TRAIN.USE_FLIPPED and training: print('Appending horizontally-flipped training examples...') imdb.append_flipped_images() print('done') print('Preparing training data...') prepare_roidb(imdb) #ratio_index = rank_roidb_ratio(imdb) print('done') return imdb.roidb def get_roidb(imdb_name, training): 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)) imdb.filter(seen) roidb = get_training_roidb(imdb, training) return imdb, roidb, imdb.cat_data, imdb.inverse_list imdbs = [] roidbs = [] querys = [] for s in imdb_names.split('+'): imdb, roidb, query, reserved = get_roidb(s, training) imdbs.append(imdb) roidbs.append(roidb) querys.append(query) imdb = imdbs[0] roidb = roidbs[0] query = querys[0] if len(roidbs) > 1 and training: for r in roidbs[1:]: roidb.extend(r) for r in range(len(querys[0])): query[r].extend(querys[1][r]) tmp = get_imdb(imdb_names.split('+')[1]) imdb = datasets.imdb.imdb(imdb_names, tmp.classes) if training: roidb = filter_roidb(roidb) ratio_list, ratio_index = rank_roidb_ratio(roidb) else: # Generate testing image, an image testing frequency(time) according to the reserved category ratio_list, ratio_index = test_rank_roidb_ratio(roidb, reserved) return imdb, roidb, ratio_list, ratio_index, query
exp_name = None # the previous experiment name in TensorBoard # ------------ if rand_seed is not None: np.random.seed(rand_seed) # load config file and get hyperparameters cfg_from_file(cfg_file) lr = cfg.TRAIN.LEARNING_RATE momentum = cfg.TRAIN.MOMENTUM weight_decay = cfg.TRAIN.WEIGHT_DECAY disp_interval = cfg.TRAIN.DISPLAY log_interval = cfg.TRAIN.LOG_IMAGE_ITERS # load imdb and create data later imdb = get_imdb(imdb_name) rdl_roidb.prepare_roidb(imdb) roidb = imdb.roidb data_layer = RoIDataLayer(roidb, imdb.num_classes) imdb_test = get_imdb(imdb_test_name) # Create network and initialize net = WSDDN(classes=imdb.classes, debug=_DEBUG) print(net) network.weights_normal_init(net, dev=0.001) if os.path.exists('pretrained_alexnet.pkl'): pret_net = pkl.load(open('pretrained_alexnet.pkl', 'rb')) else: pret_net = model_zoo.load_url( 'https://download.pytorch.org/models/alexnet-owt-4df8aa71.pth')
im2show = cv2.cvtColor(im2show, cv2.COLOR_BGR2RGB) im2show = im2show.transpose((2, 0, 1)) logger.add_image('test/image_with_box/' + str(step), im2show / 255., i) with open(det_file, 'wb') as f: cPickle.dump(all_boxes, f, cPickle.HIGHEST_PROTOCOL) print('Evaluating detections') aps = imdb.evaluate_detections(all_boxes, output_dir) return aps if __name__ == '__main__': # load data imdb = get_imdb(imdb_name) imdb.competition_mode(on=True) # load net net = WSDDN(classes=imdb.classes, debug=False) trained_model = trained_model_fmt.format(cfg.TRAIN.SNAPSHOT_PREFIX, 30000) print('Loading {}'.format(trained_model)) network.load_net(trained_model, net) print('load model successfully!') net.cuda() net.eval() # evaluation aps = test_net(save_name, net,
print('Using config:') pprint(cfg) while not os.path.exists(args.caffemodel) and args.wait: print('Waiting for {} to exist...'.format(args.caffemodel)) time.sleep(10) caffe.set_mode_gpu() caffe.set_device(args.gpu_id) label_set = args.label_set print label_set if label_set != None: label_set = label_set.split(',') imdb = get_imdb(args.imdb_name, dict(label_set=label_set, num_selected=10)) imdb.competition_mode(args.comp_mode) proto_file = args.prototxt with open(proto_file, 'r') as fp: all_content = fp.read() net_proto = caffe.proto.caffe_pb2.NetParameter() text_format.Merge(all_content, net_proto) all_finded = [layer for layer in net_proto.layer \ if layer.name == 'cls_score'] assert len(all_finded) == 1 all_finded[0].inner_product_param.num_output = len(imdb.classes) all_finded = [layer for layer in net_proto.layer \ if layer.name == 'bbox_pred'] assert len(all_finded) == 1 all_finded[0].inner_product_param.num_output = 4 * len(imdb.classes)
def run_test_visualize(): caffe.set_mode_gpu() caffe.set_device(0) m = h5py.File('/home/zawlin/Dropbox/proj/sg_vrd_meta.h5', 'r', 'core') net = caffe.Net( 'models/sg_vrd/vgg16/faster_rcnn_end2end/test.prototxt', 'output/faster_rcnn_end2end/sg_vrd_2016_train/vgg16_faster_rcnn_iter_80000.caffemodel', caffe.TEST) net2 = caffe.Net( 'models/sg_vrd/vgg16/faster_rcnn_end2end/test.prototxt', 'output/faster_rcnn_end2end/sg_vrd_2016_train/vgg16_faster_rcnn_finetune_iter_95000.caffemodel', caffe.TEST) # net.name = os.path.splitext(os.path.basename(args.caffemodel))[0] net.name = 'sgvrd' imdb = get_imdb('sg_vrd_2016_test') imdb.competition_mode(0) if not cfg.TEST.HAS_RPN: imdb.set_proposal_method(cfg.TEST.PROPOSAL_METHOD) """Test a Fast R-CNN network on an image database.""" num_images = len(imdb.image_index) # all detections are collected into: # all_boxes[cls][image] = N x 5 array of detections in # (x1, y1, x2, y2, score) all_boxes = [[[] for _ in xrange(num_images)] for _ in xrange(imdb.num_classes)] root = 'data/sg_vrd_2016/Data/sg_test_images/' cnt = 0 cv2.namedWindow('ctrl') cv2.createTrackbar('t1', 'ctrl', 200, 1000, nothing) cv2.createTrackbar('t2', 'ctrl', 200, 1000, nothing) images = [] for path, subdirs, files in os.walk(root): for name in files: cnt += 1 imid = name.split('.')[0] fpath = os.path.join(path, name) images.append(fpath) random.shuffle(images) for fpath in images: print fpath imorig = cv2.imread(fpath) dets1 = detect(imorig, net, 0.01, imid, m) dets2 = detect(imorig, net2, 0.01, imid, m) while True: im = imorig.copy() t1 = cv2.getTrackbarPos('t1', 'ctrl') / 1000. t2 = cv2.getTrackbarPos('t2', 'ctrl') / 1000. for i in xrange(len(dets1)): d = dets1[i] score = d['score'] if score < t1: continue cls_name = d['cls_name'] + '.' + str(i) di = [d['x1'], d['y1'], d['x2'], d['y2']] x, y = int(di[0]), int(di[1]) if x < 10: x = 15 if y < 10: y = 15 cv2.putText(im, cls_name, (x, y), cv2.FONT_HERSHEY_COMPLEX, 1, (0, 0, 255), 1) cv2.rectangle(im, (di[0], di[1]), (di[2], di[3]), (255, 0, 0), 2) #print '%s %f %d %d %d %f\n' % (imid, score, di[0], di[1], di[2], di[3]) for i in xrange(len(dets2)): d = dets2[i] score = d['score'] if score < t2: continue cls_name = d['cls_name'] + '.' + str(i) di = [d['x1'], d['y1'], d['x2'], d['y2']] x, y = int(di[0]), int(di[1]) if x < 10: x = 15 if y < 10: y = 15 cv2.putText(im, cls_name, (x, y), cv2.FONT_HERSHEY_COMPLEX, 1, (0, 0, 255), 1) cv2.rectangle(im, (di[0], di[1]), (di[2], di[3]), (0, 255, 0), 2) #print '%s %f %d %d %d %f\n' % (imid, score, di[0], di[1], di[2], di[3]) cv2.imshow('im', im) c = cv2.waitKey(100) & 0xFF if c == ord('s'): pass elif c == ord(' '): break elif c == 27: exit(0)
def gogo(): print 'starting ensemble' thresh = 0.01 #data_type = 'val' data_type = 'test' exclude_worst = True num_classes = 201 imdb_name = 'imagenet_' + data_type base_dir = '/home/dj/big/workspace/fast-rcnn/output/ensemble/' data = [] result = [] # 1. vgg16 frcnn data.append('vgg16_imagenet_fast_rcnn_with_ss_iter_500000') result.append('result_comp4-1648.txt') # 2. vgg16 step 2_1 #data.append('vgg16_imagenet_fast_rcnn_step2_with_rpn_iter_520000') #result.append('result_comp4-13436.txt') # 3. vgg16 step 2_2 #data.append('vgg16_imagenet_fast_rcnn2_step2_with_rpn_iter_520000') #result.append('result_comp4-31392.txt') # (2, 3) vgg16 avg (step 2_1, step 2_2) data.append('vgg16_imagenet_fast_rcnn_avg_2_3') result.append('result_comp4-3153.txt') # (2, 3, 5) vgg16 avg (step 2_1, step 2_2, step 2_4) #data.append('vgg16_imagenet_fast_rcnn_with_rpn_avg_2_3_5') #result.append('result_comp4-33831.txt') # (2, 3, 6) vgg16 avg (step 2_1, step 2_2, step 4) #data.append('vgg16_imagenet_fast_rcnn_avg_2_3_6') #result.append('result_comp4-22284.txt') # (2, 3, 4, 5) vgg16 avg (step 2_1, step 2_2, step 2_3, step 2_4) #data.append('vgg16_imagenet_fast_rcnn_with_rpn_avg_2_3_4_5') #result.append('result_comp4-6730.txt') # (2, 3, 5, 6) vgg16 avg (step 2_1, step 2_2, step 2_4, step 4) #data.append('vgg16_imagenet_fast_rcnn_avg_2_3_5_6') #result.append('result_comp4-6456.txt') # 6. vgg16 step 4 data.append('vgg16_imagenet_fast_rcnn_step4_with_rpn_iter_360000') result.append('result_comp4-16205.txt') # 7. vgg19 frcnn data.append('vgg19_imagenet_fast_rcnn_with_ss_iter_470000') result.append('result_comp4-37160.txt') # 8. googlenet frcnn #data.append('googlenet_imagenet_fast_rcnn_with_ss_iter_480000') #result.append('result_comp4-42391.txt') # 9. vgg16 step 3 #data.append('vgg16_imagenet_fast_rcnn_step2_with_rpn_step3_iter_520000') #result.append('result_comp4-25665.txt') output_dir = '%s/results' % base_dir all_boxes = None total_result = np.zeros((num_classes, len(data))) data_no = 0 for one_result, one_data in zip(result, data): result_file = base_dir + one_data + '/val/' + one_result with open(result_file, 'rt') as f: line_no = 0 for one_line in f.readlines(): try: one_number = float(one_line.rstrip()) except: continue line_no += 1 total_result[line_no, data_no] = one_number if line_no >= num_classes - 1: break data_no += 1 min_data_index_per_class = np.argmin(total_result, axis=1) data_no = 0 for one_data in data: det_file = base_dir + one_data + '/' + data_type + '/detections.pkl' if data_type == 'test': submission_file = base_dir + one_data + '/' + data_type + '/submission.txt' else: submission_file = '' print '[%s] processing %s' % (data_no + 1, one_data) with open(det_file, 'rb') as f: det = cPickle.load(f) num_images = len(det[0]) # all_boxes[cls][image] = N x 5 array of detections in (x1, y1, x2, y2, score) if all_boxes == None: all_boxes = [[[] for _ in xrange(num_images)] for _ in xrange(num_classes)] for cls_no in xrange(num_classes): if exclude_worst and cls_no > 0 and min_data_index_per_class[cls_no] == data_no: continue for img_no in xrange(num_images): det_value = det[cls_no][img_no] if len(det_value) > 0: inds = np.where((det_value[:, 4] >= thresh))[0] det_value = det_value[inds] if len(all_boxes[cls_no][img_no]) == 0: all_boxes[cls_no][img_no] = det_value else: all_boxes[cls_no][img_no] = np.vstack((all_boxes[cls_no][img_no], det_value)) data_no += 1 print '' print 'Applying NMS to all detections' nms_dets = apply_nms(all_boxes, cfg.TEST.NMS) all_boxes = None print 'Evaluating detections' imdb = get_imdb(imdb_name) imdb.evaluate_detections(nms_dets, output_dir, submission_file)
cfg_from_list(args.set_cfgs) print('Using config:') pprint.pprint(cfg) 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)
def get_roidb(imdb_name): imdb = get_imdb(imdb_name) print('Loaded dataset `{:s}` for training'.format(imdb.name)) imdb.set_proposal_method('gt') roidb = get_training_roidb(imdb) return roidb
print('Called with args:') print(args) 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) cfg.GPU_ID = args.gpu_id print('Using config:') pprint.pprint(cfg) while not os.path.exists(args.caffemodel) and args.wait: print('Waiting for {} to exist...'.format(args.caffemodel)) time.sleep(10) caffe.set_mode_gpu() caffe.set_device(args.gpu_id) net = caffe.Net(args.prototxt, args.caffemodel, caffe.TEST) net.name = os.path.splitext(os.path.basename(args.caffemodel))[0] imdb = get_imdb(args.imdb_name) imdb.competition_mode(args.comp_mode) if not cfg.TEST.HAS_RPN: imdb.set_proposal_method(cfg.TEST.PROPOSAL_METHOD) import pdb; pdb.set_trace() test_net(net, imdb)
else: filename = os.path.splitext(os.path.basename(args.weight))[0] tag = args.tag tag = tag if tag else 'default' filename = tag + '/' + filename # This extra_string used by me (Aleksis) when running code on two # different machines, for convenience extra_string = '' print(args.imdb_name) if args.imdb_name == 'voc_2012_test': extra_string += '_test' #print(args.imdb_name + extra_string) #sleep(100) imdb = get_imdb(args.imdb_name + extra_string) imdb.competition_mode(args.comp_mode) # Set class names in config file based on IMDB class_names = imdb.classes cfg_from_list(['CLASS_NAMES', [class_names]]) # Update config depending on if class-specific history used or not if not args.use_hist: cfg_from_list(['DRL_RPN.USE_HIST', False]) cfg_from_list(['DIMS_TOT', cfg.DIMS_NONHIST]) cfg_from_list(['DIMS_AUX', 2 * cfg.NBR_ANCHORS]) elif args.use_post > 0: cfg_from_list(['DRL_RPN.USE_POST', True]) # Specify if run drl-RPN in auto mode or a fix number of iterations
if args.cfg_file is not None: cfg_from_file(args.cfg_file) print('Using config:') pprint.pprint(cfg) # set up caffe caffe.set_mode_gpu() if args.gpu_id is not None: caffe.set_device(args.gpu_id) net = caffe.Net(args.prototxt, args.caffemodel, caffe.TEST) net.name = os.path.splitext(os.path.basename(args.caffemodel))[0] #load dataset imdb_name = args.imdb_name + '.' + args.image_set imdb = get_imdb(imdb_name) print 'Loaded dataset `{:s}` for training'.format(imdb.name) if args.k_fold: imdb.gen_k_fold(args.k_fold) #set classes to train classes_to_train = range(args.first_class,min(args.first_class+args.class_num,imdb.num_classes)) # enhance roidb to contain flipped examples if cfg.TRAIN.USE_FLIPPED: print 'Appending horizontally-flipped training examples...' imdb.append_flipped_images() print 'done' #train folds if args.k_fold: print 'Training with {:d} folds'.format(args.k_fold) for k in range(args.k_fold):
parser.add_argument('--data_dir', dest='data_dir', type=str) if len(sys.argv) == 1: parser.print_help() sys.exit(1) args = parser.parse_args() return args if __name__ == '__main__': args = parse_args() print('Called with args:') print(args) if args.cfg_file is not None: cfg_from_file(args.cfg_file) cfg.TEST.INFERENCE_ITER = args.inference_iter print('Using config:') pprint.pprint(cfg) cfg.GPU_ID = args.gpu_id config = tf.ConfigProto() config.allow_soft_placement=True imdb = get_imdb(args.roidb, args.imdb, args.rpndb, args.data_dir, split=1, num_im=args.test_size) merge_late(args.load_score, imdb, args.test_mode, args.write_rel_f)