def build_train_loader(cls, cfg): if cfg.INPUT.AUG: mapper = DatasetMapper( cfg, is_train=True, augmentations=build_polyp_segm_train_aug(cfg)) else: mapper = DatasetMapper(cfg, True) return build_detection_train_loader(cfg, mapper=mapper)
def build_hooks(self): """ Build a list of default hooks, including timing, evaluation, checkpointing, lr scheduling, precise BN, writing events. Returns: list[HookBase]: """ cfg = self.cfg.clone() cfg.defrost() cfg.DATALOADER.NUM_WORKERS = 0 # save some memory and time for PreciseBN ret = [ hooks.IterationTimer(), hooks.LRScheduler(self.optimizer, self.scheduler), hooks.PreciseBN( # Run at the same freq as (but before) evaluation. cfg.TEST.EVAL_PERIOD, self.model, # Build a new data loader to not affect training self.build_train_loader(cfg), cfg.TEST.PRECISE_BN.NUM_ITER, ) if cfg.TEST.PRECISE_BN.ENABLED and get_bn_modules(self.model) else None, ] ## insert custom hook ret.insert( -1, LossEvalHook( self.cfg.TEST.EVAL_PERIOD, self.model, build_detection_test_loader(self.cfg, self.cfg.DATASETS.TEST[0], DatasetMapper(self.cfg, True)))) ## change dataset index (custom) cfg.Test_index += 1 if cfg.Test_index == cfg.Test_index_MAX: cfg.Test_index = 0 # Do PreciseBN before checkpointer, because it updates the model and need to # be saved by checkpointer. # This is not always the best: if checkpointing has a different frequency, # some checkpoints may have more precise statistics than others. if comm.is_main_process(): ret.append( hooks.PeriodicCheckpointer(self.checkpointer, cfg.SOLVER.CHECKPOINT_PERIOD)) def test_and_save_results(): self._last_eval_results = self.test(self.cfg, self.model) return self._last_eval_results # Do evaluation after checkpointer, because then if it fails, # we can use the saved checkpoint to debug. ret.append(hooks.EvalHook(cfg.TEST.EVAL_PERIOD, test_and_save_results)) if comm.is_main_process(): # run writers in the end, so that evaluation metrics are written ret.append(hooks.PeriodicWriter(self.build_writers(), period=20)) return ret
def build_detection_test_loader(cfg, dataset_name, batch_size, mapper=None): dataset_dicts = get_detection_dataset_dicts( [dataset_name], filter_empty=False, proposal_files=[ cfg.DATASETS.PROPOSAL_FILES_TEST[list( cfg.DATASETS.TEST).index(dataset_name)] ] if cfg.MODEL.LOAD_PROPOSALS else None, ) dataset = DatasetFromList(dataset_dicts) if mapper is None: mapper = DatasetMapper(cfg, False) dataset = MapDataset(dataset, mapper) sampler = samplers.InferenceSampler(len(dataset)) # Always use 1 image per worker during inference since this is the # standard when reporting inference time in papers. batch_sampler = torch.utils.data.sampler.BatchSampler(sampler, batch_size, drop_last=False) data_loader = torch.utils.data.DataLoader( dataset, num_workers=cfg.DATALOADER.NUM_WORKERS, batch_sampler=batch_sampler, collate_fn=_trivial_batch_collator, ) return data_loader
def build_train_loader(cls, cfg: CfgNode): return build_detection_train_loader( cfg, # pylint:disable=redundant-keyword-arg,missing-kwoa mapper=DatasetMapper(cfg, is_train=True, augmentations=TRAIN_TRANSF), )
def build_train_loader(cls, cfg): if "SemanticSegmentor" in cfg.MODEL.META_ARCHITECTURE: mapper = DatasetMapper(cfg, is_train=True, augmentations=build_sem_seg_train_aug(cfg)) else: mapper = None return build_detection_train_loader(cfg, mapper=mapper)
def build_hooks(self): hooks = super().build_hooks() hooks.insert( -1, EarlyStop( cfg.TEST.EVAL_PERIOD, self.model, build_detection_test_loader(self.cfg, self.cfg.DATASETS.TEST[0], DatasetMapper(self.cfg, True)))) hooks.insert( -1, LossEvalHook( cfg.TEST.EVAL_PERIOD, self.model, build_detection_test_loader(self.cfg, self.cfg.DATASETS.TEST[0], DatasetMapper(self.cfg, True)))) return hooks
def build_test_loader(cls, cfg: CfgNode, dataset_name: str): return build_detection_test_loader( cfg, dataset_name, # pylint:disable=redundant-keyword-arg,missing-kwoa mapper=DatasetMapper(cfg, is_train=False, augmentations=VAL_TRANSF), )
def evaluate_loss(self, cfg, model): """Compute and log the validation loss to Comet Args: cfg (CfgNode): Detectron Config Object model (torch.nn.Module): Detectron Model Returns: dict: Empty Dict to satisfy Detectron Eval Hook API requirements """ eval_loader = build_detection_test_loader(cfg, cfg.DATASETS.TEST[0], DatasetMapper(cfg, True)) # Copying inference_on_dataset from evaluator.py total = len(eval_loader) num_warmup = min(5, total - 1) start_time = time.perf_counter() total_compute_time = 0 losses = [] if comm.is_main_process(): storage = get_event_storage() for idx, inputs in enumerate(eval_loader): if idx == num_warmup: start_time = time.perf_counter() total_compute_time = 0 start_compute_time = time.perf_counter() if torch.cuda.is_available(): torch.cuda.synchronize() total_compute_time += time.perf_counter() - start_compute_time iters_after_start = idx + 1 - num_warmup * int( idx >= num_warmup) seconds_per_img = total_compute_time / iters_after_start if idx >= num_warmup * 2 or seconds_per_img > 5: total_seconds_per_img = (time.perf_counter() - start_time) / iters_after_start eta = datetime.timedelta( seconds=int(total_seconds_per_img * (total - idx - 1))) log_every_n_seconds( logging.INFO, "Loss on Validation done {}/{}. {:.4f} s / img. ETA={}" .format(idx + 1, total, seconds_per_img, str(eta)), n=5, ) loss_batch = self._get_loss(model, inputs) losses.append(loss_batch) mean_loss = np.mean(losses) # Log to Comet self.experiment.log_metric("eval_loss", mean_loss) storage.put_scalar("eval_loss", mean_loss) comm.synchronize() # Returns empty dict to satisfy Dectron Eval Hook requirement return {}
def inference(cfg, out_dir): # build model model = build_model(cfg) # resume DetectionCheckpointer(model, save_dir=cfg.OUTPUT_DIR).resume_or_load( "./output/autoaug_post_train/model_final.pth", resume=True) # data_loader mapper = DatasetMapper(cfg, False) data_loader = build_detection_test_loader(cfg, cfg.DATASETS.TEST[0], mapper) total = len(data_loader) # inference data loader must have a fixed length num_devices = torch.distributed.get_world_size( ) if torch.distributed.is_initialized() else 1 num_warmup = min(5, total - 1) start_time = time.perf_counter() total_compute_time = 0 torch.no_grad() model.eval() for idx, inputs in enumerate(data_loader): start_compute_time = time.perf_counter() outputs = model(inputs) if torch.cuda.is_available(): torch.cuda.synchronize() total_compute_time += time.perf_counter() - start_compute_time # log iters_after_start = idx + 1 - num_warmup * int(idx >= num_warmup) seconds_per_img = total_compute_time / iters_after_start if idx >= num_warmup * 2 or seconds_per_img > 5: total_seconds_per_img = (time.perf_counter() - start_time) / iters_after_start eta = datetime.timedelta(seconds=int(total_seconds_per_img * (total - idx - 1))) log_every_n_seconds( logging.INFO, "Inference done {}/{}. {:.4f} s / img. ETA={}".format( idx + 1, total, seconds_per_img, str(eta)), n=5, ) for input, output in zip(inputs, outputs): pred_segm = output["sem_seg"].to("cpu") pred = torch.max(pred_segm, dim=0)[1].data pred = pred.numpy()[:, :, np.newaxis] pred = np.dstack((pred, pred, pred)) cv2.imwrite( out_dir + input["file_name"].split("/")[-1].replace("jpg", "png"), pred * 255)
def build_hooks(self): hooks = super().build_hooks() hooks.insert( -1, LossEvalHook( self.cfg, self.val_period, self.model, self.scheduler, build_detection_test_loader(self.cfg, self.val_data, DatasetMapper(self.cfg, True)))) return hooks
def build_train_loader(cls, cfg): if "PointsCollection" in cfg.MODEL.META_ARCHITECTURE: mapper = DatasetMapper( cfg, is_train=True, augmentations=build_Pt_collect_train_aug(cfg)) else: mapper = None return build_detection_train_loader(cfg, mapper=mapper)
def build_train_loader(cls, cfg): print(cfg.INPUT.MIN_SIZE_TRAIN) mapper = DatasetMapper(cfg, is_train=True, augmentations=[ transforms.Resize(cfg.INPUT.MIN_SIZE_TEST), transforms.RandomFlip() ]) return build_detection_train_loader(cfg, mapper)
def build_hooks(self): hooks = super().build_hooks() hooks.insert( -1, LossEvalHook( self.cfg.TEST.EVAL_PERIOD, self.model, build_detection_test_loader(self.cfg, "solar_val", DatasetMapper(self.cfg, True)))) return hooks
def build_test_loader(cfg, dataset_name): input_size = cfg.MODEL.CLSNET.INPUT_SIZE return build_detection_test_loader( cfg, dataset_name, mapper=DatasetMapper( cfg, is_train=False, augmentations=[T.Resize((input_size, input_size))]))
def build_train_loader(cls, cfg): return build_detection_train_loader( cfg, mapper=DatasetMapper( cfg, is_train=True, augmentations=[ # T.RandomBrightness(0.9, 1.1), # T.RandomFlip(prob=0.5, horizontal=True, vertical=False), T.RandomCrop("absolute", (640, 640)) ]))
def build_hooks(self): hooks = super().build_hooks() hooks.insert( -1, ValidationHook(self.cfg.TEST.EVAL_PERIOD, self.model, build_detection_test_loader( self.cfg, self.cfg.DATASETS.TEST[0], DatasetMapper(self.cfg, True)), patience=3)) return hooks
def build_train_loader(cls, cfg):#https://detectron2.readthedocs.io/tutorials/data_loading.html#how-the-existing-dataloader-works #return build_detection_train_loader(cfg, mapper=DatasetMapper(cfg, True)) dataloader = build_detection_train_loader(cfg, mapper=DatasetMapper(cfg, is_train=True)) #https://github.com/facebookresearch/detectron2/blob/63f11718c68f1ae951caee157b4e10fae4d7e4be/projects/DensePose/densepose/data/dataset_mapper.py #T.Augmentation #dataloader = build_detection_train_loader(cfg, mapper=DatasetMapper(cfg, is_train=True, augmentations=[])) #dataloader = build_detection_train_loader(cfg, mapper=mapper) #data_loader = build_detection_train_loader(cfg, mapper=mapper) #dataloader = build_detection_train_loader(cfg, mapper=MyDatasetMapper(cfg, is_train=True)) #dataloader = build_detection_train_loader(cfg, mapper=NewDatasetMapper(cfg, is_train=True)) #https://detectron2.readthedocs.io/_modules/detectron2/data/detection_utils.html#build_augmentation #https://github.com/facebookresearch/detectron2/blob/63f11718c68f1ae951caee157b4e10fae4d7e4be/detectron2/data/transforms/augmentation_impl.py return dataloader
def build_hooks(self): hooks = super().build_hooks() hooks.insert( -1, ValidationHook(self.cfg.TEST.EVAL_PERIOD, self.model, build_detection_train_loader( dataset=self.cfg.DATASETS.TEST[0], mapper=DatasetMapper(self.cfg, is_train=False), total_batch_size=16), patience=3)) return hooks
def build_train_loader(cfg): input_size = cfg.MODEL.CLSNET.INPUT_SIZE return build_detection_train_loader( cfg, mapper=DatasetMapper(cfg, is_train=True, augmentations=[ T.Resize((input_size, input_size)), T.RandomContrast(0.5, 1.5), T.RandomBrightness(0.5, 1.5), T.RandomSaturation(0.5, 1.5) ]))
def build_hooks(self): """ Extra hook to collect and plot evaluation metrics into TensorBoard. """ hooks = super().build_hooks() hooks.insert( -1, LossEvalHook( self.cfg.TEST.EVAL_PERIOD, self.model, build_detection_test_loader(self.cfg, self.cfg.DATASETS.TEST[0], DatasetMapper(self.cfg, True)))) return hooks
def build_train_loader(cls, cfg): return build_detection_train_loader( cfg, mapper=DatasetMapper(cfg, is_train=True, augmentations=[ T.RandomCrop("absolute_range", (300, 600)), T.RandomRotation(random.randrange(0, 360)), T.RandomContrast(0.5, 1.5), T.RandomSaturation(0.5, 1.5) ]))
def build_hooks(self): hooks = super().build_hooks() hooks.insert( -1, utils.LossEvalHook( self.cfg.TEST.EVAL_PERIOD, self.model, build_detection_test_loader(self.cfg, self.cfg.DATASETS.TEST[0], DatasetMapper(self.cfg, True)))) # swap the order of PeriodicWriter and ValidationLoss # code hangs with no GPUs > 1 if this line is removed hooks = hooks[:-2] + hooks[-2:][::-1] return hooks
def build_hooks(self): hooks = super().build_hooks() hooks.insert( -1, LossEvalHook( ONE_EPOCH, self.model, build_detection_test_loader( self.cfg, "tower_foreground_val", DatasetMapper(self.cfg, True, augmentations=build_sem_seg_train_aug( self.cfg))))) return hooks
def do_test(cfg, model): for dataset_name in cfg.DATASETS.TEST: # data_loader = build_detection_test_loader(cfg, dataset_name) if 'build_detection_test_loader': if dataset_name == 'coco_2017_val': dicts_valid: List[Dict] = DatasetCatalog.get(dataset_name) if "filter_empty and has_instances": ... ds_valid = DatasetFromList(dicts_valid, copy=False) mapper = DatasetMapper(cfg, is_train=False) else: # Open-Image-Dataset if 'get_detection_dataset_dicts': descs_get: List[Dict] = DatasetCatalog.get(dataset_name) # validation dataset is too large. random.seed(2020) descs_valid = random.choices(descs_get, k=N_IMAGES_PER_TEST) # TODO: clear cache. ds_valid = DatasetFromList(descs_valid) if 'DatasetMapper': mapper = make_mapper(dataset_name, is_train=False, augmentations=None) ds_valid = MapDataset(ds_valid, mapper) sampler = InferenceSampler(len(ds_valid)) # Always use 1 image per worker during inference since this is the # standard when reporting inference time in papers. batch_sampler = torch.utils.data.sampler.BatchSampler(sampler, 1, drop_last=False) data_loader = torch.utils.data.DataLoader( ds_valid, num_workers=cfg.DATALOADER.NUM_WORKERS, batch_sampler=batch_sampler, collate_fn=trivial_batch_collator, ) evaluator = get_evaluator2( cfg, dataset_name, os.path.join(cfg.OUTPUT_DIR, "inference", dataset_name) ) results_i = inference_on_dataset(model, data_loader, evaluator) if comm.is_main_process(): logger.info("Evaluation results for {} in csv format:".format(dataset_name)) # print_csv_format(results_i) for tsk, res in results_i.items(): res_df = pd.DataFrame(pd.Series(res, name='value')) res_df = res_df[res_df['value'].notna()] res_df.index = res_df.index.map(lambda x: '/'.join(x.split('/')[1:])) pd.set_option('display.max_rows', None) print(res_df) pd.reset_option('display.max_rows')
def build_train_loader(cls, cfg): if not cls.augs: augs = [ T.ResizeShortestEdge(cfg.INPUT.MIN_SIZE_TRAIN, cfg.INPUT.MAX_SIZE_TRAIN, cfg.INPUT.MIN_SIZE_TRAIN_SAMPLING) ] else: augs = cls.augs return build_detection_train_loader( cfg, mapper=DatasetMapper(cfg, is_train=True, augmentations=build_aug_transforms(cfg)))
def __init__(self, cfg: CfgNode, val_augmentation: Sequence[Augmentation], period: int): super().__init__() self.cfg = cfg.clone() self.cfg.DATASETS.TRAIN = cfg.DATASETS.TEST self._loader = iter( build_detection_train_loader( self.cfg, mapper=DatasetMapper(self.cfg, is_train=True, augmentations=val_augmentation), )) self._period = period self.num_steps = 0
def do_test(cfg, model): results = OrderedDict() for dataset_name in cfg.DATASETS.TEST: # perform inference on all testing dataset data_loader = build_detection_test_loader(cfg, dataset_name, mapper=DatasetMapper(cfg, False)) evaluator = get_evaluator( cfg, dataset_name, os.path.join(cfg.OUTPUT_DIR, "inference", dataset_name) ) results_i = inference_on_dataset(model, data_loader, evaluator) results[dataset_name] = results_i if comm.is_main_process(): logger.info("Evaluation results for {} in csv format:".format(dataset_name)) print_csv_format(results_i) if len(results) == 1: results = list(results.values())[0] return results
def build_train_loader(cls, cfg, dataset_dicts, curr_to_prev_filename, curr_to_prev_img_id): """ Returns: iterable It now calls :func:`detectron2.data.build_detection_train_loader`. Overwrite it if you'd like a different data loader. """ mapper = DatasetMapper(cfg, dataset_dicts=dataset_dicts, curr_to_prev_filename=curr_to_prev_filename, curr_to_prev_img_id=curr_to_prev_img_id) print(mapper.curr_to_prev_img_id) return build_detection_train_loader(cfg, mapper=mapper)
def build_train_loader1(cls, cfg: CfgNode, mapper=None): if mapper is None: mapper = DatasetMapper( cfg=cfg, is_train=True, augmentations=[ T.ResizeShortestEdge( cfg.INPUT.MIN_SIZE_TRAIN, cfg.INPUT.MAX_SIZE_TRAIN, cfg.INPUT.MIN_SIZE_TRAIN_SAMPLING, ), T.RandomCrop(cfg.INPUT.CROP.TYPE, cfg.INPUT.CROP.SIZE), T.RandomFlip(), ], ) return build_detection_train_loader(cfg, mapper=mapper)
def build_detection_test_loader(cfg, dataset_name, batch_size, mapper=None): """ Similar to `build_detection_train_loader`. But this function uses the given `dataset_name` argument (instead of the names in cfg), and uses batch size 1. Args: cfg: a detectron2 CfgNode dataset_name (str): a name of the dataset that's available in the DatasetCatalog 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, False)`. Returns: DataLoader: a torch DataLoader, that loads the given detection dataset, with test-time transformation and batching. """ dataset_dicts = get_detection_dataset_dicts( [dataset_name], filter_empty=False, proposal_files=[ cfg.DATASETS.PROPOSAL_FILES_TEST[list( cfg.DATASETS.TEST).index(dataset_name)] ] if cfg.MODEL.LOAD_PROPOSALS else None, ) dataset = DatasetFromList(dataset_dicts) if mapper is None: mapper = DatasetMapper(cfg, False) dataset = MapDataset(dataset, mapper) sampler = samplers.InferenceSampler(len(dataset)) # Always use 1 image per worker during inference since this is the # standard when reporting inference time in papers. batch_sampler = torch.utils.data.sampler.BatchSampler(sampler, batch_size, drop_last=False) data_loader = torch.utils.data.DataLoader( dataset, num_workers=cfg.DATALOADER.NUM_WORKERS, batch_sampler=batch_sampler, collate_fn=trivial_batch_collator, ) return data_loader