data/src/Methods/SemiSupervised/solver.py

"""
Author: Mélanie Gaillochet
Date: 2022-02-14

"""

import os
import numpy as np
from collections import defaultdict
import matplotlib.pyplot as plt
import copy
import random

from tqdm import tqdm
import torch
import torch.nn as nn
from torch.nn import functional as F

from Base.base_solver import BaseSolver
from Utils.metrics import meanIoU
from Utils.utils import default0, add_dic_values, to_onehot
from Utils.augmentation_utils import random_augmentation, JSD, augment_data, reverse_augment_data
from Utils.train_utils import sigmoid_rampup


class Solver(BaseSolver):
    """
    This is the solver class for Cross-Augmentation Consistency training
    """

    def __init__(self, config, test_dataloader, **kwargs):
        super().__init__(config, test_dataloader, **kwargs)
        
        print('Initializing CrossAugConsistency solver')

        # This is the dataloader for unsupervised loss
        extra_dataloader = kwargs.get('extra_dataloader')
        self.extra_data_iterator = iter(extra_dataloader)

        self._two_steps = self.config['two_steps_forward_prop']
        self.unsup_loss_weight = self.selection_config['CrossAugConsistency_unsup_loss_weight']
        self.unsup_loss_weight_rampup = self.selection_config['CrossAugConsistency_unsup_loss_weight_rampup']
        self.consistency_num_augmentations = self.selection_config['CrossAugConsistency_num_augmentations']
        self.consistency_alpha_jsd = self.selection_config['CrossAugConsistency_alpha_jsd']
        self.consistency_augmentation_list = eval(self.selection_config['CrossAugConsistency_augmentation_list'])
        self.consistency_aug_gaussian_mean = self.selection_config['CrossAugConsistency_aug_gaussian_mean'] if 'gaussian_noise' in self.consistency_augmentation_list else 0
        self.consistency_aug_gaussian_std = self.selection_config['CrossAugConsistency_aug_gaussian_std'] if 'gaussian_noise' in self.consistency_augmentation_list else 0

        hyper_params = {'param_consistency_loss_weight': self.unsup_loss_weight,
                        'param_consistency_loss_weight_rampup': self.unsup_loss_weight_rampup,
                        'param_two_steps_forward_prop': self._two_steps,
                        'param_consistency_num_augmentations': self.consistency_num_augmentations,
                        'param_consistency_alpha_jsd': self.consistency_alpha_jsd,
                        'param_consistency_augmentation_list': self.consistency_augmentation_list
                        }

        if self.unsup_loss_weight_rampup:
            self.unsup_loss_weight_rampup_length = self.selection_config['CrossAugConsistency_unsup_loss_weight_rampup_length']
            hyper_params['param_consistency_loss_weight_rampup_length'] = self.unsup_loss_weight_rampup_length

        self.experiment.log_parameters(hyper_params)
        
        self.loss_name_list = ['total', 'model', 'consistency']
        
    def train_step(self, data, target):

        # We set all models (task model, single conv's and latentNet) to training mode
        self.models_dic['model'].train()

        # We zero the parameter gradients of all models
        self.optimizers_dic['model'].zero_grad()

        # We put all data unto device
        data, target = data.to(self.device, dtype=torch.float), target.to(self.device)


        # EITHER We do 2 forward propagations through model, once with labeled and one with unlabeled data. Then we forward propagate unlabeled data trhough ema model
        if self._two_steps:
            # We compute the supervised loss
            scores, _ = self.models_dic['model'](data)

            onehot_target = to_onehot(target.squeeze(1), self.models_dic['model'].out_channels)
            model_loss = self.model_loss(scores, onehot_target)

            # We compute the unsupervised loss
            unsup_data, _, _ = next(self.extra_data_iterator)
            unsup_data = unsup_data.to(self.device, dtype=torch.float)

            u_scores, _ = self.models_dic['model'](unsup_data)
            
            # We compute the unsupervised loss
            unsup_loss = self.compute_consistency_loss(u_scores, unsup_data, mode='Train')

            # We combine both to get total loss
            consistency_weight = self.get_current_consistency_weight(self.epoch)
            train_loss = model_loss + consistency_weight * unsup_loss

        # OR We do forward propagation through task model with both labeled and unlabeled data (one forward pass), then we forwrad propagate unlabeled data through ema model
        else:
            # # We get the unsupervised data
            unsup_data, _, _ = next(self.extra_data_iterator)
            unsup_data = unsup_data.to(self.device, dtype=torch.float)

            n_l, n_u = len(data), len(unsup_data)
            
            # We combine labeled and unlabeled data to have only one forward propagation (batch norm reasons)
            all_data = torch.cat([data, unsup_data], dim=0)
            all_scores, _ = self.models_dic['model'](all_data)
            scores, u_scores = torch.split(all_scores, [n_l, n_u], dim=0)

            # We computed the supervised loss
            onehot_target = to_onehot(target, self.models_dic['model'].out_channels)
            model_loss = self.model_loss(scores, onehot_target)

            # We compute the unsupervised loss
            unsup_loss = self.compute_consistency_loss(u_scores, unsup_data, mode='Train')
            #print('unsup_loss {}'.format(unsup_loss))

            # We combine both to get total loss
            consistency_weight = self.get_current_consistency_weight(self.epoch)
            train_loss = model_loss + consistency_weight * unsup_loss

        if self.activate_plot and (self.epoch % self.log_every == 0) and (self.train_batch_idx in [0, 1, 2]):
            self.plot_training_data_pred(data, target, scores, indices=self.idx_l, type='Train')
            self.plot_training_data_pred_contour(data, target, scores, indices=self.idx_l, type='Train')

        # We do backward propagation
        train_loss.backward()
        self.optimizers_dic['model'].step()

        loss_dic = {
            'total': train_loss.item(),
            'model': model_loss.item(),
            'consistency': unsup_loss.item()
        }

        # We compute the metrics
        train_acc_dic = self.compute_metrics(scores, onehot_target)

        return scores, loss_dic, train_acc_dic

    def validation(self, val_dataloader, mode='val'):
        assert mode == 'val' or mode == 'test'
        self.models_dic['model'].eval()

        val_dataloader.dataset.training = False

        # We initialize loss and accuracy
        val_acc_dic = defaultdict(default0)
        val_loss_dic = {}
        for key in self.loss_name_list:
            val_loss_dic[key] = 0

        with torch.no_grad():
            for batch_idx, (val_data, val_target, idx_list) in enumerate(val_dataloader):
                val_data = val_data.to(self.device, dtype=torch.float)
                val_target = val_target.to(self.device)

                val_output, _ = self.models_dic['model'](val_data)
                model_prob = F.softmax(val_output, dim=1)

                onehot_target = to_onehot(val_target.squeeze(1), self.models_dic['model'].out_channels)
                model_loss = self.model_loss(val_output, onehot_target)

                # We compute the unsupervised loss
                unsup_loss = self.compute_consistency_loss(val_output, val_data, mode='Validation')
                
                # We combine both to get total loss
                consistency_weight = self.get_current_consistency_weight(self.epoch)
                total_loss = model_loss + consistency_weight * unsup_loss

                batch_val_loss_dic = {
                    'total': total_loss.item(),
                    'model': model_loss.item(),
                    'consistency': unsup_loss.item()
                }

                # We compute the metrics
                batch_val_acc_dic = self.compute_metrics(val_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
                val_loss_dic = add_dic_values(val_loss_dic, batch_val_loss_dic)
                val_acc_dic = add_dic_values(batch_val_acc_dic, val_acc_dic)

                if self.activate_plot and (mode == 'val') and (self.epoch % self.log_every == 0) and batch_idx in [0, 1, 2, 3]:
                    self.plot_val_data_pred(val_data, val_target, val_output, batch_idx, img_idx=0)
                    self.plot_val_data_pred_contour(val_data, val_target, val_output, batch_idx, img_idx=0)

        # We compute average accuracy and loss over all batches
        avg_val_loss_dic = self.compute_mean_value(val_loss_dic, len(val_dataloader))
        avg_val_acc_dic = self.compute_mean_value(val_acc_dic, len(val_dataloader))

        # We keep track of the consistency weight in comet_ml
        self.experiment.log_metrics({'consistency_weight': consistency_weight}, prefix="consistency_weight", epoch=self.epoch)

        return avg_val_loss_dic, avg_val_acc_dic, True

    def compute_consistency_loss(self, output, data, mode):
        """
        For each sample of the batch, we will do inference on k augmented versions of x' and compute JSD on x' and all T(x')
        """
        # We compte the probability of S(x')
        output_prob = F.softmax(output, dim=1)

        cur_prob_list = [output_prob]
        transformed_data_list = [data]  # REMOVE

        while len(cur_prob_list) < self.consistency_num_augmentations + 1:
            with torch.no_grad():
                # We augment the data
                transformed_data, aug_dic = random_augmentation(
                    data, flip_axis=2, rotaxis0=2, rotaxis1=3, augmentation_list=self.consistency_augmentation_list, type='img',
                    aug_gaussian_mean=self.consistency_aug_gaussian_mean, aug_gaussian_std=self.consistency_aug_gaussian_std)
                transformed_data = transformed_data.to(self.device)
                #print('consistency aug_dic {}'.format(aug_dic))

                # We do inference on the augmented data
                transformed_output, _ = self.models_dic['model'](transformed_data)

                # We do the inverse transformation on the output
                rev_output = reverse_augment_data(transformed_output, aug_dic['flip'], aug_dic['rot'], flip_axis=2, rot_axis0=2, rot_axis1=3)

                # We get output probability and prediction
                rev_prob = F.softmax(rev_output, dim=1)

                # We keep track of the output probabilities
                cur_prob_list.append(rev_prob)
                transformed_data_list.append(transformed_data)  # REMOVE

        # We concatenate the output probability list of augmented inputs
        transformed_prob_concat = torch.stack(cur_prob_list, dim=1)
        
        transformed_data_array = torch.stack(transformed_data_list, dim=1) # REMOVE

        jsd = JSD(transformed_prob_concat, alpha=self.consistency_alpha_jsd, p_ave_dim=1, entropy_aver_dim=1, entropy_dim=2, aver_entropy_dim=1)
        #print('torch.mean(jsd) {}'.format(torch.mean(jsd)))

        if self.activate_plot and (self.epoch % self.log_every == 0) and (self.train_batch_idx in [0, 1, 2]):
            # We plot the predictions
            for i in range(0, 1):
                self.plot_consistency_loss(transformed_data_array[i, :, :, :, :], transformed_prob_concat[i, :, :, :, :], jsd[i, :, :], mode=mode)

        # The tootal unsupervised loss is the average over all data of the batch and all sampel pixels
        unsup_loss = torch.mean(jsd)

        return unsup_loss

    def get_current_consistency_weight(self, epoch):
        """
        # Consistency ramp-up from https://arxiv.org/abs/1610.02242
        Code from https://github.com/HiLab-git/SSL4MIS/blob/10856b2dd7a05a2166744059b958b4915e8a1b5f/code/train_cross_consistency_training_2D.py
        
        The signoid rampup value depends on the current epoch and fixed parameters ( self.unsup_loss_weight and self.unsup_loss_weight_rampup_length)
        """
        return self.unsup_loss_weight * sigmoid_rampup(epoch, self.unsup_loss_weight_rampup_length)

    def plot_consistency_loss(self, aug_data_array, cur_prob_array, jsd, mode):
        fig = plt.figure(figsize=(10, 8))
        nrows, ncols = 2, self.consistency_num_augmentations + 2
        i = 1

        #cur_data = unsup_data[i:i+1, :, :, :][cur_arg, 0, :, :].detach().cpu().numpy()

        # ax = fig.add_subplot(ncols, nrows, i)
        # ax.imshow(cur_data, 'gray', interpolation='none')
        # plt.axis('off')
        # ax.set_title("Data", fontsize=12)
        # i += 1
        i = 1
        for j in range(0, len(aug_data_array)):
            ax = fig.add_subplot(nrows, ncols, i + j)
            cur_data = aug_data_array[j, 0, :, :].detach().cpu().numpy()
            ax.imshow(cur_data, 'gray', interpolation='none')
            plt.axis('off')
            #ax.set_title('{}'.format(flip_rot_pairs[j]), fontsize=12)

        i = ncols
        ax = fig.add_subplot(nrows, ncols, i)
        cur_data = aug_data_array[0,  0, :, :].detach().cpu().numpy()
        ax.imshow(cur_data, 'gray', interpolation='none')
        plt.axis('off')
        ax.imshow(jsd.detach().cpu().numpy(), cmap='viridis', alpha=0.7)
        plt.axis('off')
        ax.set_title('JSD:{:.3f}'.format(torch.mean(jsd)), fontsize=12)

        i = ncols + 1
        for j in range(0, len(cur_prob_array)):
            ax = fig.add_subplot(nrows, ncols, i + j)
            cur_data = aug_data_array[0, 0, :, :].detach().cpu().numpy()
            ax.imshow(cur_data, 'gray', interpolation='none')
            plt.axis('off')
            cur_pred = torch.argmax(cur_prob_array[j, :, :, :], dim=0).detach().cpu().numpy()
            ax.imshow(cur_pred, cmap='viridis', alpha=0.7)
            plt.axis('off')

        # We save the plot
        fig.set_tight_layout({"pad": 0.1})
        savepath = os.path.join('img.png')
        fig.savefig(savepath)
        self.experiment.log_image(savepath, name='{}_consistency_epoch{}'.format(mode, self.epoch), step=self.train_batch_idx)
        plt.close()