data/src/Utils/augmentation_utils.py

"""
Author: Mélanie Gaillochet
Date: 2021-02-22
"""
from comet_ml import Experiment
import os
import random
import numpy as np

import torch
import torch.nn as nn
import torch.nn.functional as F
import torchvision.transforms as T

from Utils.loss import DiceLoss
from Utils.utils import normalize
from Utils.train_utils import softmax_with_temp


# Loss function and optimizer
def entropy(p):
    """ We compute the entropy """
    if (len(p.size())) == 2:
        return - torch.sum(p * torch.log(p + 1e-18)) / float(len(p))
    elif (len(p.size())) == 1:
        return - torch.sum(p * torch.log(p + 1e-18))
    else:
        raise NotImplementedError


def Compute_entropy(net, x):
    """ We compute the conditional entropy H(Y|X) and the entropy H(Y) """
    p = F.softmax(net(x), dim=1)
    p_ave = torch.sum(p, dim=0) / len(x)
    return entropy(p), entropy(p_ave)


def Compute_entropies_1d(output):
    """ We compute the conditional entropy H(Y|X) and the entropy H(Y) """
    p = F.softmax(output, dim=1)
    aver_entropy = entropy(p)
    p_ave = torch.sum(p, dim=0) / len(output)
    entropy_aver = entropy(p_ave)
    return aver_entropy, entropy_aver


def entropy_2d(p, dim=0, keepdim=False):
    """ 
    We compute the entropy along the first dimension, for each value of the tensor
    :param p: tensor of probabilities
    :param dim: dimension along which we want to compute entropy (the sum across this dimension must be equal to 1)
    """
    entrop = - torch.sum(p * torch.log(p + 1e-18), dim=dim, keepdim=keepdim)
    return entrop


def compute_aver_entropy_2d(prob_input, entropy_dim=1, aver_entropy_dim=[1, 2]):
    tot_entropy = entropy_2d(prob_input, dim=entropy_dim)
    aver_entropy = torch.mean(tot_entropy, dim=aver_entropy_dim)
    return aver_entropy


def compute_entropy_aver_2d(prob_input, p_ave_dim=[2, 3], entropy_aver_dim=1):
    p_ave = torch.mean(prob_input, dim=p_ave_dim)
    entropy_aver = entropy_2d(p_ave, dim=entropy_aver_dim)
    return entropy_aver


def Compute_entropies_2d(output, softmax_temp=None):
    """ We compute the conditional entropy H(Y|X) and the entropy H(Y) """
    if softmax_temp is None:
        p = F.softmax(output, dim=1)
    else:
        output_with_temp = torch.div(output, softmax_temp)
        p = F.softmax(output_with_temp, dim=1)
    aver_entropy = compute_aver_entropy_2d(p)
    entropy_aver = compute_entropy_aver_2d(p)
    return aver_entropy, entropy_aver


def kl(p, q):
    """ We compute KL divergence between p and q """
    return torch.sum(p * torch.log((p + 1e-8) / (q + 1e-8))) / float(len(p))


def distance(y0, y1):
    # compute KL divergence between the outputs of the network
    return kl(F.softmax(y0, dim=1), F.softmax(y1, dim=1))


def JSD(prob_dists, alpha, p_ave_dim=0, entropy_aver_dim=0, entropy_dim=1, aver_entropy_dim=0):
    """
    JS divergence JSD(p1, .., pn) = H(sum_i_to_n [w_i * p_i]) - sum_i_to_n [w_i * H(p_i)], where w_i is the weight given to each probability
                                  = Entropy of average prob. - Average of entropy

    :param prob_dists: probability tensors (shape #points-to-compare, #channels, H, W)
    :param alpha: weight on terms of the JSD
    """
    entropy_mean = compute_entropy_aver_2d(prob_dists, p_ave_dim=p_ave_dim, entropy_aver_dim=entropy_aver_dim)
    mean_entropy = compute_aver_entropy_2d(prob_dists, entropy_dim=entropy_dim, aver_entropy_dim=aver_entropy_dim)
    jsd = alpha * entropy_mean - (1 - alpha) * mean_entropy
    
    return jsd


class AddGaussianNoise(object):
    def __init__(self, mean=0., std=1.):
        self.std = std
        self.mean = mean
        
    def __call__(self, tensor):
        tensor = tensor.detach().cpu()
        noise = torch.randn(tensor.size())
        return tensor + noise * self.std + self.mean
    
    def __repr__(self):
        return self.__class__.__name__ + '(mean={0}, std={1})'.format(self.mean, self.std)


def random_augmentation(x, aug_dic=None, flip_axis=2, rotaxis0=2, rotaxis1=3, augmentation_list=[], type='img',  aug_gaussian_mean=0,  aug_gaussian_std=0):
    """ We do augmentation (flip, rotation, mult(0.9 - 1.1)
    :param x: a tensor of shape (#channels, x, y) or (#channels, x, y, z)
    :param aug_dic: augmentation dictionary (if given)
    :param flip_axis: tensor axis for flipping
    :param rotaxis0: tensor first axis of rotation
    :param rotaxis1: tensor second axis of rotation
    :param type: type of input ('img' or 'target'). If 'target', no jitter or blurring will be applied
    """
    if aug_dic is None:
        # We get params for number of flips (0 or 1) and number of rotations (0 ro 3)
        flip = torch.randint(0, 2, (1,)).item() if 'flip' in augmentation_list else 0
        num_rot = torch.randint(0, 4, (1,)).item() if 'rotation' in augmentation_list else 0
        
        # We define the same value for amount of brightness, contrast, saturation and hue jitter.
        # The factor will be uniformly from [max(0, 1 - value), 1 + value], 
        # except for hue value which will be chosen between  0.5 < =[-value, value] <= 0.5
        jitter = 0.5 if 'jitter' in augmentation_list else 0
        
        # We define the same value for kernel size and max sigma. 
        # Sigma will be chosen uniformly at random between (0.1, value)
        blur = 3 if 'blur' in augmentation_list else 1
        
        mean_gaussian = aug_gaussian_mean if 'gaussian_noise' in augmentation_list else 0
        std_gaussian = aug_gaussian_std if 'gaussian_noise' in augmentation_list else 0

        aug_dic = {'flip': flip,
                    'rot': num_rot,
                    'jitter': jitter,
                    'blur': blur,
                    'mean_gaussian': mean_gaussian,
                    'std_gaussian': std_gaussian
                    }
    else:
        flip = aug_dic['flip']
        num_rot = aug_dic['rot']
        
        # If it is a target image, there will be no jitter and bluring transformation
        jitter = 0 if type == 'target' else aug_dic['jitter']
        blur = 1 if type == 'target' else aug_dic['blur']
        mean_gaussian = 0 if type == 'target' else aug_dic['mean_gaussian']
        std_gaussian = 0  if type == 'target' else aug_dic['std_gaussian']

    # We apply the transformations
    x_aug = augment_data(x, flip=flip, n_rotation=num_rot, flip_axis=flip_axis, rot_axis0=rotaxis0, rot_axis1=rotaxis1,
                         jitter=jitter, blur=blur, mean_gaussian=mean_gaussian, std_gaussian=std_gaussian)

    return x_aug, aug_dic


def augment_data(img, flip=0, n_rotation=0, flip_axis=2, rot_axis0=2, rot_axis1=3, jitter=0, blur=1, mean_gaussian=0, std_gaussian=0):
    """
    We apply the given transformation (flip and rotation) on the input image
    :param flip: [0 or 1] flip applied as the initial transformation
    :param flip: [0, 1, 2, 3] number of rotations applied as the initial transformation
    :param jitter:  (same) value for amount of brightness, contrast, saturation and hue jitter.
                    The factor will be uniformly from [max(0, 1 - value), 1 + value], 
                    except for hue value which will be chosen between  0.5 < =[-value, value] <= 0.5
    :param blur: (same) value of kernel size and sigma for Gaussian blur. Kernel will have shape (value, value)
                 Sigma will be chosen uniformly at random between 0.1 and that value.
    """
    if flip != 0:
        img = torch.flip(img, [flip_axis])
        
    if n_rotation !=0:
        img = torch.rot90(img, n_rotation, [rot_axis0, rot_axis1])
    
    if jitter != 0:
        transform = T.ColorJitter(brightness=jitter, contrast=jitter, saturation=jitter, hue=jitter)
        img = transform(img)
        
    if blur != 1:
        transform = T.GaussianBlur(kernel_size=(blur,blur), sigma=(0.1, blur))
        img = transform(img)
        
    if mean_gaussian != 0 or std_gaussian != 0:
        transform = AddGaussianNoise(mean_gaussian, std_gaussian)
        img = transform(img)
        
    return img

def reverse_augment_data(img, flip=0, n_rotation=0, flip_axis=2, rot_axis0=2, rot_axis1=3):
    """
    We reverse the transformation (flip and rotation) of the given image
    :param flip: [0 or 1] flip applied as the initial transformation
    :param flip: [0, 1, 2, 3] number of rotations applied as the initial transformation
    """
    if n_rotation !=0:
        img = torch.rot90(img, 4 - n_rotation, [rot_axis0, rot_axis1])
        
    if flip != 0:
        img = torch.flip(img, [flip_axis])
        
        
    return img


def compute_aug_loss(aug_loss_type, unsup_trans_output, unsup_output_aug, detach_trans,
                     model_norm_fct):
    if aug_loss_type == 'consistency_regularization_pixelKL':
        log_softmax = torch.nn.LogSoftmax(dim=1)
        log_softmax_output_aug = log_softmax(unsup_output_aug)
        log_softmax_trans_output = log_softmax(unsup_trans_output)

        KL_loss = torch.nn.KLDivLoss(reduction='mean', log_target=True)
        aug_loss = KL_loss(log_softmax_trans_output.detach(),
                           log_softmax_output_aug) if detach_trans else KL_loss(
            log_softmax_trans_output, log_softmax_output_aug)

    elif aug_loss_type == 'consistency_regularization_symmetricpixelKL':
        log_softmax = torch.nn.LogSoftmax(dim=1)
        log_softmax_output_aug = log_softmax(unsup_output_aug)
        log_softmax_trans_output = log_softmax(unsup_trans_output)

        KL_loss = torch.nn.KLDivLoss(reduction='mean', log_target=True)
        aug_loss = 0.5 * KL_loss(log_softmax_trans_output.detach(), log_softmax_output_aug) + \
                   0.5 * KL_loss(log_softmax_output_aug,
                                 log_softmax_trans_output.detach()) if detach_trans \
            else 0.5 * KL_loss(log_softmax_trans_output, log_softmax_output_aug) + \
                 0.5 * KL_loss(log_softmax_output_aug, log_softmax_trans_output)

    elif aug_loss_type == 'consistency_regularization_dice':
        dice = DiceLoss(normalize_fct=model_norm_fct)
        aug_loss = dice(unsup_trans_output.detach(), normalize(model_norm_fct, unsup_output_aug)) \
            if detach_trans \
            else dice(unsup_trans_output, normalize(model_norm_fct, unsup_output_aug))

    elif aug_loss_type == 'consistency_regularization_L2':
        mse = torch.nn.MSELoss()
        aug_loss = mse(F.softmax(unsup_trans_output.detach(), dim=1),
                       F.softmax(unsup_output_aug, dim=1)) \
            if detach_trans \
            else mse(F.softmax(unsup_trans_output, dim=1), F.softmax(unsup_output_aug, dim=1))

    return aug_loss


def log_aug_train_images(unsup_data_aug, unsup_trans_output, unsup_output_aug, saver, experiment,
                         epoch, train_batch_idx):
    batch_sample = 0
    _prep_aug_data = unsup_data_aug.detach().cpu()[batch_sample, :, :, :]
    prep_aug_data = torch.mean(_prep_aug_data, dim=0)

    _prep_trans_output = unsup_trans_output.detach().cpu()[batch_sample, :, :, :]
    prep_trans_output = torch.argmax(_prep_trans_output, dim=0)

    _prep_aug_output = unsup_output_aug.detach().cpu()[batch_sample, :, :, :]
    prep_aug_output = torch.argmax(_prep_aug_output, dim=0)
    saver.save_pred_img_overlay(prep_aug_data, prep_trans_output, prep_aug_output,
                                filename='epoch{}_batch{}_sample{}'
                                         ''.format(epoch, train_batch_idx,
                                                   batch_sample),
                                mode='train')
    img_path = os.path.join(saver.save_folder, 'train',
                            'epoch{}_batch{}_sample{}_overlay.png'
                            ''.format(epoch, train_batch_idx,
                                      batch_sample))
    experiment.log_image(img_path,
                         name='train_aug_overlay',
                         step=epoch)