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 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 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 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 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 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 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 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 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 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 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))
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
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)
import random
from detectron2.utils.visualizer import Visualizer
from detectron2.data.catalog import MetadataCatalog, DatasetCatalog
import data_reg
import cv2
scoliosis_metadata = MetadataCatalog.get("scoliosis")
print(scoliosis_metadata)
dataset_dicts = DatasetCatalog.get("scoliosis")
for d in random.sample(dataset_dicts, 3):
img = cv2.imread(d["file_name"])
visualizer = Visualizer(img[:, :, ::-1],
metadata=scoliosis_metadata,
scale=1)
vis = visualizer.draw_dataset_dict(d)
img = vis.get_image()[:, :, ::-1]
cv2.imshow('A random labeled picture', img)
cv2.waitKey(0)
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):
# os.system("python voc2coco.py --ann_dir=data/test --labels=data/labels.txt --output=data/test_annots.json")
run_win_cmd(
"python voc2coco.py --ann_dir=data/train --labels=data/labels.txt --output=data/train_annots.json"
)
run_win_cmd(
"python voc2coco.py --ann_dir=data/validate --labels=data/labels.txt --output=data/validate_annots.json"
)
run_win_cmd(
"python voc2coco.py --ann_dir=data/test --labels=data/labels.txt --output=data/test_annots.json"
)
register_coco_instances("train", {}, "data/train_annots.json", "data/train")
register_coco_instances("validate", {}, "data/validate_annots.json",
"data/validate")
register_coco_instances("test", {}, "data/test_annots.json", "data/test")
dataset_dicts = DatasetCatalog.get("train")
print(dataset_dicts[0])
trainset_metadata = MetadataCatalog.get("train")
# import random
# for d in random.sample(dataset_dicts, 1):
# img = cv2.imread(d["file_name"])
# visualizer = Visualizer(img[:, :, ::-1], metadata=trainset_metadata, scale=0.5)
# vis = visualizer.draw_dataset_dict(d)
# cv2.imshow("image", vis.get_image()[:, :, ::-1])
# cv2.waitKey() # press to exit
cfg = get_cfg()
# Get the basic model configuration from the model zoo
cfg.merge_from_file(
model_zoo.get_config_file("COCO-Detection/faster_rcnn_R_50_FPN_3x.yaml"))
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()
def recall_ssopg():
dataset_name = sys.argv[1]
dir_in = sys.argv[2]
assert dataset_name == "voc_2007_test"
dataset_dicts = DatasetCatalog.get(dataset_name)
height_box_all = None
width_box_all = None
level_box_all = None
score_box_all = None
cnt_yes = [0 for _ in iou_thres]
cnt_gt = [0 for _ in iou_thres]
for i, d in enumerate(dataset_dicts):
print(i, d)
if i % 1000 == 0:
print("{}/{}".format(i + 1, len(dataset_dicts)))
gpu_id = int(i / 1238)
iter_id = i % 1238
load_name = "i" + str(iter_id) + "_g" + str(gpu_id) + "_b0_box_proposal.npy"
load_path = os.path.join(dir_in, load_name)
i_boxes = np.load(load_path)
load_name = "i" + str(iter_id) + "_g" + str(gpu_id) + "_b0_logit_proposal.npy"
load_path = os.path.join(dir_in, load_name)
i_scores = np.load(load_path)
load_name = "i" + str(iter_id) + "_g" + str(gpu_id) + "_b0_level_proposal.npy"
load_path = os.path.join(dir_in, load_name)
i_levels = np.load(load_path)
print(i_boxes, i_boxes.shape)
print(i_scores, i_scores.shape)
print(i_levels, i_levels.shape)
# -------------------------------------------------------------------------------
# sort by confidence
sorted_ind = np.argsort(-(i_scores.flatten()))
i_boxes = i_boxes[sorted_ind, ...]
i_scores = i_scores[sorted_ind, ...]
i_levels = i_levels[sorted_ind, ...]
i_boxes = i_boxes[:max_num_box, ...]
i_scores = i_scores[:max_num_box, ...]
i_levels = i_levels[:max_num_box, ...]
# random
# number_of_rows = i_boxes.shape[0]
# random_indices = np.random.choice(number_of_rows, size=min(number_of_rows, max_num_box), replace=False)
# i_boxes = i_boxes[random_indices,...]
# i_scores = i_scores[random_indices,...]
# i_levels = i_levels[random_indices,...]
# -------------------------------------------------------------------------------
height = d["height"]
width = d["width"]
scale_factor = 1.0 * min(height, width) / 688
i_boxes = i_boxes * scale_factor
# -------------------------------------------------------------------------------
# -------------------------------------------------------------------------------
height_box = i_boxes[:, 3] - i_boxes[:, 1] + 1.0
width_box = i_boxes[:, 2] - i_boxes[:, 0] + 1.0
if height_box_all is None:
height_box_all = height_box
width_box_all = width_box
level_box_all = i_levels
score_box_all = i_scores
else:
# print(height_box.shape, width_box.shape)
print(height_box_all.shape, width_box_all.shape, level_box_all.shape)
height_box_all = np.concatenate((height_box_all, height_box), axis=0)
width_box_all = np.concatenate((width_box_all, width_box), axis=0)
level_box_all = np.concatenate((level_box_all, i_levels), axis=0)
score_box_all = np.concatenate((score_box_all, i_scores), axis=0)
# -------------------------------------------------------------------------------
for a in d["annotations"]:
print(a["bbox"])
bbgt = a["bbox"]
if "coco" in dataset_name:
bbgt = [bbgt[0], bbgt[1], bbgt[0] + bbgt[2], bbgt[1] + bbgt[3]]
ixmin = np.maximum(i_boxes[:, 0], bbgt[0])
iymin = np.maximum(i_boxes[:, 1], bbgt[1])
ixmax = np.minimum(i_boxes[:, 2], bbgt[2])
iymax = np.minimum(i_boxes[:, 3], bbgt[3])
iw = np.maximum(ixmax - ixmin + 1.0, 0.0)
ih = np.maximum(iymax - iymin + 1.0, 0.0)
inters = iw * ih
# union
uni = (
(bbgt[2] - bbgt[0] + 1.0) * (bbgt[3] - bbgt[1] + 1.0)
+ (i_boxes[:, 2] - i_boxes[:, 0] + 1.0) * (i_boxes[:, 3] - i_boxes[:, 1] + 1.0)
- inters
)
overlaps = inters / uni
ovmax = np.max(overlaps)
jmax = np.argmax(overlaps)
cnt_gt = [v + 1 for i, v in enumerate(cnt_gt)]
cnt_yes = [v + 1 if ovmax >= iou_thres[i] else v for i, v in enumerate(cnt_yes)]
print(ovmax, jmax)
print(cnt_yes, cnt_gt, [1.0 * a / b for a, b in zip(cnt_yes, cnt_gt)])
print(cnt_yes, cnt_gt)
print([1.0 * a / b for a, b in zip(cnt_yes, cnt_gt)])
save_path = os.path.join("mrrp_h_" + str(max_num_box) + ".npy")
np.save(save_path, height_box_all)
save_path = os.path.join("mrrp_w_" + str(max_num_box) + ".npy")
np.save(save_path, width_box_all)
save_path = os.path.join("mrrp_l_" + str(max_num_box) + ".npy")
np.save(save_path, level_box_all)
save_path = os.path.join("mrrp_s_" + str(max_num_box) + ".npy")
np.save(save_path, score_box_all)
return [1.0 * a / b for a, b in zip(cnt_yes, cnt_gt)]
def build_classification_train_loader(cfg, mapper=None, multiplier=1):
"""
A data loader is created by the following steps:
1. Use the dataset names in config to query :class:`DatasetCatalog`, and obtain a list of dicts.
2. Start workers to work on the dicts. Each worker will:
* Map each metadata dict into another format to be consumed by the model.
* Batch them by simply putting dicts into a list.
The batched ``list[mapped_dict]`` is what this dataloader will return.
Args:
cfg (CfgNode): the config
mapper (callable): a callable which takes a sample (dict) from dataset and
returns the format to be consumed by the model.
By default it will be `DatasetMapper(cfg, True)`.
Returns:
an infinite iterator of training data
"""
num_workers = get_world_size()
images_per_batch = cfg.SOLVER.IMS_PER_BATCH
sample_num = cfg.DATASETS.WEAK_CLASSIFIER_SAMPLE_NUM
assert (
images_per_batch % num_workers == 0
), "SOLVER.IMS_PER_BATCH ({}) must be divisible by the number of workers ({}).".format(
images_per_batch, num_workers)
assert (
images_per_batch >= num_workers
), "SOLVER.IMS_PER_BATCH ({}) must be larger than the number of workers ({}).".format(
images_per_batch, num_workers)
images_per_worker = images_per_batch // num_workers
images_per_worker = int(images_per_worker * multiplier)
if sample_num > 0:
np.random.seed(cfg.DATASETS.SAMPLE_SEED)
print("Setting sampling seed:", cfg.DATASETS.SAMPLE_SEED)
dataset_names = cfg.DATASETS.CLASSIFIER_TRAIN
if isinstance(dataset_names, str):
dataset_names = [dataset_names]
dataset_dicts = [
DatasetCatalog.get(dataset_name) for dataset_name in dataset_names
]
dataset_dicts = list(itertools.chain.from_iterable(dataset_dicts))
label_to_annotation_dict = {
e: []
for e in range(cfg.MODEL.ROI_HEADS.NUM_CLASSES)
}
for e in dataset_dicts:
per_label_record = {}
for ann in e['annotations']:
if ann['category_id'] in per_label_record:
per_label_record[ann['category_id']]['annotations'].append(
ann)
else:
record = copy.deepcopy(e)
# filter annotations
annotations_filtered = [ann]
record['annotations'] = annotations_filtered
per_label_record[ann['category_id']] = record
for key in per_label_record.keys():
label_to_annotation_dict[key].append(per_label_record[key])
label_to_annotation_dict_sampled = {}
for id_class, ann_list in label_to_annotation_dict.items():
if id_class in cfg.DATASETS.FEWSHOT.BASE_CLASSES_ID:
if not cfg.DATASETS.OVER_SAMPLE:
if cfg.DATASETS.BASE_MULTIPLIER > 0:
try:
ann_list_sampled = np.random.choice(
ann_list,
size=int(sample_num *
cfg.DATASETS.BASE_MULTIPLIER),
replace=False)
except:
ann_list_sampled = np.random.choice(
ann_list,
size=int(sample_num *
cfg.DATASETS.BASE_MULTIPLIER),
replace=True)
else:
ann_list_sampled = ann_list
else:
print("BASE OVER SAMPLING")
ann_list_sampled = ann_list
label_to_annotation_dict_sampled[id_class] = ann_list_sampled
else:
if not cfg.DATASETS.OVER_SAMPLE:
if cfg.DATASETS.BASE_MULTIPLIER > 0:
try:
ann_list_sampled = np.random.choice(
ann_list, size=sample_num, replace=False)
except:
ann_list_sampled = np.random.choice(
ann_list, size=sample_num, replace=True)
if cfg.DATASETS.NOVEL_MULTIPLER > 0:
ann_list_sampled = np.repeat(
ann_list_sampled, cfg.DATASETS.NOVEL_MULTIPLER)
else:
ann_list_sampled = []
else:
try:
ann_list_sampled_temp = np.random.choice(
ann_list, size=sample_num, replace=False)
if not cfg.DATASETS.SAMPLE_WITH_REPLACEMENT:
print("OVER SAMPLING")
ann_list_sampled = np.random.choice(
ann_list_sampled_temp,
size=len(ann_list),
replace=True)
else:
ann_list_sampled_temp = np.random.choice(
ann_list, size=sample_num, replace=False)
num_repeat = len(ann_list) // len(
ann_list_sampled_temp)
num_remainder = len(ann_list) % len(
ann_list_sampled_temp)
ann_list_sampled = np.repeat(
ann_list_sampled_temp, num_repeat)
if num_remainder > 0:
ann_list_sampled = np.hstack(
(ann_list_sampled,
np.random.choice(ann_list_sampled_temp,
size=num_remainder,
replace=True)))
print("OVER SAMPLING FIXED NEW",
len(ann_list_sampled_temp),
len(ann_list_sampled))
except:
ann_list_sampled = ann_list
label_to_annotation_dict_sampled[id_class] = ann_list_sampled
dataset_dicts = []
for k, v in label_to_annotation_dict_sampled.items():
dataset_dicts.extend(v)
DatasetCatalog.register("classifier_train_sampled",
lambda: dataset_dicts)
MetadataCatalog.get("classifier_train_sampled").set(
thing_classes=MetadataCatalog.get(dataset_names[0]).thing_classes,
evaluator_type='pascal_voc')
dataset_name = ('classifier_train_sampled', )
# print([(x['image_id'], len(x['annotations'])) for x in dataset_dicts[:50]])
# print_instances_class_histogram_1(dataset_dicts, MetadataCatalog.get(dataset_names[0]).thing_classes)
else:
dataset_name = cfg.DATASETS.CLASSIFIER_TRAIN
dataset_dicts = get_detection_dataset_dicts(
dataset_name,
filter_empty=cfg.DATALOADER.FILTER_EMPTY_ANNOTATIONS,
min_keypoints=cfg.MODEL.ROI_KEYPOINT_HEAD.MIN_KEYPOINTS_PER_IMAGE
if cfg.MODEL.KEYPOINT_ON else 0,
proposal_files=cfg.DATASETS.PROPOSAL_FILES_CLASSIFIER_TRAIN
if cfg.MODEL.LOAD_PROPOSALS else None)
dataset = DatasetFromList(dataset_dicts, copy=False)
# # filtering
# dataset_filtered = []
# for sample in dataset:
# e_class_ids = set([e['category_id'] for e in sample['annotations']])
# for e_class_ids_ in e_class_ids:
# if e_class_ids_ in cfg.DATASETS.FEWSHOT.NOVEL_CLASSES_ID:
# dataset_filtered.append(sample)
# break
# dataset = dataset_filtered
if mapper is None:
mapper = DatasetMapper(cfg, True)
dataset = MapDataset(dataset, mapper)
sampler_name = cfg.DATALOADER.SAMPLER_TRAIN
logger = logging.getLogger(__name__)
logger.info("Using training sampler {}".format(sampler_name))
if sampler_name == "TrainingSampler":
sampler = samplers.TrainingSampler(len(dataset))
elif sampler_name == "RepeatFactorTrainingSampler":
sampler = samplers.RepeatFactorTrainingSampler(
dataset_dicts, cfg.DATALOADER.REPEAT_THRESHOLD)
else:
raise ValueError("Unknown training sampler: {}".format(sampler_name))
if cfg.DATALOADER.ASPECT_RATIO_GROUPING:
data_loader = torch.utils.data.DataLoader(
dataset,
sampler=sampler,
num_workers=cfg.DATALOADER.NUM_WORKERS,
batch_sampler=None,
collate_fn=operator.itemgetter(
0), # don't batch, but yield individual elements
worker_init_fn=worker_init_reset_seed,
) # yield individual mapped dict
data_loader = AspectRatioGroupedDataset(data_loader, images_per_worker)
else:
batch_sampler = torch.utils.data.sampler.BatchSampler(
sampler, images_per_worker, drop_last=True)
# drop_last so the batch always have the same size
data_loader = torch.utils.data.DataLoader(
dataset,
num_workers=cfg.DATALOADER.NUM_WORKERS,
batch_sampler=batch_sampler,
collate_fn=trivial_batch_collator,
worker_init_fn=worker_init_reset_seed,
)
return data_loader
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)
plain_register_dataset()
fruits_nuts_metadata = MetadataCatalog.get("coco_my_train")
print(fruits_nuts_metadata)
dataset_dicts = DatasetCatalog.get("coco_my_train")
# Inference with a keypoint detection model
WINDOW_NAME = "COCO detections"
cfg = get_cfg()
cfg.merge_from_file(model_zoo.get_config_file("COCO-Detection/faster_rcnn_R_50_FPN_1x.yaml"))
cfg.MODEL.WEIGHTS = "/home/bruce/PycharmProjects/detectron2/tools/output/model_0001784.pth"
print('loading from: {}'.format(cfg.MODEL.WEIGHTS))
cfg.MODEL.ROI_HEADS.SCORE_THRESH_TEST = 0.5 # set the testing threshold for this model
cfg.MODEL.ROI_HEADS.NUM_CLASSES = 11
cfg.DATASETS.TEST = ("coco_my_val", )
predictor = DefaultPredictor(cfg)
cv2.namedWindow(WINDOW_NAME, cv2.WINDOW_NORMAL) # 调整图像
def recall_mcg():
dataset_name = sys.argv[1]
dir_in = sys.argv[2]
dataset_dicts = DatasetCatalog.get(dataset_name)
cnt_yes = [0 for _ in iou_thres]
cnt_gt = [0 for _ in iou_thres]
for i, d in enumerate(dataset_dicts):
print(i, d)
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)]
# -------------------------------------------------------------------------------
# sort by confidence
sorted_ind = np.argsort(-(scores_data.flatten()))
boxes_data = boxes_data[sorted_ind, :]
scores_data = scores_data[sorted_ind, :]
boxes_data = boxes_data[:max_num_box, ...]
scores_data = scores_data[:max_num_box, ...]
# random
# number_of_rows = boxes_data.shape[0]
# random_indices = np.random.choice(number_of_rows, size=min(number_of_rows, max_num_box), replace=False)
# boxes_data = boxes_data[random_indices,...]
# scores_data = scores_data[random_indices,...]
# -------------------------------------------------------------------------------
for a in d["annotations"]:
print(a["bbox"])
bbgt = a["bbox"]
if "coco" in dataset_name:
bbgt = [bbgt[0], bbgt[1], bbgt[0] + bbgt[2], bbgt[1] + bbgt[3]]
ixmin = np.maximum(boxes_data[:, 0], bbgt[0])
iymin = np.maximum(boxes_data[:, 1], bbgt[1])
ixmax = np.minimum(boxes_data[:, 2], bbgt[2])
iymax = np.minimum(boxes_data[:, 3], bbgt[3])
iw = np.maximum(ixmax - ixmin + 1.0, 0.0)
ih = np.maximum(iymax - iymin + 1.0, 0.0)
inters = iw * ih
# union
uni = (
(bbgt[2] - bbgt[0] + 1.0) * (bbgt[3] - bbgt[1] + 1.0)
+ (boxes_data[:, 2] - boxes_data[:, 0] + 1.0)
* (boxes_data[:, 3] - boxes_data[:, 1] + 1.0)
- inters
)
overlaps = inters / uni
ovmax = np.max(overlaps)
jmax = np.argmax(overlaps)
cnt_gt = [v + 1 for i, v in enumerate(cnt_gt)]
cnt_yes = [v + 1 if ovmax >= iou_thres[i] else v for i, v in enumerate(cnt_yes)]
print(ovmax, jmax)
print(cnt_yes, cnt_gt, [1.0 * a / b for a, b in zip(cnt_yes, cnt_gt)])
print(cnt_yes, cnt_gt)
print([1.0 * a / b for a, b in zip(cnt_yes, cnt_gt)])
return [1.0 * a / b for a, b in zip(cnt_yes, cnt_gt)]
def get_classification_datasets(dataset_names):
assert len(dataset_names)
datasets = [
DatasetCatalog.get(dataset_name) for dataset_name in dataset_names
]
return datasets
def recall_eb():
dataset_name = sys.argv[1]
file_in = sys.argv[2]
dataset_dicts = DatasetCatalog.get(dataset_name)
print(sio.loadmat(file_in))
# exit()
mat_data = sio.loadmat(file_in)
boxes_data = mat_data["boxes"].ravel()
scores_data = mat_data["boxScores"].ravel()
assert boxes_data.shape[0] == len(dataset_dicts)
assert scores_data.shape[0] == len(dataset_dicts)
cnt_yes = [0 for _ in iou_thres]
cnt_gt = [0 for _ in iou_thres]
for i, d in enumerate(dataset_dicts):
print(i, d)
if i % 1000 == 0:
print("{}/{}".format(i + 1, len(dataset_dicts)))
# selective search boxes are 1-indexed and (y1, x1, y2, x2)
i_boxes = boxes_data[i][:, (1, 0, 3, 2)] - 1
i_scores = scores_data[i][:]
# -------------------------------------------------------------------------------
# sort by confidence
sorted_ind = np.argsort(-(i_scores.flatten()))
i_boxes = i_boxes[sorted_ind, :]
i_scores = i_scores[sorted_ind, :]
i_boxes = i_boxes[:max_num_box, ...]
i_scores = i_scores[:max_num_box, ...]
# random
# number_of_rows = i_boxes.shape[0]
# random_indices = np.random.choice(number_of_rows, size=min(number_of_rows, max_num_box), replace=False)
# i_boxes = i_boxes[random_indices,...]
# i_scores = i_scores[random_indices,...]
# -------------------------------------------------------------------------------
for a in d["annotations"]:
print(a["bbox"])
bbgt = a["bbox"]
if "coco" in dataset_name:
bbgt = [bbgt[0], bbgt[1], bbgt[0] + bbgt[2], bbgt[1] + bbgt[3]]
ixmin = np.maximum(i_boxes[:, 0], bbgt[0])
iymin = np.maximum(i_boxes[:, 1], bbgt[1])
ixmax = np.minimum(i_boxes[:, 2], bbgt[2])
iymax = np.minimum(i_boxes[:, 3], bbgt[3])
iw = np.maximum(ixmax - ixmin + 1.0, 0.0)
ih = np.maximum(iymax - iymin + 1.0, 0.0)
inters = iw * ih
# union
uni = (
(bbgt[2] - bbgt[0] + 1.0) * (bbgt[3] - bbgt[1] + 1.0)
+ (i_boxes[:, 2] - i_boxes[:, 0] + 1.0) * (i_boxes[:, 3] - i_boxes[:, 1] + 1.0)
- inters
)
overlaps = inters / uni
ovmax = np.max(overlaps)
jmax = np.argmax(overlaps)
cnt_gt = [v + 1 for i, v in enumerate(cnt_gt)]
cnt_yes = [v + 1 if ovmax >= iou_thres[i] else v for i, v in enumerate(cnt_yes)]
print(ovmax, jmax)
print(cnt_yes, cnt_gt, [1.0 * a / b for a, b in zip(cnt_yes, cnt_gt)])
print(cnt_yes, cnt_gt)
print([1.0 * a / b for a, b in zip(cnt_yes, cnt_gt)])
return [1.0 * a / b for a, b in zip(cnt_yes, cnt_gt)]
def fsod_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)
dataset_dicts_original = [
DatasetCatalog.get(dataset_name) for dataset_name in dataset_names
]
for dataset_name, dicts in zip(dataset_names, dataset_dicts_original):
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_original = [
load_proposals_into_dataset(dataset_i_dicts, proposal_file)
for dataset_i_dicts, proposal_file in zip(dataset_dicts_original,
proposal_files)
]
if 'train' not in dataset_names[0]:
dataset_dicts = list(
itertools.chain.from_iterable(dataset_dicts_original))
else:
dataset_dicts_original = list(
itertools.chain.from_iterable(dataset_dicts_original))
dataset_dicts_original = filter_images_with_only_crowd_annotations(
dataset_dicts_original)
###################################################################################
# split image-based annotations to instance-based annotations for few-shot learning
dataset_dicts = []
index_dicts = []
split_flag = True
if split_flag:
for record in dataset_dicts_original:
file_name = record['file_name']
height = record['height']
width = record['width']
image_id = record['image_id']
annotations = record['annotations']
category_dict = {}
for ann_id, ann in enumerate(annotations):
ann.pop("segmentation", None)
ann.pop("keypoints", None)
category_id = ann['category_id']
if category_id not in category_dict.keys():
category_dict[category_id] = [ann]
else:
category_dict[category_id].append(ann)
for key, item in category_dict.items():
instance_ann = {}
instance_ann['file_name'] = file_name
instance_ann['height'] = height
instance_ann['width'] = width
instance_ann['annotations'] = item
dataset_dicts.append(instance_ann)
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)
except AttributeError: # class names are not available for this dataset
pass
return dataset_dicts