def showGt(imgid,catNm): dataType='val2017' annFile = "./annotations.json" coco=COCO(annFile) catIds = coco.getCatIds(catNms=catNm); imgIds = coco.getImgIds(catIds=catIds ); imgIds = coco.getImgIds(imgIds = [imgid]) img = coco.loadImgs(imgIds[np.random.randint(0,len(imgIds))])[0] annIds = coco.getAnnIds(imgIds=img['id'], catIds=catIds, iscrowd=None) anns = coco.loadAnns(annIds) DatasetCatalog.clear() MetadataCatalog.clear() keypoint_names_col = [ "c1", "c2", "c3", "c4", "c5", "c6", "c7", "c8", "c9", "c10" ] keypoint_names_row= [ 'r'+str(i) for i in range(10)] keypoint_names=keypoint_names_col+keypoint_names_row print(keypoint_names) register_coco_instances("my_dataset_train", {}, "./annotations.json", "/content/VOC2007/JPEGImages") my_md= MetadataCatalog.get("my_dataset_train").set( thing_classes=["table","r"], #keypoint_names=keypoint_names, #keypoint_connection_rules=[] #,keypoint_flip_map=[] ) f = '/content/VOC2007/JPEGImages/'+img['file_name'] img = cv2.imread(f) visualizer = Visualizer(img[:, :, ::-1], metadata=my_md) for an in anns: an["bbox_mode"]=BoxMode.XYWH_ABS d = {'annotations':anns} out = visualizer.draw_dataset_dict(d) return out.get_image()[:, :, ::-1] #cv2_imshow()
def blendproc_bbox_trainer(self): ##### ap calculation DatasetCatalog.clear() MetadataCatalog.clear() # DatasetCatalog.remove(val_coco_ann_path) trainer = Detectron2BaseEvalTrainer( train_coco_ann_path=self.coco_ann_path, train_img_dir=self.img_dir, val_coco_ann_path=self.val_coco_ann_path, val_img_dir=self.val_img_path, images_per_batch=1, base_lr=0.003, max_iter=1000, output_dir=self.module_save_path, min_size_train=self.min_size_train, max_size_train=self.max_size_train, checkpoint_period=200, eval_period=100, save_vis=True, latest_vis_only=True, # trainer_constructor=COCO_BBox_EvalTrainer_BlenderProc, #custom creation with mapper = none trainer_constructor= COCO_BBox_EvalTrainer, #custom creation with mapper = deafult mapper model_type='COCO-Detection', model_name=self.model_name, ) trainer.train(resume=False)
def register_train_test(dataset_dict,metadata,train_ratio=0.66,seed=0): DatasetCatalog.clear() MetadataCatalog.clear() nb_input= len(dataset_dict) x=np.arange(nb_input) random.Random(seed).shuffle(x) idx_split = int(len(x) * train_ratio) DatasetCatalog.register("datasetTrain", my_dataset_function({"images":np.array(dataset_dict)[x[:idx_split]],"metadata":metadata})) DatasetCatalog.register("datasetTest", my_dataset_function({"images":np.array(dataset_dict)[x[idx_split:]],"metadata":metadata})) MetadataCatalog.get("datasetTrain").stuff_classes = [v for k,v in metadata["category_names"].items()] MetadataCatalog.get("datasetTest").stuff_classes = [v for k,v in metadata["category_names"].items()] """if ignoreValue is not None:
def evaluate(): train_keys = ["bank"] DatasetCatalog.clear() MetadataCatalog.clear() keypoint_names = [ "c1", "c2", "c3", "c4", "c5", "c6", "c7", "c8", "c9", "c10" ] keypoint_connection_rules = [[1, 2, [255, 175, 100]], [2, 3, [255, 175, 100]], [3, 4, [255, 175, 100]], [4, 5, [255, 175, 100]], [5, 6, [255, 175, 100]], [6, 7, [255, 175, 100]], [7, 8, [255, 175, 100]], [8, 9, [255, 175, 100]], [9, 10, [255, 175, 100]]] keypoint_flip_map = [('c1', 'c10'), ('c2', 'c9'), ('c3', 'c8'), ('c4', 'c7'), ('c5', 'c6')] for d in ["testval"]: #DatasetCatalog.register("table_testval", lambda d=d: get_icdar_dicts(train_keys,'testjson')) register_coco_instances("table_testval", {}, "./annotations.json", "/content/VOC2007/JPEGImages") MetadataCatalog.get("table_testval").set( thing_classes=["table", "r"], keypoint_names=keypoint_names, keypoint_connection_rules=keypoint_connection_rules, keypoint_flip_map=keypoint_flip_map) cfg = get_cfg() cfg.merge_from_file( model_zoo.get_config_file( "COCO-Keypoints/keypoint_rcnn_R_50_FPN_3x.yaml")) cfg.DATALOADER.NUM_WORKERS = 2 cfg.DATASETS.TRAIN = ("table_testval", ) cfg.DATASETS.TEST = ("table_testval", ) cfg.SOLVER.IMS_PER_BATCH = 2 cfg.MODEL.DEVICE = "cpu" cfg.SOLVER.BASE_LR = 0.00025 # pick a good LR cfg.SOLVER.MAX_ITER = 300 # 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 = 128 # faster, and good enough for this toy dataset (default: 512) cfg.MODEL.ROI_HEADS.NUM_CLASSES = 2 # only has one class (ballon) cfg.MODEL.WEIGHTS = '/content/keypoints/workdir/savedmodel/model_final.pth' cfg.MODEL.ROI_HEADS.SCORE_THRESH_TEST = 0.3 # set the testing threshold for this model cfg.MODEL.ROI_KEYPOINT_HEAD.NUM_KEYPOINTS = 10 model = build_model(cfg) DetectionCheckpointer(model, save_dir=cfg.OUTPUT_DIR).resume_or_load( cfg.MODEL.WEIGHTS, resume=True) do_test(cfg, model)
def setup_cfg(args): DatasetCatalog.clear() MetadataCatalog.clear() keypoint_names = [ "c1", "c2", "c3", "c4", "c5", "c6", "c7", "c8", "c9", "c10" ] keypoint_connection_rules = [[1, 2, [255, 175, 100]], [2, 3, [255, 175, 100]], [3, 4, [255, 175, 100]], [4, 5, [255, 175, 100]], [5, 6, [255, 175, 100]], [6, 7, [255, 175, 100]], [7, 8, [255, 175, 100]], [8, 9, [255, 175, 100]], [9, 10, [255, 175, 100]]] keypoint_flip_map = [('c1', 'c10'), ('c2', 'c9'), ('c3', 'c8'), ('c4', 'c7'), ('c5', 'c6')] register_coco_instances("my_dataset_train", {}, "/content/keypointsl/annotations.json", "/content/VOC2007/JPEGImages") my_md = MetadataCatalog.get("my_dataset_train").set( thing_classes=["table", "r"], keypoint_names=keypoint_names, keypoint_connection_rules=keypoint_connection_rules, keypoint_flip_map=keypoint_flip_map) cfg = get_cfg() # cuda context is initialized before creating dataloader, so we don't fork anymore cfg.DATALOADER.NUM_WORKERS = 0 cfg = add_export_config(cfg) cfg.merge_from_file(args.config_file) cfg.merge_from_list(args.opts) cfg.DATASETS.my_dataset_train = ("my_dataset_train", ) cfg.DATASETS.TEST = ("my_dataset_train", ) cfg.DATASETS.TRAIN = ("my_dataset_train", ) cfg.freeze() if cfg.MODEL.DEVICE != "cpu": assert TORCH_VERSION >= ( 1, 5), "PyTorch>=1.5 required for GPU conversion!" return cfg
return [center[0],center[1], wh[1], wh[0], np.rad2deg(angle)] if __name__ == "__main__": import matplotlib.pyplot as plt from rotated_detectron_utils import RotatedVisualizer, rotated_mapper from detectron2.data import DatasetCatalog, MetadataCatalog TRAIN_PATH = "/data2/anne/UIVER/datasets/DOTA/dotadevkit/example" # TRAIN_PATH = "/data2/anne/UIVER/datasets/DOTA/trainsplit" # class_name_list = ["small-vehicle", "large-vehicle"] class_name_list = ["small-vehicle"] DatasetCatalog.clear() MetadataCatalog.clear() DatasetCatalog.register("Train", lambda: dota2detectron(TRAIN_PATH, False, whitelist=class_name_list)) MetadataCatalog.get("Train").set(thing_classes=class_name_list) train_catalog = dota2detectron(TRAIN_PATH, False, whitelist=class_name_list) d = train_catalog[1] d = rotated_mapper(d) # img = cv2.imread(d["file_name"]) img = d['image'].numpy().transpose(1,2,0) # visualizer = RotatedVisualizer(img[:, :, ::-1], metadata=MetadataCatalog.get("Train"), scale=1.0) visualizer = RotatedVisualizer(img, metadata=MetadataCatalog.get("Train"), scale=1.0) out = visualizer.draw_dataset_dict(d) # visualizer.overlay_instances(boxes=) boxes = d['instances']._fields['gt_boxes']
def retrain_detector(settings): """ settings: properties to be used in the retraining process Splits the COCO-formatted data located in annotation_path, then trains and evaluates a Detectron2 model from scratch. The resulting model is saved in the model_path/ folder. Returns an object mapping different AP (average precision) metrics to the model's scores. """ if len(settings) == 0: settings["trainSplit"] = 0.7 settings["learningRate"] = 0.005 settings["maxIters"] = 100 base_path = "annotation_data/" coco_path = os.path.join(base_path, "coco") output_path = os.path.join(base_path, "output") annotation_path = os.path.join(coco_path, "coco_results.json") train_path = os.path.join(coco_path, "train.json") test_path = os.path.join(coco_path, "test.json") # 1) Split coco json file into train and test using cocosplit code # Adapted from https://github.com/akarazniewicz/cocosplit/blob/master/cocosplit.py with open(annotation_path, "rt", encoding="UTF-8") as annotations_file: # Extract info from json coco = json.load(annotations_file) info = coco["info"] licenses = coco["licenses"] images = coco["images"] annotations = coco["annotations"] categories = coco["categories"] # Remove images without annotations images_with_annotations = set( map(lambda a: int(a["image_id"]), annotations)) images = list( filter(lambda i: i["id"] in images_with_annotations, images)) # Split images and annotations x_images, y_images = train_test_split( images, train_size=settings["trainSplit"]) x_ids = list(map(lambda i: int(i["id"]), x_images)) x_annots = list( filter(lambda a: int(a["image_id"]) in x_ids, annotations)) y_ids = list(map(lambda i: int(i["id"]), y_images)) y_annots = list( filter(lambda a: int(a["image_id"]) in y_ids, annotations)) # Save to file def save_coco(file, info, licenses, images, annotations, categories): with open(file, 'wt', encoding="UTF-8") as coco: json.dump( { "info": info, "licenses": licenses, "images": images, "annotations": annotations, "categories": categories }, coco, indent=2, sort_keys=True) save_coco(train_path, info, licenses, x_images, x_annots, categories) save_coco(test_path, info, licenses, y_images, y_annots, categories) # 2) Use train/test files to retrain detector dataset_name = "annotation_coco" image_dir = base_path + "rgb/" train_data = dataset_name + "_train" test_data = dataset_name + "_test" DatasetCatalog.clear() MetadataCatalog.clear() register_coco_instances(train_data, {}, train_path, image_dir) register_coco_instances(test_data, {}, test_path, image_dir) MetadataCatalog.get(train_data) coco_yaml = "COCO-InstanceSegmentation/mask_rcnn_R_50_FPN_3x.yaml" cfg = get_cfg() cfg.merge_from_file(model_zoo.get_config_file(coco_yaml)) cfg.DATASETS.TRAIN = (train_data, ) cfg.DATASETS.TEST = () cfg.DATALOADER.NUM_WORKERS = 2 cfg.MODEL.ROI_HEADS.NUM_CLASSES = len(categories) cfg.MODEL.ROI_HEADS.BATCH_SIZE_PER_IMAGE = 128 cfg.MODEL.WEIGHTS = model_zoo.get_checkpoint_url( coco_yaml) # Let training initialize from model zoo cfg.OUTPUT_DIR = output_path cfg.SOLVER.IMS_PER_BATCH = 2 cfg.SOLVER.BASE_LR = settings["learningRate"] # Make sure LR is good cfg.SOLVER.MAX_ITER = settings[ "maxIters"] # 300 is good for small datasets # Train os.makedirs(cfg.OUTPUT_DIR, exist_ok=True) trainer = DefaultTrainer(cfg) trainer.resume_or_load(resume=False) trainer.train() # Move model to most recent model folder model_dir = os.path.join(base_path, "model") model_names = os.listdir(model_dir) # Get highest x for model/vx model_dirs = list( filter(lambda n: os.path.isdir(os.path.join(model_dir, n)), model_names)) model_nums = list(map(lambda x: int(x.split("v")[1]), model_dirs)) last_model_num = max(model_nums) # Add model to new folder model_path = os.path.join(model_dir, "v" + str(last_model_num)) new_model_path = os.path.join(model_path, "model_999.pth") old_model_path = os.path.join(output_path, "model_final.pth") os.replace(old_model_path, new_model_path) # Evaluate evaluator = COCOEvaluator(test_data, ("bbox", "segm"), False, output_dir="../../annotation_data/output/") val_loader = build_detection_test_loader(cfg, test_data) inference = inference_on_dataset(trainer.model, val_loader, evaluator) # inference keys: bbox, semg # bbox and segm keys: AP, AP50, AP75, APs, APm, AP1, AP-category1, ... inference_json = json.loads(json.dumps(inference).replace("NaN", "null")) return inference_json