def testing(): name = "SYNTHIA_test" # "HoliCity_train" "HoliCity_valid" assign_global(name) cache_pth = f"/home/dxl/Code/PlanarReconstruction/data/SYNTHIA_test_coco_format.json" register_coco_instances(name=_name, metadata={'thing_classes': ["P"]}, json_file=cache_pth, image_root="/home/dxl/Data/PlaneRecover") cfg__ = make_cfg() # begin train trainer = DefaultTrainer(cfg__) # trainer.resume_or_load(resume=True) # trainer.train() # predict and visualization # extract_roi_feature(cfg__) # build_predictor_vis(cfg__) # evaluator_metric(cfg__) # evaluating validation data set trainer.resume_or_load(resume=True) evaluator, val_loader = build_evaluator(cfg__) inference_on_dataset(trainer.model, val_loader, evaluator)
def inference(config_file, coco_to_kitti_dict): cfg = get_cfg() cfg.merge_from_file(model_zoo.get_config_file(config_file)) cfg.DATALOADER.NUM_WORKERS = 4 cfg.MODEL.WEIGHTS = model_zoo.get_checkpoint_url(config_file) cfg.DATASETS.TRAIN = ("kitti_mots_train", ) cfg.DATASETS.TEST = ("kitti_mots_test", ) cfg.SOLVER.IMS_PER_BATCH = 8 cfg.MODEL.ROI_HEADS.BATCH_SIZE_PER_IMAGE = 512 os.makedirs(cfg.OUTPUT_DIR, exist_ok=True) trainer = DefaultTrainer(cfg) trainer.resume_or_load(resume=False) evaluator = COCOEvaluator("kitti_mots_test", cfg, False, output_dir="./output/") val_loader = build_detection_test_loader(cfg, "kitti_mots_test") inference_on_dataset(trainer.model, val_loader, evaluator) preds = evaluator._predictions filtered_preds = filter_preds(preds, coco_to_kitti_dict) evaluator._predictions = filtered_preds evaluator.evaluate()
def validation( name, metadata, json_file, image_root, output_dir, ckpt, score_thresh_test, output_meta_dirs, meta_dir_mode, ): register_coco_instances( name=name, metadata=metadata, json_file=json_file, image_root=image_root, ) cfg__ = make_cfg() cfg__.OUTPUT_DIR = output_dir os.makedirs(cfg__.OUTPUT_DIR, exist_ok=True) # evaluating validation data set cfg__.MODEL.WEIGHTS = ckpt cfg__.MODEL.ROI_HEADS.SCORE_THRESH_TEST = score_thresh_test # set the testing threshold for this model cfg__.DATASETS.TEST = (name, ) predictor = DefaultPredictor(cfg__) evaluator = COCOEvaluator(name, cfg__, False, output_dir=output_dir) val_loader = build_detection_test_loader(cfg__, name) inference_on_dataset(predictor.model, val_loader, evaluator)
def evaluate(self, test_set, output_folder): self.cfg.MODEL.ROI_HEADS.SCORE_THRESH_TEST = 0.8 predictor = DefaultPredictor(self.cfg) evaluator = COCOEvaluator( test_set, self.cfg, False, output_dir=output_folder) val_loader = build_detection_test_loader(self.cfg, test_set) inference_on_dataset(self.trainer.model, val_loader, evaluator)
def main(): # log setup_logger(output='./output/log.txt') # train args args = parse() # model configurations cfg = get_cfg() cfg.merge_from_file(args.config) register_coco_instances("val_data", {}, args.val_json_path, args.val_img_dir) cfg.DATASETS.TRAIN = ("val_data", ) cfg.DATASETS.TEST = ("val_data", ) cfg.MODEL.ROI_HEADS.NUM_CLASSES = args.num_class cfg.MODEL.WEIGHTS = args.pretrain os.makedirs(cfg.OUTPUT_DIR, exist_ok=True) # train trainer = DefaultTrainer(cfg) trainer.resume_or_load(resume=True) # validation evaluator = COCOEvaluator("val_data", cfg, False, output_dir=cfg.OUTPUT_DIR) val_loader = build_detection_test_loader(cfg, "val_data") inference_on_dataset(trainer.model, val_loader, evaluator)
def validation(cfg: DictConfig) -> None: """ Transfer learning using pretrained models from detectron2 model zoo. :param cfg: the configuration dictionary of dataset_model. :type cfg: omegaconf.dictconfig.DictConfig. :return: None """ log.info('--- Start Validation ---') val_dataset_dicts, val_dataset_metadata = register_custom_coco_dataset( cfg=cfg, process='val') visualizing_coco_dataset(dataset_dicts=val_dataset_dicts, dataset_metadata=val_dataset_metadata, num_ims=cfg.validation.show_images) model_cfg: CfgNode = get_model_configs(cfg=cfg, process='val') evaluator = COCOEvaluator(dataset_name=cfg.name + '_val', cfg=model_cfg, distributed=False, output_dir=os.getcwd()) val_loader = build_detection_test_loader(cfg=model_cfg, dataset_name=cfg.name + '_val') trainer: DefaultTrainer = DefaultTrainer(model_cfg) trainer.resume_or_load(resume=True) inference_on_dataset(model=trainer.model, data_loader=val_loader, evaluator=evaluator) log.info('--- Validation Done ---')
def test(exp, selected_dataset, theshold): print(f'Testing experiment: \n{exp}\n') cfg = get_cfg() cfg.merge_from_file(networks[exp['net']]['cfg']) cfg.DATASETS.TEST = exp['test'] cfg.INPUT.MAX_SIZE_TEST = 2500 cfg.MODEL.ROI_HEADS.NUM_CLASSES = 1 cfg.DATALOADER.NUM_WORKERS = 2 if 'from' in exp: trainFromStr = exp['from'].split('/')[-2] cfg.OUTPUT_DIR = f"{EXPERIMENTS_OUTPUT_PATH}/{exp['net']}[LR={exp['lr']}][{str(exp['train'])}]FROM[{trainFromStr}]" else: cfg.OUTPUT_DIR = f"{EXPERIMENTS_OUTPUT_PATH}/{exp['net']}[LR={exp['lr']}][{str(exp['train'])}]" cfg.MODEL.WEIGHTS = os.path.join(cfg.OUTPUT_DIR, 'model_final.pth') if all([ds in DATASETS_REAL or ds in DATASETS_SYTH for ds in exp['train']]): output_dir = f"{cfg.OUTPUT_DIR}/{selected_dataset}" model = build_model(cfg) DetectionCheckpointer(model, save_dir=cfg.OUTPUT_DIR).resume_or_load( cfg.MODEL.WEIGHTS, resume=False) evaluator = COCOEvaluator(selected_dataset, cfg, False, output_dir=output_dir) val_loader = build_detection_test_loader(cfg, selected_dataset) inference_on_dataset(model, val_loader, evaluator)
def mAPtest(yaml, weight): from detectron2.engine import DefaultTrainer from detectron2.config import get_cfg cfg = get_cfg() cfg.merge_from_file(yaml) cfg.DATALOADER.NUM_WORKERS = 2 # cfg.MODEL.WEIGHTS = "detectron2://COCO-InstanceSegmentation/mask_rcnn_R_101_FPN_3x/137849600/model_final_f10217.pkl" # initialize from model zoo cfg.MODEL.ROI_HEADS.NUM_CLASSES = 3 # 3 classes (Kong, lee, Huh) from detectron2.data.datasets import register_coco_instances register_coco_instances("Acheck_test", {}, "./Acheck_hair_test.json", "./img_hair_test") from detectron2.data import MetadataCatalog MetadataCatalog.get("Acheck_test").thing_classes = ["Kong", "Lee", "Huh"] Acheck_metadata = MetadataCatalog.get("Acheck_test") from detectron2.data import DatasetCatalog dataset_dicts = DatasetCatalog.get("Acheck_test") cfg.DATASETS.TRAIN = ("Acheck_test", ) from detectron2.engine import DefaultPredictor cfg.MODEL.WEIGHTS = weight cfg.MODEL.ROI_HEADS.SCORE_THRESH_TEST = 0.8 # set the testing threshold for this model cfg.DATASETS.TEST = ("Acheck_test", ) predictor = DefaultPredictor(cfg) trainer = DefaultTrainer(cfg) trainer.resume_or_load(resume=False) from detectron2.evaluation import COCOEvaluator, inference_on_dataset from detectron2.data import build_detection_test_loader evaluator = COCOEvaluator("Acheck_test", cfg, False, "./output/") val_loader = build_detection_test_loader(cfg, "Acheck_test") inference_on_dataset(trainer.model, val_loader, evaluator)
def main(args): cfg = setup(args) predictor = DefaultPredictor(cfg) evaluator = COCOEvaluator(args.dataset, cfg, False, cfg.OUTPUT_DIR) val_loader = build_detection_test_loader(cfg, args.dataset) inference_on_dataset(predictor.model, val_loader, evaluator)
def test(cfg, dataset_name): cfg.DATASETS.TEST = (dataset_name, ) predictor = DefaultPredictor(cfg) evaluator_FLIR = FLIREvaluator(dataset_name, cfg, False, output_dir=out_folder, out_pr_name='pr_val.png') #DefaultTrainer.test(cfg, trainer.model, evaluators=evaluator_FLIR) val_loader = build_detection_test_loader(cfg, dataset_name) inference_on_dataset(predictor.model, val_loader, evaluator_FLIR)
def main(): args = parser.parse_args() register_coco_instances(args.dataset, {}, args.label, args.file) # training dataset register_coco_instances(args.test_dataset, {}, args.test_label, args.test_file) # testing dataset ### set metadata MetadataCatalog.get(args.test_dataset).evaluator_type="coco" DatasetCatalog.get(args.test_dataset) ### cfg setting cfg = get_cfg() cfg.merge_from_file(model_zoo.get_config_file(args.model)) cfg.DATASETS.TRAIN = (args.dataset,) cfg.MODEL.ROI_HEADS.NUM_CLASSES = args.num_class # excavator, dump_truck, cement_truck cfg.MODEL.WEIGHTS = args.weight cfg.MODEL.ROI_HEADS.SCORE_THRESH_TEST = 0.7 # set the testing threshold for this model cfg.DATASETS.TEST = (args.test_dataset,) ### trainner setting trainer = DefaultTrainer(cfg) trainer.resume_or_load(cfg.MODEL.WEIGHTS) ### evaluation setting evaluator = COCOEvaluator(args.test_dataset, cfg, False, output_dir="./output/") val_loader = build_detection_test_loader(cfg, args.test_dataset) inference_on_dataset(trainer.model, val_loader, evaluator)
def HolicityV2(): name = "HoliCity_valid_scannet_pretrained" # "HoliCity_train" "HoliCity_valid" assign_global(name) # configuration # -------- change with your path ---------- gt_image = "/home/dxl/Data/LondonCity/V2/train-images" # train-images, valid-test-images # gt_label = "/home/dxl/Data/LondonCity/V2/valid-test-GT" # name = "HoliCityV2" out = "data" # ------------------------------------------ # filelist = V2_filelist(gt_image) # img_dirs = [osp.join(gt_image, path) for path in filelist] # gt_seglist = [osp.join(gt_label, path.replace("_imag.jpg", "_plan.png")) for path in filelist] cache_pth = f"{out}/HoliCityV2_valid_coco_format.json" # if not os.path.isfile(cache_pth): # cache_pth = COCO_format(img_dirs, gt_seglist, out, f"{_name}") # exit() register_coco_instances(name=_name, metadata={'thing_classes': ["P"]}, json_file=cache_pth, image_root=gt_image) cfg__ = make_cfg() cfg__.OUTPUT_DIR = f"./output/{_name}_output" # begin train # trainer = DefaultTrainer(cfg__) # trainer.resume_or_load(resume=True) # trainer.train() # predict and visualization # extract_roi_feature(cfg__) # build_predictor_vis(cfg__) # evaluator_metric(cfg__) # evaluating validation data set # trainer.resume_or_load(resume=True) cfg__.MODEL.WEIGHTS = os.path.join("./output/ScanNet_train_output", "model_0099999.pth") cfg__.MODEL.ROI_HEADS.SCORE_THRESH_TEST = 0.5 # set the testing threshold for this model cfg__.DATASETS.TEST = (_name, ) metadata = MetadataCatalog.get(_name) dataset_dicts = coco_wrapper( gt_image, "/home/dxl/Data/LondonCity/V2/test-hd-sub.txt") # dataset_dicts = DatasetCatalog.get(_name) save_npz(cfg__, dataset_dicts=dataset_dicts, metadata=metadata, isnpz=False, isviz=True) exit() predictor = DefaultPredictor(cfg__) evaluator, val_loader = build_evaluator(cfg__) inference_on_dataset(predictor.model, val_loader, evaluator)
def main(args): register_coco_instances("test", {}, args.anno_path, args.data_dir) cfg = get_cfg() cfg.merge_from_file( model_zoo.get_config_file( "COCO-Detection/faster_rcnn_R_50_FPN_1x.yaml")) cfg.DATASETS.TEST = ("test", ) cfg.MODEL.WEIGHTS = args.model_path cfg.MODEL.PIXEL_MEAN = [84.6518, 84.6518, 84.6518] cfg.MODEL.ANCHOR_GENERATOR.SIZES = [[16], [32], [64], [128], [256]] cfg.DATALOADER.NUM_WORKERS = 2 cfg.SOLVER.IMS_PER_BATCH = 2 cfg.SOLVER.MAX_ITER = 10000 cfg.MODEL.ROI_HEADS.BATCH_SIZE_PER_IMAGE = 128 cfg.MODEL.ROI_HEADS.NUM_CLASSES = 1 # INPUT settings are very important !! cfg.INPUT.CROP.ENABLED = True cfg.INPUT.CROP.TYPE = "relative" cfg.INPUT.CROP.SIZE = [0.4, 0.4] cfg.INPUT.MIN_SIZE_TRAIN = (960, ) # 2400 * 0.4 cfg.INPUT.MAX_SIZE_TRAIN = 1440 cfg.INPUT.MIN_SIZE_TEST = 2400 cfg.INPUT.MAX_SIZE_TEST = 3600 predictor = DefaultPredictor(cfg) evaluator = COCOEvaluator("test", cfg, False, output_dir=args.output_path) val_loader = build_detection_test_loader(cfg, "test") inference_on_dataset(predictor.model, val_loader, evaluator)
def evaluate(args, mode, _appcfg): name = "hmd" subset = "val" if args.subset: subset = args.subset metadata = load_and_register_dataset(name, subset, _appcfg) dataset_name = get_dataset_name(name, subset) dataset_dicts = DatasetCatalog.get(dataset_name) conf = Config(args, config) cfg = conf.merge(conf.arch, conf.cfg) cfg.DATASETS.TEST = (dataset_name) cfg.OUTPUT_DIR = "/codehub/apps/detectron2/release" cfg.MODEL.WEIGHTS = os.path.join(cfg.OUTPUT_DIR, "model_final.pth") _loader = build_detection_test_loader(cfg, dataset_name) evaluator = COCOEvaluator(dataset_name, cfg, False, output_dir=cfg.OUTPUT_DIR) file_path = cfg.MODEL.WEIGHTS model = build_model(cfg) DetectionCheckpointer(model).load(file_path) inference_on_dataset(model, _loader, evaluator)
def test(cfg, dataset_name, file_name='FLIR_thermal_only_result.out'): cfg.DATASETS.TEST = (dataset_name, ) predictor = DefaultPredictor(cfg) out_name = out_folder + file_name evaluator_FLIR = FLIREvaluator(dataset_name, cfg, False, output_dir=out_folder, save_eval=True, out_eval_path=out_name) val_loader = build_detection_test_loader(cfg, dataset_name) inference_on_dataset(predictor.model, val_loader, evaluator_FLIR)
def test_during_train(trainer, dataset_name): cfg.DATASETS.TEST = (dataset_name, ) evaluator_FLIR = FLIREvaluator(dataset_name, cfg, False, output_dir=out_folder, out_pr_name='pr_val.png') val_loader = build_detection_test_loader(cfg, dataset_name) inference_on_dataset(trainer.model, val_loader, evaluator_FLIR)
def evaluation(output_path, configuation, eval_dataset="val_kitti-mots", eval_concept=("segm", )): #EVALUATION evaluator = COCOEvaluator(eval_dataset, eval_concept, False, output_dir=output_path) val_loader = build_detection_test_loader(configuration, "val_kitti-mots") inference_on_dataset(predictor.model, val_loader, evaluator)
def evaluate(args, mode, _appcfg): name = "hmd" #uncomment if using trainer.model # for subset in ["train", "val"]: # metadata = load_and_register_dataset(name, subset, _appcfg) subset = "test" # subset = "val" metadata = load_and_register_dataset(name, subset, _appcfg) dataset_name = get_dataset_name(name, subset) dataset_dicts = DatasetCatalog.get(dataset_name) cfg = config.get_cfg() cfg.merge_from_file( "/codehub/external/detectron2/configs/COCO-InstanceSegmentation/mask_rcnn_R_50_FPN_3x.yaml" ) cfg.DATASETS.TRAIN = ("hmd_train", "hmd_val") cfg.DATASETS.TEST = (dataset_name) cfg.OUTPUT_DIR = "/codehub/apps/detectron2/release" cfg.MODEL.WEIGHTS = os.path.join(cfg.OUTPUT_DIR, "model_final.pth") cfg.DATALOADER.NUM_WORKERS = 2 cfg.SOLVER.IMS_PER_BATCH = 2 cfg.SOLVER.BASE_LR = 0.00025 cfg.MODEL.ROI_HEADS.BATCH_SIZE_PER_IMAGE = 128 # faster, and good enough for this toy dataset cfg.MODEL.ROI_HEADS.NUM_CLASSES = 3 cfg.MODEL.ROI_HEADS.SCORE_THRESH_TEST = 0.7 # mapper = DatasetMapper(cfg, False) _loader = build_detection_test_loader(cfg, dataset_name) evaluator = COCOEvaluator(dataset_name, cfg, False, output_dir=cfg.OUTPUT_DIR) # trainer = DefaultTrainer(cfg) # trainer.resume_or_load(resume=True) # model = trainer.model # predictor = DefaultPredictor(cfg) # model = predictor.model file_path = cfg.MODEL.WEIGHTS model = build_model(cfg) DetectionCheckpointer(model).load(file_path) inference_on_dataset(model, _loader, evaluator)
def main(argv): setup_logger() finetune = False trainPath = "./data/train/images/" trainjsonPath = "./data/train/train.json" testPath = "./data/val/images/" testjsonPath = "./data/val/val.json" opts, args = getopt.getopt(argv, "hf:", ["finetune="]) for opt, arg in opts: if opt == '-f': if arg == 'True': finetune = True register_coco_instances("trainSet", {}, trainjsonPath, trainPath) register_coco_instances("testSet", {}, testjsonPath, testPath) cfg = get_cfg() # cfg.MODEL.DEVICE = 'cpu' cfg.OUTPUT_DIR = './output' cfg.merge_from_file("./detectron2/configs/COCO-Detection/faster_rcnn_X_101_32x8d_FPN_3x.yaml") cfg.DATASETS.TRAIN = ("trainSet",) cfg.DATASETS.TEST = ("testSet",) cfg.DATALOADER.NUM_WORKERS = 6 cfg.SOLVER.CHECKPOINT_PERIOD = 500 cfg.SOLVER.IMS_PER_BATCH = 2 cfg.SOLVER.BASE_LR = 1e-3 cfg.MODEL.ROI_HEADS.NUM_CLASSES = 3 if finetune: cfg.SOLVER.MAX_ITER = 190500 cfg.MODEL.WEIGHTS = os.path.join(cfg.OUTPUT_DIR, "model_0005499.pth") else: cfg.SOLVER.MAX_ITER = 500 cfg.MODEL.WEIGHTS = "detectron2://COCO-Detection/faster_rcnn_X_101_32x8d_FPN_3x/139173657/model_final_68b088.pkl" os.makedirs(cfg.OUTPUT_DIR, exist_ok=True) for i in range(16): trainer = DefaultTrainer(cfg) trainer.resume_or_load(resume=True) trainer.train() evaluator = COCOEvaluator("testSet", cfg, False, output_dir = cfg.OUTPUT_DIR) val_loader = build_detection_test_loader(cfg, "testSet") inference_on_dataset(trainer.model, val_loader, evaluator) cfg.SOLVER.MAX_ITER += 500
def train(config_file, image_path, annot_file, out_filename="results.txt"): train_split = lambda: get_AICity_dataset( image_path, annot_file, mode='first', is_train=True) test_split = lambda: get_AICity_dataset( image_path, annot_file, mode='first') DatasetCatalog.clear() DatasetCatalog.register("ai_city_train", train_split) MetadataCatalog.get('ai_city_train').set( thing_classes=[k for k in thing_classes.keys()]) DatasetCatalog.register("ai_city_test", test_split) MetadataCatalog.get('ai_city_test').set( thing_classes=[k for k in thing_classes.keys()]) cfg = get_cfg() cfg.merge_from_file(model_zoo.get_config_file(config_file)) cfg.DATASETS.TRAIN = ("ai_city_train", ) cfg.DATASETS.TEST = () cfg.DATALOADER.NUM_WORKERS = 4 cfg.MODEL.WEIGHTS = model_zoo.get_checkpoint_url( "COCO-InstanceSegmentation/mask_rcnn_R_50_FPN_3x.yaml" ) # Let training initialize from model zoo cfg.SOLVER.IMS_PER_BATCH = 8 cfg.SOLVER.BASE_LR = 0.0001 cfg.SOLVER.MAX_ITER = 100 cfg.MODEL.ROI_HEADS.BATCH_SIZE_PER_IMAGE = 512 cfg.MODEL.ROI_HEADS.NUM_CLASSES = 1 cfg.MODEL.RETINANET.NUM_CLASSES = 1 os.makedirs(cfg.OUTPUT_DIR, exist_ok=True) trainer = DefaultTrainer(cfg) trainer.resume_or_load(resume=False) trainer.train() evaluator = COCOEvaluator("ai_city_test", cfg, False, output_dir="./output/") val_loader = build_detection_test_loader(cfg, "ai_city_test") inference_on_dataset(trainer.model, val_loader, evaluator) ims_from_test = [annot['file_name'] for annot in test_split()] det_bb = inference(config_file, ims_from_test, weight="./output/model_final.pth", save_results=True, out_filename=out_filename) return det_bb
def test_during_train(cfg, dataset_name, save_eval_name, save_folder): cfg.DATASETS.TEST = (dataset_name, ) trainer = DefaultTrainer(cfg) #predictor = DefaultPredictor(cfg) #evaluator_FLIR = FLIREvaluator(dataset_name, cfg, False, output_dir=out_folder, out_pr_name='pr_val.png') evaluator_FLIR = FLIREvaluator(dataset_name, cfg, False, output_dir=save_folder, save_eval=True, out_eval_path=(save_folder + save_eval_name)) #DefaultTrainer.test(cfg, trainer.model, evaluators=evaluator_FLIR) val_loader = build_detection_test_loader(cfg, dataset_name) inference_on_dataset(trainer.model, val_loader, evaluator_FLIR)
def model_configuration(model_url, learning_rate, max_iter): model_a = os.path.join("COCO-InstanceSegmentation", model_url) cfg = get_cfg() cfg.merge_from_file(model_zoo.get_config_file(model_a)) cfg.DATASETS.TRAIN = ("kitti-mots", ) cfg.DATASETS.TEST = () cfg.DATALOADER.NUM_WORKERS = 2 cfg.MODEL.WEIGHTS = model_zoo.get_checkpoint_url( "COCO-InstanceSegmentation/mask_rcnn_X_101_32x8d_FPN_3x.yaml" ) # Let training initialize from model zoo cfg.SOLVER.IMS_PER_BATCH = 2 cfg.SOLVER.BASE_LR = learning_rate cfg.SOLVER.MAX_ITER = max_iter cfg.MODEL.ROI_HEADS.BATCH_SIZE_PER_IMAGE = 512 cfg.MODEL.ROI_HEADS.NUM_CLASSES = 2 # cfg.INPUT.MASK_FORMAT = 'rle' # cfg.INPUT.MASK_FORMAT='bitmask' os.makedirs(cfg.OUTPUT_DIR, exist_ok=True) trainer = DefaultTrainer(cfg) trainer.resume_or_load(resume=False) print('Training...') trainer.train() # EVALUATION print('Evaluating...') evaluator = COCOEvaluator("kitti-mots", cfg, False, output_dir="./Search/") val_loader = build_detection_test_loader(cfg, "kitti-mots") results = inference_on_dataset(trainer.model, val_loader, evaluator) print(results) return results
def do_test(cfg, model): results = OrderedDict() for dataset_name in cfg.DATASETS.TEST: mapper = None if cfg.INPUT.TEST_INPUT_TYPE == 'default' else \ DatasetMapper( cfg, False, augmentations=build_custom_augmentation(cfg, False)) data_loader = build_detection_test_loader(cfg, dataset_name, mapper=mapper) output_folder = os.path.join(cfg.OUTPUT_DIR, "inference_{}".format(dataset_name)) evaluator_type = MetadataCatalog.get(dataset_name).evaluator_type if evaluator_type == "lvis": evaluator = LVISEvaluator(dataset_name, cfg, True, output_folder) elif evaluator_type == 'coco': evaluator = COCOEvaluator(dataset_name, cfg, True, output_folder) else: assert 0, evaluator_type results[dataset_name] = inference_on_dataset(model, data_loader, evaluator) if comm.is_main_process(): logger.info("Evaluation results for {} in csv format:".format( dataset_name)) print_csv_format(results[dataset_name]) if len(results) == 1: results = list(results.values())[0] return results
def Predict(): os.environ["CUDA_VISIBLE_DEVICES"] = "1" # register test dataset register_coco_instances("custom", {}, "datasets/testdata/midv500_coco.json", "datasets/testdata/") custom_metadata = MetadataCatalog.get("custom") dataset_dicts = DatasetCatalog.get("custom") # set cfg cfg = get_cfg() cfg.merge_from_file("configs/COCO-InstanceSegmentation/mask_rcnn_R_50_FPN_1x.yaml") cfg.DATASETS.TEST = ("custom", ) cfg.MODEL.WEIGHTS = os.path.join(cfg.OUTPUT_DIR, "model_final.pth") cfg.MODEL.ROI_HEADS.SCORE_THRESH_TEST = 0.5 cfg.MODEL.ROI_HEADS.BATCH_SIZE_PER_IMAGE = (512) cfg.MODEL.ROI_HEADS.NUM_CLASSES = 1 predictor = DefaultPredictor(cfg) # save prediction image results cnt=0 for d in dataset_dicts: img = cv2.imread(d["file_name"]) outputs = predictor(img) v = Visualizer(img[:, :, ::-1], metadata=custom_metadata, scale=1, instance_mode=ColorMode.IMAGE_BW) v = v.draw_instance_predictions(outputs["instances"].to("cpu")) cv2.imwrite('D:/eagletmp/detectron2-maskrcnn/outputimg/'+str(cnt)+'.png',v.get_image()[:, :, ::-1]) cnt+=1 # model evaulation evaluator = COCOEvaluator("custom", cfg, False, output_dir="./output/") val_loader = build_detection_test_loader(cfg, "custom") print(inference_on_dataset(predictor.model, val_loader, evaluator))
def do_test(cfg, model): dataset_name = cfg.DATASETS.TEST[0] evaluator = DatasetEvaluators( [COCOEvaluator(dataset_name, cfg, True, cfg.OUTPUT_DIR)]) data_loader = build_detection_test_loader(cfg, dataset_name) results = inference_on_dataset(model, data_loader, evaluator) return results
def do_test(cfg, model): if "evaluator" in cfg.dataloader: ret = inference_on_dataset( model, instantiate(cfg.dataloader.test), instantiate(cfg.dataloader.evaluator) ) print_csv_format(ret) return ret
def best_inference(best_model_name, config_dir, model_dir, test_path_images, \ test_annotations, confidence_threshold, result_metrics_dir, \ video_img_dir, video, framerate): #Storing test data test_dataset_metadata, test_dataset_dicts = setup_data(test_path_images, \ test_annotations) #Creating config file cfg = setup_config(config_dir, model_dir, best_model_name, \ confidence_threshold) #Creating predictor predictor = DefaultPredictor(cfg) #Creating evaluator evaluator = COCOEvaluator("test_detector", \ distributed = False, output_dir=os.path.join(model_dir, "final_test")) #Building test loader test_loader = build_detection_test_loader(cfg, "test_detector") #Loading in train trainer = COCOFormatTrainer(cfg) #Getting inference results on trainer test_results = inference_on_dataset(trainer.model, test_loader, evaluator) #Dumping into json file with open(os.path.join(result_metrics_dir, 'test_results.json'), 'w') as \ outfile: json.dump(dict(test_results), outfile) #Generating video from predictions create_video(video_img_dir, video, test_loader, \ test_dataset_metadata, test_dataset_dicts, predictor, framerate)
def do_test(cfg, model): results = OrderedDict() for dataset_name in cfg.DATASETS.TEST: data_loader = build_detection_test_loader(cfg, dataset_name) evaluator = BasicEvalOperations(dataset_name, cfg, True, os.path.join(cfg.OUTPUT_DIR, "inference", dataset_name)) results[dataset_name] = inference_on_dataset(model, data_loader, evaluator) if comm.is_main_process(): logger.info(f"Image level evaluation complete for {dataset_name}") logger.info(f"Results for {dataset_name}") WIC.only_mAP_analysis(results[dataset_name]['predictions']['correct'], results[dataset_name]['predictions']['scores'], results[dataset_name]['predictions']['pred_classes'], results[dataset_name]['category_counts'], evaluator._coco_api.cats) if comm.is_main_process(): logger.info(f"Combined results for datasets {', '.join(cfg.DATASETS.TEST)}") eval_info={} eval_info['category_counts'] = results[list(results.keys())[0]]['category_counts'] eval_info['predictions']={} for dataset_name in results: for k in results[dataset_name]['predictions'].keys(): if k not in eval_info['predictions']: eval_info['predictions'][k]=[] eval_info['predictions'][k].extend(results[dataset_name]['predictions'][k]) WIC.only_mAP_analysis(eval_info['predictions']['correct'], eval_info['predictions']['scores'], eval_info['predictions']['pred_classes'], eval_info['category_counts']) Recalls_to_process = (0.1, 0.3, 0.5) wilderness = torch.arange(0, 5, 0.1).tolist() WIC_values,wilderness_processed = WIC.WIC_analysis(eval_info,Recalls_to_process=Recalls_to_process,wilderness=wilderness) plot_WIC(WIC_values, Recalls_to_process, wilderness_processed, line_style='--', label='Faster RCNN') return
def test_model(path, model, weights, dataset, action_type='test', mode="full", visualize=False): dataset_name = os.path.basename(path) test = bottle_loader.register_dataset(path, dataset_name, action_type, mode) bottle_loader.register_dataset(path, dataset, 'train', mode) cfg_test = gen_cfg_test(dataset, model, dataset_name) cfg = gen_cfg_train(model, weights, dataset) cfg.MODEL.WEIGHTS = os.path.join(cfg.OUTPUT_DIR, "model_final.pth") cfg.MODEL.ROI_HEADS.SCORE_THRESH_TEST = 0.9 trainer = DefaultTrainer(cfg) trainer.resume_or_load(resume=False) evaluator = COCOEvaluator("%s_%s" % (dataset_name, action_type), cfg_test, False, output_dir="./output_%s/" % (dataset)) val_loader = build_detection_test_loader(cfg_test, "%s_%s" % (dataset, 'train')) result = inference_on_dataset(trainer.model, val_loader, evaluator) #Visualize the test if visualize: visualize_images_dict( dataset_name, test, MetadataCatalog.get('%s_%s' % (dataset, 'train')), cfg, dataset_name) return result
def lslm_evaluation(cfg, output_dir=None): # 创建模型 model = build_model(cfg) # 创建数据器 print(cfg.DATASETS.TEST[0]) evaluator_type = MetadataCatalog.get(cfg.DATASETS.TEST[0]).evaluator_type lslm_evaluation_data_loader = build_detection_test_loader( cfg, cfg.DATASETS.TEST[0]) # for idx, inputs in enumerate(lslm_evaluation_data_loader): # model.eval() # outputs = model(inputs) # print("outputs: ", outputs) # 创建评估器 if output_dir is None: print(cfg.OUTPUT_DIR) output_dir = os.path.join(cfg.OUTPUT_DIR, "inference") lslm_coco_evaluator = COCOEvaluator(cfg.DATASETS.TEST[0], cfg, True, output_dir=output_dir) # 进行数据评估 evaluation_result = inference_on_dataset(model, lslm_evaluation_data_loader, lslm_coco_evaluator) # 下面这种做法并没有什么用 # evaluation_result = inference_on_dataset(model, lslm_evaluation_data_loader, # DatasetEvaluators([lslm_coco_evaluator])) return evaluation_result