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()