def plain_register_dataset(): DatasetCatalog.register("football", lambda: load_coco_json(TRAIN_JSON, TRAIN_PATH, "football")) MetadataCatalog.get("football").set(thing_classes=["ball", "man"], json_file=TRAIN_JSON, image_root=TRAIN_PATH) DatasetCatalog.register("footballval", lambda: load_coco_json(VAL_JSON, VAL_PATH, "footballval")) MetadataCatalog.get("footballval").set(thing_classes=["ball", "man"], json_file=VAL_JSON, image_root=VAL_PATH)
def plain_register_dataset(): DatasetCatalog.register("train_2019", lambda: load_coco_json(TRAIN_JSON, TRAIN_PATH, "train_2019")) MetadataCatalog.get("train_2019").set(thing_classes=CATEGORIES_NAMES, json_file=TRAIN_JSON, image_root=TRAIN_PATH) DatasetCatalog.register("val_2019", lambda: load_coco_json(VAL_JSON, VAL_PATH, "val_2019")) MetadataCatalog.get("val_2019").set(thing_classes=CATEGORIES_NAMES, json_file=VAL_JSON, image_root=VAL_PATH)
def setup_register_load_inputs(cfg): outpath = Path(r'/datadrive/denmark-data/preprocessed') im_tiles_path = outpath / r'images/train2016' val_tiles_path = outpath / r'images/val2016' train_coco_instances_path = outpath / r'annotations/instances_train2016.json' val_coco_instances_path = outpath / r'annotations/instances_val2016.json' # register each val and test set if there are more than one. register_coco_instances(cfg.DATASETS.TRAIN[0], {}, str(train_coco_instances_path), str(im_tiles_path)) register_coco_instances(cfg.DATASETS.VALIDATION[0], {}, str(val_coco_instances_path), str(val_tiles_path)) # register_coco_instances(cfg.DATASETS.TEST[0], {}, test_coco_instances_path, str(next(tiles_path.glob("*jpeg*")))) train_json = load_coco_json(str(train_coco_instances_path), str(im_tiles_path)) val_json = load_coco_json(str(val_coco_instances_path), str(val_tiles_path))
def plain_register_dataset(): DatasetCatalog.register( "iecas_THz_2019_train", lambda: load_coco_json(TRAIN_JSON, TRAIN_PATH, "iecas_THz_2019_train")) MetadataCatalog.get("iecas_THz_2019_train").set( thing_classes=["gun", "phone"], json_file=TRAIN_JSON, image_root=TRAIN_PATH) DatasetCatalog.register( "iecas_THz_2019_val", lambda: load_coco_json(VAL_JSON, VAL_PATH, "iecas_THz_2019_val")) MetadataCatalog.get("iecas_THz_2019_val").set( thing_classes=["gun", "phone"], json_file=VAL_JSON, image_root=VAL_PATH)
def register_coco_instances(name, metadata, json_file, image_root): """ Register a dataset in COCO's json annotation format for instance detection, instance segmentation and keypoint detection. (i.e., Type 1 and 2 in http://cocodataset.org/#format-data. `instances*.json` and `person_keypoints*.json` in the dataset). This is an example of how to register a new dataset. You can do something similar to this function, to register new datasets. Args: name (str): the name that identifies a dataset, e.g. "coco_2014_train". metadata (dict): extra metadata associated with this dataset. You can leave it as an empty dict. json_file (str): path to the json instance annotation file. image_root (str): directory which contains all the images. """ # 1. register a function which returns dicts DatasetCatalog.register( name, lambda: load_coco_json(json_file, image_root, name)) # 2. Optionally, add metadata about this dataset, # since they might be useful in evaluation, visualization or logging MetadataCatalog.get(name).set(json_file=json_file, image_root=image_root, evaluator_type="coco", **metadata)
def load_annotations(): return load_coco_json( json_file=annotations_fpath, image_root=images_root, dataset_name=dataset_data.name, extra_annotation_keys=DENSEPOSE_KEYS, )
def train_coco_data(self, coco_json): dataset_name = "mask_train_data" DatasetCatalog.register( dataset_name, lambda: load_coco_json(json_file=coco_json, image_root=self.train_data_path)) MetadataCatalog.get(dataset_name).set( json_file=coco_json, image_root=self.train_data_path, evaluator_type="coco", thing_classes=["rightmask"], thing_dataset_id_to_contiguous_id={1: 0}) cfg = get_cfg() cfg.merge_from_file( "/home/detectron2/configs/COCO-Detection/faster_rcnn_R_50_FPN_3x.yaml" ) cfg.DATASETS.TRAIN = (dataset_name, ) cfg.DATASETS.TEST = (dataset_name, ) cfg.DATALOADER.NUM_WORKERS = 2 cfg.MODEL.WEIGHTS = "/home/detectron2/train_data/model_final_280758.pkl" cfg.SOLVER.IMS_PER_BATCH = 2 cfg.SOLVER.BASE_LR = 0.01 # 学习率 cfg.SOLVER.MAX_ITER = 300 # 最大迭代次数 cfg.MODEL.ROI_HEADS.BATCH_SIZE_PER_IMAGE = 128 cfg.MODEL.ROI_HEADS.NUM_CLASSES = 1 os.makedirs(cfg.OUTPUT_DIR, exist_ok=True) print("模型存储路径" + cfg.OUTPUT_DIR) trainer = DefaultTrainer(cfg) trainer.resume_or_load(resume=False) trainer.train() # 开始训练
def train_model(dataset): # Export the dataset to COCO format export_file, image_dir = export_dataset(dataset) # Register it as a COCO dataset in the Detectron2 framework try: register_coco_instances('my_dataset', {}, export_file, image_dir) except: print('Dataset was already registered') dataset_dicts = load_coco_json(export_file, image_dir) MetadataCatalog.get('my_dataset').set( thing_classes=[c['name'] for c in dataset.categories]) segments_metadata = MetadataCatalog.get('my_dataset') print(segments_metadata) # Configure the training run cfg = get_cfg() cfg.merge_from_file( model_zoo.get_config_file( 'COCO-InstanceSegmentation/mask_rcnn_R_50_FPN_3x.yaml')) cfg.DATASETS.TRAIN = ('my_dataset', ) cfg.DATASETS.TEST = () cfg.INPUT.MASK_FORMAT = 'bitmask' cfg.DATALOADER.NUM_WORKERS = 2 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 = 4 # 4 cfg.SOLVER.BASE_LR = 0.00025 # pick a good LR cfg.SOLVER.MAX_ITER = 6000 # 300 iterations seems good enough for this toy dataset; you may need to train longer for a practical dataset cfg.MODEL.ROI_HEADS.BATCH_SIZE_PER_IMAGE = 512 # faster, and good enough for this toy dataset (default: 512) cfg.MODEL.ROI_HEADS.NUM_CLASSES = len( dataset.categories) # number of categories # cfg.MODEL.DEVICE = 'cuda' print('Max iter is ', cfg.SOLVER.MAX_ITER) # Start the training os.makedirs(cfg.OUTPUT_DIR, exist_ok=True) trainer = DefaultTrainer(cfg) trainer.resume_or_load(resume=False) trainer.train() # Return the model cfg.MODEL.WEIGHTS = os.path.join(cfg.OUTPUT_DIR, 'model_final.pth') cfg.MODEL.ROI_HEADS.SCORE_THRESH_TEST = 0.7 # set the testing threshold for this model cfg.DATASETS.TEST = ('my_dataset', ) cfg.TEST.DETECTIONS_PER_IMAGE = 1000 built_model = build_model(cfg) # returns a torch.nn.Module DetectionCheckpointer(built_model).load( cfg.MODEL.WEIGHTS) #capture trained model checkpointer = DetectionCheckpointer( built_model, save_dir="/content/gdrive/My Drive/Colab Notebooks") checkpointer.save("model_final") # save to output/model_999.pth predictor = DefaultPredictor(cfg) model = Model(predictor) return model
def register_dataset_instances(name, metadate, json_file, image_root): """ purpose: register dataset to DatasetCatalog, register metadata to MetadataCatalog and set attribute """ DatasetCatalog.register(name, lambda: load_coco_json(json_file, image_root, name)) MetadataCatalog.get(name).set(json_file=json_file, image_root=image_root, evaluator_type="coco", **metadate)
def __init__(self, args): self.args = args use_cuda = True # for d in ["Training", "Validation"]: # DatasetCatalog.register("mywaymo1_" + d, lambda d=d: load_coco_json(self.args.datasetpath + d + "/annotations.json", self.args.datasetpath + d + "/")) d = "Validation" self.datasetname = args.datasetname + d allregistereddataset = DatasetCatalog.list() #return List[str] print(allregistereddataset) if self.datasetname not in allregistereddataset: jsonpath = os.path.join(self.args.datasetpath, d, 'annotations.json') DatasetCatalog.register( self.datasetname, lambda d=d: load_coco_json( jsonpath, os.path.join(self.args.datasetpath, d))) print("Registered dataset: ", self.datasetname) #FULL_LABEL_CLASSES = ['unknown', 'vehicle', 'pedestrian', 'sign', 'cyclist']#['ignored-regions', 'pedestrian', 'people', 'bicycle', 'car', 'van', 'truck', 'tricycle', 'awning-tricycle','bus', 'motor', 'others'] MetadataCatalog.get( self.datasetname).set(thing_classes=args.FULL_LABEL_CLASSES) # for d in ["Training", "Validation"]: # MetadataCatalog.get("mywaymo1_" + d).set(thing_classes=FULL_LABEL_CLASSES) cfg = get_cfg() #cfg.OUTPUT_DIR='./output' #'./output_x101' cfg.merge_from_file( model_zoo.get_config_file( "COCO-Detection/" + self.args.modelname + ".yaml")) #faster_rcnn_X_101_32x8d_FPN_3x #cfg.DATASETS.TRAIN = ("mywaymo1_Training",) cfg.DATASETS.TEST = (self.datasetname, ) cfg.DATALOADER.NUM_WORKERS = 1 #2 #cfg.MODEL.WEIGHTS = model_zoo.get_checkpoint_url("COCO-Detection/faster_rcnn_X_101_32x8d_FPN_3x.yaml") # Let training initialize from model zoo #cfg.MODEL.WEIGHTS = os.path.join('/home/010796032/PytorchWork', "fasterrcnn_x101_fpn_model_final_68b088.pkl")#using the local #cfg.MODEL.WEIGHTS = os.path.join('/home/010796032/PytorchWork/output', "model_final.pth") cfg.MODEL.WEIGHTS = os.path.join( self.args.modelbasefolder, self.args.modelfilename) #model_0159999.pth cfg.SOLVER.IMS_PER_BATCH = 4 cfg.SOLVER.LR_SCHEDULER_NAME = 'WarmupCosineLR' cfg.SOLVER.BASE_LR = 0.00025 # pick a good LR cfg.SOLVER.MAX_ITER = 80000 # 140000 # you may need to train longer for a practical dataset cfg.MODEL.ROI_HEADS.BATCH_SIZE_PER_IMAGE = 128 #512#128 # faster, and good enough for this toy dataset (default: 512) cfg.MODEL.ROI_HEADS.NUM_CLASSES = len( args.FULL_LABEL_CLASSES ) #5 #12 # Kitti has 9 classes (including donot care) cfg.TEST.EVAL_PERIOD = 5000 self.cfg_detectron2 = cfg self.predictor = DefaultPredictor(cfg)
def get_xview2_dicts(data_dir, split): ann_path = os.path.join(data_dir, 'annotations', split + '.json') img_dir = os.path.join(data_dir, 'images', split) ann = load_coco_json(ann_path, img_dir, dataset_name='xView2_' + split) for a in ann: img_name = '_'.join( ['post' if i == 'pre' else i for i in a['file_name'].split('_')]) img_name = os.path.basename(img_name) a['post_file_name'] = os.path.join(data_dir, 'images', split + '_post', img_name) a['pre_file_name'] = a['file_name'] del (a['file_name']) return ann
def load_ssigns(json_file, dataset_name=None): """ Load a json file in coco's annotation format. Args: json_file (str): full path to the ssigns json annotation file. dataset_name (str): the name of the dataset (e.g., "ssigns_train"). If provided, this function will put "thing_classes" into the metadata associated with this dataset. Returns: list[dict]: a list of dicts in Detectron2 standard format. (See `Using Custom Datasets </tutorials/datasets.html>`_ ) Notes: 1. This function does not read the image files. The results do not have the "image" field. """ return load_coco_json(json_file, "", dataset_name)
def compare_gt_coco(cfg, annotation_file, weight, dest_dir, score_thres_test = 0.7, num_sample = 10): cfg.MODEL.ROI_HEADS.SCORE_THRESH_TEST = score_thres_test if weight is not None: cfg.MODEL.WEIGHTS = weight predictor = DefaultPredictor(cfg) dataset_list_dict = load_coco_json(annotation_file, image_root = '', dataset_name = cfg.DATASETS.TEST[1]) if len(dataset_list_dict) > num_sample: sample = random.sample(range(len(dataset_list_dict)), num_sample) else: sample = range(len(dataset_list_dict)) for s in sample: img_dict = dataset_list_dict[s] print(img_dict['file_name']) img = read_image(img_dict['file_name'],format = 'BGR') h, w = img_dict['height'], img_dict['width'] v_gt = Visualizer(img[:, :, ::-1], metadata=MetadataCatalog.get(cfg.DATASETS.TEST[0]), scale=0.5) v_gt = v_gt.draw_dataset_dict(img_dict) #predicting outputs = predictor(img) #visualizing frmo prediction result v_pd = Visualizer(img[:, :, ::-1], MetadataCatalog.get(cfg.DATASETS.TEST[0]), scale=1.2) v_pd = v_pd.draw_instance_predictions(outputs["instances"].to("cpu")) gt = cv2.resize(v_gt.get_image()[:, :, ::-1], (w,h)) pd = cv2.resize(v_pd.get_image()[:, :, ::-1], (w,h)) #stacking groudtruth and prediction merge_img = np.hstack((gt, pd)) result_name = os.path.join(dest_dir, os.path.split(img_dict['file_name'])[1]) cv2.imwrite(result_name, merge_img)
def build_players_loader(json_file, image_root, batch_size): """ """ dataset_dicts = load_coco_json(json_file, image_root) dataset = DatasetFromList(dataset_dicts) dataset = MapDataset(dataset, PlayerMapper()) sampler = samplers.InferenceSampler(len(dataset)) # Always use 1 image per worker during inference since this is the # standard when reporting inference time in papers. batch_sampler = torch.utils.data.sampler.BatchSampler(sampler, 1, drop_last=False) data_loader = torch.utils.data.DataLoader( dataset, num_workers=batch_size, batch_sampler=batch_sampler, collate_fn=trivial_batch_collator, ) return data_loader
def register_fiber_instances(name, metadata, json_file, image_root): """ Register a dataset in COCO's json annotation format for fiber detection, i.e. mask, keypoint and fiber width detection. Args: name (str): the name that identifies a dataset, e.g. "coco_2014_train". metadata (dict): extra metadata associated with this dataset. You can leave it as an empty dict. json_file (str): path to the json instance annotation file. image_root (str): directory which contains all the images. """ DatasetCatalog.register( name, lambda: load_coco_json(json_file, image_root, name, extra_annotation_keys= ["fiberwidth", "fiberlength"]), ) MetadataCatalog.get(name).set(json_file=json_file, image_root=image_root, evaluator_type="coco", **metadata)
def register_dataset( # This function is necessary! # See https://stackoverflow.com/questions/19837486/python-lambda-in-a-loop image_root, instances_json, panoptic_root, panoptic_json, sem_seg_root, metadata): DatasetCatalog.register( prefix, lambda: merge_to_panoptic_sog( load_coco_json(instances_json, image_root, prefix, extra_keys), load_sem_seg(sem_seg_root, image_root), load_pan_seg(panoptic_root, image_root)), ) MetadataCatalog.get(prefix).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", **sog_metadata)
cfg.DATALOADER.NUM_WORKERS = 2 trainer = DefaultTrainer(cfg) trainer.resume_or_load(resume=True) cfg.MODEL.WEIGHTS = os.path.join(cfg.OUTPUT_DIR, "model_final.pth") cfg.MODEL.ROI_HEADS.SCORE_THRESH_TEST = 0.7 # set the testing threshold for this model predictor = DefaultPredictor(cfg) #store metadata #MetadataCatalog.get("endeffector_val").set(thing_classes=["endeffector"]) end_metadata = MetadataCatalog.get("endeffector_val") #visualize from detectron2.utils.visualizer import ColorMode dataset_dicts = load_coco_json( "endeffector_val/annotations/json_annotation_val.json", "endeffector_val/images", "endeffector_val") #dataset_dicts = register_coco_instances("endeffector_val", {}, "endeffector_val/annotations/json_annotation_val.json", "endeffector_val/images") for d in dataset_dicts: im = cv2.imread(d["file_name"]) outputs = predictor(im) v = Visualizer( im[:, :, ::-1], metadata=end_metadata, scale=0.8, instance_mode=ColorMode. IMAGE_BW # remove the colors of unsegmented pixels ) out = v.draw_instance_predictions(outputs["instances"].to("cpu")) cv2.imshow('image', out.get_image()[:, :, ::-1]) cv2.waitKey(0)
if i == 0 and value == 1: counts.append(0) counts.append(len(list(elements))) compressed_rle = maskutil.frPyObjects(rle, rle.get('size')[0], rle.get('size')[1]) compressed_rle['counts'] = str(compressed_rle['counts'], encoding='utf-8') return compressed_rle setup_logger() train_path = "train_images/" json_file = os.path.join(train_path, "pascal_train.json") # convert COCO format to Detectron2 format register_coco_instances("VOC_dataset", {}, json_file, train_path) dataset_dicts = load_coco_json(json_file, train_path, "VOC_dataset") VOC_metadata = MetadataCatalog.get("VOC_dataset") cfg = get_cfg() cfg.merge_from_file( "configs/COCO-InstanceSegmentation/mask_rcnn_X_101_32x8d_FPN_3x.yaml") cfg.MODEL.WEIGHTS = os.path.join(cfg.OUTPUT_DIR, "model_final.pth") cfg.MODEL.ROI_HEADS.SCORE_THRESH_TEST = 0.7 # set the testing threshold for this model cfg.MODEL.ROI_HEADS.NUM_CLASSES = 20 cfg.DATASETS.TEST = ("VOC_dataset", ) predictor = DefaultPredictor(cfg) test_dir = "test_images/" json_file = os.path.join(test_dir, "test.json") cocoGt = COCO(json_file) result_dir = 'test_result'
def main(args): setup_logger() train_path = "./datas/train_images/" json_file = "./datas/pascal_train.json" # convert COCO format to Detectron2 format register_coco_instances("VOC_dataset", {}, json_file, train_path) dataset_dicts = load_coco_json(json_file, train_path, "VOC_dataset") VOC_metadata = MetadataCatalog.get("VOC_dataset") os.makedirs('train_results', exist_ok=True) # ============ train =========== cfg = get_cfg() cfg.merge_from_file( model_zoo.get_config_file( "COCO-InstanceSegmentation/mask_rcnn_X_101_32x8d_FPN_3x.yaml")) if (args.resume): cfg.MODEL.WEIGHTS = args.resume cfg.DATASETS.TRAIN = ("VOC_dataset", ) cfg.DATASETS.TEST = () cfg.DATALOADER.NUM_WORKERS = 4 cfg.SOLVER.IMS_PER_BATCH = args.gpu_num * args.batch_size_per_gpu cfg.SOLVER.BASE_LR = args.lr cfg.SOLVER.MAX_ITER = args.num_iters cfg.SOLVER.LR_SCHEDULER_NAME = "WarmupCosineLR" cfg.MODEL.ROI_HEADS.BATCH_SIZE_PER_IMAGE = 128 # faster, and good enough for this toy dataset cfg.MODEL.ROI_HEADS.NUM_CLASSES = 20 os.makedirs(cfg.OUTPUT_DIR, exist_ok=True) tr = Trainer(cfg) tr.resume_or_load(resume=False) tr.train() # ============= training results =========== cfg = get_cfg() cfg.merge_from_file( model_zoo.get_config_file( "COCO-InstanceSegmentation/mask_rcnn_X_101_32x8d_FPN_3x.yaml")) cfg.MODEL.WEIGHTS = os.path.join(cfg.OUTPUT_DIR, "model_final.pth") cfg.MODEL.ROI_HEADS.SCORE_THRESH_TEST = 0.5 # set the testing threshold for this model cfg.MODEL.ROI_HEADS.NUM_CLASSES = 20 cfg.DATASETS.TEST = ("VOC_dataset", ) predictor = DefaultPredictor(cfg) json_file = "./datas/pascal_train.json" cocoGt = COCO(json_file) coco_dt_train = [] for imgid in cocoGt.imgs: filename = cocoGt.loadImgs(ids=imgid)[0]['file_name'] print('predicting ' + filename) im = cv2.imread(train_path + filename) # load image outputs = predictor(im) # run inference of your model output_path = os.path.join('train_results', filename) v = Visualizer( im[:, :, ::-1], metadata=VOC_metadata, scale=3, ) v = v.draw_instance_predictions(outputs["instances"].to("cpu")) cv2.imwrite(output_path, v.get_image()[:, :, ::-1]) anno = outputs["instances"].to("cpu").get_fields() masks = anno['pred_masks'].numpy() categories = anno['pred_classes'].numpy() scores = anno['scores'].numpy() n_instances = len(scores) if len(categories) > 0: # If any objects are detected in this image for i in range(n_instances): # Loop all instances # save information of the instance in a dictionary then append on coco_dt list pred = {} pred[ 'image_id'] = imgid # this imgid must be same as the key of test.json pred['category_id'] = int(categories[i]) + 1 # save binary mask to RLE, e.g. 512x512 -> rle pred['segmentation'] = binary_mask_to_rle(masks[i, :, :]) pred['score'] = float(scores[i]) coco_dt_train.append(pred) with open("train_result.json", "w") as f: json.dump(coco_dt_train, f) cocoDt = cocoGt.loadRes("train_result.json") imgIds = sorted(cocoGt.getImgIds()) cocoEval = COCOeval(cocoGt, cocoDt, 'segm') cocoEval.params.imgIds = imgIds cocoEval.evaluate() cocoEval.accumulate() cocoEval.summarize()
cfg = get_cfg() cfg.merge_from_file( "../../detectron2/configs/COCO-Detection/faster_rcnn_X_101_32x8d_FPN_3x.yaml" ) # cfg.MODEL.WEIGHTS = "/w/jinlinyi/faster_rcnn_models/model_0044999.pth" # initialize from model zoo cfg.MODEL.WEIGHTS = 'model_final_68b088.pkl' save_dir = '/y/jinlinyi/nyu_test/debug' os.makedirs(save_dir, exist_ok=True) cfg.NUM_GPUS = 1 cfg.MODEL.ROI_HEADS.SCORE_THRESH_TEST = 0.7 # set the testing threshold for this model cfg.DATASETS.TEST = ("nyu", ) predictor = DefaultPredictor(cfg) from detectron2.utils.visualizer import ColorMode from detectron2.data.datasets import load_coco_json dataset_dicts = load_coco_json(nyu_json_path, nyu_img_path, dataset_name="nyu") suncg_metadata = MetadataCatalog.get("nyu") #.set(evaluator_type='coco') # dataset_dicts = get_dicts("test") # = MetadataCatalog.get("nyu") # evaluators = DatasetEvaluators(COCOEvaluator("suncg/validation", cfg, True, save_dir),) # res = cls.test(cfg, model, evaluators) # import pdb;pdb.set_trace() for idx, d in enumerate(tqdm(random.sample(dataset_dicts, 300))): im = cv2.imread(d["file_name"]) # im = im[:, :, ::-1] outputs = predictor(im) # import pdb;pdb.set_trace() v = Visualizer( im[:, :, ::-1], metadata=suncg_metadata, scale=0.8,
"obj365_train": (TRAIN_PATH, TRAIN_JSON), "obj365_val": (VAL_PATH, VAL_JSON) } rootdir = "/home/houbowei/adet/" obj = os.path.join(rootdir, "./datasets/obj365/objects365_Tiny_train.json") with open(obj, 'r') as obj: obj = json.load(obj) things = [0] * 65 for cat in obj['categories']: things[cat['id'] - 301] = cat['name'] thing_dataset_id_to_contiguous_id = {i + 301: i for i in range(65)} DatasetCatalog.register("obj365_train", lambda: load_coco_json(TRAIN_JSON, TRAIN_PATH, "coco")) DatasetCatalog.register("obj365_val", lambda: load_coco_json(VAL_JSON, VAL_PATH, "coco")) MetadataCatalog.get('obj365_val').set( evaluator_type='coco', json_file=VAL_JSON, image_root=VAL_PATH, thing_classes=things, thing_dataset_id_to_contiguous_id=thing_dataset_id_to_contiguous_id) MetadataCatalog.get('obj365_train').set( evaluator_type='coco', json_file=TRAIN_JSON, image_root=TRAIN_PATH, thing_classes=things, thing_dataset_id_to_contiguous_id=thing_dataset_id_to_contiguous_id)
parser.add_argument('--opts', default=None, nargs=argparse.REMAINDER) args = parser.parse_args() try: os.mkdir(args.output_path) except FileExistsError: pass annotations_dir = os.path.join(args.dataset_path, "annotations") images_dir = os.path.join(args.dataset_path, "images") register_coco_instances( "custom_dataset_train", {}, os.path.join(annotations_dir, "instances_train.json"), images_dir) register_coco_instances( "custom_dataset_val", {}, os.path.join(annotations_dir, "instances_val.json"), images_dir) train_json = load_coco_json(os.path.join(annotations_dir, "instances_train.json"), image_root=images_dir, dataset_name="custom_dataset_train") val_json = load_coco_json(os.path.join(annotations_dir, "instances_val.json"), image_root=images_dir, dataset_name="custom_dataset_val") cfg = get_cfg() cfg.merge_from_file(args.config_file) cfg.DATASETS.TRAIN = ("custom_dataset_train", ) cfg.DATASETS.TEST = ("custom_dataset_val", ) cfg.TEST.EVAL_PERIOD = 300 cfg.TEST.EXPECTED_RESULTS = [['bbox', 'AP', 38.5, 0.2]] cfg.SOLVER.CHECKPOINT_PERIOD = 300 #cfg.SOLVER.IMS_PER_BATCH = 2 cfg.SOLVER.MAX_ITER = args.max_iterations cfg.MODEL.WEIGHTS = "detectron2://COCO-InstanceSegmentation/mask_rcnn_R_50_FPN_3x/137849600/model_final_f10217.pkl" if not args.weights_path else args.weights_path
def get_metadata(): meta = { "thing_classes": [ 'io', 'lo', 'tl', 'rn', 'ro', 'wo', 'ors', 'sc1', 'sc0', 'p26', 'p20', 'p23', 'ps', 'pne', 'pg', 'pn', 'po', 'pl', 'pm', 'p10', 'p11', 'p19', 'p5' ], } return meta SPLITS = { "sfdet_train": ("/home/youtian/data/ft_det/ft_det_cleanedup/images", "/home/youtian/data/ft_det/ft_det_cleanedup/train.json"), "sfdet_val": ("/home/youtian/data/ft_det/ft_det_cleanedup/images", "/home/youtian/data/ft_det/ft_det_cleanedup/valid.json"), } for key, (image_root, json_file) in SPLITS.items(): # Assume pre-defined datasets live in `./datasets`. DatasetCatalog.register( key, lambda key=key, json_file=json_file, image_root=image_root: load_coco_json(json_file, image_root, key), ) MetadataCatalog.get(key).set(json_file=json_file, image_root=image_root, **get_metadata())
("coco/train2014", "coco/annotations/densepose_train2014.json"), "densepose_coco_2014_minival": ("coco/val2014", "coco/annotations/densepose_minival2014.json"), "densepose_coco_2014_minival_100": ( "coco/val2014", "coco/annotations/densepose_minival2014_100.json", ), "densepose_coco_2014_valminusminival": ( "coco/val2014", "coco/annotations/densepose_valminusminival2014.json", ), } DENSEPOSE_KEYS = ["dp_x", "dp_y", "dp_I", "dp_U", "dp_V", "dp_masks"] for key, (image_root, json_file) in SPLITS.items(): # Assume pre-defined datasets live in `./datasets`. json_file = os.path.join("datasets", json_file) image_root = os.path.join("datasets", image_root) DatasetCatalog.register( key, lambda key=key, json_file=json_file, image_root=image_root: load_coco_json( json_file, image_root, key, extra_annotation_keys=DENSEPOSE_KEYS), ) MetadataCatalog.get(key).set(json_file=json_file, image_root=image_root, **get_densepose_metadata())
# import some common libraries import numpy as np import os, json, cv2, random # import some common detectron2 utilities from detectron2 import model_zoo from detectron2.engine import DefaultPredictor from detectron2.config import get_cfg from detectron2.utils.visualizer import Visualizer from detectron2.data import MetadataCatalog, DatasetCatalog # if your dataset is in COCO format, this cell can be replaced by the following three lines: from detectron2.data.datasets import load_coco_json from detectron2.data.datasets.coco import convert_to_coco_json train_data = load_coco_json("./data/20210204_Digi_train.json", "./data/20210204_Digi_generated/images/", "train") val_data = load_coco_json("./data/20210204_Digi_val.json", "./data/20210204_Digi_generated/valid_images/", "val") # convert_to_coco_json(dataset_name=train_data, output_file="./data/20210204_Digi_coco_train.json", allow_cached=True) # convert_to_coco_json(dataset_name=val_data, output_file="./data/20210204_Digi_coco_val.json", allow_cached=True) DatasetCatalog.register("train", lambda: load_coco_json("./data/20210204_Digi_train.json", "./data/20210204_Digi_generated/images/", "train")) MetadataCatalog.get("train").set(thing_classes=["trash"], json_file="./data/20210204_Digi_train.json", image_root="./data/20210204_Digi_generated/images/") DatasetCatalog.register("val", lambda: load_coco_json("./data/20210204_Digi_val.json", "./data/20210204_Digi_generated/valid_images/", "val")) MetadataCatalog.get("val").set(thing_classes=["trash"], json_file="./data/20210204_Digi_val.json", image_root="./data/20210204_Digi_generated/valid_images/")
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)
print(os.getcwd()) register_coco_instances( "coco_train_2", {}, "./Coco/detectron2/datasets/coco/annotations/instances_train.json", "./Coco/detectron2/datasets/coco/train") register_coco_instances( "coco_val_2", {}, "./Coco/detectron2/datasets/coco/annotations/instances_val.json", "./Coco/detectron2/datasets/coco/val") # import random #from detectron2.data import DatasetCatalog, MetadataCatalog from detectron2.data.datasets import builtin, load_coco_json dataset_dicts = load_coco_json( "./Coco/detectron2/datasets/coco/annotations/instances_train.json", "./Coco/detectron2/datasets/coco/train") print(dataset_dicts) coco_train_metadata = MetadataCatalog.get("coco_train_2") for d in random.sample(dataset_dicts, 3): img = cv2.imread(d["file_name"]) visualizer = Visualizer(img[:, :, ::-1], metadata=coco_train_metadata, scale=0.5) vis = visualizer.draw_dataset_dict(d) cv2_imshow(vis.get_image()[:, :, ::-1]) from detectron2.engine import DefaultTrainer from detectron2.config import get_cfg # print(os.getcwd()) #os.chdir(r"/home/xuyifei/anaconda3/envs/detectron2/lib/python3.7/site-packages/detectron2")
def load_asis(*l, **kv): dataset_dicts = load_coco_json(*l, **kv) [[ann.update(category_id=0) for ann in d["annotations"]] for d in dataset_dicts] return dataset_dicts
train_annotation_json = os.path.join(BaseFolder, "Training/annotations.json") train_images = os.path.join(BaseFolder, "Training") # train_annotation_json='/data/cmpe295-liu/Waymo/WaymoCOCOtest/Training/annotations.json' # train_images='/data/cmpe295-liu/Waymo/WaymoCOCOtest/Training' # val_annotation_json='/data/cmpe295-liu/Waymo/WaymoCOCOsmall/Validation/annotations.json' # val_images='/data/cmpe295-liu/Waymo/WaymoCOCOsmall/Validation' train_annotation_json = os.path.join(BaseFolder, "Validation/annotations.json") train_images = os.path.join(BaseFolder, "Validation") #dataset_dicts = load_coco_json(train_annotation_json,train_images, "mywaymo_dataset_train", extrakeys) for d in ["Training", "Validation"]: #DatasetCatalog.register("myuav1_" + d, lambda d=d: load_mycoco_json("/data/cmpe295-liu/UAVision/VisDrone2019-DET-" + d + "/annotations.json", "/data/cmpe295-liu/UAVision/VisDrone2019-DET-" + d + "/images", extrakeys)) DatasetCatalog.register( "mywaymo1_" + d, lambda d=d: load_coco_json(BaseFolder + d + "/annotations.json", BaseFolder + d + "/")) FULL_LABEL_CLASSES = [ 'unknown', 'vehicle', 'pedestrian', 'sign', 'cyclist' ] #['ignored-regions', 'pedestrian', 'people', 'bicycle', 'car', 'van', 'truck', 'tricycle', 'awning-tricycle','bus', 'motor', 'others'] for d in ["Training", "Validation"]: MetadataCatalog.get("mywaymo1_" + d).set(thing_classes=FULL_LABEL_CLASSES) # from detectron2.data.datasets import register_coco_instances # register_coco_instances("myuav1_train", {}, "/data/cmpe295-liu/UAVision/VisDrone2019-DET-train/annotations.json", "/data/cmpe295-liu/UAVision/VisDrone2019-DET-train/images") cfg = get_cfg() cfg.OUTPUT_DIR = './output_waymo' #'./output_x101' cfg.merge_from_file( model_zoo.get_config_file( "COCO-Detection/faster_rcnn_X_101_32x8d_FPN_3x.yaml") ) #faster_rcnn_R_101_FPN_3x.yaml, faster_rcnn_X_101_32x8d_FPN_3x
def register_coco_instances(name, metadata, classRemapping, json_file, image_root): DatasetCatalog.register(name, lambda: load_coco_json(json_file, image_root, None, classRemapping=classRemapping)) MetadataCatalog.get(name).set( json_file=json_file, image_root=image_root, evaluator_type="coco", **metadata )