def test_k_folds_sizes(self): """check that k_folds returns training/test pairs of the desired sizes""" data = np.zeros((23,2)) expected_combs = [ [np.zeros((18,2)), np.zeros((5,2))], [np.zeros((18,2)), np.zeros((5,2))], [np.zeros((18,2)), np.zeros((5,2))], [np.zeros((19,2)), np.zeros((4,2))], [np.zeros((19,2)), np.zeros((4,2))]] combinations = k_folds(data, num_folds=5) for pairing1, pairing2 in zip(expected_combs, combinations): assert_lists_of_ndarrays_equal(pairing1, pairing2)
def test_k_folds(self):
"""check that fold_combinations returns a list of every
possible training-test pairing formed by joining k-1 folds
into the training set and the remaining fold into the test
set."""
fold1 = sample_fold(0, 5, 2)
fold2 = sample_fold(1, 5, 2)
fold3 = sample_fold(2, 5, 2)
data = np.concatenate((fold1, fold2))
data = np.concatenate((data, fold3))
expected_combs = [[np.concatenate((fold2, fold3), axis=0), fold1],
[np.concatenate((fold1, fold3), axis=0), fold2],
[np.concatenate((fold1, fold2), axis=0), fold3]]
combinations = k_folds(data, num_folds=3)
for pairing1, pairing2 in zip(expected_combs, combinations):
assert_lists_of_ndarrays_equal(pairing1, pairing2)
def test_k_folds_sizes(self):
"""check that k_folds returns training/test pairs of the
desired sizes"""
data = np.zeros((23, 2))
expected_combs = [[np.zeros((18, 2)),
np.zeros((5, 2))],
[np.zeros((18, 2)),
np.zeros((5, 2))],
[np.zeros((18, 2)),
np.zeros((5, 2))],
[np.zeros((19, 2)),
np.zeros((4, 2))],
[np.zeros((19, 2)),
np.zeros((4, 2))]]
combinations = k_folds(data, num_folds=5)
for pairing1, pairing2 in zip(expected_combs, combinations):
assert_lists_of_ndarrays_equal(pairing1, pairing2)
def test_k_folds(self): """check that fold_combinations returns a list of every possible training-test pairing formed by joining k-1 folds into the training set and the remaining fold into the test set.""" fold1 = sample_fold(0,5,2) fold2 = sample_fold(1,5,2) fold3 = sample_fold(2,5,2) data = np.concatenate((fold1, fold2)) data = np.concatenate((data, fold3)) expected_combs = [ [np.concatenate((fold2,fold3), axis=0), fold1], [np.concatenate((fold1,fold3), axis=0), fold2], [np.concatenate((fold1,fold2), axis=0), fold3]] combinations = k_folds(data, num_folds=3) for pairing1, pairing2 in zip(expected_combs, combinations): assert_lists_of_ndarrays_equal(pairing1, pairing2)
def run():
print(torch.__version__)
num_folds = args.cv
num_samples = sum(1 for line in open(args.data))
loss_weights = get_label_weight_ratio(args.data)
#num_samples = sum(1 for line in open(os.path.join(args.data, 'train')))
#loss_weights = get_label_weight_ratio(os.path.join(args.data, 'val'))
#print("loss weights based on val set: {}".format(loss_weights))
f.write('Class dependent loss weight:\n')
f.write('{}\n'.format(loss_weights))
# loss_weights = [1,1,1,1,1]
# TODO: mechanism to load params via json file
model = get_model(os.path.join(args.savepath, args.hyper), loss_weights)
total_params = sum(p.numel() for p in model.parameters()
if p.requires_grad)
print('Total params is {}'.format(total_params))
print('Model hyperram: {}'.format(model.get_params()))
if torch.cuda.is_available():
model = model.cuda()
optimizer = optim.Adam(model.parameters(), lr=model.lr)
defaultepoch = 1
if args.load == 1:
model.load_state_dict(torch.load(args.loadpath))
if args.load == 2:
checkpoint = torch.load(args.loadpath)
model.load_state_dict(checkpoint['model_state_dict'])
optimizer.load_state_dict(checkpoint['optimizer_state_dict'])
defaultepoch = checkpoint['epoch']
loss = checkpoint['loss']
if args.inference:
indices = np.arange(num_samples).tolist()
data = data_loader.get_loader(filename=args.data,
indices=indices,
batch_size=model.batch_size)
inference(model, data)
return
if (num_folds > 0):
for train_idx, val_idx in k_folds(n_splits=num_folds,
n_samples=num_samples):
data_train = data_loader.get_loader(filename=args.data,
indices=train_idx,
batch_size=model.batch_size)
data_val = data_loader.get_loader(filename=args.data,
indices=val_idx,
batch_size=model.batch_size)
for epoch in range(1, args.epochs + 1):
train(model, data_train, optimizer, epoch)
stop_early = evaluate(model, data_val, epoch)
else:
timelist = []
data_train, data_val = train_val_split(num_samples, 0.8,
model.batch_size)
#data_train = data_loader.get_loader(filename=os.path.join(args.data,'train'), indices=np.array([]), batch_size=model.batch_size)
#data_val = data_loader.get_loader(filename=os.path.join(args.data,'val'), indices=np.array([]), batch_size=model.batch_size)
early_stopping = None
if not args.noearlystopping:
early_stopping = EarlyStopping(patience=20,
verbose=True,
save_mode=args.save,
runname=args.runname,
save_path=args.savepath)
for epoch in range(defaultepoch, args.epochs + 1):
time_glob = time.time()
train(model, data_train, optimizer, epoch)
stop_early = evaluate(model, data_train, data_val, epoch,
early_stopping)
time_ep = time.time() - time_glob
print('Epoch time {}'.format(time_ep))
timelist.append(time_ep)
if stop_early:
break
# save model param
if not args.inference:
with open(
os.path.join(args.savepath,
args.runname + '_hyperparameters.json'),
'w') as fp:
json.dump(model.get_params(), fp)
total = sum(timelist)
print('Average training time: {}, total time: {}'.format(
total / len(timelist), total))
from data import data_transforms
train_dataset = datasets.ImageFolder('data/train_images',
transform=data_transforms)
val_loader = torch.utils.data.DataLoader(datasets.ImageFolder(
'data/val_images', transform=data_transforms),
batch_size=args.batch_size,
shuffle=False,
num_workers=1)
# Neural network and optimizer
# We define neural net in model.py so that it can be reused by the evaluate.py script
import model as md
for fold, (train_idx, test_idx) in enumerate(k_folds(n_splits=10)):
train_loader = torch.utils.data.DataLoader(torch.utils.data.Subset(
train_dataset, train_idx),
batch_size=args.batch_size,
shuffle=True,
num_workers=1)
val_loader = torch.utils.data.DataLoader(torch.utils.data.Subset(
train_dataset, test_idx),
batch_size=args.batch_size,
shuffle=False,
num_workers=1)
model = md.DenseNet161()
if use_cuda:
print('Using GPU')
def main(epochs, batch_size, learning_rate):
total_train_loss = 0
total_val_loss = 0
train_loss_seg = np.zeros(5)
val_loss_seg = np.zeros(5)
for train_list, test_list in k_folds(n_splits=4, subjects=41):
# Loading train data
train_loader = torch.utils.data.DataLoader(SegThorDataset(
"/home/WIN-UNI-DUE/smnemada/Master_Thesis/SegThor/data_sub/train_cv",
phase='train',
transform=transforms.Compose(
[Rescale(1.0), Normalize(),
ToTensor2()]),
file_list=train_list),
batch_size=batch_size,
shuffle=False)
# Loading validation data
val_set = SegThorDataset(
"/home/WIN-UNI-DUE/smnemada/Master_Thesis/SegThor/data_sub/train_cv",
phase='val',
transform=transforms.Compose(
[Rescale(1.0), Normalize(),
ToTensor2()]),
file_list=test_list)
val_loader = torch.utils.data.DataLoader(dataset=val_set,
batch_size=1,
shuffle=False)
device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
model = UNet().to(device)
model.apply(weight_init)
#optimizer = optim.Adam(model.parameters(), lr=learning_rate) #learning rate to 0.001 for initial stage
optimizer = optim.SGD(model.parameters(),
lr=0.01,
momentum=0.9,
weight_decay=0.00001)
#optimizer = adabound.AdaBound(params = model.parameters(), lr = 0.001, final_lr = 0.1)
for epoch in range(epochs):
print('Epoch {}/{}'.format(epoch + 1, epochs))
print('-' * 10)
train_loss, train_loss_label = train(train_loader, model,
optimizer, epoch, device,
batch_size, train_list)
val_loss, val_loss_label = validation(val_loader, model, epoch,
device, batch_size,
test_list)
if val_loss < train_loss:
os.makedirs("models", exist_ok=True)
torch.save(model, "models/model.pt")
# Save model output
#save_results(epoch, device)
if epoch % 4 == 0:
os.makedirs("models", exist_ok=True)
torch.save(model, "models/model.pt")
total_train_loss = total_train_loss + train_loss
total_val_loss = total_val_loss + val_loss
train_loss_seg = train_loss_seg + train_loss_label
val_loss_seg = val_loss_seg + val_loss_label
#evaluate_model(epoch, device)
train_loss_seg = np.true_divide(train_loss_seg, 4)
val_loss_seg = np.true_divide(val_loss_seg, 4)
print(" Training Loss: ")
print(total_train_loss // epochs)
print(
"Background = {:.4f} Eusophagus = {:.4f} Heart = {:.4f} Trachea = {:.4f} Aorta = {:.4f}\n"
.format(train_loss_seg[0], train_loss_seg[1], train_loss_seg[2],
train_loss_seg[3], train_loss_seg[4]))
print(" Validation Loss: ")
print(total_val_loss // epochs)
print(
"Background = {:.4f} Eusophagus = {:.4f} Heart = {:.4f} Trachea = {:.4f} Aorta = {:.4f}\n"
.format(val_loss_seg[0], val_loss_seg[1], val_loss_seg[2],
val_loss_seg[3], val_loss_seg[4]))
