""" Author: Mélanie Gaillochet Date: 2020-11-23 """ from comet_ml import Experiment import copy import os import time from collections import defaultdict import numpy as np import pandas as pd from tqdm import tqdm import matplotlib.pyplot as plt from skimage.measure import find_contours import torch import torch.nn.functional as F import torch.optim as optim import torch.utils.data from torch.cuda.amp import GradScaler from Enums.loss_enum import losses from Enums.metric_enum import metrics from Utils.optimizer_utils import create_optimizer from Utils.scheduler_utils import create_scheduler from Utils.utils import add_dic_values, to_onehot, defaultinf, default0 from Utils.train_utils import compute_metrics, compute_mean_value, print_epoch_update # , read_data from Samplers.sampler_random import RandomSampler from Samplers.sampler_TTA import TestTimeAugmentationSampler from Samplers.sampler_entropy import PredictionEntropySampler from Samplers.sampler_coreset import CoresetsSampler from Samplers.sampler_dropout import DropoutSampler class BaseSolver: """ This is the base solver class for AL strategies used on the same model In solver, the following need to be defined: - (function) train_step - (function) validation - (function) sample_for_labeling - (variable) self.loss_name_list # name of model losses """ def __init__(self, config, test_dataloader, **kwargs): self.config = config self.selection_config = self.config['data_selection'] self.device = kwargs.get('device') self.saver = kwargs.get('saver') # We define the data (labeled and val) self.querry_dataloader = kwargs.get('querry_dataloader') self.querry_iter = iter(self.querry_dataloader) self.val_dataloader = kwargs.get('val_dataloader') self.test_dataloader = test_dataloader print('Training on batches of size {}, Validating on {} samples, Testing ' 'on {} samples'.format(self.config['batch_size'], len(self.val_dataloader) * self.val_dataloader.batch_size, len(self.test_dataloader) * self.test_dataloader.batch_size)) # For test results in 3D self.test_volume_list = kwargs.get('test_volume_list') # We define task model and its optimizer and scheduler self.models_dic = {'model': kwargs.get('model').to(self.device)} self.optimizers_dic = {'model': create_optimizer(self.config['optimizer'], self.models_dic['model'].parameters())} self.schedulers_dic = {'model': create_scheduler(self.config['scheduler'], self.optimizers_dic['model'])} # Training parameters self.model_norm_fct = self.config['normalize_fct'] self.metrics = metrics self.main_metric = list(self.metrics.keys())[0] self.model_loss = losses[self.config['loss']](normalize_fct=self.config['normalize_fct']) self.scale_loss = self.config['scale_loss'] self.scaler = GradScaler() self.sched_early_stop_model_only = self.config['scheduler']['sched_early_stop_model_only'] # We define number of baches per epoch and number of epochs self.batch_size = self.config['batch_size'] self.num_batches_per_epoch = self.config['num_batches_per_epoch'] self.epoch = 1 self.num_epochs = self.config['num_train_iter'] print('\nThere will be {} training epochs of {} batch iterations' '\n'.format(self.num_epochs, self.num_batches_per_epoch)) self.last_iter = False # Here, iters will keep track of every forward-bacward iteration self.iters = 0 # We create a variable that will become positive if the model has converged self.early_stop_model = False # Whether we will plot validation plots or not and frequency of logs self.activate_plot = self.config['activate_plot'] self.log_every = self.config['log_every'] print('Will log images every {} epochs'.format(self.log_every)) # We define sampling strategy and budget self.sampling_type = self.selection_config['sampling_type'] print('\n Sampling with {}'.format(self.sampling_type)) self.budget = self.selection_config['budget'] self.labeled_indices = kwargs.get('labeled_indices') self.dataset = kwargs.get('dataset') # To plot the data from its index self.sampling_with_best_models = self.selection_config['sampling_with_best_models'] # If we are using random sampling, we will check the indice file self.random_indice_filepath = kwargs.get('random_indice_filepath') # Create an experiment with your api key self.experiment = Experiment( api_key="anonymous", project_name="TAAL", workspace="anonymous", ) # Report multiple hyperparameters using a dictionary: hyper_params = { "seed": kwargs.get('seed'), "save_file": self.saver.save_folder, "selection_type": self.selection_config['type'], "deterministic": self.config['deterministic'], "data_num_labeled": len(self.selection_config['initial_budget']) if isinstance(self.selection_config['initial_budget'], list) else self.selection_config['initial_budget'], "data_num_batches": len(self.querry_dataloader), "data_batch_size": self.batch_size, "num_epochs": self.num_epochs, "augment_data": kwargs.get('augment_data'), 'augmentation_list': kwargs.get('augmentations') if kwargs.get('augment_data') else [], 'augmentation_gaussian_mean': kwargs.get('augmentation_gaussian_mean', None), 'augmentation_gaussian_std': kwargs.get('augmentation_gaussian_std', None), "optimizer_model": self.config['optimizer']['optimizer_name'], "scheduler_model": self.config['scheduler']['sched_name'], "LR_init_model": self.config['optimizer']['init_lr'], "model_loss": self.config['loss'], "labeled_indices": self.labeled_indices, "scale_loss": self.scale_loss, "sampling_type": self.sampling_type, "sampling_with_best_models": self.sampling_with_best_models, "finetune": kwargs.get('finetune') } if self.test_volume_list is not None: hyper_params["sched_early_stop_model_only"] = self.sched_early_stop_model_only hyper_params["model_batch_normalization"] = kwargs.get('batch_normalization') hyper_params["model_dropout"] = kwargs.get('dropout') hyper_params["test_volume_list"] = self.test_volume_list hyper_params["model_finetune_folder"] = kwargs.get('model_finetune_folder') # Extra parameters for some sampling strategies self.finite_labeled_dataloader = kwargs.get('finite_labeled_dataloader') # For coresets (finite query dataloader) if ('TestTimeAug' in self.sampling_type) or ('Dropout' in self.sampling_type): if 'JSD' in self.sampling_type: # For JSD self.alpha_jsd = self.selection_config['alpha_jsd'] print('Setting JSD with alpha {}'.format(self.alpha_jsd)) hyper_params["param_alpha_jsd"] = self.alpha_jsd else: self.alpha_jsd = 0.5 if 'TestTimeAug' in self.sampling_type: self.data_aug_gaussian_mean = self.selection_config['data_aug_gaussian_mean'] self.data_aug_gaussian_std = self.selection_config['data_aug_gaussian_std'] hyper_params["param_data_aug_gaussian_mean"] = self.data_aug_gaussian_mean hyper_params["param_data_aug_gaussian_std"] = self.data_aug_gaussian_std print('self.data_aug_gaussian_mean: {}'.format(self.data_aug_gaussian_mean)) print('self.data_aug_gaussian_std: {}'.format(self.data_aug_gaussian_std)) self.experiment.log_parameters(hyper_params) def train(self): # We initialize the default best values best_model_val_acc = 0 best_losses_dic = defaultdict(defaultinf) best_models_dic = {} last_models_dic = {} best_models_dic['model'] = self.models_dic['model'] # We iterate over all epochs while not self.last_iter: torch.cuda.empty_cache() epoch_start_time = time.time() # We train one epoch and do validation with self.experiment.train(): model_train_acc_dic, train_loss_dic, solver_models, lr_dic = self.train_epoch() self.experiment.log_metrics(train_loss_dic, prefix="Loss", epoch=self.epoch) self.experiment.log_metrics(model_train_acc_dic, prefix="metric", epoch=self.epoch) self.experiment.log_metrics(lr_dic, prefix='LR', epoch=self.epoch) with self.experiment.validate(): val_loss_dic, model_val_acc_dic, early_stop_modules = self.validation( self.val_dataloader) self.experiment.log_metrics(val_loss_dic, prefix="Loss", epoch=self.epoch) self.experiment.log_metrics(model_val_acc_dic, prefix="metric", epoch=self.epoch) # We update the model scheduler after each epoch self.early_stop_model = self.update_model_scheduler(val_loss_dic['model']) # We will save the best validation accuracy if model_val_acc_dic[self.main_metric] > best_model_val_acc: best_model_val_acc = model_val_acc_dic[self.main_metric] if val_loss_dic['model'] < best_losses_dic['model']: best_losses_dic['model'] = val_loss_dic['model'] best_models_dic['model'] = copy.deepcopy(solver_models['model']).to('cpu') self.saver.save_best_model(best_models_dic['model'], 'model') if self.epoch % self.log_every == 0: for cur_model in solver_models.keys(): print('Saving {} at epoch {}'.format(cur_model, self.epoch)) last_models_dic[cur_model] = copy.deepcopy(solver_models[cur_model]).to('cpu') self.saver.save_model(last_models_dic[cur_model], 'training_' + cur_model + '_epoch' + str(self.epoch)) # We prepare the variables to be printed self.print_epoch_update(train_loss_dic, val_loss_dic, model_train_acc_dic, model_val_acc_dic, epoch_start_time, lr_dic) if self.epoch == self.num_epochs: print('Last iteration done') self.last_iter = True elif self. sched_early_stop_model_only and self.early_stop_model: print('Early stopping with model only') self.last_iter = True elif not self.sched_early_stop_model_only and (self.early_stop_model and early_stop_modules): print('Early stopping with model and module') self.last_iter = True else: self.epoch += 1 if self.last_iter: for cur_model in solver_models.keys(): last_models_dic[cur_model] = copy.deepcopy(solver_models[cur_model]).to('cpu') self.saver.save_model(last_models_dic[cur_model], 'last_' + cur_model ) # We evaluate the model on test data with self.experiment.test(): # 2D inference with last model last_avg_test_loss, last_test_acc_dic = self.inference( last_models_dic['model'].to(self.device), self.test_dataloader) self.experiment.log_metrics(last_test_acc_dic, prefix='metric_last') # 2D inference with best model avg_test_loss, test_acc_dic = self.inference(best_models_dic['model'].to(self.device), self.test_dataloader) self.experiment.log_metrics(test_acc_dic, prefix='metric_best') if self.test_volume_list is not None: # 3D inference with last model _, last_test_acc_dic3d = self.inference3d(last_models_dic['model'].to(self.device), self.test_dataloader, self.test_volume_list, plot=True) self.experiment.log_metrics(last_test_acc_dic3d, prefix='metric3d_last') # 3D inference with best model _, test_acc_dic3d = self.inference3d(best_models_dic['model'].to(self.device), self.test_dataloader, self.test_volume_list, plot=False) self.experiment.log_metrics(test_acc_dic3d, prefix='metric3d_best') else: last_test_acc_dic3d = None test_acc_dic3d = None # We prepare the dictionaries for loss and accuracy results acc_dic = { "val_acc_last": model_val_acc_dic[self.main_metric], "val_acc_best": best_model_val_acc, "3D_last_acc": last_test_acc_dic3d, "3D_best_acc": test_acc_dic3d, "last_acc": last_test_acc_dic, "best_acc": test_acc_dic, } loss_dic = { "test_loss": avg_test_loss, "val_loss_last": val_loss_dic['total'], "val_loss_best": best_losses_dic['total'] } self.experiment.log_parameters({'best_val_loss_model': best_losses_dic['model']}) return acc_dic, loss_dic#, kwargs_sampler def train_epoch(self): """ Training one epoch We implement the logic of a epoch (before any validation or scheduler update) -epoch over the given number of steps Returns: - avg_model_train_acc_dic - train_loss_dic - val_loss_dic - solver_models """ # We initialize loss and accuracy counts model_train_acc_dic = defaultdict(default0) train_loss_dic = {} for key in self.loss_name_list: train_loss_dic[key] = 0 self.querry_dataloader.dataset.training = True for self.train_batch_idx in tqdm(range(self.num_batches_per_epoch)): labeled_imgs, labeled_labels, self.idx_l = next(self.querry_iter) # We do a forward-backward prop of the task model and latent model with the labeled data _, curr_train_loss_dic, curr_model_train_acc_dic = self.train_step(labeled_imgs, labeled_labels) # We add the loss and metrics for each batch # Note for accuracy, we put the batch values first because initial model_train_acc_dic is empty train_loss_dic = add_dic_values(train_loss_dic, curr_train_loss_dic) model_train_acc_dic = add_dic_values(curr_model_train_acc_dic, model_train_acc_dic) self.iters += 1 # We compute average accuracy avg_train_loss_dic = self.compute_mean_value(train_loss_dic, self.num_batches_per_epoch) avg_model_train_acc_dic = self.compute_mean_value(model_train_acc_dic, self.num_batches_per_epoch) # We create an output dictionary of models solver_models = {} for model_name, cur_model in self.models_dic.items(): solver_models[model_name] = cur_model # We create an output dictionary of LR's lr_dic = {} for model_name, cur_optim in self.optimizers_dic.items(): lr_dic[model_name] = cur_optim.param_groups[0]['lr'] return avg_model_train_acc_dic, avg_train_loss_dic, solver_models, lr_dic def train_step(self, data, target): """ We implement the logic of one train step Returns: - output - loss_dic - train_acc_dic (any metrics you need to summarize) """ # raise NotImplementedError def validation(self, val_dataloader, mode='val'): """ We implement the logic of the validation step. Runs once after each epoch """ raise NotImplementedError def inference(self, model, test_dataloader): """ We implement the logic of the segmentation inference step. Runs once at the end of training """ model.eval() test_dataloader.dataset.training = False # We initialize loss and accuracy loss = 0.0 acc_dic = defaultdict(default0) # We iterate through validation batched with torch.no_grad(): for batch_idx, (data, target, idx_list) in enumerate(test_dataloader): data = data.to(self.device, dtype=torch.float) target = target.to(self.device) output, _ = model(data) onehot_target = to_onehot(target, model.out_channels) batch_loss = self.model_loss(output, onehot_target) # We compute the metrics for the batch batch_acc_dic = self.compute_metrics(output, onehot_target) # We add the loss and metrics for each batch # Note for accuracy, we put the batch values first because initial val_acc_dic is empty loss += batch_loss.item() acc_dic = add_dic_values(batch_acc_dic, acc_dic) # self.save_comet_plot(data, target, output, batch_idx, 'test', img_number=batch_idx) # We compute average loss and metric over all batches avg_loss = self.compute_mean_value(loss, len(test_dataloader)) avg_acc_dic = self.compute_mean_value(acc_dic, len(test_dataloader)) avg_loss_dic = {'model': avg_loss} return avg_loss_dic, avg_acc_dic def inference3d(self, model, test_dataloader, test_volume_list, plot=False): """ We implement the logic of the segmentation inference step. Runs once at the end of training """ model.eval() test_dataloader.dataset.training = False # We initialize loss and accuracy loss = 0.0 acc_dic = defaultdict(default0) data_list = [] output_list = [] target_list = [] onehot_target_list = [] cur_slice = 0 # We iterate through validation batched with torch.no_grad(): for batch_idx, (data, target, idx_list) in enumerate(test_dataloader): data = data.to(self.device, dtype=torch.float) target = target.to(self.device) output, _ = model(data) onehot_target = to_onehot(target, model.out_channels) data_list.append(data) output_list.append(output) target_list.append(target) onehot_target_list.append(onehot_target) cur_slice += 1 # If we reached the last sampled or if we will be changing value in the next samples, we compute the volume metric if (batch_idx + 1 == len(test_dataloader)) or ( test_volume_list[batch_idx + 1] != test_volume_list[batch_idx]): _vol_data = torch.stack(data_list, dim=0) _vol_output = torch.stack(output_list, dim=0) _vol_target = torch.stack(target_list, dim=0) _vol_onehot_target = torch.stack(onehot_target_list, dim=0) vol_data = _vol_data.permute(1, 2, 0, 3, 4) vol_output = _vol_output.permute(1, 2, 0, 3, 4) vol_target = _vol_target.permute(1, 0, 2, 3) vol_onehot_target = _vol_onehot_target.permute(1, 2, 0, 3, 4) # We compute the metrics for the batch batch_acc_dic = self.compute_metrics(vol_output, vol_onehot_target) batch_loss = self.model_loss(vol_output, vol_onehot_target) # We add the loss and metrics for each batch # Note for accuracy, we put the batch values first because initial val_acc_dic is empty loss += batch_loss.item() acc_dic = add_dic_values(batch_acc_dic, acc_dic) if plot: for slice in range(vol_output.shape[2]): self.save_comet_plot(vol_data[:, :, slice, :, :], vol_target[:, slice, :, :], vol_output[:, :, slice, :, :], batch_idx, 'test', img_number=slice, test_name='test_volume_{}'.format( test_volume_list[batch_idx])) self.plot_test_data_pred_contour(vol_data[:, :, slice, :, :], vol_target[:, slice, :, :], vol_output[:, :, slice, :, :], batch_idx, img_idx=slice) data_list = [] output_list = [] target_list = [] onehot_target_list = [] cur_slice = 0 # We compute average loss and metric over all batches avg_loss = self.compute_mean_value(loss, len(set(test_volume_list))) avg_acc_dic = self.compute_mean_value(acc_dic, len(set(test_volume_list))) avg_loss_dic = {'model': avg_loss} return avg_loss_dic, avg_acc_dic def sample_for_labeling(self, unlabeled_dataloader, **kwargs): """ We implement the logic of sample selection for labeling (AL step) """ print('\n sampling_type {}'.format(self.sampling_type)) unlabeled_dataloader.dataset.training = False if self.sampling_type == 'Random': try: with open(self.random_indice_filepath + '.txt', encoding='utf8') as f: for line in f: if 'sampled_{}: '.format(len(self.labeled_indices)) in line: _indice_list = line.strip( 'sampled_{}: '.format(len(self.labeled_indices))) _indice_list = _indice_list.strip('\n') querry_indices = eval(_indice_list) assert len(querry_indices) == self.budget print('Sampled indices taken from file') except (NameError, FileNotFoundError) as e: sampler = RandomSampler(self.budget) querry_indices = sampler.sample(unlabeled_dataloader) with open(self.random_indice_filepath + '.txt', "a") as f: f.write('sampled_{}: {}\n'.format( len(self.labeled_indices), querry_indices)) uncertainty_values = [] elif self.sampling_type == 'OutputEntropy': sampler = PredictionEntropySampler(self.budget) querry_indices, uncertainty_values = sampler.sample( self.models_dic['model'], unlabeled_dataloader, self.device, self.experiment) elif 'TestTimeAug' in self.sampling_type: sampler = TestTimeAugmentationSampler(self.budget) querry_indices, uncertainty_values = sampler.sample( self.models_dic['model'], unlabeled_dataloader, self.device, self.sampling_type, alpha_jsd=self.alpha_jsd, data_aug_gaussian_mean=self.data_aug_gaussian_mean, data_aug_gaussian_std=self.data_aug_gaussian_std) elif 'Dropout' in self.sampling_type: sampler = DropoutSampler(self.budget) querry_indices, uncertainty_values = sampler.sample( self.models_dic['model'], unlabeled_dataloader, self.device, self.sampling_type, num_dropout_inference=self.selection_config['dropout_num_inference'], alpha_jsd=self.alpha_jsd) elif self.sampling_type == 'Coresets': pooling_kwargs = {'kernel_size': 4, 'stride': 4, 'padding': 0} sampler = CoresetsSampler(self.budget) querry_indices = sampler.sample( self.models_dic['model'], unlabeled_dataloader, self.device, self.experiment, self.finite_labeled_dataloader, pooling_kwargs) uncertainty_values = [] self.experiment.log_other('sampled_indices', querry_indices) self.experiment.log_other('uncertainty', uncertainty_values) with self.experiment.test(): self.experiment.log_other('querry_indices', querry_indices) for i, sample in enumerate(querry_indices): subset = torch.utils.data.Subset(self.dataset, [sample]) singleloader_subset = torch.utils.data.DataLoader(subset, batch_size=1, num_workers=0, shuffle=False) _img, _, _ = next(iter(singleloader_subset)) img = torch.mean(_img[0, :, :, :].to(torch.float), dim=0) self.experiment.log_image(img, name='querry_img', step=sample) print(i, sample) return querry_indices def save_comet_plot(self, val_data, val_target, val_output, batch_idx, mode, idx_list=[], log_val_idx=None, img_number=None, test_name='test_images'): # TODO make better if len(idx_list) != 0: [batch_samples] = np.where(np.array(idx_list) == log_val_idx) batch_sample = batch_samples[0] else: batch_sample = 0 val_data = val_data.detach().cpu() val_target = val_target.detach().cpu() val_output = val_output.detach().cpu() _prep_val_data = val_data[batch_sample, :, :, :] prep_val_data = torch.mean(_prep_val_data, dim=0) prep_val_target = val_target[batch_sample, :, :] _prep_val_pred = val_output[batch_sample, :, :, :] prep_val_pred = torch.argmax(_prep_val_pred, dim=0) self.saver.save_pred_img_overlay(prep_val_data, prep_val_target, prep_val_pred, filename='epoch{}_batch{}_sample{}' ''.format(self.epoch, batch_idx, batch_sample), mode=mode) img_path = os.path.join(self.saver.save_folder, mode, 'epoch{}_batch{}_sample{}_overlay.png' ''.format(self.epoch, batch_idx, batch_sample)) if img_number is None: self.experiment.log_image(img_path, name='idx{}_overlay'.format(log_val_idx), step=self.epoch) else: self.experiment.log_image(img_path, name=test_name, step=img_number) def compute_metrics(self, output, onehot_target): return compute_metrics(output, onehot_target, self.metrics, self.model_norm_fct, self.models_dic['model'].out_channels) def compute_mean_value(self, input, num_items): return compute_mean_value(input, num_items) def print_epoch_update(self, train_loss_dic, val_loss_dic, model_train_acc_dic, model_val_acc_dic, epoch_start_time, lr_dic, best_losses_dic='', best_model_val_acc=''): return print_epoch_update(self.epoch, train_loss_dic, val_loss_dic, model_train_acc_dic, model_val_acc_dic, epoch_start_time, lr_dic, best_losses_dic, best_model_val_acc) def update_model_scheduler(self, model_val_loss): """ :param model_val_loss: (optional) needed for a certain type of scheduler """ early_stop = False try: #self.scheduler_model.step() self.schedulers_dic['model'].step() except TypeError: old_lr = float(self.schedulers_dic['model'].optimizer.param_groups[0]['lr']) self.schedulers_dic['model'].step(model_val_loss) new_lr = max(old_lr * self.scheduler_model.factor, self.schedulers_dic['model'].min_lrs[0]) if (old_lr - new_lr < self.schedulers_dic['model'].eps) and \ (self.schedulers_dic['model'].num_bad_epochs == self.schedulers_dic['model'].patience): early_stop = True return early_stop def plot_training_data_pred(self, data, target, scores, indices, type='Train'): """_summary_ Args: data (_type_): _description_ target (_type_): _description_ scores (_type_): _description_ type (str, optional): _description_. Defaults to 'Train'. step (_type_, optional): _description_. Defaults to None. """ fig = plt.figure(figsize=(20, 10)) ncols, nrows = 1, 3 for img_idx in range(data.shape[0]): ## Labeled image i = 1 ax = fig.add_subplot(ncols, nrows, i) ax.imshow(data[img_idx, 0, :, :].detach().cpu().numpy(), 'gray') plt.axis('off') ax.set_title("Data", fontsize=12) i = 2 ax = fig.add_subplot(ncols, nrows, i) ax.imshow(data[img_idx, 0, :, :].detach().cpu().numpy(), 'gray', interpolation='none') plt.axis('off') ax.imshow(target.squeeze(1)[img_idx, :, :].detach().cpu().numpy(), cmap='viridis', alpha=0.7) plt.axis('off') ax.set_title("Target", fontsize=12) i = 3 ax = fig.add_subplot(ncols, nrows, i) ax.imshow(data[img_idx, 0, :, :].detach().cpu().numpy(), 'gray', interpolation='none') plt.axis('off') model_pred = torch.argmax(scores, dim=1) ax.imshow(model_pred[img_idx, :, :].detach().cpu().numpy(), cmap='viridis', alpha=0.7) plt.axis('off') ax.set_title("Pred Model", fontsize=12) # We save the plot fig.set_tight_layout({"pad": 0.}) savepath = os.path.join('img.png') fig.savefig(savepath) self.experiment.log_image(savepath, name='{}_predictions_epoch{}'.format(type, self.epoch), step=indices[img_idx]) plt.close() def plot_training_data_pred_contour(self, data, target, scores, indices, type='Train'): """_summary_ Args: data (_type_): _description_ target (_type_): _description_ scores (_type_): _description_ type (str, optional): _description_. Defaults to 'Train'. step (_type_, optional): _description_. Defaults to None. """ fig = plt.figure(figsize=(10, 10)) ncols, nrows = 1, scores.shape[1] - 1 for img_idx in range(data.shape[0]): cur_data = data[img_idx, 0, :, :].detach().cpu().numpy() cur_target = target.squeeze(1)[img_idx, :, :].detach().cpu().numpy() cur_pred = torch.argmax(scores, dim=1)[img_idx, :, :].detach().cpu().numpy() # Computing the Active Contour for the given image contour_target = find_contours(cur_target.T, 0.5) contour_pred = find_contours(cur_pred.T, 0.5) ## Labeled image ax = fig.add_subplot(ncols, nrows, 1) ax.imshow(cur_data, 'gray') plt.axis('off') for contour in contour_target: ax.plot(contour[:, 0], contour[:, 1], '-b', lw=5) plt.axis('off') for contour in contour_pred: ax.plot(contour[:, 0], contour[:, 1], '-r', lw=5) plt.axis('off') # We save the plot fig.set_tight_layout({"pad": 0.}) savepath = os.path.join('img.png') fig.savefig(savepath) self.experiment.log_image(savepath, name='{}_Predictions_epoch{}_Contour'.format(type, self.epoch), step=indices[img_idx]) plt.close() def plot_val_data_pred(self, val_data, val_target, val_output, batch_idx, img_idx=0): fig = plt.figure(figsize=(20, 10)) ncols, nrows = 1, 3 ## Labeled image i = 1 ax = fig.add_subplot(ncols, nrows, i) ax.imshow(val_data[img_idx, 0, :,:].detach().cpu().numpy(), 'gray') plt.axis('off') ax.set_title("Data", fontsize=12) i = 2 ax = fig.add_subplot(ncols, nrows, i) ax.imshow(val_data[img_idx, 0, :, :].detach().cpu().numpy(), 'gray', interpolation='none') plt.axis('off') ax.imshow(val_target[img_idx, :, :].detach().cpu().numpy(), cmap='viridis', alpha=0.7) ax.imshow(val_target.squeeze(1)[img_idx, :, :].detach().cpu().numpy(), cmap='viridis', alpha=0.7) plt.axis('off') ax.set_title("Target", fontsize=12) i = 3 ax = fig.add_subplot(ncols, nrows, i) ax.imshow(val_data[img_idx, 0, :, :].detach().cpu().numpy(), 'gray', interpolation='none') plt.axis('off') val_pred = torch.argmax(val_output, dim=1) ax.imshow(val_pred[img_idx, :, :].detach().cpu().numpy(), cmap='viridis', alpha=0.7) plt.axis('off') ax.set_title("Pred", fontsize=12) # We save the plot fig.set_tight_layout({"pad": 0.}) savepath = os.path.join('img.png') fig.savefig(savepath) self.experiment.log_image(savepath, name='Validation_predictions_batch{}_img{}'.format(batch_idx, img_idx), step=self.epoch) plt.close() def plot_val_data_pred_contour(self, val_data, val_target, val_output, batch_idx, img_idx=0): fig = plt.figure(figsize=(10, 10)) ncols, nrows = 1, val_output.shape[1] - 1 cur_data = val_data[img_idx, 0, :, :].detach().cpu().numpy() cur_target = val_target.squeeze(1)[img_idx, :, :].detach().cpu().numpy() cur_pred = torch.argmax(val_output, dim=1)[img_idx, :, :].detach().cpu().numpy() # Computing the Active Contour for the given image contour_target = find_contours(cur_target.T, 0.5) contour_pred = find_contours(cur_pred.T, 0.5) ## Labeled image ax = fig.add_subplot(ncols, nrows, 1) ax.imshow(cur_data, 'gray') plt.axis('off') for contour in contour_target: ax.plot(contour[:, 0], contour[:, 1], '-b', lw=5) plt.axis('off') for contour in contour_pred: ax.plot(contour[:, 0], contour[:, 1], '-r', lw=5) plt.axis('off') # We save the plot fig.set_tight_layout({"pad": 0.}) savepath = os.path.join('img.png') fig.savefig(savepath) self.experiment.log_image(savepath, name='Validation_predictions_batch{}_img{}_Contour'.format( batch_idx, img_idx), step=self.epoch) plt.close() def plot_test_data_pred_contour(self, val_data, val_target, val_output, batch_idx, img_idx=0): fig = plt.figure(figsize=(10, 10)) ncols, nrows = 1, val_output.shape[1] - 1 cur_data = val_data[0, 0, :, :].detach().cpu().numpy() cur_target = val_target.squeeze(1)[0, :, :].detach().cpu().numpy() cur_pred = torch.argmax(val_output, dim=1)[0, :, :].detach().cpu().numpy() # Computing the Active Contour for the given image contour_target = find_contours(cur_target.T, 0.5) contour_pred = find_contours(cur_pred.T, 0.5) ## Labeled image ax = fig.add_subplot(ncols, nrows, 1) ax.imshow(cur_data, 'gray') plt.axis('off') for contour in contour_target: ax.plot(contour[:, 0], contour[:, 1], '-b', lw=5) plt.axis('off') for contour in contour_pred: ax.plot(contour[:, 0], contour[:, 1], '-r', lw=5) plt.axis('off') # We save the plot fig.set_tight_layout({"pad": 0.}) savepath = os.path.join('img.png') fig.savefig(savepath) self.experiment.log_image(savepath, name='Test_predictions_vol{}_Contour'.format(batch_idx), step=img_idx) plt.close()