BrainMapperUNet.py

"""Brain Mapper U-Net Architecture

Description:

    This folder contains the Pytorch implementation of the core U-net architecture.
    This arcitecture predicts functional connectivity rsfMRI from structural connectivity information from dMRI.

Usage:

    To use this module, import it and instantiate is as you wish:

        from BrainMapperUNet import BrainMapperUNet
        deep_learning_model = BrainMapperUnet(parameters)

"""

import numpy as np
import torch
import torch.nn as nn
import utils.modules as modules


class BrainMapperUNet3D(nn.Module):
    """Architecture class BrainMapper 3D U-net.

    This class contains the pytorch implementation of the U-net architecture underpinning the BrainMapper project.

    Args:
        parameters (dict): Contains information relevant parameters
        parameters = {
            'kernel_heigth': 5
            'kernel_width': 5
            'kernel_depth': 5
            'kernel_classification': 1
            'input_channels': 1
            'output_channels': 64
            'convolution_stride': 1
            'dropout': 0.2
            'pool_kernel_size': 2
            'pool_stride': 2
            'up_mode': 'upconv'
            'number_of_classes': 1
        }

    Returns:
        probability_map (torch.tensor): Output forward passed tensor through the U-net block
    """

    def __init__(self, parameters):
        super(BrainMapperUNet3D, self).__init__()

        original_input_channels = parameters['input_channels']
        original_output_channels = parameters['output_channels']

        self.encoderBlock1 = modules.EncoderBlock3D(parameters)
        parameters['input_channels'] = parameters['output_channels']
        parameters['output_channels'] = parameters['output_channels'] * 2
        self.encoderBlock2 = modules.EncoderBlock3D(parameters)
        parameters['input_channels'] = parameters['output_channels']
        parameters['output_channels'] = parameters['output_channels'] * 2
        self.encoderBlock3 = modules.EncoderBlock3D(parameters)
        parameters['input_channels'] = parameters['output_channels']
        parameters['output_channels'] = parameters['output_channels'] * 2
        self.encoderBlock4 = modules.EncoderBlock3D(parameters)

        parameters['input_channels'] = parameters['output_channels']
        parameters['output_channels'] = parameters['output_channels'] * 2
        self.bottleneck = modules.ConvolutionalBlock3D(parameters)

        parameters['input_channels'] = parameters['output_channels']
        parameters['output_channels'] = parameters['output_channels'] // 2
        self.decoderBlock1 = modules.DecoderBlock3D(parameters)
        parameters['input_channels'] = parameters['output_channels']
        parameters['output_channels'] = parameters['output_channels'] // 2
        self.decoderBlock2 = modules.DecoderBlock3D(parameters)
        parameters['input_channels'] = parameters['output_channels']
        parameters['output_channels'] = parameters['output_channels'] // 2
        self.decoderBlock3 = modules.DecoderBlock3D(parameters)
        parameters['input_channels'] = parameters['output_channels']
        parameters['output_channels'] = parameters['output_channels'] // 2
        self.decoderBlock4 = modules.DecoderBlock3D(parameters)

        parameters['input_channels'] = parameters['output_channels']
        self.classifier = modules.ClassifierBlock3D(parameters)

        parameters['input_channels'] = original_input_channels
        parameters['output_channels'] = original_output_channels

    def forward(self, X):
        """Forward pass for 3D U-net

        Function computing the forward pass through the 3D U-Net
        The input to the function is the dMRI map

        Args:
            X (torch.tensor): Input dMRI map, shape = (N x C x D x H x W) 

        Returns:
            probability_map (torch.tensor): Output forward passed tensor through the U-net block
        """

        Y_encoder_1, Y_np1, _ = self.encoderBlock1.forward(X)
        Y_encoder_2, Y_np2, _ = self.encoderBlock2.forward(
            Y_encoder_1)

        del Y_encoder_1

        Y_encoder_3, Y_np3, _ = self.encoderBlock3.forward(
            Y_encoder_2)

        del Y_encoder_2

        Y_encoder_4, Y_np4, _ = self.encoderBlock4.forward(
            Y_encoder_3)

        del Y_encoder_3

        Y_bottleNeck = self.bottleneck.forward(Y_encoder_4)

        del Y_encoder_4

        Y_decoder_1 = self.decoderBlock1.forward(
            Y_bottleNeck, Y_np4)

        del Y_bottleNeck, Y_np4

        Y_decoder_2 = self.decoderBlock2.forward(
            Y_decoder_1, Y_np3)

        del Y_decoder_1, Y_np3

        Y_decoder_3 = self.decoderBlock3.forward(
            Y_decoder_2, Y_np2)

        del Y_decoder_2, Y_np2

        Y_decoder_4 = self.decoderBlock4.forward(
            Y_decoder_3, Y_np1)

        del Y_decoder_3, Y_np1

        probability_map = self.classifier.forward(Y_decoder_4)

        del Y_decoder_4

        return probability_map

    def save(self, path):
        """Model Saver

        Function saving the model with all its parameters to a given path.
        The path must end with a *.model argument.

        Args:
            path (str): Path string
        """

        print("Saving Model... {}".format(path))
        torch.save(self, path)

    @property
    def test_if_cuda(self):
        """Cuda Test

        This function tests if the model parameters are allocated to a CUDA enabled GPU.

        Returns:
            bool: Flag indicating True if the tensor is stored on the GPU and Flase otherwhise
        """

        return next(self.parameters()).is_cuda

    def predict(self, X, device=0):
        """Post-training Output Prediction

        This function predicts the output of the of the U-net post-training

        Args:
            X (torch.tensor): input dMRI volume
            device (int/str): Device type used for training (int - GPU id, str- CPU)

        Returns:
            prediction (ndarray): predicted output after training

        """
        self.eval()  # PyToch module setting network to evaluation mode

        if type(X) is np.ndarray:
            X = torch.tensor(X, requires_grad=False).type(torch.FloatTensor)
        elif type(X) is torch.Tensor and not X.is_cuda:
            X = X.type(torch.FloatTensor).cuda(device, non_blocking=True)

        # .cuda() call transfers the densor from the CPU to the GPU if that is the case.
        # Non-blocking argument lets the caller bypas synchronization when necessary

        with torch.no_grad():  # Causes operations to have no gradients
            output = self.forward(X)

        _, idx = torch.max(output, 1)

        # We retrieve the tensor held by idx (.data), and map it to a cpu as an ndarray
        idx = idx.data.cpu().numpy()

        prediction = np.squeeze(idx)

        del X, output, idx

        return prediction

# DEPRECATED ARCHITECTURES!


class BrainMapperUNet(nn.Module):
    """Architecture class BrainMapper U-net.

    This class contains the pytorch implementation of the U-net architecture underpinning the BrainMapper project.

    Args:
        parameters (dict): Contains information relevant parameters
        parameters = {
            'kernel_heigth': 5
            'kernel_width': 5
            'kernel_classification': 1
            'input_channels': 1
            'output_channels': 64
            'convolution_stride': 1
            'dropout': 0.2
            'pool_kernel_size': 2
            'pool_stride': 2
            'up_mode': 'upconv'
            'number_of_classes': 1
        }

    Returns:
        probability_map (torch.tensor): Output forward passed tensor through the U-net block
    """

    def __init__(self, parameters):
        super(BrainMapperUNet, self).__init__()

        # TODO: currently, architecture based on QuickNAT - need to adjust parameter values accordingly!

        self.encoderBlock1 = modules.EncoderBlock(parameters)
        parameters['input_channels'] = parameters['output_channels']
        self.encoderBlock2 = modules.EncoderBlock(parameters)
        self.encoderBlock3 = modules.EncoderBlock(parameters)
        self.encoderBlock4 = modules.EncoderBlock(parameters)

        self.bottleneck = modules.ConvolutionalBlock(parameters)

        parameters['input_channels'] = parameters['output_channels'] * 2.0
        self.decoderBlock1 = modules.DecoderBlock(parameters)
        self.decoderBlock2 = modules.DecoderBlock(parameters)
        self.decoderBlock3 = modules.DecoderBlock(parameters)
        self.decoderBlock4 = modules.DecoderBlock(parameters)

        parameters['input_channels'] = parameters['output_channels']
        self.classifier = modules.ClassifierBlock(parameters)

    def forward(self, X):
        """Forward pass for U-net

        Function computing the forward pass through the U-Net
        The input to the function is the dMRI map

        Args:
            X (torch.tensor): Input dMRI map, shape = (N x C x H x W) 

        Returns:
            probability_map (torch.tensor): Output forward passed tensor through the U-net block
        """

        Y_encoder_1, Y_np1, pool_indices1 = self.encoderBlock1.forward(X)
        Y_encoder_2, Y_np2, pool_indices2 = self.encoderBlock2.forward(
            Y_encoder_1)

        del Y_encoder_1

        Y_encoder_3, Y_np3, pool_indices3 = self.encoderBlock3.forward(
            Y_encoder_2)

        del Y_encoder_2

        Y_encoder_4, Y_np4, pool_indices4 = self.encoderBlock4.forward(
            Y_encoder_3)

        del Y_encoder_3

        Y_bottleNeck = self.bottleneck.forward(Y_encoder_4)

        del Y_encoder_4

        Y_decoder_1 = self.decoderBlock1.forward(
            Y_bottleNeck, Y_np4, pool_indices4)

        del Y_bottleNeck, Y_np4, pool_indices4

        Y_decoder_2 = self.decoderBlock2.forward(
            Y_decoder_1, Y_np3, pool_indices3)

        del Y_decoder_1, Y_np3, pool_indices3

        Y_decoder_3 = self.decoderBlock3.forward(
            Y_decoder_2, Y_np2, pool_indices2)

        del Y_decoder_2, Y_np2, pool_indices2

        Y_decoder_4 = self.decoderBlock4.forward(
            Y_decoder_3, Y_np1, pool_indices1)

        del Y_decoder_3, Y_np1, pool_indices1

        probability_map = self.classifier.forward(Y_decoder_4)

        del Y_decoder_4

        return probability_map

    def save(self, path):
        """Model Saver

        Function saving the model with all its parameters to a given path.
        The path must end with a *.model argument.

        Args:
            path (str): Path string
        """

        print("Saving Model... {}".format(path))
        torch.save(self, path)

    @property
    def test_if_cuda(self):
        """Cuda Test

        This function tests if the model parameters are allocated to a CUDA enabled GPU.

        Returns:
            bool: Flag indicating True if the tensor is stored on the GPU and Flase otherwhise
        """

        return next(self.parameters()).is_cuda

    def predict(self, X, device=0):
        """Post-training Output Prediction

        This function predicts the output of the of the U-net post-training

        Args:
            X (torch.tensor): input dMRI volume
            device (int/str): Device type used for training (int - GPU id, str- CPU)

        Returns:
            prediction (ndarray): predicted output after training

        """
        self.eval()  # PyToch module setting network to evaluation mode

        if type(X) is np.ndarray:
            X = torch.tensor(X, requires_grad=False).type(torch.FloatTensor)
        elif type(X) is torch.Tensor and not X.is_cuda:
            X = X.type(torch.FloatTensor).cuda(device, non_blocking=True)

        # .cuda() call transfers the densor from the CPU to the GPU if that is the case.
        # Non-blocking argument lets the caller bypas synchronization when necessary

        with torch.no_grad():  # Causes operations to have no gradients
            output = self.forward(X)

        _, idx = torch.max(output, 1)

        # We retrieve the tensor held by idx (.data), and map it to a cpu as an ndarray
        idx = idx.data.cpu().numpy()

        prediction = np.squeeze(idx)

        del X, output, idx

        return prediction


class BrainMapperUNet3D_Simple(nn.Module):
    """Architecture class BrainMapper 3D U-net.

    This class contains the pytorch implementation of the U-net architecture underpinning the BrainMapper project.

    Args:
        parameters (dict): Contains information relevant parameters
        parameters = {
            'kernel_heigth': 5
            'kernel_width': 5
            'kernel_depth': 5
            'kernel_classification': 1
            'input_channels': 1
            'output_channels': 64
            'convolution_stride': 1
            'dropout': 0.2
            'pool_kernel_size': 2
            'pool_stride': 2
            'up_mode': 'upconv'
            'number_of_classes': 1
        }

    Returns:
        probability_map (torch.tensor): Output forward passed tensor through the U-net block
    """

    def __init__(self, parameters):
        super(BrainMapperUNet3D_Simple, self).__init__()

        # TODO: currently, architecture based on QuickNAT - need to adjust parameter values accordingly!

        self.encoderBlock1 = modules.EncoderBlock3D(parameters)
        parameters['input_channels'] = parameters['output_channels']
        self.encoderBlock2 = modules.EncoderBlock3D(parameters)
        self.encoderBlock3 = modules.EncoderBlock3D(parameters)
        self.encoderBlock4 = modules.EncoderBlock3D(parameters)

        self.bottleneck = modules.ConvolutionalBlock3D(parameters)

        parameters['input_channels'] = parameters['output_channels'] * 2
        self.decoderBlock1 = modules.DecoderBlock3D(parameters)
        self.decoderBlock2 = modules.DecoderBlock3D(parameters)
        self.decoderBlock3 = modules.DecoderBlock3D(parameters)
        self.decoderBlock4 = modules.DecoderBlock3D(parameters)

        parameters['input_channels'] = parameters['output_channels']
        self.classifier = modules.ClassifierBlock3D(parameters)

    def forward(self, X):
        """Forward pass for 3D U-net

        Function computing the forward pass through the 3D U-Net
        The input to the function is the dMRI map

        Args:
            X (torch.tensor): Input dMRI map, shape = (N x C x D x H x W) 

        Returns:
            probability_map (torch.tensor): Output forward passed tensor through the U-net block
        """

        Y_encoder_1, Y_np1, pool_indices1 = self.encoderBlock1.forward(X)
        Y_encoder_2, Y_np2, pool_indices2 = self.encoderBlock2.forward(
            Y_encoder_1)

        del Y_encoder_1

        Y_encoder_3, Y_np3, pool_indices3 = self.encoderBlock3.forward(
            Y_encoder_2)

        del Y_encoder_2

        Y_encoder_4, Y_np4, pool_indices4 = self.encoderBlock4.forward(
            Y_encoder_3)

        del Y_encoder_3

        Y_bottleNeck = self.bottleneck.forward(Y_encoder_4)

        del Y_encoder_4

        Y_decoder_1 = self.decoderBlock1.forward(
            Y_bottleNeck, Y_np4, pool_indices4)

        del Y_bottleNeck, Y_np4, pool_indices4

        Y_decoder_2 = self.decoderBlock2.forward(
            Y_decoder_1, Y_np3, pool_indices3)

        del Y_decoder_1, Y_np3, pool_indices3

        Y_decoder_3 = self.decoderBlock3.forward(
            Y_decoder_2, Y_np2, pool_indices2)

        del Y_decoder_2, Y_np2, pool_indices2

        Y_decoder_4 = self.decoderBlock4.forward(
            Y_decoder_3, Y_np1, pool_indices1)

        del Y_decoder_3, Y_np1, pool_indices1

        probability_map = self.classifier.forward(Y_decoder_4)

        del Y_decoder_4

        probability_map = self.classifier.forward(Y_decoder_4)

        return probability_map

    def save(self, path):
        """Model Saver

        Function saving the model with all its parameters to a given path.
        The path must end with a *.model argument.

        Args:
            path (str): Path string
        """

        print("Saving Model... {}".format(path))
        torch.save(self, path)

    @property
    def test_if_cuda(self):
        """Cuda Test

        This function tests if the model parameters are allocated to a CUDA enabled GPU.

        Returns:
            bool: Flag indicating True if the tensor is stored on the GPU and Flase otherwhise
        """

        return next(self.parameters()).is_cuda

    def predict(self, X, device=0):
        """Post-training Output Prediction

        This function predicts the output of the of the U-net post-training

        Args:
            X (torch.tensor): input dMRI volume
            device (int/str): Device type used for training (int - GPU id, str- CPU)

        Returns:
            prediction (ndarray): predicted output after training

        """
        self.eval()  # PyToch module setting network to evaluation mode

        if type(X) is np.ndarray:
            X = torch.tensor(X, requires_grad=False).type(torch.FloatTensor)
        elif type(X) is torch.Tensor and not X.is_cuda:
            X = X.type(torch.FloatTensor).cuda(device, non_blocking=True)

        # .cuda() call transfers the densor from the CPU to the GPU if that is the case.
        # Non-blocking argument lets the caller bypas synchronization when necessary

        with torch.no_grad():  # Causes operations to have no gradients
            output = self.forward(X)

        _, idx = torch.max(output, 1)

        # We retrieve the tensor held by idx (.data), and map it to a cpu as an ndarray
        idx = idx.data.cpu().numpy()

        prediction = np.squeeze(idx)

        del X, output, idx

        return prediction

# if __name__ == '__main__':

#     # For debugging - To be deleted later! TODO

#     parameters = {
#         'kernel_heigth': 5,
#         'kernel_width': 5,
#         'kernel_depth': 5,
#         'kernel_classification': 1,
#         'input_channels': 1,
#         'output_channels': 64,
#         'convolution_stride': 1,
#         'dropout': 0.2,
#         'pool_kernel_size': 2,
#         'pool_stride': 2,
#         'up_mode': 'upconv',
#         'number_of_classes': 1
#     }

#     network = BrainMapperUNet3D(parameters)