def main():
# Load configuration
config = load_config()
# Create the model
model = get_model(config)
# Load model state
model_path = config['model_path']
logger.info(f'Loading model from {model_path}...')
utils.load_checkpoint(model_path, model)
# use DataParallel if more than 1 GPU available
device = config['device']
if torch.cuda.device_count() > 1 and not device.type == 'cpu':
model = nn.DataParallel(model)
logger.info(f'Using {torch.cuda.device_count()} GPUs for prediction')
logger.info(f"Sending the model to '{device}'")
model = model.to(device)
output_dir = config['loaders'].get('output_dir', None)
if output_dir is not None:
os.makedirs(output_dir, exist_ok=True)
logger.info(f'Saving predictions to: {output_dir}')
for test_loader in get_test_loaders(config):
logger.info(f"Processing '{test_loader.dataset.file_path}'...")
output_file = _get_output_file(dataset=test_loader.dataset,
output_dir=output_dir)
predictor = _get_predictor(model, test_loader, output_file, config)
# run the model prediction on the entire dataset and save to the 'output_file' H5
predictor.predict()
def main():
# Load and log experiment configuration
config = load_config()
logger.info(config)
manual_seed = config.get('manual_seed', None)
if manual_seed is not None:
logger.info(f'Seed the RNG for all devices with {manual_seed}')
torch.manual_seed(manual_seed)
# see https://pytorch.org/docs/stable/notes/randomness.html
torch.backends.cudnn.deterministic = True
torch.backends.cudnn.benchmark = False
# create trainer
default_trainer_builder_class = 'UNet3DTrainerBuilder'
trainer_builder_class = config['trainer'].get(
'builder', default_trainer_builder_class)
trainer_builder = get_class(trainer_builder_class,
modules=['pytorch3dunet.unet3d.trainer'])
trainer = trainer_builder.build(config)
# trainer_builder = UNet3DTrainerBuilder()
# trainer = trainer_builder.build(config)
# Start training
trainer.fit()
def main():
# Load configuration
config = load_config()
# Create the model
model = get_model(config['model'])
# Load model state
model_path = config['model_path']
logger.info(f'Loading model from {model_path}...')
utils.load_checkpoint(model_path, model)
# use DataParallel if more than 1 GPU available
device = config['device']
if torch.cuda.device_count() > 1 and not device.type == 'cpu':
model = nn.DataParallel(model)
logger.info(f'Using {torch.cuda.device_count()} GPUs for prediction')
logger.info(f"Sending the model to '{device}'")
model = model.to(device)
output_dir = config['loaders'].get('output_dir', None)
if output_dir is not None:
os.makedirs(output_dir, exist_ok=True)
logger.info(f'Saving predictions to: {output_dir}')
# create predictor instance
predictor = _get_predictor(model, output_dir, config)
for test_loader in get_test_loaders(config):
# run the model prediction on the test_loader and save the results in the output_dir
predictor(test_loader)
def main():
parser = ArgumentParser()
parser.add_argument("-r",
"--runconfig",
dest='runconfig',
type=str,
required=True,
help=f"The run config yaml file")
parser.add_argument("-n",
"--numworkers",
dest='numworkers',
type=int,
required=True,
help=f"Number of workers")
parser.add_argument("-d",
"--device",
dest='device',
type=str,
required=False,
help=f"Device")
args = parser.parse_args()
runconfig = args.runconfig
nworkers = int(args.numworkers)
# Load configuration
config = load_config(runconfig, nworkers, args.device)
# Create the model
model = get_model(config['model'])
# Load model state
model_path = config['model_path']
logger.info(f'Loading model from {model_path}...')
utils.load_checkpoint(model_path, model)
# use DataParallel if more than 1 GPU available
device = config['device']
if torch.cuda.device_count() > 1 and not device.type == 'cpu':
model = nn.DataParallel(model)
logger.info(f'Using {torch.cuda.device_count()} GPUs for prediction')
logger.info(f"Sending the model to '{device}'")
model = model.to(device)
output_dir = config['loaders'].get('output_dir', None)
if output_dir is not None:
os.makedirs(output_dir, exist_ok=True)
logger.info(f'Saving predictions to: {output_dir}')
# create predictor instance
predictor = _get_predictor(model, output_dir, config)
for test_loader in get_test_loaders(config):
# run the model prediction on the test_loader and save the results in the output_dir
predictor(test_loader)
def main():
# Load and log experiment configuration
config = load_config()
logger.info(config)
manual_seed = config.get('manual_seed', None)
if manual_seed is not None:
logger.info(f'Seed the RNG for all devices with {manual_seed}')
torch.manual_seed(manual_seed)
# see https://pytorch.org/docs/stable/notes/randomness.html
torch.backends.cudnn.deterministic = True
torch.backends.cudnn.benchmark = False
# Create the model
model = get_model(config)
# use DataParallel if more than 1 GPU available
device = config['device']
if torch.cuda.device_count() > 1 and not device.type == 'cpu':
model = nn.DataParallel(model)
logger.info(f'Using {torch.cuda.device_count()} GPUs for training')
# put the model on GPUs
logger.info(f"Sending the model to '{config['device']}'")
model = model.to(device)
# Log the number of learnable parameters
logger.info(
f'Number of learnable params {get_number_of_learnable_parameters(model)}'
)
# Create loss criterion
loss_criterion = get_loss_criterion(config)
# Create evaluation metric
eval_criterion = get_evaluation_metric(config)
# Create data loaders
loaders = get_train_loaders(config)
# Create the optimizer
optimizer = _create_optimizer(config, model)
# Create learning rate adjustment strategy
lr_scheduler = _create_lr_scheduler(config, optimizer)
# Create model trainer
trainer = _create_trainer(config,
model=model,
optimizer=optimizer,
lr_scheduler=lr_scheduler,
loss_criterion=loss_criterion,
eval_criterion=eval_criterion,
loaders=loaders)
# Start training
trainer.fit()
def main():
# Load and log experiment configuration
config = load_config()
logger.info(config)
manual_seed = config.get('manual_seed', None)
if manual_seed is not None:
logger.info(f'Seed the RNG for all devices with {manual_seed}')
logger.warning('Using CuDNN deterministic setting. This may slow down the training!')
random.seed(manual_seed)
torch.manual_seed(manual_seed)
# see https://pytorch.org/docs/stable/notes/randomness.html
torch.backends.cudnn.deterministic = True
# create trainer
trainer = create_trainer(config)
# Start training
trainer.fit()
def main():
# Load configuration
config = load_config()
# Create the model
model = get_model(config)
# Load model state
model_path = config['model_path']
logger.info(f'Loading model from {model_path}...')
utils.load_checkpoint(model_path, model)
# use DataParallel if more than 1 GPU available
device = config['device']
if torch.cuda.device_count() > 1 and not device.type == 'cpu':
model = nn.DataParallel(model)
logger.info(f'Using {torch.cuda.device_count()} GPUs for prediction')
logger.info(f"Sending the model to '{device}'")
model = model.to(device)
param_count = 0
for param in model.parameters():
param_count += param.view(-1).size()[0]
logger.info(f"parmeter {param_count}!!!!!!!!!!!!!!!!!!!!")
logger.info('Loading HDF5 datasets...')
for test_loader in hdf5.get_test_loaders(config):
logger.info(f"Processing '{test_loader.dataset.file_path}'...")
output_file = _get_output_file(test_loader.dataset)
predictor = _get_predictor(model, test_loader, output_file, config)
# run the model prediction on the entire dataset and save to the 'output_file' H5
predictor.predict()
path = './predict_h5/'
output_path = './predict_npz/'
datalist = os.listdir(path)
for i in datalist:
file = h5py.File(path + i, 'r')
ar = file['predictions'][1, :, :, :]
new_ar = np.exp(ar) / np.sum(np.exp(file['predictions']), axis=0)
np.savez(output_path + i[0:-4] + '.npz', prediction=new_ar)
def main():
# Load configuration
config = load_config()
# Create the model
model = get_model(config)
# Load model state
model_path = config['model_path']
logger.info(f'Loading model from {model_path}...')
utils.load_checkpoint(model_path, model)
logger.info(f"Sending the model to '{config['device']}'")
model = model.to(config['device'])
logger.info('Loading HDF5 datasets...')
for test_loader in get_test_loaders(config):
logger.info(f"Processing '{test_loader.dataset.file_path}'...")
output_file = _get_output_file(test_loader.dataset)
predictor = _get_predictor(model, test_loader, output_file, config)
# run the model prediction on the entire dataset and save to the 'output_file' H5
predictor.predict()
