def main(args): logger = logging.getLogger(__name__) dummy_coco_dataset = dummy_datasets.get_coco_dataset() cfg_orig = load_cfg(envu.yaml_dump(cfg)) im = cv2.imread(args.im_file) if args.rpn_pkl is not None: proposal_boxes, _proposal_scores = get_rpn_box_proposals(im, args) workspace.ResetWorkspace() else: proposal_boxes = None cls_boxes, cls_segms, cls_keyps, cls_bodys = None, None, None, None for i in range(0, len(args.models_to_run), 2): pkl = args.models_to_run[i] yml = args.models_to_run[i + 1] cfg.immutable(False) merge_cfg_from_cfg(cfg_orig) merge_cfg_from_file(yml) if len(pkl) > 0: weights_file = pkl else: weights_file = cfg.TEST.WEIGHTS cfg.NUM_GPUS = 1 assert_and_infer_cfg(cache_urls=False) model = model_engine.initialize_model_from_cfg(weights_file) with c2_utils.NamedCudaScope(0): cls_boxes_, cls_segms_, cls_keyps_ , cls_bodys_= \ model_engine.im_detect_all(model, im, proposal_boxes) cls_boxes = cls_boxes_ if cls_boxes_ is not None else cls_boxes cls_segms = cls_segms_ if cls_segms_ is not None else cls_segms cls_keyps = cls_keyps_ if cls_keyps_ is not None else cls_keyps cls_bodys = cls_bodys_ if cls_bodys_ is not None else cls_bodys workspace.ResetWorkspace() out_name = os.path.join( args.output_dir, '{}'.format(os.path.basename(args.im_file) + '.pdf')) logger.info('Processing {} -> {}'.format(args.im_file, out_name)) with open('test_vis.pkl', 'w') as f: pickle.dump( { 'im': im, 'cls_boxes': np.array(cls_boxes), 'cls_bodys': np.array(cls_bodys) }, f) vis_utils.vis_one_image(im[:, :, ::-1], args.im_file, args.output_dir, cls_boxes, cls_segms, cls_keyps, cls_bodys, dataset=dummy_coco_dataset, box_alpha=0.3, show_class=True, thresh=0.7, kp_thresh=2)
def main(args): logger = logging.getLogger(__name__) dummy_nucoco_dataset = dummy_datasets.get_nucoco_dataset() cfg_orig = load_cfg(envu.yaml_dump(cfg)) ## Load image coco = COCO_PLUS(args.ann_file, args.imgs_dir) image_id = coco.dataset['images'][args.im_ind]['id'] img_path = os.path.join(args.imgs_dir, coco.imgs[image_id]["file_name"]) im = cv2.imread(img_path) ## Get the proposals for this image proposals = rrpn_loader(args.rpn_pkl) proposal_boxes = proposals[image_id]['boxes'] _proposal_scores = proposals[image_id]['scores'] workspace.ResetWorkspace() ## run models cls_boxes, cls_segms, cls_keyps = None, None, None for i in range(0, len(args.models_to_run), 2): pkl = args.models_to_run[i] yml = args.models_to_run[i + 1] cfg.immutable(False) merge_cfg_from_cfg(cfg_orig) merge_cfg_from_file(yml) if len(pkl) > 0: weights_file = pkl else: weights_file = cfg.TEST.WEIGHTS cfg.NUM_GPUS = 1 assert_and_infer_cfg(cache_urls=False) model = model_engine.initialize_model_from_cfg(weights_file) with c2_utils.NamedCudaScope(0): cls_boxes_, cls_segms_, cls_keyps_ = \ model_engine.im_detect_all(model, im, proposal_boxes) cls_boxes = cls_boxes_ if cls_boxes_ is not None else cls_boxes cls_segms = cls_segms_ if cls_segms_ is not None else cls_segms cls_keyps = cls_keyps_ if cls_keyps_ is not None else cls_keyps workspace.ResetWorkspace() out_name = os.path.join( args.output_dir, '{}'.format(os.path.basename(img_path) + '.pdf') ) logger.info('Processing {} -> {}'.format(img_path, out_name)) vis_utils.vis_one_image( im[:, :, ::-1], img_path, args.output_dir, cls_boxes, cls_segms, cls_keyps, dataset=dummy_nucoco_dataset, box_alpha=0.3, show_class=True, thresh=0.7, kp_thresh=2 )
def test_gpu_random_input(self): X = np.random.rand(5, 4) track_n_rois = [2, 3] for output in ['Cosine', 'MatchNet']: cfg.immutable(False) cfg.TRCNN.OUTPUT = output assert_and_infer_cfg(cache_urls=False) Y_exp = self._add_track_outputs_np(X.copy(), track_n_rois) Y_act = self._add_track_outputs( X, np.array(track_n_rois, dtype=np.int32)) np.testing.assert_allclose(Y_act, Y_exp, rtol=1e-06)
def get_detectron_result(im): """ 功能: 获取传入图像的检测结果 输入参数列表: im: BGR格式图片 返回参数列表: img: 检测结果图片 detectron_result_info: 检测结果字典 """ setup_logging(__name__) logger = logging.getLogger(__name__) dummy_coco_dataset = dummy_datasets.get_coco_dataset() cfg_orig = load_cfg(yaml.dump(cfg)) if rpn_pkl is not None: proposal_boxes, _proposal_scores = get_rpn_box_proposals(im) workspace.ResetWorkspace() else: proposal_boxes = None cls_boxes, cls_segms, cls_keyps = None, None, None pkl = rpn_pkl yml = rpn_cfg cfg.immutable(False) merge_cfg_from_cfg(cfg_orig) merge_cfg_from_file(yml) if len(pkl) > 0: weights_file = pkl else: weights_file = cfg.TEST.WEIGHTS cfg.NUM_GPUS = 1 assert_and_infer_cfg(cache_urls=False) model = model_engine.initialize_model_from_cfg(weights_file) with c2_utils.NamedCudaScope(0): cls_boxes_, cls_segms_, cls_keyps_ = \ model_engine.im_detect_all(model, im, proposal_boxes) cls_boxes = cls_boxes_ if cls_boxes_ is not None else cls_boxes cls_segms = cls_segms_ if cls_segms_ is not None else cls_segms cls_keyps = cls_keyps_ if cls_keyps_ is not None else cls_keyps workspace.ResetWorkspace() img, detectron_result_info = vis_utils.vis_one_image_opencv( im, cls_boxes, cls_segms, cls_keyps, dataset=dummy_coco_dataset, show_box=True, show_class=True) return img, detectron_result_info
def main(args): logger = logging.getLogger(__name__) dummy_coco_dataset = dummy_datasets.get_coco_dataset() cfg_orig = load_cfg(yaml.dump(cfg)) im = cv2.imread(args.im_file) if args.rpn_pkl is not None: proposal_boxes, _proposal_scores = get_rpn_box_proposals(im, args) workspace.ResetWorkspace() else: proposal_boxes = None cls_boxes, cls_segms, cls_keyps = None, None, None for i in range(0, len(args.models_to_run), 2): pkl = args.models_to_run[i] yml = args.models_to_run[i + 1] cfg.immutable(False) merge_cfg_from_cfg(cfg_orig) merge_cfg_from_file(yml) if len(pkl) > 0: weights_file = pkl else: weights_file = cfg.TEST.WEIGHTS cfg.NUM_GPUS = 1 assert_and_infer_cfg(cache_urls=False) model = model_engine.initialize_model_from_cfg(weights_file) with c2_utils.NamedCudaScope(0): cls_boxes_, cls_segms_, cls_keyps_ = \ model_engine.im_detect_all(model, im, proposal_boxes) cls_boxes = cls_boxes_ if cls_boxes_ is not None else cls_boxes cls_segms = cls_segms_ if cls_segms_ is not None else cls_segms cls_keyps = cls_keyps_ if cls_keyps_ is not None else cls_keyps workspace.ResetWorkspace() out_name = os.path.join( args.output_dir, '{}'.format(os.path.basename(args.im_file) + '.pdf') ) logger.info('Processing {} -> {}'.format(args.im_file, out_name)) vis_utils.vis_one_image( im[:, :, ::-1], args.im_file, args.output_dir, cls_boxes, cls_segms, cls_keyps, dataset=dummy_coco_dataset, box_alpha=0.3, show_class=True, thresh=0.7, kp_thresh=2 )
def get_rpn_box_proposals(im, args): cfg.immutable(False) merge_cfg_from_file(args.rpn_cfg) cfg.NUM_GPUS = 1 cfg.MODEL.RPN_ONLY = True cfg.TEST.RPN_PRE_NMS_TOP_N = 10000 cfg.TEST.RPN_POST_NMS_TOP_N = 2000 assert_and_infer_cfg(cache_urls=False) model = model_engine.initialize_model_from_cfg(args.rpn_pkl) with c2_utils.NamedCudaScope(0): boxes, scores = rpn_engine.im_proposals(model, im) return boxes, scores
def test_gpu_random_input(self): X = np.random.rand(1, 6).astype(np.float32) X_gt = np.random.randint(2, size=(1, 6)).astype(np.float32) for loss in [ 'Cosine', 'L2', 'L2Balanced', 'CrossEntropy', 'CrossEntropyBalanced', 'CrossEntropyWeighted' ]: cfg.immutable(False) cfg.TRCNN.LOSS = loss assert_and_infer_cfg(cache_urls=False) Y_exp = self._add_track_losses_np(X.copy(), X_gt.copy()) Y_act = self._add_track_losses(X.copy(), X_gt.copy()) np.testing.assert_allclose(Y_act, Y_exp, rtol=1e-06)
def main(): # Initialize C2 workspace.GlobalInit( ['caffe2', '--caffe2_log_level=0', '--caffe2_gpu_memory_tracking=1']) # Set up logging and load config options logger = setup_logging(__name__) logging.getLogger('detectron.roi_data.loader').setLevel(logging.INFO) args = parse_args() logger.info('Called with args:') logger.info(args) if args.cfg_file is not None: merge_cfg_from_file(args.cfg_file) if args.opts is not None: merge_cfg_from_list(args.opts) assert_and_infer_cfg() smi_output, cuda_ver, cudnn_ver = c2_utils.get_nvidia_info() logger.info("cuda version : {}".format(cuda_ver)) logger.info("cudnn version: {}".format(cudnn_ver)) logger.info("nvidia-smi output:\n{}".format(smi_output)) logger.info('Training with config:') logger.info(pprint.pformat(cfg)) # Note that while we set the numpy random seed network training will not be # deterministic in general. There are sources of non-determinism that cannot # be removed with a reasonble execution-speed tradeoff (such as certain # non-deterministic cudnn functions). np.random.seed(cfg.RNG_SEED) # Execute the training run checkpoints = detectron.utils.train.train_model() # Test the trained model if not args.skip_test: test_model(checkpoints['final'], args.multi_gpu_testing, args.opts) print('reprint snapshot name for the result: ', checkpoints['final']) cfg.immutable(False) cfg.TEST.BBOX_AUG.ENABLED = False cfg.REID.VIS = False cfg.immutable(True) for snapshot in sorted(checkpoints.iterkeys(), reverse=True): test_model(checkpoints[snapshot], args.multi_gpu_testing, args.opts) print('reprint snapshot name for the result: ', snapshot, checkpoints[snapshot])
def main(args): logger = logging.getLogger(__name__) if not os.path.exists(args.output_dir): os.makedirs(args.output_dir) merge_cfg_from_file(args.cfg) cfg.NUM_GPUS = 1 args.weights = cache_url(args.weights, cfg.DOWNLOAD_CACHE) if len(args.datasets): cfg.TRAIN.DATASETS = tuple(args.datasets) assert_and_infer_cfg(cache_urls=False) cfg.immutable(False) cfg.TRAIN.IMS_PER_BATCH = 1 cfg.immutable(True) model = create_model(args.weights) dummy_coco_dataset = dummy_datasets.get_coco_dataset() # Iterate through all images # TODO: find a proper way to stop iteration for i in xrange(1000): logger.info("Processing {}".format(i +)) with c2_utils.NamedCudaScope(0): try: workspace.RunNet(model.net.Proto().name) except: pass # Fetch specified blobs blobs = [(blob_name, workspace.FetchBlob(core.ScopedName(blob_name))) \ for blob_name in args.blobs] invalid_blobs = [blob for blob in blobs if not hasattr(blob[1], 'shape')] assert len(invalid_blobs) == 0, "Blobs not found: {}".format([blob[0] \ for blob in invalid_blobs]) # Save blobs save_file = os.path.join(args.output_dir, str(i) + ".npz") logger.info("Saving to {}".format(save_file)) to_save = [blob[1] for blob in blobs] np.savez(open(save_file, "w+"), *to_save)
def configure_bbox_reg_weights(model, saved_cfg): """Compatibility for old models trained with bounding box regression mean/std normalization (instead of fixed weights). """ if 'MODEL' not in saved_cfg or 'BBOX_REG_WEIGHTS' not in saved_cfg.MODEL: logger.warning('Model from weights file was trained before config key ' 'MODEL.BBOX_REG_WEIGHTS was added. Forcing ' 'MODEL.BBOX_REG_WEIGHTS = (1., 1., 1., 1.) to ensure ' 'correct **inference** behavior.') # Generally we don't allow modifying the config, but this is a one-off # hack to support some very old models is_immutable = cfg.is_immutable() cfg.immutable(False) cfg.MODEL.BBOX_REG_WEIGHTS = (1., 1., 1., 1.) cfg.immutable(is_immutable) logger.info('New config:') logger.info(pprint.pformat(cfg)) assert not model.train, ( 'This model was trained with an older version of the code that ' 'used bounding box regression mean/std normalization. It can no ' 'longer be used for training. To upgrade it to a trainable model ' 'please use fb/compat/convert_bbox_reg_normalized_model.py.')
def get_rpn_box_proposals(im): """ 功能: 获取传入图像的region proposal 输入参数列表: im: BGR格式图片 返回参数列表: boxes: 建议boxes scores: 对应的分数 """ cfg.immutable(False) merge_cfg_from_file(rpn_cfg) cfg.NUM_GPUS = 1 cfg.MODEL.RPN_ONLY = True cfg.TEST.RPN_PRE_NMS_TOP_N = 10000 cfg.TEST.RPN_POST_NMS_TOP_N = 2000 assert_and_infer_cfg(cache_urls=False) model = model_engine.initialize_model_from_cfg(rpn_pkl) with c2_utils.NamedCudaScope(0): boxes, scores = rpn_engine.im_proposals(model, im) return boxes, scores
def configure_bbox_reg_weights(model, saved_cfg): """Compatibility for old models trained with bounding box regression mean/std normalization (instead of fixed weights). """ if 'MODEL' not in saved_cfg or 'BBOX_REG_WEIGHTS' not in saved_cfg.MODEL: logger.warning('Model from weights file was trained before config key ' 'MODEL.BBOX_REG_WEIGHTS was added. Forcing ' 'MODEL.BBOX_REG_WEIGHTS = (1., 1., 1., 1.) to ensure ' 'correct **inference** behavior.') # Generally we don't allow modifying the config, but this is a one-off # hack to support some very old models is_immutable = cfg.is_immutable() cfg.immutable(False) cfg.MODEL.BBOX_REG_WEIGHTS = (1., 1., 1., 1.) cfg.immutable(is_immutable) logger.info('New config:') logger.info(pprint.pformat(cfg)) assert not model.train, ( 'This model was trained with an older version of the code that ' 'used bounding box regression mean/std normalization. It can no ' 'longer be used for training. To upgrade it to a trainable model ' 'please use fb/compat/convert_bbox_reg_normalized_model.py.' )
for scoped_name, blob in restored_all_params.items(): unscoped_name = c2_utils.UnscopeName(scoped_name) np.testing.assert_array_equal(blob, orig_gpu_0_params[unscoped_name]) if __name__ == '__main__': workspace.GlobalInit(['caffe2', '--caffe2_log_level=0']) logger = setup_logging(__name__) logger.setLevel(logging.DEBUG) logging.getLogger('Detectron-ZZnet.roi_data.loader').setLevel(logging.INFO) np.random.seed(cfg.RNG_SEED) output_dir = tempfile.mkdtemp() # Generate config for test cfg.MODEL.TYPE = 'generalized_rcnn' cfg.MODEL.CONV_BODY = 'FPN.add_fpn_ResNet50_conv5_body' cfg.MODEL.NUM_CLASSES = 81 cfg.MODEL.FASTER_RCNN = True cfg.FPN.FPN_ON = True cfg.FPN.MULTILEVEL_ROIS = True cfg.FPN.MULTILEVEL_RPN = True cfg.FAST_RCNN.ROI_BOX_HEAD = 'fast_rcnn_heads.add_roi_2mlp_head' cfg.FAST_RCNN.ROI_XFORM_METHOD = 'RoIAlign' cfg.OUTPUT_DIR = output_dir cfg.TRAIN.DATASETS = ('coco_2014_minival', ) cfg.TRAIN.WEIGHTS = b'' for num_gpu in range(workspace.NumCudaDevices()): cfg.immutable(False) cfg.NUM_GPUS = num_gpu + 1 assert_and_infer_cfg() test_restore_checkpoint()
def grid_search(): dataset_name, proposal_file = get_inference_dataset(0, is_parent=False) roidb, dataset, start_ind, end_ind, total_num_images = get_roidb_and_dataset( dataset_name, proposal_file, None ) num_images = len(roidb) num_classes = cfg.MODEL.NUM_CLASSES subinds = np.array_split(range(num_images), cfg.NUM_GPUS) tag = 'detection' output_dir = get_output_dir(cfg.TEST.DATASETS, training=False) det_file = os.path.join(output_dir, 'detections.pkl') outputs = load_object(det_file) print(len(outputs)) all_dets_cache = outputs['all_boxes'] print(len(all_dets_cache)) all_boxes_cache = [] all_scores_cache = [] for i, entry in enumerate(roidb): print(i) max_det = all_dets_cache[1][i].shape[0] print(max_det, num_classes) boxes = np.zeros((max_det, 4), dtype=np.float32) scores = np.zeros((max_det, num_classes), dtype=np.float32) boxes[:] = -1 scores[:] = -1 for j in range(num_classes): if len(all_dets_cache[j]) > 0: pass else: continue scores[:, j] = all_dets_cache[j][i][:, 4] boxes[:, 0:4] = all_dets_cache[1][i][:, :4] boxes = np.tile(boxes, (1, scores.shape[1])) print(scores.shape, boxes.shape) all_boxes_cache.append(boxes) all_scores_cache.append(scores) timers = defaultdict(Timer) resultss = [] nmses = [1.0, 0.9, 0.8, 0.7, 0.6, 0.5, 0.4, 0.3, 0.2, 0.1, 0.0] threshs = [1e-10, 1e-9, 1e-8, 1e-7, 1e-6, 1e-5, 1e-4, 1e-3, 1e-2, 1e-1] max_per_images = [10000, 1000, 100, 10, 1] for nms in nmses: for thresh in threshs: for max_per_image in max_per_images: print("----------------------------------------------------") print('NUM: ', nms, ' Thresh: ', thresh, ' MAX_PER_IM: ', max_per_image) cfg.immutable(False) cfg.TEST.NMS = nms cfg.TEST.SCORE_THRESH = thresh cfg.TEST.DETECTIONS_PER_IM = max_per_image cfg.immutable(True) all_boxes, all_segms, all_keyps = empty_results(num_classes, num_images) for i, entry in enumerate(roidb): # print(i) timers['im_detect_bbox'].tic() scores = all_scores_cache[i] boxes = all_boxes_cache[i] # print(scores.shape, boxes.shape) timers['im_detect_bbox'].toc() timers['misc_bbox'].tic() scores, boxes, cls_boxes_i = box_results_with_nms_and_limit(scores, boxes) timers['misc_bbox'].toc() extend_results(i, all_boxes, cls_boxes_i) results = task_evaluation.evaluate_all( dataset, all_boxes, all_segms, all_keyps, output_dir ) print(results) print(resultss) f = open('grid_search.csv', 'wb') wr = csv.writer(f, dialect='excel') wr.writerows(resultss)
def create_cpg_net(train=True): logger = logging.getLogger(__name__) FREEZE_CONV_BODY = cfg.TRAIN.FREEZE_CONV_BODY FREEZE_AT = cfg.TRAIN.FREEZE_AT WSL_CSC = cfg.WSL.CSC CENTER_LOSS = cfg.WSL.CENTER_LOSS MIN_ENTROPY_LOSS = cfg.WSL.MIN_ENTROPY_LOSS MASK_ON = cfg.MODEL.MASK_ON EXECUTION_TYPE = cfg.MODEL.EXECUTION_TYPE cfg.immutable(False) cfg.TRAIN.FREEZE_CONV_BODY = False cfg.TRAIN.FREEZE_AT = 0 cfg.WSL.CSC = False cfg.WSL.CPG = False cfg.WSL.CENTER_LOSS = False cfg.WSL.MIN_ENTROPY_LOSS = False cfg.MODEL.MASK_ON = False cfg.MODEL.EXECUTION_TYPE = b'simple' cfg.immutable(True) output_dir = get_output_dir(cfg.TRAIN.DATASETS, training=True) for gpu_id in range(cfg.NUM_GPUS): logger.info('Building model: {}'.format('gpu_' + str(gpu_id) + '_' + cfg.MODEL.TYPE + '_cpg')) model = model_builder_wsl.create('gpu_' + str(gpu_id) + '_' + cfg.MODEL.TYPE + '_cpg', train=train) # workspace.RunNetOnce(model.param_init_net) #----------------------------------------------------------------------------------- # logger.info( # 'Outputs saved to: {:s}'.format(os.path.abspath(output_dir))) # dump_proto_files(model, output_dir) if cfg.MEMONGER and False: start_op, end_op = OP_surgery_head(model, gpu_id) optimize_memory_cpg(model, gpu_id) OP_surgery_back(model, gpu_id, start_op, end_op) namescope = 'gpu_{}/'.format(gpu_id) model.net._net.op[0].input[ 0] = namescope + cfg.WSL.CPG_PRE_BLOB + '_grad' model.net._net.op[-1].output[ -1] = namescope + cfg.WSL.CPG_DATA_BLOB + '_grad' # share_surgery(model, gpu_id) else: OP_surgery(model, gpu_id) Input_surgery(model, gpu_id) workspace.CreateBlob('gpu_' + str(gpu_id) + '/' + cfg.WSL.CPG_PRE_BLOB + '_grad') optimize_memory_cpg(model, gpu_id) #----------------------------------------------------------------------------------- # nu.broadcast_parameters(model) workspace.CreateNet(model.net) logger.info('Outputs saved to: {:s}'.format( os.path.abspath(output_dir))) dump_proto_files(model, output_dir) cfg.immutable(False) cfg.TRAIN.FREEZE_CONV_BODY = FREEZE_CONV_BODY cfg.TRAIN.FREEZE_AT = FREEZE_AT cfg.WSL.CSC = WSL_CSC cfg.WSL.CENTER_LOSS = CENTER_LOSS cfg.WSL.MIN_ENTROPY_LOSS = MIN_ENTROPY_LOSS cfg.MODEL.MASK_ON = MASK_ON cfg.MODEL.EXECUTION_TYPE = EXECUTION_TYPE cfg.immutable(True)
def main(args): logger = logging.getLogger(__name__) merge_cfg_from_file(args.cfg) cfg.NUM_GPUS = 1 if "mot-classes" in args.opts: dummy_dataset = dummy_datasets.get_mot_dataset() cfg.NUM_CLASSES = 14 else: dummy_dataset = dummy_datasets.get_coco_dataset() cfg.NUM_CLASSES = 81 for i, weights_file in enumerate(args.weights_pre_list): args.weights_pre_list[i] = cache_url(weights_file, cfg.DOWNLOAD_CACHE) for i, weights_file in enumerate(args.weights_post_list): args.weights_post_list[i] = cache_url(weights_file, cfg.DOWNLOAD_CACHE) assert_and_infer_cfg(cache_urls=False) logger.info('Testing with config:') logger.info(pprint.pformat(cfg)) # If True: Evaluation with respect to specified parameters (model from # specifig training iterations or inference hyper-parameters) # If False: Infer test sequence for evaluation on the MOT benchmark server EVAL = "eval" in args.opts train_dir = get_output_dir(cfg.TRAIN.DATASETS, training=True) train_dir_split = train_dir.split("/") train_dir = os.path.join("/".join(train_dir_split[:-1]) + \ args.model_suffix, train_dir_split[-1]) model_list = [] files = os.listdir(train_dir) if EVAL: test_dir = "/".join(get_output_dir(cfg.TEST.DATASETS, training=False).split("/")[:-1]) + args.model_suffix # Evaluation with respect to inference hyper-parameters if HYPER_PARAM is not None: test_dir = os.path.join(test_dir, HYPER_PARAM.lower()) model_param = ((args.model, param) for param in PARAM_RANGE) # Evaluation with respect to weights from specific training iterations else: model_param = [] for f in files: if f.startswith("model_") and f.endswith(".pkl"): iter_string = re.findall(r'(?<=model_iter)\d+(?=\.pkl)', f) if len(iter_string) > 0: model_param.append((f, int(iter_string[0]))) model_param.sort(key=lambda tup: tup[1]) if "model_final.pkl" in files: model_param.append(("model_final.pkl", "final")) # Tracking evaluation by interface to matlab engine seq_map_path = os.path.join(test_dir, "seq_map.txt") if not os.path.exists(test_dir): os.makedirs(test_dir) with open(seq_map_path, "w+") as seq_map: seq_map.write("name\n") for dataset in cfg.TEST.DATASETS: seq_map.write(get_im_dir(dataset).split("/")[-2] + '\n') seq_map_path = os.path.relpath(os.path.abspath(seq_map_path), os.path.expanduser(os.path.join(args.devkit_path, "seqmaps"))) matlab_eng = get_matlab_engine(args.devkit_path) eval_datections = lambda res_dir, gt_dir: eval_detections_matlab( matlab_eng, seq_map_path, res_dir, gt_dir, 'MOT17') else: if args.model is not None: model_param = ((args.model, None),) else: model_param = (("model_final.pkl", "final"),) # Iterate through (model, parameter) tuples for i, (model, param) in enumerate(model_param): if EVAL and (i + 1 + args.offset) % (args.skip + 1) != 0: logger.info("Skipping {}".format(model)) continue # Hyper parameter inference elif HYPER_PARAM is not None: cfg.immutable(False) setattr(cfg.TRCNN, HYPER_PARAM, param) assert_and_infer_cfg(cache_urls=False) print(cfg.TRCNN) if not EVAL or param >= args.start_at: weights_list = args.weights_pre_list + [os.path.join(train_dir, model)] + \ args.weights_post_list preffix_list = args.preffix_list if len(args.preffix_list) \ else [""] * (len(args.weights_pre_list) + len(args.weights_post_list) + 1) workspace.ResetWorkspace() model = infer_engine.initialize_mixed_model_from_cfg(weights_list, preffix_list=preffix_list) logger.info("Processing {}".format(param)) timing = [] # iterate through test sequences for dataset in cfg.TEST.DATASETS: tracking = Tracking(args.thresh, cfg.TRCNN.MAX_BACK_TRACK) logger.info("Processing dataset {}".format(dataset)) im_dir = get_im_dir(dataset) vis = None if EVAL: output_file = os.path.join(test_dir, str(param), im_dir.split("/")[-2] + ".txt") # Visualize detections along with tracking detection file creation else: output_dir = os.path.join("outputs/MOT17", im_dir.split("/")[-2]) if "vis" in args.opts: vis = { "output-dir": output_dir, "dummy-dataset": dummy_dataset, "show-class": "show-class" in args.opts, "show-track": "show-track" in args.opts, "thresh": args.thresh, "track-thresh": cfg.TRCNN.DETECTION_THRESH, "n-colors": 15, } output_file = os.path.join("outputs/MOT17", im_dir.split("/")[-2] + ".txt") # Use custom proposals if provided if "proposals" in args.opts: proposals = pickle.load(open(os.path.join('/', *(im_dir.split("/")[:-1] + \ ["det/proposals.pkl"])), 'r')) else: proposals = None head, tail = os.path.split(output_file) if not os.path.exists(head): os.makedirs(head) start = time.time() # Run inference infer_track_sequence(model, im_dir, tracking, proposals=proposals, vis=vis, det_file=output_file) delta = time.time() - start freq = float(len(os.listdir(im_dir))) / delta timing.append(freq) # Save evaluation results if EVAL: val_directory = os.path.abspath(head) + "/" eval_datections(val_directory, os.path.abspath(os.path.join(*im_dir.split("/")[:-2])) + "/") with open(val_directory + "eval.txt", "r") as f: temp = f.readline().strip() with open(val_directory + "eval.txt", "w+") as f: f.write("{},{}".format(temp, np.average(timing)))
for scoped_name, blob in restored_all_params.items(): unscoped_name = c2_utils.UnscopeName(scoped_name) np.testing.assert_array_equal(blob, orig_gpu_0_params[unscoped_name]) if __name__ == '__main__': workspace.GlobalInit(['caffe2', '--caffe2_log_level=0']) logger = setup_logging(__name__) logger.setLevel(logging.DEBUG) logging.getLogger('detectron.roi_data.loader').setLevel(logging.INFO) np.random.seed(cfg.RNG_SEED) output_dir = tempfile.mkdtemp() # Generate config for test cfg.MODEL.TYPE = 'generalized_rcnn' cfg.MODEL.CONV_BODY = 'FPN.add_fpn_ResNet50_conv5_body' cfg.MODEL.NUM_CLASSES = 81 cfg.MODEL.FASTER_RCNN = True cfg.FPN.FPN_ON = True cfg.FPN.MULTILEVEL_ROIS = True cfg.FPN.MULTILEVEL_RPN = True cfg.FAST_RCNN.ROI_BOX_HEAD = 'fast_rcnn_heads.add_roi_2mlp_head' cfg.FAST_RCNN.ROI_XFORM_METHOD = 'RoIAlign' cfg.OUTPUT_DIR = output_dir cfg.TRAIN.DATASETS = ('coco_2014_minival',) cfg.TRAIN.WEIGHTS = b'' for num_gpu in range(workspace.NumCudaDevices()): cfg.immutable(False) cfg.NUM_GPUS = num_gpu + 1 assert_and_infer_cfg() test_restore_checkpoint()