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
