def trace_model_from_checkpoint(logdir, method_name): config_path = logdir / "configs/_config.json" checkpoint_path = logdir / "checkpoints/best.pth" print("Load config") config: Dict[str, dict] = safitty.load(config_path) # Get expdir name config_expdir = Path(config["args"]["expdir"]) # We will use copy of expdir from logs for reproducibility expdir_from_logs = Path(logdir) / "code" / config_expdir.name print("Import experiment and runner from logdir") ExperimentType, RunnerType = \ import_experiment_and_runner(expdir_from_logs) experiment: Experiment = ExperimentType(config) print("Load model state from checkpoints/best.pth") model = experiment.get_model(next(iter(experiment.stages))) checkpoint = UtilsFactory.load_checkpoint(checkpoint_path) UtilsFactory.unpack_checkpoint(checkpoint, model=model) print("Tracing") traced = trace_model(model, experiment, RunnerType, method_name) print("Done") return traced
def trace_model_from_checkpoint(logdir, logger, method_name='forward'): config_path = f'{logdir}/configs/_config.json' checkpoint_path = f'{logdir}/checkpoints/best.pth' logger.info('Load config') config = safitty.load(config_path) if 'distributed_params' in config: del config['distributed_params'] # Get expdir name # noinspection SpellCheckingInspection,PyTypeChecker # We will use copy of expdir from logs for reproducibility expdir_name = os.path.basename(config['args']['expdir']) expdir_from_logs = os.path.abspath(join(logdir, '../', expdir_name)) logger.info('Import experiment and runner from logdir') ExperimentType, RunnerType = \ import_experiment_and_runner(Path(expdir_from_logs)) experiment: Experiment = ExperimentType(config) logger.info('Load model state from checkpoints/best.pth') model = experiment.get_model(next(iter(experiment.stages))) checkpoint = utils.load_checkpoint(checkpoint_path) utils.unpack_checkpoint(checkpoint, model=model) logger.info('Tracing') traced = trace_model(model, experiment, RunnerType, method_name) logger.info('Done') return traced
def trace_model_from_checkpoint(logdir, logger, method_name='forward', file='best'): config_path = f'{logdir}/configs/_config.json' checkpoint_path = f'{logdir}/checkpoints/{file}.pth' logger.info('Load config') config = safitty.load(config_path) if 'distributed_params' in config: del config['distributed_params'] # Get expdir name # noinspection SpellCheckingInspection,PyTypeChecker # We will use copy of expdir from logs for reproducibility expdir_name = config['args']['expdir'] logger.info(f'expdir_name from args: {expdir_name}') sys.path.insert(0, os.path.abspath(join(logdir, '../'))) expdir_from_logs = os.path.abspath(join(logdir, '../', expdir_name)) logger.info(f'expdir_from_logs: {expdir_from_logs}') logger.info('Import experiment and runner from logdir') ExperimentType, RunnerType = \ import_experiment_and_runner(Path(expdir_from_logs)) experiment: Experiment = ExperimentType(config) logger.info(f'Load model state from checkpoints/{file}.pth') model = experiment.get_model(next(iter(experiment.stages))) checkpoint = utils.load_checkpoint(checkpoint_path) utils.unpack_checkpoint(checkpoint, model=model) device = 'cpu' stage = list(experiment.stages)[0] loader = 0 mode = 'eval' requires_grad = False opt_level = None runner: RunnerType = RunnerType() runner.model, runner.device = model, device batch = experiment.get_native_batch(stage, loader) logger.info('Tracing') traced = trace_model( model, runner, batch, method_name=method_name, mode=mode, requires_grad=requires_grad, opt_level=opt_level, device=device, ) logger.info('Done') return traced
def __init__(self, in_dir: Path, out_dir: Path, index2color: Path): self.in_dir = in_dir self.out_dir = out_dir index2color = safitty.load(args.index2color) self.index2color = { int(key): tuple(value) for key, value in index2color.items() }
def prepare_splits(args): tag2class = dict(safitty.load(args.labeling)) df_with_labels = map_dataframe(pd.read_csv(args.df), tag_column="class", class_column="label", tag2class=tag2class, verbose=False) train_data, val_data = train_test_split(df_with_labels, random_state=args.seed, test_size=args.test) train_data.to_csv(os.path.join(args.out_path, 'train.csv'), index=False) val_data.to_csv(os.path.join(args.out_path, 'valid.csv'), index=False)
def get_configs(): parser = ArgumentParser() parser.add_argument("-c", "--config", type=str, required=True) parser.add_argument( "-d", "--dump", type=str, required=False, default=None, help="File to dump results to", ) args = parser.parse_args() return safitty.load(args.config), args.dump
def __init__(self, in_dir: Path, out_dir: Path, index2color: Path): """Constructor method for the :class:`Preprocessor` class. Args: in_dir (Path): path to folder with input masks out_dir (Path): path to folder to store processed masks index2color (Path): path to file with mapping from mask index to mask color, look at COCO dataset for details """ self.in_dir = in_dir self.out_dir = out_dir index2color = safitty.load(args.index2color) self.index2color = { int(key): tuple(value) for key, value in index2color.items() }
def main(args, _=None): logits = np.load(args.in_npy, mmap_mode="r") probs = softmax(logits) confidence = np.max(probs, axis=1) preds = np.argmax(logits, axis=1) df_infer = pd.read_csv(args.in_csv_infer) df_train = pd.read_csv(args.in_csv_train) df_infer["filename"] = df_infer["filepath"].map(lambda x: Path(x).name) df_train["filename"] = df_train["filepath"].map(lambda x: Path(x).name) tag2lbl = safitty.load(args.in_tag2cls) cls2tag = {int(v): k for k, v in tag2lbl.items()} df_infer["tag"] = [cls2tag[x] for x in preds] df_infer["confidence"] = confidence train_filepath = df_train["filename"].tolist() df_infer = df_infer[~df_infer["filename"].isin(train_filepath)] if df_infer.shape[0] == 0: raise NotImplementedError( "Pseudo Labeling done. Nothing more to label.") counter_ = 0 for _, row in df_infer.iterrows(): if row["confidence"] < args.threshold: continue filepath_src = args.in_dir / row["filepath"] filename = filepath_src.name filepath_dst = args.out_dir / row["tag"] / filename filepath_dst.parent.mkdir(parents=True, exist_ok=True) shutil.copy2(filepath_src, filepath_dst) counter_ += 1 print(f"Predicted: {counter_} ({100 * counter_ / len(df_infer):2.2f}%)") if counter_ == 0: raise NotImplementedError( "Pseudo Labeling done. Nothing more to label.")
def trace_model_from_checkpoint( logdir: Path, method_name: str, checkpoint_name: str, mode: str = "eval", requires_grad: bool = False, ): config_path = logdir / "configs" / "_config.json" checkpoint_path = logdir / "checkpoints" / f"{checkpoint_name}.pth" print("Load config") config: Dict[str, dict] = safitty.load(config_path) # Get expdir name config_expdir = safitty.get(config, "args", "expdir", apply=Path) # We will use copy of expdir from logs for reproducibility expdir = Path(logdir) / "code" / config_expdir.name print("Import experiment and runner from logdir") ExperimentType, RunnerType = import_experiment_and_runner(expdir) experiment: Experiment = ExperimentType(config) print(f"Load model state from checkpoints/{checkpoint_name}.pth") model = experiment.get_model(next(iter(experiment.stages))) checkpoint = utils.load_checkpoint(checkpoint_path) utils.unpack_checkpoint(checkpoint, model=model) print("Tracing") traced = trace_model( model, experiment, RunnerType, method_name=method_name, mode=mode, requires_grad=requires_grad, ) print("Done") return traced
def render_config( in_template: Path, out_config: Path, expdir: Path, dataset_path: Path, num_workers: int, batch_size: int, max_image_size: int, balance_strategy: str, criterion: str, ): _template_path = in_template.absolute().parent _env = Environment(loader=FileSystemLoader([str(_template_path)]), trim_blocks=True, lstrip_blocks=True) template = _env.get_template(in_template.name) tag2class = safitty.load(dataset_path / "tag2class.json") num_classes = len(tag2class) class_names = [ key for key, _ in sorted(tag2class.items(), key=lambda x: x[1]) ] out_config.parent.mkdir(parents=True, exist_ok=True) out_config.write_text( template.render(expdir=str(expdir), dataset_path=str(dataset_path), num_classes=num_classes, class_names=class_names, num_workers=num_workers, batch_size=batch_size, max_image_size=max_image_size, balance_strategy=balance_strategy, criterion=criterion))
from argparse import ArgumentParser, Namespace import safitty import pytorch_lightning as pl from pl_model import LightningModel if __name__ == "__main__": parser = ArgumentParser() parser.add_argument("-c", "--configs", required=True) args = parser.parse_args() configs = safitty.load(args.configs) configs = Namespace(**configs) model = LightningModel(hparams=configs) trainer = pl.Trainer.from_argparse_args( configs, fast_dev_run=False, early_stop_callback=True, default_root_dir=configs.default_root_dir, ) trainer.fit(model)
def get_datasets( self, stage: str, datapath: str = None, in_csv: str = None, in_csv_train: str = None, in_csv_valid: str = None, in_csv_infer: str = None, train_folds: str = None, valid_folds: str = None, tag2class: str = None, class_column: str = None, tag_column: str = None, folds_seed: int = 42, n_folds: int = 5, one_hot_classes: int = None, balance_strategy: str = "upsampling", ): datasets = collections.OrderedDict() tag2class = safitty.load(tag2class) if tag2class is not None else None df, df_train, df_valid, df_infer = read_csv_data( in_csv=in_csv, in_csv_train=in_csv_train, in_csv_valid=in_csv_valid, in_csv_infer=in_csv_infer, train_folds=train_folds, valid_folds=valid_folds, tag2class=tag2class, class_column=class_column, tag_column=tag_column, seed=folds_seed, n_folds=n_folds, ) open_fn = [ ImageReader( input_key="filepath", output_key="image", rootpath=datapath ) ] if stage.startswith('infer'): open_fn.append(ScalarReader( input_key="filepath", output_key="filepath", default_value=-1, dtype=np.str, )) else: open_fn.append(ScalarReader( input_key="class", output_key="targets", default_value=-1, dtype=np.int64, )) if one_hot_classes: open_fn.append( ScalarReader( input_key="class", output_key="targets_one_hot", default_value=-1, dtype=np.int64, one_hot_classes=one_hot_classes, ) ) open_fn = ReaderCompose(readers=open_fn) for source, mode in zip( (df_train, df_valid, df_infer), ("train", "valid", "infer") ): if source is not None and len(source) > 0: dataset = ListDataset( source, open_fn=open_fn, dict_transform=self.get_transforms( stage=stage, dataset=mode ), ) if mode == "train": labels = [x["class"] for x in source] sampler = BalanceClassSampler( labels, mode=balance_strategy ) dataset = {"dataset": dataset, "sampler": sampler} datasets[mode] = dataset if stage == 'infer': datasets['infer'] = datasets['valid'] del datasets['valid'] if 'train' in datasets: del datasets['train'] return datasets
if scheduler_name not in schedulers.keys(): raise KeyError(f'{scheduler_name} is not a valid criterion. Please provide one of: {schedulers.keys()}') return schedulers[scheduler_name](**scheduler_params, optimizer=optimizer_) # @TODO: add metrics support # (catalyst expects logits, rather than sigmoid outputs) # metrics = [ # smp.utils.metrics.IoUMetric(eps=1.), # smp.utils.metrics.FscoreMetric(eps=1.), # ] if __name__ == '__main__': args = parse_args() config = safitty.load(args.config_path) runner = SupervisedWandbRunner() model = get_model( model_name=safitty.get(config, 'model', 'name', default='unet'), model_params=safitty.get(config, 'model', 'params', default={})) criterion = get_criterion( criterion_name=safitty.get(config, 'criterion', 'name', default='bce_dice'), criterion_params=safitty.get(config, 'criterion', 'params', default={})) optimizer = get_optimizer( optimizer_name=safitty.get(config, 'optimizer', 'name', default='adam'), optimizer_params=safitty.get(config, 'optimizer', 'params', default={}), model_=model)
def parse_args() -> Namespace: parser = ArgumentParser() parser.add_argument("-c", "--configs", type=str, required=True) args = parser.parse_args() configs = safitty.load(args.configs) return Namespace(**configs)
def get_configs(): parser = ArgumentParser() parser.add_argument("-c", "--config", type=str, required=True) args = parser.parse_args() return safitty.load(args.config)
def trace_model_from_checkpoint( logdir: Path, method_name: str, checkpoint_name: str, stage: str = None, loader: Union[str, int] = None, mode: str = "eval", requires_grad: bool = False, opt_level: str = None, device: Device = "cpu", ): """ Traces model using created experiment and runner. Args: logdir (Union[str, Path]): Path to Catalyst logdir with model checkpoint_name (str): Name of model checkpoint to use stage (str): experiment's stage name loader (Union[str, int]): experiment's loader name or its index method_name (str): Model's method name that will be used as entrypoint during tracing mode (str): Mode for model to trace (``train`` or ``eval``) requires_grad (bool): Flag to use grads opt_level (str): AMP FP16 init level device (str): Torch device Returns: the traced model """ config_path = logdir / "configs" / "_config.json" checkpoint_path = logdir / "checkpoints" / f"{checkpoint_name}.pth" print("Load config") config: Dict[str, dict] = safitty.load(config_path) runner_params = config.pop("runner_params", {}) or {} # Get expdir name config_expdir = safitty.get(config, "args", "expdir", apply=Path) # We will use copy of expdir from logs for reproducibility expdir = Path(logdir) / "code" / config_expdir.name print("Import experiment and runner from logdir") ExperimentType, RunnerType = utils.import_experiment_and_runner(expdir) experiment: Experiment = ExperimentType(config) print(f"Load model state from checkpoints/{checkpoint_name}.pth") if stage is None: stage = list(experiment.stages)[0] model = experiment.get_model(stage) checkpoint = utils.load_checkpoint(checkpoint_path) utils.unpack_checkpoint(checkpoint, model=model) runner: RunnerType = RunnerType(**runner_params) runner.model, runner.device = model, device if loader is None: loader = 0 batch = experiment.get_native_batch(stage, loader) print("Tracing") traced = trace.trace_model( model=model, runner=runner, batch=batch, method_name=method_name, mode=mode, requires_grad=requires_grad, opt_level=opt_level, device=device, ) print("Done") return traced