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
