def main(dataset_name, n_epochs):
dataset = dataset_prep(load_dataset(join(join(dataset_loc,'Flukes/patches'),dataset_name)))
img_dir = join(dataset_loc,'Flukes/CRC_combined constrained')
batch_size = 32
losses = {}
epoch_losses = []
batch_losses = []
img_shape = (87,240)
patch_layer, descriptor_layer, match_layer = build_siamese_whole(img_shape)
iter_funcs = similarity_iter(patch_layer, match_layer, {'learning_rate':1e-2}, match_layer_w=0.5)
batch_loader = partial(img_batch_loader, img_dir, img_shape)
for epoch in range(n_epochs):
tic = time.time()
print("Epoch %d" % epoch)
loss = train_epoch(iter_funcs, dataset, batch_size=batch_size, batch_loader=batch_loader)
epoch_losses.append(loss['train_loss'])
batch_losses.append(loss['all_train_loss'])
# shuffle training set
dataset['train'] = shuffle_dataset(dataset['train'])
toc = time.time() - tic
print("Train loss (reg): %0.3f\nTrain loss: %0.3f\nValid loss: %0.3f" %
(loss['train_reg_loss'],loss['train_loss'],loss['valid_loss']))
print("Took %0.2f seconds" % toc)
batch_losses = list(chain(*batch_losses))
losses['batch'] = batch_losses
losses['epoch'] = epoch_losses
parameter_analysis(match_layer)
desc = desc_func(descriptor_layer)
def main(dataset_name, n_epochs):
with open('../dataset_loc','r') as f:
dataset_loc = f.read().rstrip()
all_datasets = dataset_prep(load_dataset(join(join(dataset_loc,'Flukes/patches'),dataset_name)))
batch_size = 32
desc_funcs = {}
losses = {}
for patch_type in all_datasets:
epoch_losses = []
batch_losses = []
patch_layer, descriptor_layer, match_layer = build_siamese_separate_similarity()
iter_funcs = similarity_iter(patch_layer, match_layer, {'learning_rate':1e-2}, match_layer_w=0.)
for epoch in range(n_epochs):
tic = time.time()
print("%s: Epoch %d" % (patch_type, epoch))
loss = train_epoch(iter_funcs, all_datasets[patch_type], batch_size=batch_size)
epoch_losses.append(loss['train_loss'])
batch_losses.append(loss['all_train_loss'])
# shuffle training set
all_datasets[patch_type]['train'] = shuffle_dataset(all_datasets[patch_type]['train'])
toc = time.time() - tic
print("Train loss (reg): %0.3f\nTrain loss: %0.3f\nValid loss: %0.3f" %
(loss['train_reg_loss'],loss['train_loss'],loss['valid_loss']))
print("Took %0.2f seconds" % toc)
batch_losses = list(chain(*batch_losses))
losses[patch_type] = {}
losses[patch_type]['batch'] = batch_losses
losses[patch_type]['epoch'] = epoch_losses
print(patch_type)
parameter_analysis(match_layer)
desc_funcs[patch_type] = desc_func(descriptor_layer)
display_losses(losses, n_epochs, batch_size, all_datasets['notch']['train']['X1'].shape[0])
# Evaluate train rank accuracy and val rank accuracy
identifier_eval_dataset = load_identifier_eval(join(join(dataset_loc,'Flukes/patches'),dataset_name))
norm_idmap = normalize_image_idmap(identifier_eval_dataset['idmap'])
#check_for_dupes(identifier_eval_dataset['idmap'])
print("Identification performance train:")
print_cdfs(identifier_eval(desc_funcs, identifier_eval_dataset['train'], norm_idmap))
print("Identification performance valid:")
print_cdfs(identifier_eval(desc_funcs, identifier_eval_dataset['val'], norm_idmap))
num_workers=args.n_threads,
sampler=LimitedRandomSampler(
train_ds, N_batches, args.bs))
else:
train_loader = data.DataLoader(train_ds,
batch_size=args.bs,
num_workers=args.n_threads,
shuffle=True)
print(colored('==> ', 'blue') + 'Epoch:', epoch + 1, cur_snapshot)
# Adjusting learning rate using the scheduler
optimizer, cur_lr = adjust_learning_rate(optimizer, epoch + 1, args)
print(colored('==> ', 'red') + 'LR:', cur_lr)
# Training one epoch and measure the time
start = time.time()
train_loss = train_epoch(epoch, net, optimizer, train_loader,
criterion, args.n_epoch)
epoch_time = np.round(time.time() - start, 4)
print(
colored('==> ', 'green') +
'Epoch training time: {} s.'.format(epoch_time))
# If it is time to start the validation, we will do it
# args.args.start_val can be used to avoid time-consuming validation
# in the beginning of the training
if epoch >= args.start_val:
start = time.time()
val_loss, probs, truth, _ = validate_epoch(net, val_loader,
criterion)
preds = probs.argmax(1)
# Validation metrics
cm = confusion_matrix(truth, preds)
best_dice = 0
prev_model = None
train_started = time.time()
batch_size = 64
n_epochs = 3
max_ep = n_epochs
start_val = 0
for epoch in range(n_epochs):
train_ds = KneeGradingDataset(dataset, transform=augment_transforms)
train_loader = data.DataLoader(train_ds,
batch_size=batch_size,
shuffle=True)
start = time.time()
train_loss = train_epoch(epoch, net, optimizer, train_loader,
criterion, n_epochs, USE_CUDA)
epoch_time = np.round(time.time() - start, 4)
print(
colored('==> ', 'green') +
'Epoch training time: {} s.'.format(epoch_time))
if epoch >= start_val:
start = time.time()
val_loss, probs, truth, _ = validate_epoch(net, val_loader,
criterion, USE_CUDA)
preds = probs.argmax(1)
# Validation metrics
cm = confusion_matrix(truth, preds)
kappa = np.round(
cohen_kappa_score(truth, preds, weights="quadratic"), 4)
acc = np.round(
test_loader = DataLoader(ds_test, batch_size=2048, shuffle=False)
#########################
# Model, Optimizer, Loss#
#########################
model = Model(hidden_size=hidden_size,
input_size=input_size,
dropout_rate=dropout_rate).to(DEVICE)
optimizer = torch.optim.Adam(model.parameters(), lr=learning_rate)
loss_func = nn.MSELoss()
n_epochs = 100 # Number of training epochs
for i in range(n_epochs):
train_epoch(model, optimizer, tr_loader, loss_func, i + 1, DEVICE)
obs, preds = eval_model(model, val_loader, DEVICE)
preds = ds_val.local_rescale(preds.cpu().numpy(), variable="output")
nse = calc_nse(obs.cpu().numpy(), preds)
tqdm.write(f"Validation NSE: {nse:.2f}")
# Evaluate on test set
obs, preds = eval_model(model, test_loader, DEVICE)
preds = ds_val.local_rescale(preds.cpu().numpy(), variable="output")
obs = obs.cpu().numpy()
nse = calc_nse(obs, preds)
if nse > max_nse:
max_nse = nse
best_features = features
# Plot results
start_date = ds_test.dates[0]
#batch_maker = {k:partial(make_batch, dataset=dset[k], actives=active_triplets[k]) for k in ['train','valid']}
else:
print("Number of pairs: %r" % ({k:len(dset[k]['y']) for k in dset}))
train_pairs_shuffled = {k:shuffle_dataset({part:dset[k][part] for part in ['pairs','y']})
for k in ['train','valid']}
assert(all(train_pairs_shuffled['train']['y'] ==
map(lambda x: int(dset['train']['ids'][x[0]] == dset['train']['ids'][x[1]]),
train_pairs_shuffled['train']['pairs'])))
dataset = train_pairs_shuffled
batch_maker = {k:partial(FUNCTIONS[options.loss_type]['bm'], dataset=dset[k]) for k in ['train','valid']}
batch_loader = partial(FUNCTIONS[options.loss_type]['nonaug_bl'], batch_maker=batch_maker)
# so we're going to just give dset as
loss = train_epoch(iter_funcs, dataset, batch_size, batch_loader, layer_names=layer_names)
epoch_losses.append(loss['train_loss'])
batch_losses.append(loss['all_train_loss'])
toc = time.time() - tic
print("Learning rate: %0.5f" % momentum_params['l_r'].get_value())
print("Train loss (reg): %0.3f\nTrain loss: %0.3f\nValid loss: %0.3f" %
(loss['train_reg_loss'],loss['train_loss'],loss['valid_loss']))
print("Train %s failed: %s\nValid %s failed: %s" % (options.loss_type, loss['train_acc'],
options.loss_type, loss['valid_acc'],))
if loss['valid_loss'] < best_val_loss:
best_params = ll.get_all_param_values(embedder)
best_val_loss = loss['valid_loss']
print("New best validation loss!")
print("Took %0.2f seconds" % toc)
except KeyboardInterrupt:
print("Training interrupted, save model? y/n")
if options.resume and exists(model_path):
params = ut.load_cPkl(model_path)
ll.set_all_param_values(segmenter, params)
#iter_funcs = loss_iter(segmenter, update_params={'learning_rate':.01})
lr = theano.shared(np.array(0.010, dtype=np.float32))
momentum_params = {'l_r':lr, 'momentum':0.9}
iter_funcs = loss_iter(segmenter, update_params=momentum_params)
best_params = ll.get_all_param_values(segmenter)
best_val_loss = np.inf
layer_names = [p.name for p in ll.get_all_params(segmenter, trainable=True)]
save_model = True
try:
for epoch in range(n_epochs):
tic = time.time()
print("Epoch %d" % (epoch))
loss = train_epoch(iter_funcs, dset, batch_size, augmenting_batch_loader, layer_names=layer_names)
epoch_losses.append(loss['train_loss'])
batch_losses.append(loss['all_train_loss'])
# shuffle training set
dset['train'] = shuffle_dataset(dset['train'])
toc = time.time() - tic
print("Learning rate: %0.5f" % momentum_params['l_r'].get_value())
print("Train loss (reg): %0.3f\nTrain loss: %0.3f\nValid loss: %0.3f" %
(loss['train_reg_loss'],loss['train_loss'],loss['valid_loss']))
print("Train Pixel Precision @0.5: %s\nValid Pixel Precision @0.5: %s" % (loss['train_acc'], loss['valid_acc']))
if loss['valid_loss'] < best_val_loss:
best_params = ll.get_all_param_values(segmenter)
best_val_loss = loss['valid_loss']
print("New best validation loss!")
print("Took %0.2f seconds" % toc)
except KeyboardInterrupt:
epoch_losses = []
batch_losses = []
segmenter = build_segmenter_vgg()
model_path = join(dataset_loc, "Flukes/patches/%s/model.pkl" % dset_name)
if options.resume and exists(model_path):
with open(model_path, 'r') as f:
params = pickle.load(f)
ll.set_all_param_values(segmenter, params)
#iter_funcs = loss_iter(segmenter, update_params={'learning_rate':.01})
iter_funcs = loss_iter(segmenter, update_params={})
best_params = ll.get_all_param_values(segmenter)
best_val_loss = np.inf
for epoch in range(n_epochs):
tic = time.time()
print("Epoch %d" % (epoch))
loss = train_epoch(iter_funcs, dset, batch_size=batch_size)
epoch_losses.append(loss['train_loss'])
batch_losses.append(loss['all_train_loss'])
# shuffle training set
dset['train'] = shuffle_dataset(dset['train'])
toc = time.time() - tic
print("Train loss (reg): %0.3f\nTrain loss: %0.3f\nValid loss: %0.3f" %
(loss['train_reg_loss'],loss['train_loss'],loss['valid_loss']))
print("Train acc: %0.3f\nValid acc: %0.3f" % (loss['train_acc'], loss['valid_acc']))
if loss['valid_loss'] < best_val_loss:
best_params = ll.get_all_param_values(segmenter)
best_val_loss = loss['valid_loss']
print("New best validation loss!")
print("Took %0.2f seconds" % toc)
batch_losses = list(chain(*batch_losses))
losses = {}