def do_test(cfg, args, myargs):
eval_ckpt_dir = cfg.start.eval_ckpt_dir
eval_epoch = cfg.start.eval_epoch
dataset_name = cfg.start.dataset_name
IMS_PER_BATCH = cfg.start.IMS_PER_BATCH
cfg.defrost()
cfg.freeze()
# build dataset
DatasetCatalog.get(dataset_name)
metadata = MetadataCatalog.get(dataset_name)
num_images = metadata.get('num_images')
iter_every_epoch = num_images // IMS_PER_BATCH
model = build_trainer(cfg,
myargs=myargs,
iter_every_epoch=1,
img_size=cfg.dataset.img_size,
train_bs=32)
logger.info("Model:\n{}".format(model))
eval_iter = (eval_epoch) * iter_every_epoch - 1
eval_ckpt = os.path.join(eval_ckpt_dir, f'model_{eval_iter:07}.pth')
model.eval_func(eval_ckpt=eval_ckpt)
def register_hico_instances(name, metadata, json_file, image_root,
evaluator_type):
"""
Register a hico-det dataset in COCO's json annotation format for human-object
interaction detection (i.e., `instances_hico_*.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. "hico-det".
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.
"""
# 1. register a function which returns dicts
DatasetCatalog.register(
name, lambda: load_hico_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=evaluator_type,
**metadata)
def register_dacon_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_dacon_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 generate_datasets(self, Ntraining, method, gt_frames):
dataset_train, dataset_val = get_dicts(Ntraining, method, gt_frames)
for d in ['train', 'val']:
DatasetCatalog.register(d + '_set',
lambda d=d: dataset_train
if d == 'train' else dataset_val)
MetadataCatalog.get(d + '_set').set(
thing_classes=['Person', 'None', 'Car'])
def train(polygons):
dataset_folder = Path("datasets/")
dataset_file = dataset_folder / "default.json"
register_coco_instances(dataset_file.name, {}, dataset_file, "")
cfg.DATASETS.TRAIN = (dataset_file.name, )
cfg.DATASETS.TEST = ()
trainer = Trainer(cfg)
trainer.resume_or_load(resume=False)
trainer.train()
DatasetCatalog.remove(dataset_file.name)
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 get_hoi_dataset_dicts(dataset_names, filter_empty=True):
"""
Load and prepare dataset dicts for HOI detection.
Args:
dataset_names (list[str]): a list of dataset names
filter_empty (bool): whether to filter out images without instance annotations
min_keypoints (int): filter out images with fewer keypoints than
`min_keypoints`. Set to 0 to do nothing.
proposal_files (list[str]): if given, a list of object proposal files
that match each dataset in `dataset_names`.
"""
assert len(dataset_names)
dataset_dicts = [DatasetCatalog.get(dataset_name) for dataset_name in dataset_names]
for dataset_name, dicts in zip(dataset_names, dataset_dicts):
assert len(dicts), "Dataset '{}' is empty!".format(dataset_name)
dataset_dicts = list(itertools.chain.from_iterable(dataset_dicts))
has_instances = "annotations" in dataset_dicts[0]
if filter_empty and has_instances:
dataset_dicts = filter_images_with_only_crowd_annotations(dataset_dicts)
if filter_empty and has_instances and "actions" in dataset_dicts[0]["annotations"][0]:
dataset_dicts = filter_images_without_any_hois(dataset_dicts)
if has_instances:
try:
class_names = MetadataCatalog.get(dataset_names[0]).thing_classes
check_metadata_consistency("thing_classes", dataset_names)
print_instances_class_histogram(dataset_dicts, class_names)
except AttributeError: # class names are not available for this dataset
pass
return dataset_dicts
def get_detection_dataset_dicts_support(dataset_name,
filter_empty=True,
min_keypoints=0,
proposal_file=None):
dataset_dict = DatasetCatalog.get(dataset_name)
dataset_dict_flattened = []
for id_class, annotations_class in dataset_dict.items():
dataset_dict_flattened.extend(annotations_class)
# pre-extracted proposal: need to think about this later
"""
if proposal_files is not None:
assert len(dataset_names) == len(proposal_files)
# load precomputed proposals from proposal files
dataset_dicts = [
load_proposals_into_dataset(dataset_i_dicts, proposal_file)
for dataset_i_dicts, proposal_file in zip(dataset_dicts, proposal_files)
]
"""
# data distribution
class_names = MetadataCatalog.get(dataset_name).thing_classes
check_metadata_consistency("thing_classes", [dataset_name])
print_instances_class_histogram(dataset_dict_flattened, class_names)
return dataset_dict
def convert_ss_box():
dataset_name = sys.argv[1]
file_in = sys.argv[2]
file_out = sys.argv[3]
dataset_dicts = DatasetCatalog.get(dataset_name)
raw_data = sio.loadmat(file_in)["boxes"].ravel()
assert raw_data.shape[0] == len(dataset_dicts)
boxes = []
scores = []
ids = []
for i in range(len(dataset_dicts)):
if i % 1000 == 0:
print("{}/{}".format(i + 1, len(dataset_dicts)))
if "flickr" in dataset_name:
index = os.path.basename(dataset_dicts[i]["file_name"])[:-4]
elif "coco" in dataset_name:
index = os.path.basename(dataset_dicts[i]["file_name"])[:-4]
else:
index = dataset_dicts[i]["image_id"]
# selective search boxes are 1-indexed and (y1, x1, y2, x2)
i_boxes = raw_data[i][:, (1, 0, 3, 2)] - 1
# i_scores = np.zeros((i_boxes.shape[0]), dtype=np.float32)
i_scores = np.ones((i_boxes.shape[0]), dtype=np.float32)
boxes.append(i_boxes.astype(np.int16))
scores.append(np.squeeze(i_scores.astype(np.float32)))
index = dataset_dicts[i]["image_id"]
ids.append(index)
with open(file_out, "wb") as f:
pickle.dump(dict(boxes=boxes, scores=scores, indexes=ids), f,
pickle.HIGHEST_PROTOCOL)
def get_classification_dataset_dicts(dataset_names):
"""
Load and prepare dataset dicts for instance detection/segmentation and semantic segmentation.
Args:
dataset_names (list[str]): a list of dataset names
"""
assert len(dataset_names)
dataset_dicts = []
for dataset_name in dataset_names:
assert dataset_name in _GRUUL_DATASETS, f"Unknown train dataset {dataset_name}"
# dataset = ImageFolder(_GRUUL_DATASETS[cfg.DATASETS.TRAIN[0]])
dataset_dicts = [
DatasetCatalog.get(dataset_name) for dataset_name in dataset_names
]
for dataset_name, dicts in zip(dataset_names, dataset_dicts):
assert len(dicts), "Dataset '{}' is empty!".format(dataset_name)
dataset_dicts = list(itertools.chain.from_iterable(dataset_dicts))
try:
class_names = MetadataCatalog.get(dataset_names[0]).classes
print_instances_class_histogram(dataset_dicts, class_names)
except AttributeError: # class names are not available for this dataset
pass
return dataset_dicts
def visualize_samples(self, number):
from detectron2.utils.visualizer import Visualizer
from detectron2.data import MetadataCatalog
from detectron2.data.catalog import DatasetCatalog
from detectron2.data.datasets import register_coco_instances
register_coco_instances(
'sugar_beet_{}'.format(self.split), {},
join(self.root, 'instances_{}2016.json'.format(self.split)),
join(self.root, self.split, 'img'))
# register_coco_instances('sugar_beet_{}'.format(self.split), {},
# join(self.root, 'instances_{}2016.json'.format(self.split)),
# join(self.root, self.split, 'img'))
# register_coco_instances("sugar_beet_test", {},
# "/home/robot/datasets/structured_cwc/instances_test2016.json",
# "/home/robot/datasets/structured_cwc/test/img/")
# visualize training data
my_dataset_train_metadata = MetadataCatalog.get('sugar_beet_{}'.format(
self.split))
dataset_dicts = DatasetCatalog.get('sugar_beet_{}'.format(self.split))
for d in random.sample(dataset_dicts, number):
img = cv2.imread(d["file_name"])
visualizer = Visualizer(img[:, :, ::-1],
metadata=my_dataset_train_metadata,
scale=0.5)
vis = visualizer.draw_dataset_dict(d)
# cv2.imshow(vis.get_image()[:, :, ::-1])
cv2.imshow('image', vis.get_image())
cv2.waitKey()
def setup_dataset(dataset_name):
logger.info("Loading dataset {}".format(dataset_name))
start = timer()
dataset = DatasetCatalog.get(dataset_name)
stop = timer()
logger.info("Loaded dataset {} in {:.3f}s".format(dataset_name, stop - start))
return dataset
def combine_detection_dataset_dicts(
dataset_names: Collection[str],
keep_instance_predicate: Optional[InstancePredicate] = None,
proposal_files: Optional[Collection[str]] = None,
) -> List[Instance]:
"""
Load and prepare dataset dicts for training / testing
Args:
dataset_names (Collection[str]): a list of dataset names
keep_instance_predicate (Callable: Dict[str, Any] -> bool): predicate
applied to instance dicts which defines whether to keep the instance
proposal_files (Collection[str]): if given, a list of object proposal files
that match each dataset in `dataset_names`.
"""
assert len(dataset_names)
if proposal_files is None:
proposal_files = [None] * len(dataset_names)
assert len(dataset_names) == len(proposal_files)
# load datasets and metadata
dataset_name_to_dicts = {}
for dataset_name in dataset_names:
dataset_name_to_dicts[dataset_name] = DatasetCatalog.get(dataset_name)
assert len(
dataset_name_to_dicts), f"Dataset '{dataset_name}' is empty!"
# merge categories, requires category metadata to be loaded
# cat_id -> [(orig_cat_id, cat_name, dataset_name)]
merged_categories = _merge_categories(dataset_names)
_warn_if_merged_different_categories(merged_categories)
merged_category_names = [
merged_categories[cat_id][0].mapped_name
for cat_id in sorted(merged_categories)
]
# map to contiguous category IDs
_add_category_id_to_contiguous_id_maps_to_metadata(merged_categories)
# load annotations and dataset metadata
for dataset_name, proposal_file in zip(dataset_names, proposal_files):
dataset_dicts = dataset_name_to_dicts[dataset_name]
assert len(dataset_dicts), f"Dataset '{dataset_name}' is empty!"
if proposal_file is not None:
dataset_dicts = load_proposals_into_dataset(
dataset_dicts, proposal_file)
dataset_dicts = _maybe_filter_and_map_categories(
dataset_name, dataset_dicts)
print_instances_class_histogram(dataset_dicts, merged_category_names)
dataset_name_to_dicts[dataset_name] = dataset_dicts
if keep_instance_predicate is not None:
all_datasets_dicts_plain = [
d for d in itertools.chain.from_iterable(
dataset_name_to_dicts.values()) if keep_instance_predicate(d)
]
else:
all_datasets_dicts_plain = list(
itertools.chain.from_iterable(dataset_name_to_dicts.values()))
return all_datasets_dicts_plain
def register_vcoco_instances(name, metadata, json_file, image_root,
evaluator_type):
"""
Register a vcoco dataset in COCO's json annotation format for human-object
interaction detection (i.e., `instances_hico_*.json` in the dataset).
Args:
see `register_hico_instances`
"""
# 1. register a function which returns dicts
DatasetCatalog.register(
name, lambda: load_vcoco_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=evaluator_type,
**metadata)
def get_detection_dataset_dicts(dataset_names,
filter_empty=True,
min_keypoints=0,
proposal_files=None):
"""
Load and prepare dataset dicts for instance detection/segmentation and semantic segmentation.
Args:
dataset_names (list[str]): a list of dataset names
filter_empty (bool): whether to filter out images without instance annotations
min_keypoints (int): filter out images with fewer keypoints than
`min_keypoints`. Set to 0 to do nothing.
proposal_files (list[str]): if given, a list of object proposal files
that match each dataset in `dataset_names`.
"""
assert len(dataset_names)
print(dataset_names)
dataset_dicts = [
DatasetCatalog.get(dataset_name) for dataset_name in dataset_names
]
for dataset_name, dicts in zip(dataset_names, dataset_dicts):
assert len(dicts), "Dataset '{}' is empty!".format(dataset_name)
if proposal_files is not None:
assert len(dataset_names) == len(proposal_files)
# load precomputed proposals from proposal files
dataset_dicts = [
load_proposals_into_dataset(dataset_i_dicts, proposal_file)
for dataset_i_dicts, proposal_file in zip(dataset_dicts,
proposal_files)
]
dataset_dicts = list(itertools.chain.from_iterable(dataset_dicts))
has_instances = "annotations" in dataset_dicts[0]
# Keep images without instance-level GT if the dataset has semantic labels.
if filter_empty and has_instances and "sem_seg_file_name" not in dataset_dicts[
0]:
dataset_dicts = filter_images_with_only_crowd_annotations(
dataset_dicts)
if min_keypoints > 0 and has_instances:
dataset_dicts = filter_images_with_few_keypoints(
dataset_dicts, min_keypoints)
if has_instances:
try:
class_names = MetadataCatalog.get(dataset_names[0]).thing_classes
check_metadata_consistency("thing_classes", dataset_names)
print_instances_class_histogram(dataset_dicts, class_names)
plot_instances_class_histogram(dataset_dicts, class_names,
dataset_name)
except AttributeError: # class names are not available for this dataset
pass
return dataset_dicts
def combine_detection_dataset_dicts(
dataset_names: Collection[str],
keep_instance_predicate: Optional[InstancePredicate] = None,
proposal_files: Optional[Collection[str]] = None,
) -> List[Instance]:
"""
Load and prepare dataset dicts for training / testing
Args:
dataset_names (Collection[str]): a list of dataset names
keep_instance_predicate (Callable: Dict[str, Any] -> bool): predicate
applied to instance dicts which defines whether to keep the instance
proposal_files (Collection[str]): if given, a list of object proposal files
that match each dataset in `dataset_names`.
"""
assert len(dataset_names)
if proposal_files is None:
proposal_files = [None] * len(dataset_names)
assert len(dataset_names) == len(proposal_files)
# load annotations and dataset metadata
dataset_map = {}
for dataset_name in dataset_names:
dataset_dicts = DatasetCatalog.get(dataset_name)
dataset_map[dataset_name] = dataset_dicts
# initialize category maps
_add_category_id_to_contiguous_id_maps_to_metadata(dataset_names)
# apply category maps
all_datasets_dicts = []
for dataset_name, proposal_file in zip(dataset_names, proposal_files):
dataset_dicts = dataset_map[dataset_name]
assert len(dataset_dicts), f"Dataset '{dataset_name}' is empty!"
if proposal_file is not None:
dataset_dicts = load_proposals_into_dataset(
dataset_dicts, proposal_file)
dataset_dicts = _maybe_filter_and_map_categories(
dataset_name, dataset_dicts)
_map_category_id_to_contiguous_id(dataset_name, dataset_dicts)
print_instances_class_histogram(
dataset_dicts,
MetadataCatalog.get(dataset_name).thing_classes)
all_datasets_dicts.append(dataset_dicts)
if keep_instance_predicate is not None:
all_datasets_dicts_plain = [
d for d in itertools.chain.from_iterable(all_datasets_dicts)
if keep_instance_predicate(d)
]
else:
all_datasets_dicts_plain = list(
itertools.chain.from_iterable(all_datasets_dicts))
return all_datasets_dicts_plain
def main(args):
cfg = setup(args)
json_dir = cfg.INPUT.DIR
for d in ["train", "val"]:
json_path = json_dir + f"plane_net_{d}_coco_format.json"
with open(json_path, "r") as f:
dataset_dicts = json.load(f)
DatasetCatalog.register("plane_" + d, dataset_dicts)
MetadataCatalog.get("plane_" + d).set(thing_classes=["plane"])
plane_metadata = MetadataCatalog.get("plane_train")
if args.eval_only:
model = Trainer.build_model(cfg)
DetectionCheckpointer(model, save_dir=cfg.OUTPUT_DIR).resume_or_load(
cfg.MODEL.WEIGHTS, resume=args.resume)
res = Trainer.test(cfg, model)
if comm.is_main_process():
verify_results(cfg, res)
return res
trainer = Trainer(cfg)
trainer.resume_or_load(resume=args.resume)
return trainer.train()
def get_classification_dataset_dicts(dataset_names):
"""
Load and prepare dataset dicts for instance detection/segmentation and semantic segmentation.
Args:
dataset_names (list[str]): a list of dataset names
"""
assert len(dataset_names)
dataset_dicts = [DatasetCatalog.get(dataset_name)
for dataset_name in dataset_names]
for dataset_name, dicts in zip(dataset_names, dataset_dicts):
assert len(dicts), "Dataset '{}' is empty!".format(dataset_name)
dataset_dicts = list(itertools.chain.from_iterable(dataset_dicts))
return dataset_dicts
def convert_mcg_seg():
dataset_name = sys.argv[1]
dir_in = sys.argv[2]
dir_out = sys.argv[3]
if not os.path.isdir(dir_out):
os.makedirs(dir_out)
dataset_dicts = DatasetCatalog.get(dataset_name)
process_pool = Pool(processes=32)
arg_process = []
for i in range(len(dataset_dicts)):
arg_process.append((dataset_dicts[i], dataset_name, dir_in, dir_out))
results = process_pool.starmap_async(convert_mcg_seg_i, arg_process)
results = results.get()
def convert_mcg_box():
dataset_name = sys.argv[1]
dir_in = sys.argv[2]
file_out = sys.argv[3]
dataset_dicts = DatasetCatalog.get(dataset_name)
boxes = []
scores = []
ids = []
for i in range(len(dataset_dicts)):
if i % 1000 == 0:
print("{}/{}".format(i + 1, len(dataset_dicts)))
if "flickr" in dataset_name:
index = os.path.basename(dataset_dicts[i]["file_name"])[:-4]
elif "coco" in dataset_name:
index = os.path.basename(dataset_dicts[i]["file_name"])[:-4]
else:
index = dataset_dicts[i]["image_id"]
box_file = os.path.join(dir_in, "{}.mat".format(index))
mat_data = sio.loadmat(box_file)
if i == 0:
print(mat_data.keys())
if "flickr" in dataset_name:
boxes_data = mat_data["bboxes"]
scores_data = mat_data["bboxes_scores"]
else:
boxes_data = mat_data["boxes"]
scores_data = mat_data["scores"]
# selective search boxes are 1-indexed and (y1, x1, y2, x2)
# Boxes from the MCG website are in (y1, x1, y2, x2) order
boxes_data = boxes_data[:, (1, 0, 3, 2)] - 1
# boxes_data_ = boxes_data.astype(np.uint16) - 1
# boxes_data = boxes_data_[:, (1, 0, 3, 2)]
boxes.append(boxes_data.astype(np.int16))
scores.append(np.squeeze(scores_data.astype(np.float32)))
index = dataset_dicts[i]["image_id"]
ids.append(index)
with open(file_out, "wb") as f:
pickle.dump(dict(boxes=boxes, scores=scores, indexes=ids), f,
pickle.HIGHEST_PROTOCOL)
def get_detection_dataset_dicts_with_source(dataset_names,
filter_empty=True,
min_keypoints=0,
proposal_files=None):
assert len(dataset_names)
dataset_dicts = [
DatasetCatalog.get(dataset_name) for dataset_name in dataset_names
]
for dataset_name, dicts in zip(dataset_names, dataset_dicts):
assert len(dicts), "Dataset '{}' is empty!".format(dataset_name)
for source_id, (dataset_name, dicts) in \
enumerate(zip(dataset_names, dataset_dicts)):
assert len(dicts), "Dataset '{}' is empty!".format(dataset_name)
for d in dicts:
d['dataset_source'] = source_id
if "annotations" in dicts[0]:
try:
class_names = MetadataCatalog.get(dataset_name).thing_classes
check_metadata_consistency("thing_classes", dataset_name)
print_instances_class_histogram(dicts, class_names)
except AttributeError: # class names are not available for this dataset
pass
assert proposal_files is None
dataset_dicts = list(itertools.chain.from_iterable(dataset_dicts))
has_instances = "annotations" in dataset_dicts[0]
if filter_empty and has_instances:
dataset_dicts = filter_images_with_only_crowd_annotations(
dataset_dicts)
if min_keypoints > 0 and has_instances:
dataset_dicts = filter_images_with_few_keypoints(
dataset_dicts, min_keypoints)
return dataset_dicts
def register_dataset():
if regist_train_name in DatasetCatalog._REGISTERED:
log = 'regist_data exists before: %s , and try to del.... ' % regist_train_name
print(log)
print(log, file=open(log_file, "a"))
DatasetCatalog._REGISTERED.pop(regist_train_name)
DatasetCatalog._REGISTERED.pop(regist_val_name)
else:
log = 'regist_data : %s .... ' % regist_train_name
print(log)
print(log, file=open(log_file, "a"))
register_coco_instances(regist_train_name, {}, train_json_path,
train_images_dir)
register_coco_instances(regist_val_name, {}, val_json_path,
val_images_dir)
train_metadata = MetadataCatalog.get(regist_train_name)
val_metadata = MetadataCatalog.get(regist_val_name)
trainset_dicts = DatasetCatalog.get(regist_train_name)
return train_metadata, val_metadata
def __init__(self, cfg):
super().__init__()
# fmt: off
# backbone - DLA
head_conv = cfg.MODEL.CENTERNET.HEAD_CONV
final_kernel = cfg.MODEL.CENTERNET.FINAL_KERNEL
backbone_type = cfg.MODEL.BACKBONE.NAME
# heads
self.heads = cfg.MODEL.CENTERNET.TASK
# loss
self.hm_weight = cfg.MODEL.CENTERNET.HM_WEIGHT
self.wh_weight = cfg.MODEL.CENTERNET.WH_WEIGHT
self.off_weight = cfg.MODEL.CENTERNET.OFF_WEIGHT
self.focal_loss_alpha = cfg.MODEL.CENTERNET.FOCAL_LOSS_ALPHA
# inference
self.score_threshold = cfg.MODEL.CENTERNET.SCORE_THRESH_TEST
self.topk_candidates = cfg.MODEL.CENTERNET.TOPK_CANDIDATES_TEST
self.max_detections_per_image = cfg.TEST.DETECTIONS_PER_IMAGE
# fmt: on
# other
given_dataset = cfg.DATASETS.TRAIN[0]
DatasetCatalog.get(given_dataset)
self.meta = MetadataCatalog.get(given_dataset)
self.num_classes = len(
self.meta.thing_classes
) # modify num_classes by meta data of given dataset
self.heads["HM"] = self.num_classes
self.register_buffer("pixel_mean",
torch.Tensor(cfg.MODEL.PIXEL_MEAN).view(-1, 1, 1))
self.register_buffer("pixel_std",
torch.Tensor(cfg.MODEL.PIXEL_STD).view(-1, 1, 1))
# self modules
self.backbone_type = backbone_type.split('_')[1]
self.backbone = build_backbone(cfg)
if self.backbone_type == 'resnet' or self.backbone_type == 'vovnet':
self.backbone.down_ratio = 4
self.size_divisibility = 16
self.deconv_layers = self._make_deconv_layer(
self.backbone._out_feature_channels['res4'] if \
self.backbone_type == 'resnet' else \
self.backbone._out_feature_channels['stage4'],
2,
[256, 256],
[4, 4],
)
for head in sorted(self.heads):
num_output = self.heads[head]
if head_conv > 0:
fc = nn.Sequential(
nn.Conv2d(256,
head_conv,
kernel_size=3,
padding=1,
bias=True), nn.ReLU(inplace=True),
nn.Conv2d(head_conv,
num_output,
kernel_size=1,
stride=1,
padding=0))
if 'hm' in head.lower():
fc[-1].bias.data.fill_(-2.19)
else:
fill_fc_weights(fc)
else:
fc = nn.Conv2d(in_channels=256,
out_channels=num_output,
kernel_size=1,
stride=1,
padding=0)
if 'hm' in head.lower():
fc[-1].bias.data.fill_(-2.19)
else:
fill_fc_weights(fc)
self.__setattr__(head.lower(), fc)
if self.backbone_type == 'resnet': self.init_weights(50)
return
self.size_divisibility = self.backbone.size_divisibility
for head in self.heads:
classes = self.heads[head]
if head_conv > 0:
fc = nn.Sequential(
nn.Conv2d(
self.backbone.channels[self.backbone.first_level],
head_conv,
kernel_size=3,
padding=1,
bias=True), nn.ReLU(inplace=True),
nn.Conv2d(head_conv,
classes,
kernel_size=final_kernel,
stride=1,
padding=final_kernel // 2,
bias=True))
if 'hm' in head.lower():
fc[-1].bias.data.fill_(-2.19)
else:
fill_fc_weights(fc)
else:
fc = nn.Conv2d(
self.backbone.channels[self.backbone.first_level],
classes,
kernel_size=final_kernel,
stride=1,
padding=final_kernel // 2,
bias=True)
if 'hm' in head:
fc.bias.data.fill_(-2.19)
else:
fill_fc_weights(fc)
self.__setattr__(head.lower(), fc)
def register_torchvision_test_instance(name, data_root):
DatasetCatalog.register(
name, lambda: load_torchvision_json(data_root, name, False))
import glob
# 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
from detectron2.data.catalog import DatasetCatalog
from detectron2.data.datasets import register_coco_instances
from detectron2.utils.visualizer import ColorMode
from detectron2.data import DatasetCatalog, MetadataCatalog, build_detection_test_loader
from detectron2.evaluation import COCOEvaluator, inference_on_dataset
DatasetCatalog.clear()
register_coco_instances("my_dataset_test", {},
"/content/test/_annotations.coco.json",
"/content/test")
cfg = get_cfg()
cfg.merge_from_file(
model_zoo.get_config_file(
"COCO-Detection/faster_rcnn_X_101_32x8d_FPN_3x.yaml"))
#cfg.merge_from_file(model_zoo.get_config_file("COCO-InstanceSegmentation/mask_rcnn_X_101_32x8d_FPN_3x.yaml"))
#cfg.DATASETS.TRAIN = ("my_dataset_train",)
cfg.DATASETS.TEST = ("my_dataset_val", )
cfg.DATALOADER.NUM_WORKERS = 4
cfg.MODEL.WEIGHTS = model_zoo.get_checkpoint_url(
"COCO-Detection/faster_rcnn_X_101_32x8d_FPN_3x.yaml"
def d2_train_model(regist_train_name, regist_val_name, train_json_path,
train_images_dir, val_json_path, val_images_dir,
ims_per_batch, model_lr, bach_size_per_img, max_train_iter,
num_workers, num_labels):
## 1. models:
model_name = "mask_rcnn_R_50_FPN_3x.yaml"
cfgFile = "COCO-InstanceSegmentation/mask_rcnn_R_50_FPN_3x.yaml"
# work_root = os.getcwd()
work_root = "/home/user/qunosen/2_project/4_train/2_zhuchao/6_d2_final_train/2_train/1_train_2020_9_17/test6"
log_file = os.path.join(work_root, "log_dat.txt")
d2_start = time.time()
datetime_now = datetime.datetime.now()
log = ("###" * 100 + "\n") * 5 + " %s\n" % (
str(datetime_now)) + "model_name: %s ..." % model_name
print(log)
print(log, file=open(log_file, "a"))
log = "parameter setting:\n model_to_try:%s\n num_labels: %d\n ims_per_batch:%d\n num_workers:%d\n model_lr:%s\n max_train_iter:%d\n bach_size_per_img:%d\n" % \
(model_name, num_labels, ims_per_batch, num_workers, str(model_lr), max_train_iter, bach_size_per_img)
print(log)
print(log, file=open(log_file, "a"))
new_root = os.path.join(
work_root,
str(model_name) + "_%s_%s_%s_%s" %
(str(model_lr), str(bach_size_per_img), str(max_train_iter),
str(ims_per_batch)))
if not os.path.exists(new_root): os.makedirs(new_root)
os.chdir(new_root)
# register_coco_instances(regist_train_name, {}, train_json_path, train_images_dir)
# register_coco_instances(regist_val_name, {}, val_json_path, val_images_dir)
if regist_train_name in DatasetCatalog._REGISTERED:
log = 'regist_data exists before: %s , and try to del.... ' % regist_train_name
print(log)
print(log, file=open(log_file, "a"))
DatasetCatalog._REGISTERED.pop(regist_train_name)
DatasetCatalog._REGISTERED.pop(regist_val_name)
else:
log = 'regist_data : %s .... ' % regist_train_name
print(log)
print(log, file=open(log_file, "a"))
register_coco_instances(regist_train_name, {}, train_json_path,
train_images_dir)
register_coco_instances(regist_val_name, {}, val_json_path,
val_images_dir)
train_metadata = MetadataCatalog.get(regist_train_name)
val_metadata = MetadataCatalog.get(regist_val_name)
trainset_dicts = DatasetCatalog.get(regist_train_name)
################
# #### trainning:
cfg = get_cfg()
mode_config = cfgFile
log = "model_to_train: %s ..." % mode_config
print(log)
print(log, file=open(log_file, "a"))
cfg.merge_from_file(model_zoo.get_config_file(mode_config))
cfg.DATASETS.TRAIN = (regist_train_name, )
cfg.DATASETS.TEST = (regist_val_name,
) # no metrics implemented for this dataset
cfg.DATALOADER.NUM_WORKERS = num_workers
cfg.MODEL.WEIGHTS = model_zoo.get_checkpoint_url(
mode_config) ## out_model : ./output/model_final.pth
# cfg.MODEL.WEIGHTS = '/home/user/tmp/pycharm_project_310/1_detectron2/ImageDetectionAPI/d2_object_detection/pre_trained_model/model_final_a54504.pkl'
cfg.SOLVER.IMS_PER_BATCH = ims_per_batch
cfg.SOLVER.BASE_LR = model_lr
cfg.SOLVER.MAX_ITER = (
max_train_iter
) # 300 iterations seems good enough, but you can certainly train longer
cfg.MODEL.ROI_HEADS.BATCH_SIZE_PER_IMAGE = (
bach_size_per_img) # faster, and good enough for this toy dataset
cfg.MODEL.ROI_HEADS.NUM_CLASSES = num_labels # len(select_cats) # 5 classes ['chair', 'table', 'swivelchair', 'sofa', 'bed']
os.makedirs(cfg.OUTPUT_DIR, exist_ok=True)
trainer = DefaultTrainer(cfg)
trainer.resume_or_load(resume=False)
trainer.train()
model_path = os.path.join(new_root, 'output/model_final.pth')
if os.path.exists(model_path):
log = "model_save: %s" % model_path
print(log)
print(log, file=open(log_file, "a"))
#### predict
cfg.MODEL.WEIGHTS = os.path.join(cfg.OUTPUT_DIR, "model_final.pth")
cfg.MODEL.ROI_HEADS.SCORE_THRESH_TEST = 0.2 # set the testing threshold for this model
cfg.DATASETS.TEST = (regist_val_name, )
predictor = DefaultPredictor(cfg)
out_model_dir = os.path.join(new_root, "output")
out_dir = os.path.join(out_model_dir, 'result_' + str(model_name))
if not os.path.exists(out_dir): os.makedirs(out_dir)
test_dir = val_images_dir # os.path.join(work_dir,"./val_images")
# test_dir = "/home/user/qunosen/2_project/4_train/2_zhuchao/6_d2_final_train/1_data/1_data_2020_9_17/new_set_6/val"
imgs_list = [
os.path.join(test_dir, file_name)
for file_name in os.listdir(test_dir)
if file_name.endswith(".jpg") or file_name.endswith(".png")
or file_name.endswith(".bmp") or file_name.endswith(".jpeg")
]
for d in imgs_list:
im = cv2.imread(d)
outputs = predictor(im)
v = Visualizer(im[:, :, ::-1],
metadata=train_metadata,
scale=0.9,
instance_mode=ColorMode.IMAGE_BW)
v = v.draw_instance_predictions(outputs["instances"].to("cpu"))
predict_file = os.path.join(
out_dir,
os.path.splitext(os.path.basename(d))[0] + "_predict.png")
cv2.imwrite(predict_file, v.get_image()[:, :, ::-1])
if os.path.exists(predict_file):
print("Done: %s" % predict_file)
#### evaluate
evaluator = COCOEvaluator(regist_val_name,
cfg,
False,
output_dir="./output/")
val_loader = build_detection_test_loader(cfg, regist_val_name)
my_eval = inference_on_dataset(trainer.model, val_loader, evaluator)
print(my_eval)
log = ("%s evaluate: \n" % (model_name), my_eval)
print(log, file=open(log_file, "a"))
###############
DatasetCatalog._REGISTERED.pop(regist_train_name)
DatasetCatalog._REGISTERED.pop(regist_val_name)
log = "clean regist_data: %s and %s" % (regist_train_name,
regist_val_name)
print(log)
print(log, file=open(log_file, "a"))
d2_end = time.clock()
log = "model %s : it takes %s ." % (model_name, str(d2_end - d2_start))
print(log)
print(log, file=open(log_file, "a"))
os.chdir(work_root)
else:
print("NotFound: {}".format(model_path))
import random
from detectron2.utils.visualizer import Visualizer
from detectron2.data.catalog import MetadataCatalog, DatasetCatalog
import data_register
from cv2 import cv2
fruits_nuts_metadata = MetadataCatalog.get("test")
print(fruits_nuts_metadata)
dataset_dicts = DatasetCatalog.get("test")
d = dataset_dicts[1]
img = cv2.imread(d["file_name"])
visualizer = Visualizer(img[:, :, ::-1],
metadata=fruits_nuts_metadata,
scale=1)
vis = visualizer.draw_dataset_dict(d)
img = vis.get_image()[:, :, ::-1]
cv2.imshow('rr', img)
cv2.waitKey(0)
def get_detection_dataset_dicts(cfg,
dataset_names,
frames_per_group,
train=True,
proposal_files=None,
long_term=False):
"""
Load and prepare dataset dicts for instance detection/segmentation and semantic segmentation.
Args:
dataset_names (list[str]): a list of dataset names
filter_empty (bool): whether to filter out images without instance annotations
proposal_files (list[str]): if given, a list of object proposal files
that match each dataset in `dataset_names`.
"""
def chunks(lst, n):
"""Yield successive n-sized chunks from lst."""
for i in range(0, len(lst), n):
yield lst[i:i + n]
assert len(dataset_names)
dataset_dicts = [
DatasetCatalog.get(dataset_name) for dataset_name in dataset_names
]
for dataset_name, dicts in zip(dataset_names, dataset_dicts):
assert len(dicts), "Dataset '{}' is empty!".format(dataset_name)
if proposal_files is not None:
assert len(dataset_names) == len(proposal_files)
# load precomputed proposals from proposal files
dataset_dicts = [
load_proposals_into_dataset(dataset_i_dicts, proposal_file)
for dataset_i_dicts, proposal_file in zip(dataset_dicts,
proposal_files)
]
dataset_dicts = list(itertools.chain.from_iterable(dataset_dicts))
# Group frames by video
dataset_dicts = itertools.groupby(dataset_dicts, key=lambda x: x["video"])
dataset_dicts = [list(v) for k, v in dataset_dicts]
if train:
# Build frame batches per video
dataset_dicts = [
list(chunks(video_dicts, frames_per_group))
for video_dicts in dataset_dicts
]
# Assign consecutive batch ids per video
dataset_dicts = [[(b_id, batch)
for b_id, batch in enumerate(video_batches)]
for video_batches in dataset_dicts]
# Filter batches by length (last batch of each video might be shorter than frames_per_group)
dataset_dicts = [[(b_id, batch) for b_id, batch in video_batches
if len(batch) == frames_per_group]
for video_batches in dataset_dicts]
# Remove batches with incomplete GT tubelets
dataset_dicts = filter_invalid_frame_groups(dataset_dicts,
frames_per_group)
# Subsample videos
if cfg.DATALOADER.TRAIN_SUBSAMPLING:
for video_idx in range(len(dataset_dicts)):
if long_term:
video_copy = copy.deepcopy(dataset_dicts[video_idx])
# Add long-term support frames
for i in range(len(video_copy)):
if len(video_copy) > 1:
valid = list(range(len(video_copy)))
valid.remove(i)
batch_1 = np.random.choice(valid)
if len(
video_copy
) > 2: # We can't select two different long-term batches
valid.remove(batch_1)
batch_2 = np.random.choice(valid)
else:
batch_1 = 0
batch_2 = 0
dataset_dicts[video_idx][i] = \
(video_copy[i][0], video_copy[i][1] + video_copy[batch_1][1] + video_copy[batch_2][1])
if len(
dataset_dicts[video_idx]
) <= cfg.DATALOADER.TRAIN_GROUPS_PER_VIDEO * frames_per_group:
continue
filtered_batch_ids = [
b_id for b_id, _ in dataset_dicts[video_idx]
]
# Select TRAIN_GROUPS_PER_VIDEO batches evenly spaced from the first valid batch to the last one
sampled_idx = np.round(
np.linspace(filtered_batch_ids[0], filtered_batch_ids[-1],
cfg.DATALOADER.TRAIN_GROUPS_PER_VIDEO))
# Map sampled_idx to filtered dataset_dicts (removing short batches and incomplete GT tubelets)
mapped_idx = np.searchsorted(filtered_batch_ids, sampled_idx)
# Apply the mask
dataset_dicts[video_idx] = [
dataset_dicts[video_idx][idx] for idx in mapped_idx
]
# Remove batch ids
dataset_dicts = [[batch for _, batch in video_batches]
for video_batches in dataset_dicts]
dataset_dicts = list(itertools.chain.from_iterable(dataset_dicts))
else: # test: batch size = 1
# frame padding at the beginning of each video
frame_padding = cfg.MODEL.SPATIOTEMPORAL.NUM_FRAMES - 1
for v_idx in range(len(dataset_dicts)):
v = dataset_dicts[v_idx]
for frame in v:
frame['is_padding'] = False
padding = []
for _ in range(frame_padding):
padding.append(copy.deepcopy(v[0]))
padding[-1]['is_padding'] = True
dataset_dicts[v_idx] = padding + v
# frame padding at the end of each video
if cfg.MODEL.SPATIOTEMPORAL.FORWARD_AGGREGATION:
for v_idx in range(len(dataset_dicts)):
v = dataset_dicts[v_idx]
padding = []
for _ in range(frame_padding + 1):
padding.append(copy.deepcopy(v[-1]))
padding[-1]['is_padding'] = True
# We need one extra left frame padding
dataset_dicts[v_idx] = [copy.deepcopy(v[0])] + v + padding
dataset_dicts[v_idx][0]['is_padding'] = True
dataset_dicts = list(itertools.chain.from_iterable(dataset_dicts))
dataset_dicts = [[dataset_dict] for dataset_dict in dataset_dicts]
logger = logging.getLogger(__name__)
logger.info("Generating {} frame groups with {} frames.".format(
len(dataset_dicts), frames_per_group))
return dataset_dicts
from detectron2.engine import DefaultPredictor
from detectron2.config import get_cfg
from detectron2.utils.visualizer import Visualizer
from detectron2.data import MetadataCatalog
from detectron2.data.catalog import DatasetCatalog
from detectron2.data.datasets import register_coco_instances
from detectron2.evaluation import COCOEvaluator
from detectron2.data import build_detection_test_loader
from detectron2.evaluation import inference_on_dataset
register_coco_instances("my_dataset_train", {}, "content/train/_annotations.coco.json", "content/train")
register_coco_instances("my_dataset_val", {}, "content/valid/_annotations.coco.json", "content/valid")
#visualize training data
my_dataset_train_metadata = MetadataCatalog.get("my_dataset_train")
dataset_dicts = DatasetCatalog.get("my_dataset_train")
for d in random.sample(dataset_dicts, 3):
img = cv2.imread(d["file_name"])
visualizer = Visualizer(img[:, :, ::-1], metadata=my_dataset_train_metadata, scale=0.5)
vis = visualizer.draw_dataset_dict(d)
cv2.imshow('preview',vis.get_image()[:, :, ::-1])
cv2.waitKey(100)
#Importing our own Trainer Module to use the COCO validation evaluation
#during training. Otherwise no validation eval occurs.
class CocoTrainer(DefaultTrainer):
@classmethod
def build_evaluator(cls, cfg, dataset_name, output_folder=None):
from detectron2.data.datasets import register_coco_instances
from detectron2.data.catalog import MetadataCatalog, DatasetCatalog
import random
from detectron2.utils.visualizer import Visualizer
import cv2
from PIL import Image
import numpy as np
register_coco_instances("fsod", {}, "annotations/instances_train2017.json", "images/")
m = MetadataCatalog.get("fsod")
print(m)
dataset_dicts = DatasetCatalog.get("fsod")
for d in random.sample(dataset_dicts, 1):
img = cv2.imread(d["file_name"])
visualizer = Visualizer(img[:, :, ::-1], metadata=m, scale=0.5)
vis = visualizer.draw_dataset_dict(d)
img = Image.fromarray(vis.get_image()[:, :, ::-1], 'RGB')
img.show()
