def main(save_path=cfg.save, n_epochs=cfg.n_epochs, seed=cfg.seed):
if seed is not None:
set_seed(cfg.seed)
cudnn.benchmark = True
os.makedirs(save_path)
copy_file_backup(save_path)
# Datasets
train_set = LIDCDataset(crop_size=48,
move=5,
data_path=env.data,
train=True)
valid_set = None
test_set = LIDCDataset(crop_size=48,
move=5,
data_path=env.data,
train=False)
# # Models
model = FCNResNet18(pretrained=cfg.pretrained, num_classes=2)
# model = UNet(num_classes=2)
torch.save(model.state_dict(), os.path.join(save_path, 'model.dat'))
# Train the model
train(model=model,
train_set=train_set,
valid_set=valid_set,
test_set=test_set,
save=save_path,
n_epochs=n_epochs)
print('Done!')
def main(save_path=cfg.save, n_epochs=cfg.n_epochs, seed=cfg.seed):
if seed is not None:
set_seed(cfg.seed)
cudnn.benchmark = True
os.makedirs(save_path)
copy_file_backup(save_path)
# Datasets
train_set = datasets
valid_set = None
test_set = datasets
# # Models
model = torchvision.models.resnet18(pretrained=True, num_classes=6)
torch.save(model.state_dict(), os.path.join(save_path, 'model.dat'))
# Train the model
train(model=model,
train_set=train_set,
valid_set=valid_set,
test_set=test_set,
save=save_path,
n_epochs=n_epochs)
print('Done!')
def main(save_path=cfg.save, n_epochs=cfg.n_epochs, seed=cfg.seed):
# set seed
if seed is not None:
set_seed(cfg.seed)
cudnn.benchmark = True
# back up your code
os.makedirs(save_path)
copy_file_backup(save_path)
redirect_stdout(save_path)
# Datasets
train_set = LIDCSegDataset(crop_size=48,
move=5,
data_path=env.data,
train=True)
valid_set = None
test_set = LIDCSegDataset(crop_size=48,
move=5,
data_path=env.data,
train=False)
# Define model
model_dict = {
'resnet18': FCNResNet,
'vgg16': FCNVGG,
'densenet121': FCNDenseNet
}
model = model_dict[cfg.backbone](pretrained=cfg.pretrained,
num_classes=2,
backbone=cfg.backbone)
# convert to counterparts and load pretrained weights according to various convolution
if cfg.conv == 'ACSConv':
model = model_to_syncbn(ACSConverter(model))
if cfg.conv == 'Conv2_5d':
model = model_to_syncbn(Conv2_5dConverter(model))
if cfg.conv == 'Conv3d':
if cfg.pretrained_3d == 'i3d':
model = model_to_syncbn(Conv3dConverter(model, i3d_repeat_axis=-3))
else:
model = model_to_syncbn(
Conv3dConverter(model, i3d_repeat_axis=None))
if cfg.pretrained_3d == 'video':
model = load_video_pretrained_weights(
model, env.video_resnet18_pretrain_path)
elif cfg.pretrained_3d == 'mednet':
model = load_mednet_pretrained_weights(
model, env.mednet_resnet18_pretrain_path)
print(model)
torch.save(model.state_dict(), os.path.join(save_path, 'model.dat'))
# train and test the model
train(model=model,
train_set=train_set,
valid_set=valid_set,
test_set=test_set,
save=save_path,
n_epochs=n_epochs)
print('Done!')
def main(
save_path=cfg.save, # configuration file
n_epochs=cfg.n_epochs,
seed=cfg.seed):
# set seed
if seed is not None:
set_seed(cfg.seed)
cudnn.benchmark = True # improve efficiency
# back up your code
os.makedirs(save_path)
copy_file_backup(save_path)
redirect_stdout(save_path)
# Datasets
valid_set = None
test_set = CACTwoClassDataset(crop_size=[48, 48, 48],
data_path=env.data,
datatype=2,
fill_with=-1)
# Define model
model_dict = {
'resnet18': ClsResNet,
'vgg16': ClsVGG,
'densenet121': ClsDenseNet
}
model = model_dict[cfg.backbone](pretrained=cfg.pretrained,
num_classes=2,
backbone=cfg.backbone)
# convert to counterparts and load pretrained weights according to various convolution
if cfg.conv == 'ACSConv':
model = model_to_syncbn(ACSConverter(model))
if cfg.conv == 'Conv2_5d':
model = model_to_syncbn(Conv2_5dConverter(model))
if cfg.conv == 'Conv3d':
if cfg.pretrained_3d == 'i3d':
model = model_to_syncbn(Conv3dConverter(model, i3d_repeat_axis=-3))
else:
model = model_to_syncbn(
Conv3dConverter(model, i3d_repeat_axis=None))
if cfg.pretrained_3d == 'video':
model = load_video_pretrained_weights(
model, env.video_resnet18_pretrain_path)
elif cfg.pretrained_3d == 'mednet':
model = load_mednet_pretrained_weights(
model, env.mednet_resnet18_pretrain_path)
# print(model)
torch.save(model.state_dict(), os.path.join(save_path, 'model.dat'))
model_path = '/cluster/home/it_stu167/wwj/classification_after_crop/result/CACClass/resnet18/ACSConv/48_1-2_m0/epoch_107/model.dat'
model.load_state_dict(torch.load(model_path))
# train and test the model
train(model=model,
valid_set=valid_set,
test_set=test_set,
save=save_path,
n_epochs=n_epochs)
print('Done!')
def main(save_path=cfg.save, n_epochs=cfg.n_epochs, seed=cfg.seed):
if seed is not None:
set_seed(cfg.seed)
cudnn.benchmark = True
os.makedirs(save_path)
copy_file_backup(save_path)
redirect_stdout(save_path)
# Datasets
train_data = env.data_train
test_data = env.data_test
shape_cp = env.shape_checkpoint
train_set = BaseDatasetVoxel(train_data, cfg.train_samples)
valid_set = None
test_set = BaseDatasetVoxel(test_data, 200)
# # Models
model = UNet(6)
if cfg.conv == 'Conv3D':
model = Conv3dConverter(model)
initialize(model.modules())
elif cfg.conv == 'Conv2_5D':
if cfg.pretrained:
shape_cp = torch.load(shape_cp)
shape_cp.popitem()
shape_cp.popitem()
incompatible_keys = model.load_state_dict(shape_cp, strict=False)
print('load shape pretrained weights\n', incompatible_keys)
model = Conv2_5dConverter(model)
elif cfg.conv == 'ACSConv':
# You can use either the naive ``ACSUNet`` or the ``ACSConverter(model)``
model = ACSConverter(model)
# model = ACSUNet(6)
if cfg.pretrained:
shape_cp = torch.load(shape_cp)
shape_cp.popitem()
shape_cp.popitem()
incompatible_keys = model.load_state_dict(shape_cp, strict=False)
print('load shape pretrained weights\n', incompatible_keys)
else:
raise ValueError('not valid conv')
print(model)
torch.save(model.state_dict(), os.path.join(save_path, 'model.dat'))
# Train the model
train(model=model,
train_set=train_set,
valid_set=valid_set,
test_set=test_set,
save=save_path,
n_epochs=n_epochs)
print('Done!')
def main(save_path=cfg.save,
n_epochs=cfg.n_epochs,
seed=cfg.seed,
groupmodel=merge.groupmodel,
canal=canal):
if seed is not None:
set_seed(cfg.seed)
cudnn.benchmark = True
# # Models
os.makedirs(save_path, exist_ok=True)
#copy_file_backup(save_path)
redirect_stdout(save_path)
# Datasets
train_data = env.data_train
test_data = env.data_test
shape_cp = env.shape_checkpoint
#val_data=env.data_test
train_set = BaseDatasetVoxel(train_data, cfg.train_samples)
valid_set = None
test_set = BaseDatasetVoxel(test_data, cfg.test_samples)
model = groupmodel[canal]
#model= MyEnsemble()
print(model)
#print(save_path)
#torch.save(model.state_dict(), os.path.join(save_path,'canal_{}'.format(canal), 'model.dat'))
# Train the model
train(model=model,
train_set=train_set,
valid_set=valid_set,
test_set=test_set,
save=save_path,
n_epochs=n_epochs,
canal=canal)
elapsed = timeit.default_timer() - start_time
print(elapsed)
print(os.path.join(save_path, 'canal_{}'.format(canal), 'model.dat'))
print('canal_{}' + format(canal) + 'Done!')
def main(save_path=cfg.save, n_epochs=cfg.n_epochs, seed=cfg.seed):
# set seed
if seed is not None:
set_seed(cfg.seed)
cudnn.benchmark = True
# back up your code
os.makedirs(save_path)
copy_file_backup(save_path)
redirect_stdout(save_path)
# Datasets
train_set = CACSegDataset(crop_size=[48, 48, 48],
data_path=env.data,
random=cfg.random,
datatype=0)
valid_set = CACSegDataset(crop_size=[48, 48, 48],
data_path=env.data,
random=cfg.random,
datatype=1)
test_set = CACSegDataset(crop_size=[48, 48, 48],
data_path=env.data,
random=cfg.random,
datatype=2)
# Define model
model_dict = {
'resnet18': FCNResNet,
'resnet34': FCNResNet,
'resnet50': FCNResNet,
'resnet101': FCNResNet,
'vgg16': FCNVGG,
'densenet121': FCNDenseNet,
'unet': UNet
}
model = model_dict[cfg.backbone](pretrained=cfg.pretrained,
num_classes=3,
backbone=cfg.backbone,
checkpoint=cfg.checkpoint) # modified
# model.load_state_dict(torch.load('/cluster/home/it_stu167/wwj/classification_after_crop/result/CACSeg/resnet18/ACSConv/200911_104150_pretrained/model.dat'))
# convert to counterparts and load pretrained weights according to various convolution
if cfg.conv == 'ACSConv':
model = model_to_syncbn(ACSConverter(model))
if cfg.conv == 'Conv2_5d':
model = model_to_syncbn(Conv2_5dConverter(model))
if cfg.conv == 'Conv3d':
if cfg.pretrained_3d == 'i3d':
model = model_to_syncbn(Conv3dConverter(model, i3d_repeat_axis=-3))
else:
model = model_to_syncbn(
Conv3dConverter(model, i3d_repeat_axis=None))
if cfg.pretrained_3d == 'video':
model = load_video_pretrained_weights(
model, env.video_resnet18_pretrain_path)
elif cfg.pretrained_3d == 'mednet':
model = load_mednet_pretrained_weights(
model, env.mednet_resnet18_pretrain_path)
# print(model)
torch.save(model.state_dict(), os.path.join(save_path, 'model.dat'))
# train and test the model
train(model=model,
train_set=train_set,
valid_set=valid_set,
test_set=test_set,
save=save_path,
n_epochs=n_epochs)
print('Done!')
def main(save_path=cfg.save_path):
# back up your code
backup_code(save_path)
# set seed
set_seed(cfg.seed)
# accelaration
torch.backends.cudnn.benchmark = True
# Datasets
train_set = LIDCSegDataset(crop_size=48, move=5, data_path=env.data, train=True)
test_set = LIDCSegDataset(crop_size=48, move=5, data_path=env.data, train=False)
train_loader = DataLoader(train_set, batch_size=cfg.batch_size, shuffle=True,
pin_memory=(torch.cuda.is_available()), num_workers=cfg.num_workers)
test_loader = DataLoader(test_set, batch_size=cfg.batch_size, shuffle=False,
pin_memory=(torch.cuda.is_available()), num_workers=cfg.num_workers)
# Define model
model_dict = {'resnet18': FCNResNet, 'vgg16': FCNVGG, 'densenet121': FCNDenseNet}
model = model_dict[cfg.backbone](pretrained=cfg.pretrained, num_classes=2, backbone=cfg.backbone)
print(model)
torch.save(model.state_dict(), os.path.join(save_path, 'model.dat'))
# Model on cuda and then wrap model for multi-GPUs, if necessary
model = to_device(model)
if torch.cuda.is_available() and torch.cuda.device_count() > 1:
if cfg.use_syncbn:
print('Using sync-bn')
model_wrapper = DataParallelWithCallback(model).cuda()
else:
model_wrapper = torch.nn.DataParallel(model).cuda()
else:
model_wrapper = model
# optimizer and scheduler
optimizer = getattr(torch.optim, cfg.optimizer_choice)(model_wrapper.parameters(), lr=cfg.optimizer_lr)
scheduler = torch.optim.lr_scheduler.MultiStepLR(optimizer, milestones=cfg.scheduler_milestones,
gamma=cfg.scheduler_gamma)
results_logger = ResultsLogger(save_path, train_log_items=[] , test_log_items=[])
# train and test the model
best_dice_global = 0
global iteration
iteration = 0
for epoch in range(n_epochs):
# os.makedirs(os.path.join(cfg.save, 'epoch_{}'.format(epoch)))
print('learning rate: ', scheduler.get_lr())
train_results = train_epoch(model=model_wrapper, loader=train_loader, optimizer=optimizer,
epoch=epoch, results_logger=results_logger)
test_results = test_epoch(model=model_wrapper, loader=test_loader, epoch=epoch, results_logger=results_logger)
scheduler.step()
results_logger.log_epoch(train_results, test_results)
# save model checkpoint
if cfg.save_all:
torch.save(model.state_dict(), os.path.join(save, 'epoch_{}'.format(epoch), 'model.dat'))
if > best_dice_global:
torch.save(model.state_dict(), os.path.join(save, 'best_model.dat'))
best_dice_global =
print('New best global dice: %.4f' % )
else:
print('Current best global dice: %.4f' % best_dice_global)
results_logger.close(best_result=best_dice_global)
print('best global dice: ', best_dice_global)
print('Done!')
def main(
save_path=cfg.save, # configuration file
n_epochs=cfg.n_epochs,
seed=cfg.seed):
# set seed
if seed is not None:
set_seed(cfg.seed)
cudnn.benchmark = True # improve efficiency
# back up your code
os.makedirs(save_path)
copy_file_backup(save_path)
redirect_stdout(save_path)
# Datasets
train_set = CACTwoClassDataset(crop_size=[48, 48, 48],
data_path=env.data,
datatype=0,
fill_with=-1)
test_set = CACTwoClassDataset(crop_size=[48, 48, 48],
data_path=env.data,
datatype=1,
fill_with=-1)
# Define model
model_dict = {
'resnet18': ClsResNet,
'resnet34': ClsResNet,
'resnet50': ClsResNet,
'resnet101': ClsResNet,
'resnet152': ClsResNet,
'vgg16': ClsVGG,
'densenet121': ClsDenseNet
}
model = model_dict[cfg.backbone](pretrained=cfg.pretrained,
num_classes=2,
backbone=cfg.backbone,
checkpoint=cfg.checkpoint,
pooling=cfg.pooling)
# convert to counterparts and load pretrained weights according to various convolution
if cfg.conv == 'ACSConv':
model = model_to_syncbn(ACSConverter(model))
if cfg.conv == 'Conv2_5d':
model = model_to_syncbn(Conv2_5dConverter(model))
if cfg.conv == 'Conv3d':
if cfg.pretrained_3d == 'i3d':
model = model_to_syncbn(Conv3dConverter(model, i3d_repeat_axis=-3))
else:
model = model_to_syncbn(
Conv3dConverter(model, i3d_repeat_axis=None))
if cfg.pretrained_3d == 'video':
model = load_video_pretrained_weights(
model, env.video_resnet18_pretrain_path)
elif cfg.pretrained_3d == 'mednet':
model = load_mednet_pretrained_weights(
model, env.mednet_resnet18_pretrain_path)
# print(model)
torch.save(model.state_dict(), os.path.join(save_path, 'model.dat'))
# torch.save(model.state_dict(), os.path.join(save_path, 'model.pth'))
# train and test the model
train(model=model,
train_set=train_set,
test_set=test_set,
save=save_path,
n_epochs=n_epochs)
print('Done!')
