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 plain_register_dataset():
DatasetCatalog.register("coco_my_train", lambda: load_coco_json(TRAIN_JSON, TRAIN_PATH))
MetadataCatalog.get("coco_my_train").set( # thing_classes=CLASS_NAMES, # 可以选择开启，但是不能显示中文，所以本人关闭
evaluator_type='coco', # 指定评估方式
json_file=TRAIN_JSON,
image_root=TRAIN_PATH)
# DatasetCatalog.register("coco_my_val", lambda: load_coco_json(VAL_JSON, VAL_PATH, "coco_2017_val"))
DatasetCatalog.register("coco_my_val", lambda: load_coco_json(VAL_JSON, VAL_PATH))
MetadataCatalog.get("coco_my_val").set( # thing_classes=CLASS_NAMES, # 可以选择开启，但是不能显示中文，所以本人关闭
evaluator_type='coco', # 指定评估方式
json_file=VAL_JSON,
image_root=VAL_PATH)
def plain_register_dataset():
DatasetCatalog.register(
"CCDP_train_2020",
lambda: load_coco_json(TRAIN_JSON, TRAIN_PATH, "CCDP_train_2020"))
MetadataCatalog.get("CCDP_train_2020").set(thing_classes=["pos", "neg"],
json_file=TRAIN_JSON,
image_root=TRAIN_PATH)
DatasetCatalog.register(
"CCDP_val_2020",
lambda: load_coco_json(VAL_JSON, VAL_PATH, "CCDP_val_2020"))
MetadataCatalog.get("CCDP_val_2020").set(thing_classes=["pos", "neg"],
json_file=VAL_JSON,
image_root=VAL_PATH)
def plain_register_dataset():
#训练集
DatasetCatalog.register("coco_my_train", lambda: load_coco_json(TRAIN_JSON, TRAIN_PATH))
MetadataCatalog.get("coco_my_train").set(thing_classes=CLASS_NAMES, # 可以选择开启，但是不能显示中文，这里需要注意，中文的话最好关闭
evaluator_type='coco', # 指定评估方式
json_file=TRAIN_JSON,
image_root=TRAIN_PATH)
#验证/测试集
DatasetCatalog.register("coco_my_val", lambda: load_coco_json(VAL_JSON, VAL_PATH))
MetadataCatalog.get("coco_my_val").set(thing_classes=CLASS_NAMES, # 可以选择开启，但是不能显示中文，这里需要注意，中文的话最好关闭
evaluator_type='coco', # 指定评估方式
json_file=VAL_JSON,
image_root=VAL_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 or path-like): directory which contains all the images.
"""
assert isinstance(name, str), name
assert isinstance(json_file, (str, os.PathLike)), json_file
assert isinstance(image_root, (str, os.PathLike)), image_root
# 1. register a function which returns dicts
DatasetCatalog.register(
name, lambda: load_coco_json(
json_file, image_root, name, extra_annotation_keys=["blind"]))
# 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 register_coco_instances_with_points(name, metadata, json_file, image_root):
"""
Register a dataset in COCO's json annotation format for
instance segmentation with point annotation.
The point annotation json does not have "segmentation" field, instead,
it has "point_coords" and "point_labels" fields.
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 or path-like): directory which contains all the images.
"""
assert isinstance(name, str), name
assert isinstance(json_file, (str, os.PathLike)), json_file
assert isinstance(image_root, (str, os.PathLike)), image_root
# 1. register a function which returns dicts
DatasetCatalog.register(
name, lambda: load_coco_json(json_file, image_root, name,
["point_coords", "point_labels"]))
# 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 custom_dataset_dict(json_file, img_root, name, subset='train'):
# Basically try out register_coco_instances but without the metadata.
dataset_dicts = load_coco_json(json_file, img_root, name)
# Logic for filtering dataset_dicts can go here. This includes omitting some classes and such.
# End of logic
return dataset_dicts
def _register_datasets(self, ):
# Query: Train
DatasetCatalog.register(
"coco_note_base_training_query_train",
lambda: self.get_query_set_base_training_train())
MetadataCatalog.get("coco_note_base_training_query_train").set(
thing_classes=MetadataCatalog.get(
"coco_2017_train_copy").thing_classes,
evaluator_type='coco')
# Support: Train + Validation
DatasetCatalog.register("coco_note_base_training_support",
lambda: self.get_support_set_base_training())
MetadataCatalog.get("coco_note_base_training_support").set(
thing_classes=MetadataCatalog.get(
"coco_2017_train_copy").thing_classes,
evaluator_type='coco')
# Query: Validation
DatasetCatalog.register(
"coco_note_base_training_query_val",
# lambda: self.get_query_set_base_training_val(self.base_train_adaptor_instance)
lambda: load_coco_json(
"/scratch/ssd001/home/skhandel/FewshotDetection/WSASOD/data/data_utils/data/MSCOCO2017/annotations/instances_val2017.json",
"/scratch/ssd001/home/skhandel/FewshotDetection/WSASOD/data/data_utils/data/MSCOCO2017/images/val2017/",
"coco_note_base_training_query_val"))
MetadataCatalog.get("coco_note_base_training_query_val").set(
# thing_classes=self.base_train_adaptor_instance.cfg.coco_classes,
evaluator_type='coco',
json_file=
"/scratch/ssd001/home/skhandel/FewshotDetection/WSASOD/data/data_utils/data/MSCOCO2017/annotations/instances_val2017.json"
)
def plain_register_dataset():
DatasetCatalog.register("rectal_tumor_train",
lambda: load_coco_json(TRAIN_JSON, TRAIN_PATH))
MetadataCatalog.get("rectal_tumor_train").set(thing_classes=CLASS_NAMES,
evaluator_type='coco',
json_file=TRAIN_JSON,
image_root=TRAIN_PATH)
#DatasetCatalog.register("coco_my_val", lambda: load_coco_json(VAL_JSON, VAL_PATH, "coco_2017_val"))
DatasetCatalog.register("rectal_tumor_val",
lambda: load_coco_json(VAL_JSON, VAL_PATH))
MetadataCatalog.get("rectal_tumor_val").set(thing_classes=CLASS_NAMES,
evaluator_type='coco',
json_file=VAL_JSON,
image_root=VAL_PATH)
def main():
parser = argparse.ArgumentParser(
description='This script support analyzing data.')
parser.add_argument('--data_dir',
type=str,
default=None,
required=True,
help='path to annotation files directory.')
parser.add_argument('--format',
type=str,
default='coco',
help='format to analyze.(coco or voc)')
args = parser.parse_args()
logger = logging.getLogger('detectron2')
logger.setLevel(logging.DEBUG)
ch = logging.StreamHandler(stream=sys.stdout)
ch.setLevel(logging.DEBUG)
logger.addHandler(ch)
if args.format == 'coco':
dataset_dicts = load_coco_json(
os.path.join(args.data_dir, 'annotations/train.json'),
os.path.join(args.data_dir, 'images'), '1')
class_names = MetadataCatalog.get('1').thing_classes
elif args.format == 'voc':
dataset_dicts, class_names = load_voc_instances(args.data_dir)
else:
raise Exception("only support coco or voc format")
print_instances_class_histogram(dataset_dicts, class_names)
def register_cityscapes(root="datasets"):
# Assume pre-defined datasets live in `./datasets`.
DatasetCatalog.register(
'cityscapes_coco_fine_instance_seg_train', lambda: load_coco_json(
os.path.join(root, 'cityscape-coco/coco_ann/instance_train.json'),
os.path.join(root, 'cityscape-coco/coco_img/train'),
'cityscapes_coco_fine_instance_seg_train'))
DatasetCatalog.register(
'cityscapes_coco_fine_instance_seg_val', lambda: load_coco_json(
os.path.join(root, 'cityscape-coco/coco_ann/instance_val.json'),
os.path.join(root, 'cityscape-coco/coco_img/val'),
'cityscapes_coco_fine_instance_seg_val'))
MetadataCatalog.get('cityscapes_coco_fine_instance_seg_train').set(
evaluator_type="coco", )
MetadataCatalog.get('cityscapes_coco_fine_instance_seg_val').set(
evaluator_type="coco", )
def main():
setup_logger()
for d in [ds_train, ds_validation]:
DatasetCatalog.register(os.path.join(path_ds, d), lambda d=d:
load_coco_json(os.path.join(path_ds_meta, ds_train + ds_file_base),
os.path.join(path_ds, ds_train)))
# Update class names
MetadataCatalog.get(os.path.join(path_ds, d)).set(thing_classes=["apple_green", "apple_red", "clementine",
"cucumber", "garlic", "lemon", "onion"])
project_metadata = MetadataCatalog.get(os.path.join(path_ds, ds_train))
cfg = get_cfg()
cfg.merge_from_file(path_config)
cfg.DATASETS.TRAIN = (os.path.join(path_ds, ds_train), )
cfg.DATASETS.TEST = () # no metrics implemented for this dataset
cfg.DATALOADER.NUM_WORKERS = 2
cfg.MODEL.WEIGHTS = model_weights # initialize from model zoo
cfg.SOLVER.IMS_PER_BATCH = 2
cfg.SOLVER.BASE_LR = 0.00025 # pick a good LR (original: 0.00025)
cfg.SOLVER.MAX_ITER = 1000 # 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 small dataset (default: 512)
cfg.MODEL.ROI_HEADS.NUM_CLASSES = 7 # Update number of classes
cfg.OUTPUT_DIR = path_output
os.makedirs(cfg.OUTPUT_DIR, exist_ok=True)
trainer = DefaultTrainer(cfg)
trainer.resume_or_load(resume=False)
trainer.train()
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 = (os.path.join(path_ds + ds_validation), )
predictor = DefaultPredictor(cfg)
dataset_dicts = load_coco_json(os.path.join(path_ds_meta, ds_validation + ds_file_base),
os.path.join(path_ds, ds_validation))
for d in random.sample(dataset_dicts, 3): # Show n validation images
im = cv2.imread(d["file_name"])
outputs = predictor(im)
v = Visualizer(im[:, :, ::-1], metadata=project_metadata, scale=1)
v = v.draw_instance_predictions(outputs["instances"].to("cpu"))
cv2.imshow('object_detection', v.get_image()[:, :, ::-1])
cv2.waitKey()
def checkout_dataset_annotation(name="val_2019"):
dataset_dicts = load_coco_json(TRAIN_JSON, TRAIN_PATH, name)
for d in dataset_dicts:
img = cv2.imread(d["file_name"])
visualizer = Visualizer(img[:, :, ::-1],
metadata=MetadataCatalog.get(name),
scale=1.5)
vis = visualizer.draw_dataset_dict(d)
cv2.imshow('show', vis.get_image()[:, :, ::-1])
cv2.waitKey(0)
def register_dataset_instances(name, 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")
def checkout_dataset_annotation(json_file, dataset_dir, name="MHPv1_foot"):
dataset_dicts = load_coco_json(json_file, dataset_dir, name)
for d in dataset_dicts:
img = cv2.imread(d["file_name"])
visualizer = Visualizer(img[:, :, ::-1],
metadata=MetadataCatalog.get(name),
scale=1.5)
vis = visualizer.draw_dataset_dict(d)
cv2.imshow('show', vis.get_image()[:, :, ::-1])
cv2.waitKey(0)
def checkout_dataset_annotation(name="coco_my_train"):
dataset_dicts = load_coco_json(TRAIN_JSON, TRAIN_PATH)
print(len(dataset_dicts))
for i, d in enumerate(dataset_dicts,0):
print(d)
img = cv2.imread(d["file_name"])
visualizer = Visualizer(img[:, :, ::-1], metadata=MetadataCatalog.get(name), scale=1.5)
vis = visualizer.draw_dataset_dict(d)
cv2.imshow('show', vis.get_image()[:, :, ::-1])
# cv2.imwrite('out/'+str(i) + '.jpg',vis.get_image()[:, :, ::-1])
cv2.waitKey(0)
def register_isaid():
# Register iSAID Dataset (in COCO format)
data_dir = "/home/an1/detectron2/datasets/isaid"
for d in ["train", "val"]:
DatasetCatalog.register(
"isaid_" + d,
lambda d=d: load_coco_json(
json_file=data_dir + '/annotations/instances_{}.json'.format(d
),
image_root=data_dir + '/images/{}/'.format(d),
dataset_name="isaid_{}".format(d)))
MetadataCatalog.get("isaid_" + d).json_file = os.path.join(
data_dir, "annotations", "instances_{}.json".format(d))
def checkout_dataset_annotation(name="rectal_tumor_val"):
# dataset_dicts = load_coco_json(TRAIN_JSON, TRAIN_PATH, name)
dataset_dicts = load_coco_json(VAL_JSON, VAL_PATH)
print(len(dataset_dicts))
for i, d in enumerate(dataset_dicts, 0):
img = cv2.imread(d["file_name"])
visualizer = Visualizer(img[:, :, ::-1],
metadata=MetadataCatalog.get(name),
scale=1)
vis = visualizer.draw_dataset_dict(d)
# cv2.imshow('show', vis.get_image()[:, :, ::-1])
cv2.imwrite('out/' + d['file_name'][-14:], vis.get_image()[:, :, ::-1])
#cv2.waitKey(0)
if i == 200:
break
def register_distill_coco_instances(name, metadata, json_file, image_root):
"""
add extra_annotation_keys
"""
assert isinstance(name, str), name
assert isinstance(json_file, (str, os.PathLike)), json_file
assert isinstance(image_root, (str, os.PathLike)), image_root
# 1. register a function which returns dicts
DatasetCatalog.register(name, lambda: load_coco_json(
json_file, image_root, name, extra_annotation_keys=['score']))
# 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 test(self):
# Make a dummy dataset.
mask = make_mask()
DatasetCatalog.register("test_dataset",
lambda: make_dataset_dicts(mask))
MetadataCatalog.get("test_dataset").set(thing_classes=["test_label"])
# Dump to json.
json_dict = convert_to_coco_dict("test_dataset")
with tempfile.TemporaryDirectory() as tmpdir:
json_file_name = os.path.join(tmpdir, "test.json")
with open(json_file_name, "w") as f:
json.dump(json_dict, f)
# Load from json.
dicts = load_coco_json(json_file_name, "")
# Check the loaded mask matches the original.
anno = dicts[0]["annotations"][0]
loaded_mask = pycocotools.mask.decode(anno["segmentation"])
self.assertTrue(np.array_equal(loaded_mask, mask))
def checkout_dataset_annotation(name="coco_my_train"):
#dataset_dicts = load_coco_json(TRAIN_JSON, TRAIN_PATH, name)
dataset_dicts = load_coco_json(TRAIN_JSON, TRAIN_PATH)
# print(len(dataset_dicts))
for i, d in enumerate(dataset_dicts, 0):
img_path = d["file_name"]
print("img_path: {}".format(img_path))
img = cv2.imread(img_path)
visualizer = Visualizer(img[:, :, ::-1],
metadata=MetadataCatalog.get(name),
scale=1.5)
vis = visualizer.draw_dataset_dict(d)
# v = Visualizer(im[:, :, ::-1], metadata=train_metadata, scale=0.9, instance_mode=ColorMode.IMAGE_BW)
# v = v.draw_instance_predictions(outputs["instances"].to("cpu"))
#cv2.imshow('show', vis.get_image()[:, :, ::-1])
cv2.imwrite('./out/' + str(os.path.basename(img_path)),
vis.get_image()[:, :, ::-1])
# Change model by selecting a new one from the model zoo and updating following 2 lines
# https://github.com/facebookresearch/detectron2/blob/master/MODEL_ZOO.md
path_config = os.path.join("detectron2", "detectron2_repo", "configs", "COCO-Detection",
"faster_rcnn_R_101_FPN_3x.yaml")
model_weights = "detectron2://COCO-Detection/faster_rcnn_R_101_FPN_3x/137851257/model_final_f6e8b1.pkl"
# Update class names
project_metadata = MetadataCatalog.get(path_ds + ds_train).set(thing_classes=["apple_green", "apple_red", "clementine",
"cucumber", "garlic", "lemon", "onion"]
)
cfg = get_cfg()
cfg.merge_from_file(path_config)
cfg.OUTPUT_DIR = path_output
cfg.MODEL.ROI_HEADS.NUM_CLASSES = 7
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 = (os.path.join(path_ds, ds_validation), )
predictor = DefaultPredictor(cfg)
dataset_dicts = load_coco_json(os.path.join(path_ds_meta, ds_validation + ds_file_base),
os.path.join(path_ds, ds_validation))
# for d in random.sample(dataset_dicts, 3):
for d in dataset_dicts:
im = cv2.imread(d["file_name"])
outputs = predictor(im)
v = Visualizer(im[:, :, ::-1], metadata=project_metadata, scale=1)
v = v.draw_instance_predictions(outputs["instances"].to("cpu"))
cv2.imshow('object_detection', v.get_image()[:, :, ::-1])
cv2.waitKey()
from detectron2.structures import Boxes, BoxMode, Instances
from detectron2.utils.logger import setup_logger
from detectron2.utils.visualizer import Visualizer
from detectron2.data.datasets.coco import load_coco_json
DATASET_ROOT = '/home/dasen/chennan/detectron2/data'
ANN_ROOT = os.path.join(DATASET_ROOT, 'annotations')
TRAIN_PATH = os.path.join(DATASET_ROOT, 'images')
VAL_PATH = os.path.join(DATASET_ROOT, 'images')
TRAIN_JSON = os.path.join(ANN_ROOT, 'voc_2019_trainval.json')
VAL_JSON = os.path.join(ANN_ROOT, 'voc_2019_test.json')
DatasetCatalog.register("coco_my_val",
lambda: load_coco_json(VAL_JSON, VAL_PATH))
def create_instances(predictions, image_size):
ret = Instances(image_size)
score = np.asarray([x["score"] for x in predictions])
chosen = (score > args.conf_threshold).nonzero()[0]
score = score[chosen]
bbox = np.asarray([predictions[i]["bbox"] for i in chosen])
bbox = BoxMode.convert(bbox, BoxMode.XYWH_ABS, BoxMode.XYXY_ABS)
labels = np.asarray(
[dataset_id_map(predictions[i]["category_id"]) for i in chosen])
ret.scores = score
