def main(cfg):
OmegaConf.set_struct(cfg, False)
# Get device
device = torch.device("cuda" if (torch.cuda.is_available() and cfg.cuda) else "cpu")
log.info("DEVICE : {}".format(device))
# Enable CUDNN BACKEND
torch.backends.cudnn.enabled = cfg.enable_cudnn
# Checkpoint
checkpoint = ModelCheckpoint(cfg.checkpoint_dir, cfg.model_name, cfg.weight_name, strict=True)
# Create model and datasets
dataset = instantiate_dataset(checkpoint.data_config)
model = checkpoint.create_model(dataset, weight_name=cfg.weight_name)
log.info(model)
log.info("Model size = %i", sum(param.numel() for param in model.parameters() if param.requires_grad))
# Set dataloaders
dataset.create_dataloaders(
model, cfg.batch_size, cfg.shuffle, cfg.num_workers, cfg.precompute_multi_scale,
)
log.info(dataset)
model.eval()
if cfg.enable_dropout:
model.enable_dropout_in_eval()
model = model.to(device)
tracker: BaseTracker = dataset.get_tracker(model, dataset, False, False)
# Run training / evaluation
run(cfg, model, dataset, device, tracker, checkpoint)
def main(cfg):
OmegaConf.set_struct(cfg, False)
# Get device
device = torch.device("cuda" if (
torch.cuda.is_available() and cfg.cuda) else "cpu")
log.info("DEVICE : {}".format(device))
# Enable CUDNN BACKEND
torch.backends.cudnn.enabled = cfg.enable_cudnn
# Checkpoint
checkpoint = ModelCheckpoint(cfg.checkpoint_dir,
cfg.model_name,
cfg.weight_name,
strict=True)
# Setup the dataset config
# Generic config
train_dataset_cls = get_dataset_class(checkpoint.data_config)
setattr(checkpoint.data_config, "class", train_dataset_cls.FORWARD_CLASS)
setattr(checkpoint.data_config, "dataroot", cfg.input_path)
# Datset specific configs
if cfg.data:
for key, value in cfg.data.items():
checkpoint.data_config.update(key, value)
# Create dataset and mdoel
dataset = instantiate_dataset(checkpoint.data_config)
model = checkpoint.create_model(dataset, weight_name=cfg.weight_name)
log.info(model)
log.info(
"Model size = %i",
sum(param.numel() for param in model.parameters()
if param.requires_grad))
# Set dataloaders
dataset.create_dataloaders(
model,
cfg.batch_size,
cfg.shuffle,
cfg.num_workers,
False,
)
log.info(dataset)
model.eval()
if cfg.enable_dropout:
model.enable_dropout_in_eval()
model = model.to(device)
# Run training / evaluation
if not os.path.exists(cfg.output_path):
os.makedirs(cfg.output_path)
run(model, dataset, device, cfg.output_path)
def __init__(self, checkpoint_dir, model_name, weight_name, feat_name, num_classes=None, mock_dataset=True):
# Checkpoint
from src.datasets.base_dataset import BaseDataset
from src.datasets.dataset_factory import instantiate_dataset
checkpoint = model_checkpoint.ModelCheckpoint(checkpoint_dir, model_name, weight_name, strict=True)
if mock_dataset:
dataset = MockDataset(num_classes)
dataset.num_classes = num_classes
else:
dataset = instantiate_dataset(checkpoint.data_config)
BaseDataset.set_transform(self, checkpoint.data_config)
self.model = checkpoint.create_model(dataset, weight_name=weight_name)
self.model.eval()
def main(cfg):
OmegaConf.set_struct(
cfg,
False) # This allows getattr and hasattr methods to function correctly
if cfg.pretty_print:
print(cfg.pretty())
set_debugging_vars_to_global(cfg.debugging)
# Get device
device = torch.device("cuda" if (
torch.cuda.is_available() and cfg.training.cuda) else "cpu")
log.info("DEVICE : {}".format(device))
# Enable CUDNN BACKEND
torch.backends.cudnn.enabled = cfg.training.enable_cudnn
dataset = instantiate_dataset(cfg.data)
model = instantiate_model(cfg, dataset)
log.info(model)
log.info(
"Model size = %i",
sum(param.numel() for param in model.parameters()
if param.requires_grad))
# Set dataloaders
dataset.create_dataloaders(
model,
cfg.training.batch_size,
cfg.training.shuffle,
cfg.training.num_workers,
cfg.training.precompute_multi_scale,
)
log.info(dataset)
# Run training / evaluation
model = model.to(device)
measurement_name = "{}_{}".format(cfg.model_name,
dataset.__class__.__name__)
run(cfg, model, dataset, device, measurement_name)
def main(cfg):
OmegaConf.set_struct(cfg, False)
# Get device
device = torch.device("cuda" if (
torch.cuda.is_available() and cfg.cuda) else "cpu")
log.info("DEVICE : {}".format(device))
# Enable CUDNN BACKEND
torch.backends.cudnn.enabled = cfg.enable_cudnn
# Checkpoint
checkpoint = ModelCheckpoint(cfg.checkpoint_dir,
cfg.model_name,
cfg.weight_name,
strict=True)
# Setup the dataset config
# Generic config
dataset = instantiate_dataset(cfg.data)
model = checkpoint.create_model(dataset, weight_name=cfg.weight_name)
log.info(model)
log.info(
"Model size = %i",
sum(param.numel() for param in model.parameters()
if param.requires_grad))
log.info(dataset)
model.eval()
if cfg.enable_dropout:
model.enable_dropout_in_eval()
model = model.to(device)
# Run training / evaluation
output_path = os.path.join(cfg.checkpoint_dir, cfg.data.name, "features")
if not os.path.exists(output_path):
os.makedirs(output_path, exist_ok=True)
run(model, dataset, device, output_path, cfg)
def main(cfg):
OmegaConf.set_struct(
cfg,
False) # This allows getattr and hasattr methods to function correctly
if cfg.pretty_print:
print(cfg.pretty())
# Get device
device = torch.device("cuda" if (
torch.cuda.is_available() and cfg.training.cuda) else "cpu")
log.info("DEVICE : {}".format(device))
# Enable CUDNN BACKEND
torch.backends.cudnn.enabled = cfg.training.enable_cudnn
# Start Wandb if public
launch_wandb(cfg, cfg.wandb.public and cfg.wandb.log)
# Checkpoint
checkpoint = ModelCheckpoint(
cfg.training.checkpoint_dir,
cfg.model_name,
cfg.training.weight_name,
run_config=cfg,
resume=bool(cfg.training.checkpoint_dir),
)
# Create model and datasets
if not checkpoint.is_empty:
dataset = instantiate_dataset(checkpoint.data_config)
model = checkpoint.create_model(dataset,
weight_name=cfg.training.weight_name)
else:
dataset = instantiate_dataset(cfg.data)
model = instantiate_model(cfg, dataset)
model.instantiate_optimizers(cfg)
log.info(model)
model.log_optimizers()
log.info(
"Model size = %i",
sum(param.numel() for param in model.parameters()
if param.requires_grad))
# Set dataloaders
dataset.create_dataloaders(
model,
cfg.training.batch_size,
cfg.training.shuffle,
cfg.training.num_workers,
cfg.training.precompute_multi_scale,
)
log.info(dataset)
# Choose selection stage
selection_stage = getattr(cfg, "selection_stage", "")
checkpoint.selection_stage = dataset.resolve_saving_stage(selection_stage)
tracker: BaseTracker = dataset.get_tracker(model, dataset, cfg.wandb.log,
cfg.tensorboard.log)
launch_wandb(cfg, not cfg.wandb.public and cfg.wandb.log)
# Run training / evaluation
model = model.to(device)
visualizer = Visualizer(cfg.visualization, dataset.num_batches,
dataset.batch_size, os.getcwd())
run(cfg, model, dataset, device, tracker, checkpoint, visualizer)
