target_fields = per_image["instances"].get_fields() labels = [ metadata.thing_classes[i] for i in target_fields["gt_classes"] ] vis = visualizer.overlay_instances( labels=labels, boxes=target_fields.get("gt_boxes", None), masks=target_fields.get("gt_masks", None), keypoints=target_fields.get("gt_keypoints", None), ) output(vis, str(per_image["image_id"]) + ".jpg") else: dicts = list( chain.from_iterable( [DatasetCatalog.get(k) for k in cfg.DATASETS.TEST])) if cfg.MODEL.KEYPOINT_ON: dicts = filter_images_with_few_keypoints(dicts, 1) class_info = defaultdict(list) area_info = defaultdict(list) names = metadata.get('thing_classes', None) for dic in tqdm.tqdm(dicts): annos = dic.get("annotations", None) boxes = [ BoxMode.convert(x["bbox"], x["bbox_mode"], BoxMode.XYWH_ABS) for x in annos ] for i, box in enumerate(boxes): try: ratio = min(box[2] / box[3], box[3] / box[2])
def dataset_from_records(name, records, ordered_labels): DatasetCatalog.register(name, lambda: records) MetadataCatalog.get(name).set(thing_classes=ordered_labels) return DatasetCatalog.get(name), MetadataCatalog.get(name)
record["dim"] = 3 record["points"] = pclouds dataset_dicts.append(record) return dataset_dicts data_path = "datasets/points/" registed_name_list = [ 'swiss_roll_5000', ] registed_func_list = [ get_dict_swiss_roll, ] kwargs_list = [ { 'n_samples': 5000, 'noise': 0.05 }, ] for name, func, kwargs in zip(registed_name_list, registed_func_list, kwargs_list): # warning : lambda must specify keyword arguments DatasetCatalog.register( name, (lambda name=name, func=func, data_path=data_path, kwargs=kwargs: func(name=name, data_path=data_path, **kwargs))) pass
val_json_path = '../../../Datasets/' + dataset + '/val/thermal_RGBT_pairs_3_class.json' #thermal_annotations_4_channel_no_dogs.json'#thermal_annotations_3_channel_no_dogs.json'#val/thermal_RGBT_pairs_3_class.json'#thermal_RGBT_pairs_3_class.json'#thermal_annotations_3_channel_no_dogs.json'#thermal_annotations_4_channel_no_dogs.json' #thermal_annotations_4_channel_no_dogs_Day.json model = 'faster_rcnn_R_101_FPN_3x' # Create config cfg = get_cfg() cfg.DATALOADER.NUM_WORKERS = 6 cfg.OUTPUT_DIR = out_folder cfg.merge_from_file("./configs/COCO-Detection/faster_rcnn_R_101_FPN_3x.yaml") cfg.MODEL.ROI_HEADS.SCORE_THRESH_TEST = 0.5 # set threshold for this model #cfg.MODEL.WEIGHTS = "detectron2://COCO-Detection/faster_rcnn_R_101_FPN_3x/137851257/model_final_f6e8b1.pkl" #cfg.MODEL.WEIGHTS = 'good_model/3_class/thermal_only/out_model_thermal_only_gnll_78_45.pth'#'0304/output_thermal_only_gNLL/out_model_thermal_only_best.pth'#"good_model/3_class/thermal_only/out_model_iter_15000.pth" cfg.MODEL.WEIGHTS = '0228/output_thermal_only_gNLL/out_model_thermal_only_best.pth' #'0304/output_thermal_only_gNLL/out_model_thermal_only_best.pth'#"good_model/3_class/thermal_only/out_model_iter_15000.pth" cfg.MODEL.ROI_HEADS.NUM_CLASSES = 3 cfg.DATASETS.TEST = (dataset, ) ### 3 Channel input ### cfg.INPUT.FORMAT = 'BGR' cfg.INPUT.NUM_IN_CHANNELS = 3 cfg.MODEL.PIXEL_MEAN = [103.530, 116.280, 123.675] cfg.MODEL.PIXEL_STD = [1.0, 1.0, 1.0] ####################### # Test on validation set dataset_test = 'FLIR_val' register_coco_instances(dataset_test, {}, val_json_path, val_folder) FLIR_metadata_test = MetadataCatalog.get(dataset_test) dataset_dicts_test = DatasetCatalog.get(dataset_test) file_name = 'FLIR_thermal_only_gnll.out' test(cfg, dataset_test, file_name)
def get_dicts_val_mini_img(): return get_dicts('/tcdata_train/validation_dataset_part1', 'image', n_items=200) def get_dicts_val_mini_vid(): return get_dicts('/tcdata_train/validation_dataset_part1', 'video', n_items=100) if DEBUG: DatasetCatalog.register('taobao_train_mini', get_dicts_train_mini) DatasetCatalog.register('taobao_val_mini_img', get_dicts_val_mini_img) DatasetCatalog.register('taobao_val_mini_vid', get_dicts_val_mini_vid) MetadataCatalog.get('taobao_train_mini').set(thing_classes=thing_cls) MetadataCatalog.get('taobao_val_mini_img').set(thing_classes=thing_cls) MetadataCatalog.get('taobao_val_mini_vid').set(thing_classes=thing_cls) else: DatasetCatalog.register('taobao_train_all', get_dicts_train_all) DatasetCatalog.register('taobao_val_mini_img', get_dicts_val_mini_img) DatasetCatalog.register('taobao_val_mini_vid', get_dicts_val_mini_vid) MetadataCatalog.get('taobao_train_all').set(thing_classes=thing_cls) MetadataCatalog.get('taobao_val_mini_img').set(thing_classes=thing_cls) MetadataCatalog.get('taobao_val_mini_vid').set(thing_classes=thing_cls)
def main(config_file, ann_val, write, img2show, save_img, eval_chkp, force_test, score_thresh , nms_thresh, kitti_root ): # KITTI paths kitti_im_path = kitti_root+'/image_2' kitti_calib_path = kitti_root+'/calib' # LOGGER AND CONFIGURATION LOAD logger = logging.getLogger("detectron2.trainer") cfg = get_cfg() cfg.merge_from_file(os.path.join(detectron2_root,"configs/{}.yaml".format(config_file))) default_setup(cfg, None) nclasses = cfg.MODEL.ROI_HEADS.NUM_CLASSES optional_arguments = [] if cfg.VIEWPOINT: optional_arguments.append('viewpoint') if cfg.VIEWPOINT_RESIDUAL: optional_arguments.append('vp_res') if cfg.ROTATED_BOX_TRAINING: optional_arguments.append('bbox3D') if cfg.HEIGHT_TRAINING: optional_arguments.append('height') val_path = detectron2_root+"/datasets/bv_kitti/annotations/{}.json".format(ann_val) register_coco_instances("birdview_val", {}, val_path, detectron2_root, optional_arguments) toeval = [] models = os.listdir(cfg.OUTPUT_DIR) for model in models: if model.endswith('.pth') and not model=='model_final.pth': toeval.append(model) toeval.sort() toeval = toeval[:-1] if force_test: toeval = [e for e in toeval if force_test in e] f_eval = [folder.split('_')[1].split('.')[0] for folder in toeval] elif eval_chkp!=0: length = len(toeval)//2 toeval = toeval[length::eval_chkp] toeval.append('model_final.pth') f_eval = [folder.split('_')[1].split('.')[0] for folder in toeval] else: toeval = ['model_final.pth'] f_eval = ['final'] print('Checkpoints to be evaluated: ',toeval) for checkpoint, eval_folder in zip(toeval,f_eval): cfg.MODEL.WEIGHTS = os.path.join(cfg.OUTPUT_DIR, checkpoint) cfg.MODEL.ROI_HEADS.SCORE_THRESH_TEST = score_thresh cfg.MODEL.ROI_HEADS.NMS_THRESH_TEST = nms_thresh predictor = DefaultPredictor(cfg) val_bv_dicts = DatasetCatalog.get("birdview_val") val_bv_meta = MetadataCatalog.get("birdview_val") obj_anns = [] kitti_results = [] c = 0 sample_idx = range(img2show) if img2show != 0 else [-1] logger.info("Showing {} predictions".format(str(img2show))) ann_outdir = os.path.join(cfg.OUTPUT_DIR,'annotations',eval_folder) if not os.path.exists(ann_outdir): os.makedirs(ann_outdir) for image_id, d in enumerate(val_bv_dicts): c += 1 file = os.path.join(ann_outdir,d["file_name"][-10:].split('.png')[0]+'.txt') im = cv2.imread(d["file_name"]) print("Preparing prediction {}, from {}, image: {}".format(str(c),str(len(val_bv_dicts)),d["file_name"])) if not os.path.exists(file) or write: is_kitti_ann=False # Inference outputs = predictor(im) list_anns, obj_anns, instances = prepare_for_coco_detection_KITTI(outputs["instances"].to("cpu"), ann_outdir, d["file_name"], write, kitti_calib_path, nclasses, cfg.VIEWPOINT, cfg.VP_BINS, cfg.VIEWPOINT_RESIDUAL, cfg.ROTATED_BOX_TRAINING, cfg.HEIGHT_TRAINING) kitti_results.append(list_anns) else: is_kitti_ann=True with open(file,'r') as f: list_anns = f.read().splitlines() kitti_results.append([anns.split(' ') for anns in list_anns] if list_anns else []) for ann in list_anns: obj_anns.append(Object3d(ann)) if c in sample_idx: # Change BV aspect nonzero = np.where(im>0) im[nonzero]=255-im[nonzero] im=cv2.bitwise_not(im) kitti_im = cv2.imread(os.path.join(kitti_im_path,d["file_name"][-10:])) calib_file = os.path.join(kitti_calib_path,d["file_name"][-10:].split('.png')[0]+'.txt') # Show obstacles for i, obj in enumerate(obj_anns): kitti_im, im, _ = _draw_projection_obstacle_to_cam(obj, calib_file, bvres, only_front, True, kitti_im, im, is_kitti_ann=is_kitti_ann) cv2.imshow('image',kitti_im) cv2.imshow('bv_image',im) if save_img: im_outdir = os.path.join(cfg.OUTPUT_DIR,'images') if not os.path.exists(im_outdir): os.makedirs(im_outdir) cv2.imwrite(os.path.join(im_outdir,'3D_'+d["file_name"][-10:]), kitti_im) cv2.imwrite(os.path.join(im_outdir,'BEV_'+d["file_name"][-10:]), im) cv2.waitKey(0) cv2.destroyAllWindows() elif c > max(sample_idx) and not write: break
parser.add_argument("--conf-threshold", default=0.5, type=float, help="confidence threshold") args = parser.parse_args() logger = setup_logger() with PathManager.open(args.input, "r") as f: predictions = json.load(f) pred_by_image = defaultdict(list) for p in predictions: pred_by_image[p["image_id"]].append(p) dicts = list(DatasetCatalog.get(args.dataset)) metadata = MetadataCatalog.get(args.dataset) if hasattr(metadata, "thing_dataset_id_to_contiguous_id"): def dataset_id_map(ds_id): return metadata.thing_dataset_id_to_contiguous_id[ds_id] elif "lvis" in args.dataset: # LVIS results are in the same format as COCO results, but have a different # mapping from dataset category id to contiguous category id in [0, #categories - 1] def dataset_id_map(ds_id): return ds_id - 1 else: raise ValueError("Unsupported dataset: {}".format(args.dataset))
np.max(py)], "bbox_mode": BoxMode.XYXY_ABS, "segmentation": [poly], "category_id": category_id[anno["label"]], } objs.append(obj) record["annotations"] = objs dataset_dicts.append(record) return dataset_dicts from detectron2.data import MetadataCatalog, DatasetCatalog category_id = {"shrimp": 0, "head": 1, "tail": 2} TRAIN_ROOT = 'dataset/shrimp/train/' TEST_ROOT = 'dataset/shrimp/test/' DatasetCatalog.register( "shrimp-train", lambda: get_shrimp_dicts(TRAIN_ROOT + 'img', TRAIN_ROOT + 'json', category_id)) DatasetCatalog.register( "shrimp-test", lambda: get_shrimp_dicts(TEST_ROOT + 'img', TEST_ROOT + 'json', category_id)) MetadataCatalog.get("shrimp-train").set( thing_classes=["shrimp", "head", "tail"]) MetadataCatalog.get("shrimp-test").set( thing_classes=["shrimp", "head", "tail"])
path_1 = '../../../Datasets/FLIR/' + data_set + '/resized_RGB/' path_2 = '../../../Datasets/FLIR/' + data_set + '/thermal_8_bit/' out_folder = 'out/box_comparison/' #train_json_path = '../../../Datasets/'+dataset+'/train/thermal_annotations_4_channel_no_dogs.json' val_file_name = 'thermal_annotations_4_channel_no_dogs_3_class.json' #'RGB_annotations_4_channel_no_dogs.json'#'thermal_annotations_4_channel_no_dogs_Day.json'# val_json_path = '../../../Datasets/' + dataset + '/val/' + val_file_name val_folder = '../../../Datasets/FLIR/val/thermal_8_bit' if not os.path.exists(out_folder): os.mkdir(out_folder) # Register dataset dataset = 'FLIR_val' register_coco_instances(dataset, {}, val_json_path, val_folder) FLIR_metadata = MetadataCatalog.get(dataset) dataset_dicts = DatasetCatalog.get(dataset) # Create config cfg = get_cfg() cfg.DATALOADER.NUM_WORKERS = 2 cfg.OUTPUT_DIR = out_folder cfg.merge_from_file( "./configs/COCO-Detection/faster_rcnn_R_101_FPN_3x.yaml") cfg.MODEL.ROI_HEADS.SCORE_THRESH_TEST = 0.5 # set threshold for this model cfg.MODEL.WEIGHTS = "detectron2://COCO-Detection/faster_rcnn_R_101_FPN_3x/137851257/model_final_f6e8b1.pkl" #cfg.MODEL.WEIGHTS = os.path.join(cfg.OUTPUT_DIR, "good_model/out_model_iter_32000.pth") cfg.MODEL.ROI_HEADS.NUM_CLASSES = 80 cfg.DATASETS.TEST = (dataset, ) cfg.INPUT.FORMAT = 'BGR' cfg.INPUT.NUM_IN_CHANNELS = 3 cfg.MODEL.PIXEL_MEAN = [103.530, 116.280, 123.675]
import glob csv_files = glob.glob(surgical_tool_path + '/*.csv') N = len(csv_files) val_inds = np.random.choice(N, N // 3) train_inds = np.setdiff1d(np.arange(N), val_inds) train_val_split = { 'train': [csv_files[i] for i in train_inds], 'val': [csv_files[i] for i in val_inds] } m2cai_data_dir = '/home/mona/share/data/m2cai16-tool-locations' for d in ["train", "val"]: dataset_name = "tool_" + d DatasetCatalog.register( dataset_name, lambda d=d: create_dataset(surgical_tool_path, train_val_split[d], m2cai_data_dir, f'{d}.txt')) MetadataCatalog.get(dataset_name).set(thing_classes=["tool"]) if show_example: dataset_dicts = get_iMerit_dicts(surgical_tool_path, csv_files=["1461-f1763033.csv"]) print(len(dataset_dicts), dataset_dicts[0].keys()) tool_metadata = MetadataCatalog.get("tool_train_1461") for d in random.sample(dataset_dicts, 3): img = cv2.imread(d["file_name"]) visualizer = Visualizer(img[:, :, ::-1], metadata=tool_metadata, scale=0.5) out = visualizer.draw_dataset_dict(d) cv2_imshow(out.get_image()[:, :, ::-1])
def main(args): cfg = get_cfg() cfg.merge_from_file( model_zoo.get_config_file( "COCO-Detection/faster_rcnn_X_101_32x8d_FPN_3x.yaml")) dataset_base_path = Path('/home/baoxiong/Datasets') data_path = dataset_base_path / 'data' anno_path = dataset_base_path / 'annotations' / 'full' detection_path = dataset_base_path / 'detections' rcnn_cache_path = detection_path / 'cache' dataset_list = ['rec_tpv_frames'] for d in dataset_list: DatasetCatalog.register(d, lambda d=d: get_data_dicts( anno_path / '{}.p'.format(d), data_path)) MetadataCatalog.get(d).set(thing_classes=['person']) if args.vis: dataset_dicts = get_data_dicts(anno_path / 'rec_tpv_frames.p', data_path) metadata = MetadataCatalog.get("rec_tpv_frames") for d in random.sample(dataset_dicts, 5): img = cv2.imread(d["file_name"]) visualizer = Visualizer(img[:, :, ::-1], metadata=metadata, scale=0.5) vis = visualizer.draw_dataset_dict(d).get_image() plt.imshow(vis) plt.show() cfg.OUTPUT_DIR = args.output cfg.DATASETS.TRAIN = ("rec_tpv_frames_full", ) cfg.DATASETS.TEST = ("rec_tpv_frames_full", ) cfg.DATALOADER.NUM_WORKERS = 8 cfg.SOLVER.IMS_PER_BATCH = 2 cfg.SOLVER.BASE_LR = 0.00025 cfg.SOLVER.MAX_ITER = 210000 cfg.MODEL.ROI_HEADS.BATCH_SIZE_PER_IMAGE = 512 cfg.MODEL.ROI_HEADS.NUM_CLASSES = 1 cfg.MODEL.ROI_HEADS.SCORE_THRESH_TEST = 0.7 if not Path(cfg.OUTPUT_DIR).exists(): Path(cfg.OUTPUT_DIR).mkdir(parents=True, exist_ok=True) if args.mode == 'train': # cfg.MODEL.WEIGHTS = model_zoo.get_checkpoint_url("COCO-Detection/faster_rcnn_X_101_32x8d_FPN_3x.yaml") cfg.MODEL.WEIGHTS = str(Path(cfg.OUTPUT_DIR) / 'model_0067999.pth') trainer = DefaultTrainer(cfg) trainer.resume_or_load(resume=True) trainer.train() else: cfg.MODEL.WEIGHTS = str(Path(cfg.OUTPUT_DIR) / 'model_0007099.pth') predictor = DefaultPredictor(cfg) for dataset in dataset_list: dataset_anno_path = anno_path / '{}.p'.format(dataset) dataset_dicts = get_data_dicts(dataset_anno_path, data_path) pred_infos = [] for idx, d in enumerate(dataset_dicts): if (idx + 1) % 1000 == 0: print('Finished detection for {}/{} images'.format( idx + 1, len(dataset_dicts))) img = cv2.imread(d["file_name"]) vid_name, frame_id = d["image_id"].split('$') cache_file_path = rcnn_cache_path / '{}_{}.p'.format( vid_name, frame_id) if cache_file_path.exists() and args.cache: with cache_file_path.open('rb') as f: outputs = pickle.load(f) else: outputs = predictor(img) pred_boxes = [ pred_box.cpu().numpy() for pred_box in outputs["instances"].pred_boxes ] outputs["instances"].pred_boxes = pred_boxes pred_scores = [ pred_score.cpu().numpy() for pred_score in outputs["instances"].scores ] outputs["instances"].scores = pred_scores if not cache_file_path.parent.exists(): cache_file_path.parent.mkdir(parents=True) with cache_file_path.open('wb') as f: pickle.dump(outputs, f) if len(outputs['instances'].pred_boxes) == 0 and len( d['annotations']) != 0: print(vid_name, frame_id) pred_boxes = outputs['instances'].pred_boxes pred_scores = outputs["instances"].scores if args.vis: v = Visualizer(img[:, :, ::-1], metadata=metadata, scale=0.8, instance_mode=ColorMode.IMAGE) vis = v.draw_instance_predictions( outputs["instances"].to("cpu")).get_image() plt.imshow(vis) plt.show() for pred_box, pred_score in zip(pred_boxes, pred_scores): pred_infos.append( [vid_name, int(frame_id), pred_box, pred_score]) if not detection_path.exists(): detection_path.mkdir() with (detection_path / '{}.p'.format(dataset)).open('wb') as f: pickle.dump(pred_infos, f) from detectron2.evaluation import COCOEvaluator, inference_on_dataset from detectron2.data import build_detection_test_loader evaluator = COCOEvaluator('rec_tpv_frames_full', cfg, False, output_dir=cfg.OUTPUT_DIR) val_loader = build_detection_test_loader(cfg, 'rec_tpv_frames_full') trainer = DefaultTrainer(cfg) trainer.resume_or_load(resume=True) inference_on_dataset(trainer.model, val_loader, evaluator)
if __name__ == "__main__": import random import cv2 import os from detectron2.data import MetadataCatalog, DatasetCatalog from detectron2.utils.visualizer import Visualizer from detectron2.evaluation import COCOEvaluator, inference_on_dataset, LVISEvaluator from detectron2.data import build_detection_test_loader from detectron2.config import get_cfg from detectron2 import model_zoo from detectron2.engine import DefaultTrainer thing_classes = ["Pedestrian", "WTF", "Car"] DatasetCatalog.register("mots", get_MOTS_dicts) MetadataCatalog.get("mots").set(thing_classes=thing_classes) DatasetCatalog.register("kitti-mots", lambda: get_KITTI_MOTS_dicts()) MetadataCatalog.get("kitti-mots").set(thing_classes=thing_classes) # We train the model with the weight initialized. cfg = get_cfg() cfg.merge_from_file(model_zoo.get_config_file("COCO-Detection/retinanet_R_101_FPN_3x.yaml")) cfg.DATASETS.TRAIN = ("kitti-mots",) cfg.DATASETS.TEST = () cfg.DATALOADER.NUM_WORKERS = 2 cfg.MODEL.WEIGHTS = model_zoo.get_checkpoint_url("COCO-Detection/retinanet_R_101_FPN_3x.yaml") # Let training initialize from model zoo cfg.SOLVER.IMS_PER_BATCH = 2 cfg.SOLVER.BASE_LR = 0.0025 # pick a good LR
train_folder = '../../../Datasets/FLIR/train/thermal_8_bit' #train_json_path = '../../../Datasets/'+dataset+'/train/thermal_annotations_4class.json' train_json_path = '../../../Datasets/' + dataset + '/train/thermal_annotations_4_channel_no_dogs.json' #train_json_path = '../../../Datasets/'+dataset+'/train/thermal_annotations.json' # Validation path val_path = '../../../Datasets/' + dataset + '/val/thermal_8_bit/' val_folder = '../../../Datasets/FLIR/val/thermal_8_bit' #val_json_path = '../../../Datasets/'+dataset+'/val/thermal_annotations_4class.json' val_json_path = '../../../Datasets/' + dataset + '/val/thermal_annotations_4_channel_no_dogs.json' print(train_json_path) # Register dataset dataset_train = 'FLIR_train' register_coco_instances(dataset_train, {}, train_json_path, train_folder) FLIR_metadata_train = MetadataCatalog.get(dataset_train) dataset_dicts_train = DatasetCatalog.get(dataset_train) # Test on validation set dataset_test = 'FLIR_val' register_coco_instances(dataset_test, {}, val_json_path, val_folder) FLIR_metadata_test = MetadataCatalog.get(dataset_test) dataset_dicts_test = DatasetCatalog.get(dataset_test) model = 'faster_rcnn_R_101_FPN_3x' #files_names = [f for f in listdir(train_path) if isfile(join(train_path, f))] out_folder = 'output_6_channel' out_model_path = os.path.join(out_folder, 'out_model_final.pth') if not os.path.exists(out_folder): os.mkdir(out_folder)
def main(args): # Register custom datasets register_coco_instances( "robust_misc_train", {}, "data/robust_misc/annotations/instances_train.json", "data/robust_misc/train") register_coco_instances("robust_misc_val", {}, "data/robust_misc/annotations/instances_val.json", "data/robust_misc/val") register_coco_instances( "robust_misc_test_stage1", {}, "data/robust_misc_testing/Stage_1/annotations/instances_test.json", "data/robust_misc_testing/Stage_1/test") register_coco_instances( "robust_misc_test_stage2", {}, "data/robust_misc_testing/Stage_2/annotations/instances_test.json", "data/robust_misc_testing/Stage_2/test") register_coco_instances( "robust_misc_test_stage3", {}, "data/robust_misc_testing/Stage_3/annotations/instances_test.json", "data/robust_misc_testing/Stage_3/test") cfg = setup(args) print(cfg) if args.vis_only: # visualise masks cfg.MODEL.WEIGHTS = os.path.join(cfg.OUTPUT_DIR, "model_final.pth") cfg.MODEL.ROI_HEADS.SCORE_THRESH_TEST = 0.5 cfg.DATASETS.TEST = ("robust_misc_test_stage3", ) predictor = DefaultPredictor(cfg) dataset_dicts = DatasetCatalog.get("robust_misc_test_stage3") for d in dataset_dicts: img = cv2.imread(d["file_name"]) outputs = predictor(img) v = Visualizer(img) v = v.draw_instance_predictions(outputs["instances"].to("cpu")) os.makedirs("visualizations", exist_ok=True) res = v.get_image() f_name = d['file_name'].split("/")[-1] cv2.imwrite(f"visualizations/{f_name}", res) return # train model trainer = DefaultTrainer(cfg) trainer.resume_or_load(resume=False) if args.eval_only: # run coco eval on all test sets cfg.MODEL.WEIGHTS = os.path.join(cfg.OUTPUT_DIR, "model_final.pth") model = build_model(cfg) DetectionCheckpointer(model).load( os.path.join(cfg.OUTPUT_DIR, "model_final.pth")) os.makedirs("evaluation/stage_1", exist_ok=True) os.makedirs("evaluation/stage_2", exist_ok=True) os.makedirs("evaluation/stage_3", exist_ok=True) cfg.DATASETS.TEST = ("robust_misc_test_stage1", "robust_misc_test_stage2", "robust_misc_test_stage3") cfg.MODEL.ROI_HEADS.SCORE_THRESH_TEST = 0.5 ev1 = COCOEvaluator("robust_misc_test_stage1", output_dir="evaluation/stage_1") st1_loader = build_detection_test_loader(cfg, "robust_misc_test_stage1") inference_on_dataset(model, st1_loader, ev1) ev2 = COCOEvaluator("robust_misc_test_stage2", output_dir="evaluation/stage_2") st2_loader = build_detection_test_loader(cfg, "robust_misc_test_stage2") inference_on_dataset(model, st2_loader, ev2) ev3 = COCOEvaluator("robust_misc_test_stage3", output_dir="evaluation/stage_3") st3_loader = build_detection_test_loader(cfg, "robust_misc_test_stage3") inference_on_dataset(model, st3_loader, ev3) return return trainer.train()
print("number of instance: ", len(list_dict)) if split != "overfit": print("Example of instace: ", list_dict[100]) else: print(list_dict) return list_dict class_names = [] img_folder = "../../../data/HICO_DET/images/" json_folder = "../../../data/HICO_DET/hico_det_json/" with open(osp.join(json_folder, "object_list.json")) as jfp: object_list = json.load(jfp) for each_object in object_list: object_name = each_object["name"] class_names.append(object_name) assert len(class_names) == 80, "number class is wrong " + str(len(class_names)) splits = [ "train", "test", "overfit", ] for split in splits: DatasetCatalog.register( "HICO_DET_" + split, lambda: load_hico_data( img_folder=img_folder, json_folder=json_folder, split=split)) MetadataCatalog.get("HICO_DET_" + split).set(thing_classes=class_names)
def register_all_cityscapes_panoptic(root): meta = {} # The following metadata maps contiguous id from [0, #thing categories + # #stuff categories) to their names and colors. We have to replica of the # same name and color under "thing_*" and "stuff_*" because the current # visualization function in D2 handles thing and class classes differently # due to some heuristic used in Panoptic FPN. We keep the same naming to # enable reusing existing visualization functions. thing_classes = [k["name"] for k in CITYSCAPES_CATEGORIES] thing_colors = [k["color"] for k in CITYSCAPES_CATEGORIES] stuff_classes = [k["name"] for k in CITYSCAPES_CATEGORIES] stuff_colors = [k["color"] for k in CITYSCAPES_CATEGORIES] meta["thing_classes"] = thing_classes meta["thing_colors"] = thing_colors meta["stuff_classes"] = stuff_classes meta["stuff_colors"] = stuff_colors # There are three types of ids in cityscapes panoptic segmentation: # (1) category id: like semantic segmentation, it is the class id for each # pixel. Since there are some classes not used in evaluation, the category # id is not always contiguous and thus we have two set of category ids: # - original category id: category id in the original dataset, mainly # used for evaluation. # - contiguous category id: [0, #classes), in order to train the classifier # (2) instance id: this id is used to differentiate different instances from # the same category. For "stuff" classes, the instance id is always 0; for # "thing" classes, the instance id starts from 1 and 0 is reserved for # ignored instances (e.g. crowd annotation). # (3) panoptic id: this is the compact id that encode both category and # instance id by: category_id * 1000 + instance_id. thing_dataset_id_to_contiguous_id = {} stuff_dataset_id_to_contiguous_id = {} for k in CITYSCAPES_CATEGORIES: if k["isthing"] == 1: thing_dataset_id_to_contiguous_id[k["id"]] = k["trainId"] else: stuff_dataset_id_to_contiguous_id[k["id"]] = k["trainId"] meta[ "thing_dataset_id_to_contiguous_id"] = thing_dataset_id_to_contiguous_id meta[ "stuff_dataset_id_to_contiguous_id"] = stuff_dataset_id_to_contiguous_id for key, (image_dir, gt_dir, gt_json) in _RAW_CITYSCAPES_PANOPTIC_SPLITS.items(): image_dir = os.path.join(root, image_dir) gt_dir = os.path.join(root, gt_dir) gt_json = os.path.join(root, gt_json) DatasetCatalog.register(key, lambda x=image_dir, y=gt_dir, z=gt_json: load_cityscapes_panoptic(x, y, z, meta)) MetadataCatalog.get(key).set( panoptic_root=gt_dir, image_root=image_dir, panoptic_json=gt_json, gt_dir=gt_dir.replace("cityscapes_panoptic_", ""), evaluator_type="cityscapes_panoptic_seg", ignore_label=255, label_divisor=1000, **meta, )
cfg.MODEL.DEVICE = "cuda" if torch.cuda.is_available() else "cpu" cfg.MODEL.WEIGHTS = "model_final.pth" predictor = DefaultPredictor(cfg) def get_images(folder_source: str): image_values = [] for filename in glob.glob( os.path.abspath(os.path.join(folder_source, '*.jpg'))): obj = dict() obj['file_name'] = filename image_values.append(obj) return image_values DatasetCatalog.register("cars_test", lambda: get_images(folder)) MetadataCatalog.get("cars_test").set(thing_classes=["cars"]) metadata = MetadataCatalog.get("cars_test") if __name__ == '__main__': results = [] try: images = get_images(folder) count = 0 for file in tqdm(images): im = cv2.imread(file['file_name']) outputs = predictor(im) boxes = outputs["instances"].get('pred_boxes') boxes_centers = boxes.get_centers() name_image = os.path.basename(file['file_name'])
def register_coco_panoptic_separated(name, metadata, image_root, panoptic_root, panoptic_json, sem_seg_root, instances_json): """ Register a "separated" version of COCO panoptic segmentation dataset named `name`. The annotations in this registered dataset will contain both instance annotations and semantic annotations, each with its own contiguous ids. Hence it's called "separated". It follows the setting used by the PanopticFPN paper: 1. The instance annotations directly come from polygons in the COCO instances annotation task, rather than from the masks in the COCO panoptic annotations. The two format have small differences: Polygons in the instance annotations may have overlaps. The mask annotations are produced by labeling the overlapped polygons with depth ordering. 2. The semantic annotations are converted from panoptic annotations, where all "things" are assigned a semantic id of 0. All semantic categories will therefore have ids in contiguous range [1, #stuff_categories]. This function will also register a pure semantic segmentation dataset named ``name + '_stuffonly'``. Args: name (str): the name that identifies a dataset, e.g. "coco_2017_train_panoptic" metadata (dict): extra metadata associated with this dataset. image_root (str): directory which contains all the images panoptic_root (str): directory which contains panoptic annotation images panoptic_json (str): path to the json panoptic annotation file sem_seg_root (str): directory which contains all the ground truth segmentation annotations. instances_json (str): path to the json instance annotation file """ panoptic_name = name + "_separated" DatasetCatalog.register( panoptic_name, lambda: merge_to_panoptic( load_coco_json(instances_json, image_root, panoptic_name), load_sem_seg(sem_seg_root, image_root), ), ) MetadataCatalog.get(panoptic_name).set( panoptic_root=panoptic_root, image_root=image_root, panoptic_json=panoptic_json, sem_seg_root=sem_seg_root, json_file=instances_json, # TODO rename evaluator_type="coco_panoptic_seg", ignore_label=255, **metadata, ) semantic_name = name + "_stuffonly" DatasetCatalog.register(semantic_name, lambda: load_sem_seg(sem_seg_root, image_root)) MetadataCatalog.get(semantic_name).set( sem_seg_root=sem_seg_root, image_root=image_root, evaluator_type="sem_seg", ignore_label=255, **metadata, )
if __name__ == "__main__": """ Test the COCO json dataset loader. Usage: python -m detectron2.data.datasets.coco \ path/to/json path/to/image_root dataset_name "dataset_name" can be "coco_2014_minival_100", or other pre-registered ones """ from detectron2.utils.logger import setup_logger from detectron2.utils.visualizer import Visualizer import sys logger = setup_logger(name=__name__) assert sys.argv[3] in DatasetCatalog.list() meta = MetadataCatalog.get(sys.argv[3]) dicts = load_coco_json(sys.argv[1], sys.argv[2], sys.argv[3]) logger.info("Done loading {} samples.".format(len(dicts))) dirname = "coco-data-vis" os.makedirs(dirname, exist_ok=True) for d in dicts: img = np.array(Image.open(d["file_name"])) visualizer = Visualizer(img, metadata=meta) vis = visualizer.draw_dataset_dict(d) fpath = os.path.join(dirname, os.path.basename(d["file_name"])) vis.save(fpath)
MODEL_FILE_PATH = "COCO-Detection-faster_rcnn_R_50_FPN_1x-eps3000-thresh0.5/model_final.pth" """ DATA_PATH = "/home/jinsuby/Desktop/PycharmProjects/data/Kia/3d_reference/Kia_coco_thick_1_v3" DATA = "3d_reference_thick1" DATA_JSON_PATH = os.path.join(DATA_PATH, "annotations/Kia_test_cocoformat.json") DATA_IMG_PATH = os.path.join(DATA_PATH, "test") CONFIG_FILE = "COCO-Detection/faster_rcnn_R_50_FPN_1x.yaml" MODEL_FILE_PATH = "COCO-Detection-faster_rcnn_R_50_FPN_1x-eps3000-thresh0.5/model_final.pth" register_coco_instances(DATA, {}, DATA_JSON_PATH, DATA_IMG_PATH) DATA_metadata = MetadataCatalog.get(DATA) DATA_dataset_dicts = DatasetCatalog.get(DATA) # Inference should use the config with parameters that are used in training # cfg now already contains everything we've set previously. We changed it a little bit for inference: cfg = get_cfg() cfg.merge_from_file(model_zoo.get_config_file(CONFIG_FILE)) cfg.DATALOADER.NUM_WORKERS = 2 cfg.MODEL.ROI_HEADS.NUM_CLASSES = 12 # Numbers of classes cfg.MODEL.WEIGHTS = os.path.join( "./output/", DATA, MODEL_FILE_PATH) # path to the model we just trained cfg.OUTPUT_DIR = os.path.join( "./output", DATA, MODEL_FILE_PATH.split("/")[0] + "/ground_truth_visualization-meeting/") os.makedirs(cfg.OUTPUT_DIR, exist_ok=True)
record["annotations"] = objs dataset_dicts.append(record) return dataset_dicts # Dataset registration for d in ["train_kitti", "val_kitti"]: print("d=", d) # /home/group00/mcv/datasets/KITTI/training/label_2 path = os.path.join("/home/group00/mcv/datasets/KITTI", d + ".txt") with open(path, "r") as f: lines = f.read().split('\n') #DatasetCatalog.register("balloon_" + d, lambda d=d: get_balloon_dicts("balloon/" + d)) DatasetCatalog.register(d, lambda d=d: get_kitti_dataset(lines)) MetadataCatalog.get(d).set(thing_classes=[ 'Car', 'Van', 'Truck', 'Pedestrian', 'Person_sitting', 'Cyclist', 'Tram', 'Misc', 'DontCare' ]) kitti_train_metadata = MetadataCatalog.get("train_kitti") path = os.path.join("/home/group00/mcv/datasets/KITTI", "train_kitti.txt") with open(path, "r") as f: lines = f.read().split('\n') dataset_dicts = get_kitti_dataset(lines) for d in random.sample(dataset_dicts, 3): img = cv2.imread(d["file_name"]) visualizer = Visualizer(img[:, :, ::-1],
# Register dataset and metadata catologues DatasetCatalog._REGISTERED.clear() #del DatasetCatalog._REGISTERED['weapons_train'] #del DatasetCatalog._REGISTERED['weapons_val'] print(DatasetCatalog._REGISTERED) print(len(DatasetCatalog._REGISTERED)) entriesToRemove = ('weapons_train', 'weapons_val') for k in entriesToRemove: DatasetCatalog._REGISTERED.pop(k, None) for d in ["train", "val"]: DatasetCatalog.register("weapons_" + d, lambda d=d: create_dataset_dicts( train_df if d == "train" else test_df, classes)) MetadataCatalog.get("weapons_" + d).set(thing_classes=classes) statement_metadata = MetadataCatalog.get("weapons_train") class CocoTrainer(DefaultTrainer): @classmethod def build_evaluator(cls, cfg, dataset_name, output_folder=None): if output_folder is None: os.makedirs("coco_eval", exist_ok=True) output_folder = "coco_eval" # output_folder = os.path.join(cfg.OUTPUT_DIR, "inference") return COCOEvaluator(dataset_name, cfg, False, output_folder)
if hotspots_only: # change the category ID. Ignore sign data. hotspot["category_id"] = 0 return dat # load sign list. with open("data/signs.txt", "r") as sgns: signs = [sign.strip() for sign in sgns.readlines()] # register everything in the Detectron2 DatasetCatalog and MetadataCatalog. DatasetCatalog.register( "signs_train", functools.partial(get_data, "data/hotspots_train.json", "data/images_cropped", hotspots_only=False), ) DatasetCatalog.register( "signs_val", functools.partial(get_data, "data/hotspots_val.json", "data/images_cropped", hotspots_only=False), ) DatasetCatalog.register( "signs_test", functools.partial(get_data, "data/hotspots_test.json", "data/images_cropped",
from detectron2.data.datasets import register_coco_instances register_coco_instances( "my_dataset_train", {}, "/media/b/PSSD/haixia/workspace/pics_haixia_addin_uppter_cabin_1/train/instances.json", "/media/b/PSSD/haixia/workspace/pics_haixia_addin_uppter_cabin_1/train/jpg" ) register_coco_instances( "my_dataset_val", {}, "/media/b/PSSD/haixia/workspace/pics_haixia_addin_uppter_cabin_1/val/instances.json", "/media/b/PSSD/haixia/workspace/pics_haixia_addin_uppter_cabin_1/val/jpg") coco_val_metadata = MetadataCatalog.get('my_dataset_val') dataset_dicts = DatasetCatalog.get('my_dataset_val') coco_train_metadata = MetadataCatalog.get('my_dataset_train') dataset_dicts2 = DatasetCatalog.get('my_dataset_train') ### end of register ### visualize data for d in random.sample(dataset_dicts2, 3): img = cv2.imread(d["file_name"]) visualizer = Visualizer(img[:, :, ::-1], metadata=coco_train_metadata, scale=0.5) out = visualizer.draw_dataset_dict(d) plt.figure() #cv2_imshow(out.get_image()[:, :, ::-1])
xyz[y1 : y2 + 1, x1 : x2 + 1, :] = xyz_crop xyz_show = get_emb_show(xyz) grid_show( [img[:, :, [2, 1, 0]], img_vis[:, :, [2, 1, 0]], img_vis_kpt2d[:, :, [2, 1, 0]], depth, xyz_show], ["img", "vis_img", "img_vis_kpts2d", "depth", "emb_show"], row=2, col=3, ) if __name__ == "__main__": """Test the dataset loader. Usage: python -m core.datasets.lm_syn_imgn dataset_name """ from lib.vis_utils.image import grid_show from lib.utils.setup_logger import setup_my_logger import detectron2.data.datasets # noqa # add pre-defined metadata from lib.vis_utils.image import vis_image_mask_bbox_cv2 from core.utils.utils import get_emb_show from core.utils.data_utils import read_image_cv2 print("sys.argv:", sys.argv) logger = setup_my_logger(name="core") register_with_name_cfg(sys.argv[1]) print("dataset catalog: ", DatasetCatalog.list()) test_vis()
with open(trainjsonPath, 'r') as f: imgs_anns = json.load(f) print('json loader finished') images = {} for image in imgs_anns['images']: images[image['id']] = {'file_name': image['file_name'], 'annotations': []} for ann in imgs_anns['annotations']: images[ann['image_id']]['annotations'].append(ann) categories = [] for img in imgs_anns['categories']: categories.append(img['name']) print('categories: ', categories) DatasetCatalog.register( "trainSet", lambda I=images, P=trainPath: utils.get_textImg_dicts(I, P)) MetadataCatalog.get("trainSet").set(thing_classes=categories) textImg_metadata = MetadataCatalog.get("trainSet") print('textImg_metadata: ', textImg_metadata) #utils.draw_textImg_dicts(utils.get_textImg_dicts(images, trainPath), 3, textImg_metadata) cfg = get_cfg() cfg.merge_from_file( "./detectron2_repo/configs/COCO-Detection/faster_rcnn_X_101_32x8d_FPN_3x.yaml" ) cfg.DATASETS.TRAIN = ("trainSet", ) cfg.DATASETS.TEST = () cfg.DATALOADER.NUM_WORKERS = 6 # cfg.MODEL.WEIGHTS = "detectron2://COCO-Detection/faster_rcnn_X_101_32x8d_FPN_3x/139173657/model_final_68b088.pkl" cfg.MODEL.WEIGHTS = os.path.join(cfg.OUTPUT_DIR, "model_final.pth")
def register_mhpv1_instance(name, root): image_root = Path(root) / 'images' human_id_root = Path(root) / 'annotations' DatasetCatalog.register( name, lambda: load_mhpv1_dataset(image_root, human_id_root))
"iscrowd": 0, } objs.append(obj) record["annotations"] = objs dataset_dicts.append(record) return dataset_dicts if __name__ == "__main__": # on Windows, PyTorch code has to be run within if __name__ == "__main__": # the data has to be registered within detectron2, once for the train and once for # the val data for d in ["train", "val"]: DatasetCatalog.register( "buildings_" + d, lambda d=d: get_building_dicts("./via-2.0.8/buildings/" + d), ) # MetadataCatalog.get("buildings_" + d).set(thing_classes=["buildings"]) building_metadata = MetadataCatalog.get("buildings_train") dataset_dicts = get_building_dicts("./via-2.0.8/buildings/train") for i, d in enumerate(random.sample(dataset_dicts, 5)): img = cv2.imread(d["file_name"]) visualizer = Visualizer(img[:, :, ::-1], metadata=building_metadata, scale=0.5) vis = visualizer.draw_dataset_dict(d) plt.imshow(vis.get_image()[:, :, ::-1]) # the folder inputs has to be created first
# obj = { # "bbox": ann, # "bbox_mode": BoxMode.XYXY_ABS, # "category_id": 1 # } # objs.append(obj) record["annotations"] = objs dataset_dicts.append(record) return dataset_dicts DatasetCatalog.register( "kitti_train", lambda d="train": get_dicts( "/mnt/nfs/scratch1/pmallya/KITTI/object/training/image_2/", "./output/ground_kitti.json")) DatasetCatalog.register( "kitti_infer", lambda d="infer": get_dicts( "/mnt/nfs/scratch1/pmallya/KITTI/object/training/image_2/", "./output/infer_kitti_faster_rcnn_x101.json")) # MetadataCatalog.get("nusc_train").set(thing_classes=["barrier", "bicycle", "bus", "car", "construction_vehicle", "motorcycle", "pedestrian", "traffic_cone", "trailer", "truck", "void"]) MetadataCatalog.get("kitti_train").set(thing_classes=["car"]) MetadataCatalog.get("kitti_infer").set(thing_classes=["car"]) nusc_metadata_ground = MetadataCatalog.get("kitti_train") nusc_metadata_infer = MetadataCatalog.get("kitti_infer") nusc_dicts_ground = get_dicts( "/mnt/nfs/scratch1/pmallya/KITTI/object/training/image_2/",
"bbox": [np.min(px), np.min(py), np.max(px), np.max(py)], "bbox_mode": BoxMode.XYXY_ABS, "segmentation": [poly], "category_id": 0, } objs.append(obj) record["annotations"] = objs dataset_dicts.append(record) return dataset_dicts for d in ["train", "val"]: DatasetCatalog.register("balloon_" + d, lambda d=d: get_balloon_dicts("balloon/" + d)) MetadataCatalog.get("balloon_" + d).set(thing_classes=["balloon"]) balloon_metadata = MetadataCatalog.get("balloon_train") ### end of register ### original visualize data #dataset_dicts = get_balloon_dicts("balloon/train") #for d in random.sample(dataset_dicts, 3): # img = cv2.imread(d["file_name"]) # visualizer = Visualizer(img[:, :, ::-1], metadata=balloon_metadata, scale=0.5) # out = visualizer.draw_dataset_dict(d) # cv2_imshow(out.get_image()[:, :, ::-1]) ### end visualize ### my local visualize data dataset_dicts = get_balloon_dicts("balloon/train")