def build_train_loader( cls, cfg, aug_settings_file_path: str = None, aug_on: bool = True, train_val: bool = False, train_type: str = 'seg', aug_vis_save_path: str = 'aug_vis.png', show_aug_seg: bool = False, aug_n_rows: int = 3, aug_n_cols: int = 5, aug_save_dims: Tuple[int] = (3 * 500, 5 * 500), ): if aug_on: aug_seq = get_augmentation(load_path=aug_settings_file_path) aug_loader = AugmentedLoader( cfg=cfg, train_type=train_type, aug=aug_seq, aug_vis_save_path=aug_vis_save_path, show_aug_seg=show_aug_seg, aug_n_rows=aug_n_rows, aug_n_cols=aug_n_cols, aug_save_dims=aug_save_dims, ) return build_detection_train_loader(cfg, mapper=aug_loader) else: return build_detection_train_loader(cfg, mapper=None)
def build_train_loader(cls, cfg): """ Returns: iterable It now calls :func:`detectron2.data.build_detection_train_loader`. Overwrite it if you'd like a different data loader. """ if cfg.DATALOADER.MAPPER == "amodal_and_visible": return build_detection_train_loader(cfg, mapper=AmodalDatasetMapper( cfg, is_train=True)) return build_detection_train_loader(cfg)
def build_train_loader(cls, cfg): """ Returns: iterable It now calls :func:`detectron2.data.build_detection_train_loader`. Overwrite it if you'd like a different data loader. """ # _C.INPUT.MIN_SIZE_TRAIN_SAMPLING = "choice" assert len(cfg.INPUT.MIN_SIZE_TRAIN) == 1 assert cfg.INPUT.MIN_SIZE_TRAIN_SAMPLING == "choice" min_size = cfg.INPUT.MIN_SIZE_TRAIN max_size = cfg.INPUT.MAX_SIZE_TRAIN if not isinstance(min_size, int): min_size = min(min_size) tfm_gens = [] tfm_gens.append(custom_aug.ResizeWithPad((min_size, max_size))) tfm_gens.append(aug.RandomFlip(prob=0.4, horizontal=True, vertical=False)) tfm_gens.append(aug.RandomFlip(prob=0.4, horizontal=False, vertical=True)) tfm_gens.append(aug.RandomApply(aug.RandomRotation([-20, 20], expand=False), prob=0.5)) tfm_gens.append(aug.RandomApply(aug.RandomContrast(0.8, 1.2), prob=0.3)) tfm_gens.append(aug.RandomApply(aug.RandomBrightness(0.9, 1.1), prob=0.2)) mapper = DatasetMapper(cfg, True, augs=tfm_gens) return build_detection_train_loader(cfg, mapper=mapper)
def build_train_loader(cls, cfg): dataset_names = cfg.DATASETS.TRAIN return build_detection_train_loader(cfg, mapper=PlaneRCNNMapper( cfg, True, dataset_names=dataset_names))
def setup(file): # get cfg cfg = get_cfg() cfg.merge_from_file(file) cfg.SOLVER.IMS_PER_BATCH = 2 # get data loader iter data_loader = build_detection_train_loader(cfg) data_loader_iter = iter(data_loader) batched_inputs = next(data_loader_iter) # build anchors backbone = build_backbone(cfg).to(device) images = [x["image"].to(device) for x in batched_inputs] images = ImageList.from_tensors(images, backbone.size_divisibility) features = backbone(images.tensor.float()) input_shape = backbone.output_shape() in_features = cfg.MODEL.RPN.IN_FEATURES anchor_generator = build_anchor_generator( cfg, [input_shape[f] for f in in_features]) anchors = anchor_generator([features[f] for f in in_features]) anchors = Boxes.cat(anchors).to(device) # build matcher raw_matcher = Matcher(cfg.MODEL.RPN.IOU_THRESHOLDS, cfg.MODEL.RPN.IOU_LABELS, allow_low_quality_matches=True) matcher = TopKMatcher(cfg.MODEL.RPN.IOU_THRESHOLDS, cfg.MODEL.RPN.IOU_LABELS, 9) return cfg, data_loader_iter, anchors, matcher, raw_matcher
def benchmark_train(args): cfg = setup(args) model = build_model(cfg) logger.info("Model:\n{}".format(model)) if comm.get_world_size() > 1: model = DistributedDataParallel(model, device_ids=[comm.get_local_rank()], broadcast_buffers=False) optimizer = build_optimizer(cfg, model) checkpointer = DetectionCheckpointer(model, optimizer=optimizer) checkpointer.load(cfg.MODEL.WEIGHTS) cfg.defrost() cfg.DATALOADER.NUM_WORKERS = 2 data_loader = build_detection_train_loader(cfg) dummy_data = list(itertools.islice(data_loader, 100)) def f(): data = DatasetFromList(dummy_data, copy=False, serialize=False) while True: yield from data max_iter = 400 trainer = (AMPTrainer if cfg.SOLVER.AMP.ENABLED else SimpleTrainer)( model, f(), optimizer) trainer.register_hooks([ hooks.IterationTimer(), hooks.PeriodicWriter([CommonMetricPrinter(max_iter)]), hooks.TorchProfiler(lambda trainer: trainer.iter == max_iter - 1, cfg.OUTPUT_DIR, save_tensorboard=True), ]) trainer.train(1, max_iter)
def __init__(self, cfg): super().__init__() self.cfg = cfg.clone() self.cfg.DATASETS.TRAIN = cfg.DATASETS.TEST self._loader = iter(build_detection_train_loader(self.cfg)) self.best_loss = float('inf') self.weights = None
def build_train_loader(cls, cfg): """ custom dataloader to provide model with ground truth bounding boxes """ # returns a list of dicts. Every entry in the list corresponds to one sample, represented by a dict. dataset_dicts = detectron2.data.get_detection_dataset_dicts( cfg.DATASETS.TRAIN[0]) # add proposal boxes for i, s in enumerate(dataset_dicts): s["proposal_boxes"] = np.array( [ann["bbox"] for ann in dataset_dicts[i]["annotations"]] ) # np.array([[xmin, ymin, xmax, ymax],[xmin, ymin, xmax, ...], ...]) # kx4 matrix for k proposed bounding boxes s["proposal_objectness_logits"] = np.full( (s["proposal_boxes"].shape[0], ), 10) # logit of 10 is 99.999...% s["proposal_bbox_mode"] = detectron2.structures.BoxMode.XYWH_ABS # 1 # (x0, y0, w, h) in absolute floating points coordinates print("Proposal boxes added.") return build_detection_train_loader( dataset_dicts, mapper=DatasetMapper(is_train=True, augmentations=[], image_format=cfg.INPUT.FORMAT, precomputed_proposal_topk=500), total_batch_size=cfg.SOLVER.IMS_PER_BATCH, aspect_ratio_grouping=cfg.DATALOADER.ASPECT_RATIO_GROUPING, num_workers=cfg.DATALOADER.NUM_WORKERS)
def build_train_loader(cls, cfg): return build_detection_train_loader(cfg, mapper=SickTreesDatasetMapper( cfg, is_train=True, nb_channels=4, augmenter=Augmenter()))
def benchmark_data(args): cfg = setup(args) logger.info("After spawning " + RAM_msg()) timer = Timer() dataloader = build_detection_train_loader(cfg) logger.info("Initialize loader using {} seconds.".format(timer.seconds())) timer.reset() itr = iter(dataloader) for i in range(10): # warmup next(itr) if i == 0: startup_time = timer.seconds() logger.info("Startup time: {} seconds".format(startup_time)) timer = Timer() max_iter = 1000 for _ in tqdm.trange(max_iter): next(itr) logger.info("{} iters ({} images) in {} seconds.".format( max_iter, max_iter * cfg.SOLVER.IMS_PER_BATCH, timer.seconds())) # test for a few more rounds for k in range(10): logger.info(f"Iteration {k} " + RAM_msg()) timer = Timer() max_iter = 1000 for _ in tqdm.trange(max_iter): next(itr) logger.info("{} iters ({} images) in {} seconds.".format( max_iter, max_iter * cfg.SOLVER.IMS_PER_BATCH, timer.seconds()))
def build_train_loader(cls, cfg): return build_detection_train_loader(cfg, mapper=PersonalMapper( cfg, is_train=True, augmentations=[]))
def benchmark_data(args): cfg = setup(args) dataloader = build_detection_train_loader(cfg) timer = Timer() itr = iter(dataloader) for i in range(10): # warmup next(itr) if i == 0: startup_time = timer.seconds() timer = Timer() max_iter = 1000 for _ in tqdm.trange(max_iter): next(itr) logger.info( "{} iters ({} images) in {} seconds.".format( max_iter, max_iter * cfg.SOLVER.IMS_PER_BATCH, timer.seconds() ) ) logger.info("Startup time: {} seconds".format(startup_time)) vram = psutil.virtual_memory() logger.info( "RAM Usage: {:.2f}/{:.2f} GB".format( (vram.total - vram.available) / 1024 ** 3, vram.total / 1024 ** 3 ) )
def benchmark_train(args): cfg = setup(args) model = build_model(cfg) logger.info("Model:\n{}".format(model)) if comm.get_world_size() > 1: model = DistributedDataParallel( model, device_ids=[comm.get_local_rank()], broadcast_buffers=False ) optimizer = build_optimizer(cfg, model) checkpointer = DetectionCheckpointer(model, optimizer=optimizer) checkpointer.load(cfg.MODEL.WEIGHTS) cfg.defrost() cfg.DATALOADER.NUM_WORKERS = 0 data_loader = build_detection_train_loader(cfg) dummy_data = list(itertools.islice(data_loader, 100)) def f(): while True: yield from DatasetFromList(dummy_data, copy=False) max_iter = 400 trainer = SimpleTrainer(model, f(), optimizer) trainer.register_hooks( [hooks.IterationTimer(), hooks.PeriodicWriter([CommonMetricPrinter(max_iter)])] ) trainer.train(1, max_iter)
def build_train_loader(cls, cfg): try: data = data_dict[cfg.DATASETS.TRAIN[0].split('_')[0]] data_mapper = data['mapper'] if 'mapper' in list( data.keys()) else DatasetMapper except KeyError: data_mapper = DatasetMapper return build_detection_train_loader(cfg, mapper=data_mapper(cfg, True))
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_train_loader(cls, cfg): mapper = RotatedDatasetMapper(cfg) res = build._train_loader_from_config(cfg, mapper=mapper) dataset = res["dataset"] return build_detection_train_loader( dataset=dataset, mapper=mapper, total_batch_size=cfg.SOLVER.IMS_PER_BATCH)
def build_train_loader(cls, cfg): if 'coco' in cfg.DATASETS.TRAIN[0]: mapper = DqrfDatasetMapper(cfg, True) elif 'crowd' in cfg.DATASETS.TRAIN[0]: mapper = CH_DqrfDatasetMapper(cfg, True) else: mapper = None return build_detection_train_loader(cfg, mapper=mapper)
def build_train_loader(cls, cfg): """ Returns: iterable It calls :func:`detectron2.data.build_detection_train_loader` with a customized DatasetMapper, which adds categorical labels as a semantic mask. """ mapper = DatasetMapper(cfg, True) return build_detection_train_loader(cfg, mapper)
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_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): """ Returns: iterable dataloader for semi datasets. """ return build_detection_train_loader(cfg, mapper=DatasetMapper(cfg, True))
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 do_train(cfg, model, resume=False): model.train() optimizer = build_optimizer(cfg, model) scheduler = build_lr_scheduler(cfg, optimizer) checkpointer = DetectionCheckpointer( model, cfg.OUTPUT_DIR, optimizer=optimizer, scheduler=scheduler ) start_iter = ( checkpointer.resume_or_load(cfg.MODEL.WEIGHTS, resume=resume).get("iteration", -1) + 1 ) max_iter = cfg.SOLVER.MAX_ITER periodic_checkpointer = PeriodicCheckpointer( checkpointer, cfg.SOLVER.CHECKPOINT_PERIOD, max_iter=max_iter ) writers = default_writers(cfg.OUTPUT_DIR, max_iter) if comm.is_main_process() else [] # compared to "train_net.py", we do not support accurate timing and # precise BN here, because they are not trivial to implement in a small training loop data_loader = build_detection_train_loader(cfg) logger.info("Starting training from iteration {}".format(start_iter)) with EventStorage(start_iter) as storage: for data, iteration in zip(data_loader, range(start_iter, max_iter)): storage.iter = iteration loss_dict = model(data) losses = sum(loss_dict.values()) assert torch.isfinite(losses).all(), loss_dict loss_dict_reduced = {k: v.item() for k, v in comm.reduce_dict(loss_dict).items()} losses_reduced = sum(loss for loss in loss_dict_reduced.values()) if comm.is_main_process(): storage.put_scalars(total_loss=losses_reduced, **loss_dict_reduced) optimizer.zero_grad() losses.backward() optimizer.step() storage.put_scalar("lr", optimizer.param_groups[0]["lr"], smoothing_hint=False) scheduler.step() if ( cfg.TEST.EVAL_PERIOD > 0 and (iteration + 1) % cfg.TEST.EVAL_PERIOD == 0 and iteration != max_iter - 1 ): do_test(cfg, model) # Compared to "train_net.py", the test results are not dumped to EventStorage comm.synchronize() if iteration - start_iter > 5 and ( (iteration + 1) % 20 == 0 or iteration == max_iter - 1 ): for writer in writers: writer.write() periodic_checkpointer.step(iteration)
def build_train_loader(cls, cfg): """ Returns: iterable It now calls :func:`detectron2.data.build_detection_train_loader`. Overwrite it if you'd like a different data loader. """ return build_detection_train_loader(cfg)
def build_train_loader(cls, cfg, aug_settings_file_path: str = None, aug_on: bool = True, train_val: bool = False, train_type: str = 'seg', aug_vis_save_path: str = 'aug_vis.png', show_aug_seg: bool = False): if aug_on: aug_seq = get_augmentation(load_path=aug_settings_file_path) aug_loader = AugmentedLoader(cfg=cfg, train_type=train_type, aug=aug_seq, aug_vis_save_path=aug_vis_save_path, show_aug_seg=show_aug_seg) return build_detection_train_loader(cfg, mapper=aug_loader) else: return build_detection_train_loader(cfg, mapper=None)
def build_train_loader(cls, cfg, mapper=None): if cfg.ISPRS.MODE != "COCO": dataset_name = cfg.DATASETS.TRAIN[0] if mapper is None: mapper = ISPRSOnlineTrainMapper(cfg, True) func = DatasetCatalog[dataset_name] isprs = func(cfg, cfg.SOLVER.IMS_PER_BATCH, mapper=mapper, dataset_name=dataset_name) return isprs elif cfg.ISPRS.LABEL.BOXMODE == "ROTATED": # mapper = ISPRSCOCOStyleMapperRotated(cfg,is_train = True, augmentations = [T.ISPRSRandomRotation([0,360])] ) mapper = ISPRSCOCOStyleMapperRotated(cfg, is_train=True) return build_detection_train_loader(cfg, mapper=mapper) else: mapper = ISPRSCOCOStyleMapperAxisAligned(cfg, is_train=True) return build_detection_train_loader(cfg, mapper=mapper)
def __init__(self, cfg: CfgNode, dataset_name: str, trainer: DefaultTrainer, steps: int=10, ndata: int=5): super().__init__() self.cfg = cfg.clone() self.cfg.DATASETS.TRAIN = (dataset_name, ) self._loader = iter(build_detection_train_loader(self.cfg)) self.trainer = trainer self.steps = steps self.ndata = ndata self.loss_dict = {} self.data_time = 0
def build_train_loader(cls, cfg): """ Builds DataLoader for train set. Args: cfg(CfgNode): a detectron2 CfgNode Returns: detectron2 DataLoader object specific to the train set. """ return build_detection_train_loader(cfg)
def build_train_loader(cls, cfg): if cfg.MODE == "caffe": return build_detection_train_loader(cfg, mapper=DatasetMapper( cfg, True)) elif cfg.MODE == "d2": return build_detection_train_loader_with_attributes(cfg) else: raise Exception("detectron mode note supported: {}".format( args.model))