initial commit

app.py

@@ -0,0 +1,185 @@
+import utils
+import gradio as gr
+import tensorflow as tf
+import matplotlib.pyplot as plt
+from ttictoc import tic,toc
+
+# '''--------------------------- Preprocesamiento ----------------------------'''
+# tic()
+# 3D U-Net
+path_3d_unet = 'F:/Desktop/Universidad/Semestres/NovenoSemestre/Proyecto_de_Grado/Codigo/3D_U-Net/outputs/checkpoints/model.49-0.97.h5'
+
+with tf.device("cpu:0"):
+    model_unet = utils.import_3d_unet(path_3d_unet)
+
+# # Cargar imagen
+# img = utils.load_img('F:/Downloads/ADNI_002_S_0295_MR_MP-RAGE__br_raw_20070525135721811_1_S32678_I55275.nii')
+
+# # Extraer cerebro
+# with tf.device("cpu:0"):
+#     brain = utils.brain_stripping(img, model_unet)
+# print(toc())
+
+# '''---------------------------- Procesamiento ------------------------------'''
+# # Med net
+# weight_path = 'F:/Desktop/Universidad/Semestres/NovenoSemestre/Proyecto_de_Grado/Codigo/Procesamiento/mednet_weights/pretrain/resnet_50_23dataset.pth'
+# device_ids = [0]
+# mednet = utils.create_mednet(weight_path, device_ids)
+
+# # Extraer características
+# features = utils.get_features(brain, mednet)
+
+def load_img(file):
+    sitk, array = utils.load_img(file.name)     
+    return sitk, array
+
+def show_img(img, mri_slice):
+    fig = plt.figure()
+    plt.imshow(img[:,:,mri_slice], cmap='gray')
+    
+    return fig, gr.update(visible=True)
+
+def show_brain(brain, brain_slice):
+    fig = plt.figure()
+    plt.imshow(brain[brain_slice,:,:], cmap='gray')
+    
+    return fig, gr.update(visible=True)
+
+def process_img(img, brain_slice):
+    with tf.device("cpu:0"):
+        brain = utils.brain_stripping(img, model_unet)
+        
+        fig, update = show_brain(brain, brain_slice)
+        
+    return brain, fig, update
+
+def clear():
+    return gr.File.update(value=None), gr.Plot.update(value=None), gr.update(visible=False)
+
+# gr.Textbox.update(placeholder='Ingrese nombre del paciente'), gr.Number.update(value=0), 
+
+# demo = gr.Interface(fn=load_img,
+#                     inputs=gr.File(file_count="single", file_type=[".nii"]),
+#                     outputs=gr.Plot()
+#                     # outputs='text'
+#                     )
+
+with gr.Blocks() as demo:
+    with gr.Row():
+        gr.Markdown("""
+                    # SIMCI
+                    Interfaz de SIMCI
+                    """)
+    
+    # Inputs
+    with gr.Row():
+        with gr.Column(scale=1):  
+            # Objeto para subir archivo nifti
+            input_name = gr.Textbox(placeholder='Ingrese nombre del paciente', label='Nombre')
+            input_age = gr.Number(label='Edad')
+            
+            
+            input_file = gr.File(file_count="single", file_type=[".nii"], label="Archivo Imagen MRI")
+                
+            with gr.Row():
+                # Botón para cargar imagen
+                load_img_button = gr.Button(value="Load")
+                
+                # Botón para borrar
+                clear_button = gr.Button(value="Clear")
+            
+            # Botón para procesar imagen
+            process_button = gr.Button(value="Procesar")
+    
+        # Outputs 
+        with gr.Column(scale=1):
+            # Plot para imágen original
+            plot_img_original = gr.Plot(label="Imagen MRI original")
+            
+            # Slider para imágen original
+            mri_slider = gr.Slider(minimum=0,
+                                    maximum=166,
+                                    value=100,
+                                    step=1,
+                                    label="MRI Slice",
+                                    visible=False) 
+            
+            # Plot para imágen procesada
+            plot_brain = gr.Plot(label="Imagen MRI procesada")
+            
+            # Slider para imágen procesada
+            brain_slider = gr.Slider(minimum=0,
+                                     maximum=192,
+                                     value=100,
+                                     step=1,
+                                     label="MRI Slice",
+                                     visible=False)
+    
+    # componentes = 
+    
+    # Variables
+    original_input_sitk = gr.State()
+    original_input_img = gr.State()
+    brain_img = gr.State()
+    
+    # Cambios
+    # Cargar imagen nueva
+    input_file.change(load_img, 
+                      input_file, 
+                      [original_input_sitk, original_input_img])
+    
+    # Mostrar imagen nueva
+    load_img_button.click(show_img, 
+                          [original_input_img, mri_slider], 
+                          [plot_img_original, mri_slider])
+    
+    # Limpiar campos
+    clear_button.click(fn=clear, 
+                       outputs=[input_file, plot_img_original, mri_slider])
+    
+    # Actualizar imagen original
+    mri_slider.change(show_img, 
+                      [original_input_img, mri_slider], 
+                      [plot_img_original,mri_slider])
+    
+    # Procesar imagen
+    process_button.click(fn=process_img, 
+                         inputs=[original_input_sitk, brain_slider], 
+                         outputs=[brain_img,plot_brain,brain_slider])
+    
+    # Actualizar imagen procesada
+    brain_slider.change(show_brain,
+                        [brain_img, brain_slider], 
+                        [plot_brain,brain_slider])
+
+
+if __name__ == "__main__":
+    demo.launch()
+
+# # Visualización resultados 
+# mri_slice = 100
+
+# # Plot Comparación máscaras
+# fig, axs = plt.subplots(1,2)
+# fig.subplots_adjust(bottom=0.15)
+# fig.suptitle('Comparación Máscaras Obtenidas')
+
+# axs[0].set_title('MRI original')
+# axs[0].imshow(img[mri_slice,:,:],cmap='gray')
+
+# axs[1].set_title('Cerebro extraido con 3D U-Net')
+# axs[1].imshow(brain[mri_slice,:,:],cmap='gray')
+
+
+# # Slider para cambiar slice
+# ax_slider = plt.axes([0.15, 0.05, 0.75, 0.03])
+# mri_slice_slider = Slider(ax_slider, 'Slice', 0, 192, 100, valstep=1)
+
+# def update(val):
+#     mri_slice = mri_slice_slider.val
+    
+#     axs[0].imshow(img[:,:,mri_slice],cmap='gray')
+#     axs[1].imshow(brain[mri_slice,:,:],cmap='gray')
+    
+# # Actualizar plot comparación máscaras
+# mri_slice_slider.on_changed(update)

resnet.py

@@ -0,0 +1,263 @@
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+from torch.autograd import Variable
+import math
+from functools import partial
+
+__all__ = [
+    'ResNet', 'resnet10', 'resnet18', 'resnet34', 'resnet50', 'resnet101',
+    'resnet152', 'resnet200'
+]
+
+
+def conv3x3x3(in_planes, out_planes, stride=1, dilation=1):
+    # 3x3x3 convolution with padding
+    return nn.Conv3d(
+        in_planes,
+        out_planes,
+        kernel_size=3,
+        dilation=dilation,
+        stride=stride,
+        padding=dilation,
+        bias=False)
+
+
+def downsample_basic_block(x, planes, stride, no_cuda=False):
+    out = F.avg_pool3d(x, kernel_size=1, stride=stride)
+    zero_pads = torch.Tensor(
+        out.size(0), planes - out.size(1), out.size(2), out.size(3),
+        out.size(4)).zero_()
+    if not no_cuda:
+        if isinstance(out.data, torch.cuda.FloatTensor):
+            zero_pads = zero_pads.cuda()
+
+    out = Variable(torch.cat([out.data, zero_pads], dim=1))
+
+    return out
+
+
+class BasicBlock(nn.Module):
+    expansion = 1
+
+    def __init__(self, inplanes, planes, stride=1, dilation=1, downsample=None):
+        super(BasicBlock, self).__init__()
+        self.conv1 = conv3x3x3(inplanes, planes, stride=stride, dilation=dilation)
+        self.bn1 = nn.BatchNorm3d(planes)
+        self.relu = nn.ReLU(inplace=True)
+        self.conv2 = conv3x3x3(planes, planes, dilation=dilation)
+        self.bn2 = nn.BatchNorm3d(planes)
+        self.downsample = downsample
+        self.stride = stride
+        self.dilation = dilation
+
+    def forward(self, x):
+        residual = x
+
+        out = self.conv1(x)
+        out = self.bn1(out)
+        out = self.relu(out)
+        out = self.conv2(out)
+        out = self.bn2(out)
+
+        if self.downsample is not None:
+            residual = self.downsample(x)
+
+        out += residual
+        out = self.relu(out)
+
+        return out
+
+
+class Bottleneck(nn.Module):
+    expansion = 4
+
+    def __init__(self, inplanes, planes, stride=1, dilation=1, downsample=None):
+        super(Bottleneck, self).__init__()
+        self.conv1 = nn.Conv3d(inplanes, planes, kernel_size=1, bias=False)
+        self.bn1 = nn.BatchNorm3d(planes)
+        self.conv2 = nn.Conv3d(
+            planes, planes, kernel_size=3, stride=stride, dilation=dilation, padding=dilation, bias=False)
+        self.bn2 = nn.BatchNorm3d(planes)
+        self.conv3 = nn.Conv3d(planes, planes * 4, kernel_size=1, bias=False)
+        self.bn3 = nn.BatchNorm3d(planes * 4)
+        self.relu = nn.ReLU(inplace=True)
+        self.downsample = downsample
+        self.stride = stride
+        self.dilation = dilation
+
+    def forward(self, x):
+        residual = x
+
+        out = self.conv1(x)
+        out = self.bn1(out)
+        out = self.relu(out)
+
+        out = self.conv2(out)
+        out = self.bn2(out)
+        out = self.relu(out)
+
+        out = self.conv3(out)
+        out = self.bn3(out)
+
+        if self.downsample is not None:
+            residual = self.downsample(x)
+
+        out += residual
+        out = self.relu(out)
+
+        return out
+
+
+class ResNet(nn.Module):
+
+    def __init__(self,
+                 block,
+                 layers,
+                 sample_input_D,
+                 sample_input_H,
+                 sample_input_W,
+                 num_seg_classes,
+                 shortcut_type='B',
+                 no_cuda = False):
+        self.inplanes = 64
+        self.no_cuda = no_cuda
+        super(ResNet, self).__init__()
+        self.conv1 = nn.Conv3d(
+            1,
+            64,
+            kernel_size=7,
+            stride=(2, 2, 2),
+            padding=(3, 3, 3),
+            bias=False)
+            
+        self.bn1 = nn.BatchNorm3d(64)
+        self.relu = nn.ReLU(inplace=True)
+        self.maxpool = nn.MaxPool3d(kernel_size=(3, 3, 3), stride=2, padding=1)
+        self.layer1 = self._make_layer(block, 64, layers[0], shortcut_type)
+        self.layer2 = self._make_layer(
+            block, 128, layers[1], shortcut_type, stride=2)
+        self.layer3 = self._make_layer(
+            block, 256, layers[2], shortcut_type, stride=1, dilation=2)
+        self.layer4 = self._make_layer(
+            block, 512, layers[3], shortcut_type, stride=1, dilation=4)
+
+        self.conv_seg = nn.Sequential(
+                                        nn.ConvTranspose3d(
+                                        512 * block.expansion,
+                                        32,
+                                        2,
+                                        stride=2
+                                        ),
+                                        nn.BatchNorm3d(32),
+                                        nn.ReLU(inplace=True),
+                                        nn.Conv3d(
+                                        32,
+                                        32,
+                                        kernel_size=3,
+                                        stride=(1, 1, 1),
+                                        padding=(1, 1, 1),
+                                        bias=False), 
+                                        nn.BatchNorm3d(32),
+                                        nn.ReLU(inplace=True),
+                                        nn.Conv3d(
+                                        32,
+                                        num_seg_classes,
+                                        kernel_size=1,
+                                        stride=(1, 1, 1),
+                                        bias=False) 
+                                        )
+
+        for m in self.modules():
+            if isinstance(m, nn.Conv3d):
+                m.weight = nn.init.kaiming_normal_(m.weight, mode='fan_out')
+            elif isinstance(m, nn.BatchNorm3d):
+                m.weight.data.fill_(1)
+                m.bias.data.zero_()
+
+    def _make_layer(self, block, planes, blocks, shortcut_type, stride=1, dilation=1):
+        downsample = None
+        if stride != 1 or self.inplanes != planes * block.expansion:
+            if shortcut_type == 'A':
+                downsample = partial(
+                    downsample_basic_block,
+                    planes=planes * block.expansion,
+                    stride=stride,
+                    no_cuda=self.no_cuda)
+            else:
+                downsample = nn.Sequential(
+                    nn.Conv3d(
+                        self.inplanes,
+                        planes * block.expansion,
+                        kernel_size=1,
+                        stride=stride,
+                        bias=False), nn.BatchNorm3d(planes * block.expansion))
+
+        layers = []
+        layers.append(block(self.inplanes, planes, stride=stride, dilation=dilation, downsample=downsample))
+        self.inplanes = planes * block.expansion
+        for i in range(1, blocks):
+            layers.append(block(self.inplanes, planes, dilation=dilation))
+
+        return nn.Sequential(*layers)
+
+    def forward(self, x):
+        x = self.conv1(x)
+        x = self.bn1(x)
+        x = self.relu(x)
+        x = self.maxpool(x)
+        x = self.layer1(x)
+        x = self.layer2(x)
+        x = self.layer3(x)
+        x = self.layer4(x)
+        x = self.conv_seg(x)
+
+        return x
+
+def resnet10(**kwargs):
+    """Constructs a ResNet-18 model.
+    """
+    model = ResNet(BasicBlock, [1, 1, 1, 1], **kwargs)
+    return model
+
+
+def resnet18(**kwargs):
+    """Constructs a ResNet-18 model.
+    """
+    model = ResNet(BasicBlock, [2, 2, 2, 2], **kwargs)
+    return model
+
+
+def resnet34(**kwargs):
+    """Constructs a ResNet-34 model.
+    """
+    model = ResNet(BasicBlock, [3, 4, 6, 3], **kwargs)
+    return model
+
+
+def resnet50(**kwargs):
+    """Constructs a ResNet-50 model.
+    """
+    model = ResNet(Bottleneck, [3, 4, 6, 3], **kwargs)
+    return model
+
+
+def resnet101(**kwargs):
+    """Constructs a ResNet-101 model.
+    """
+    model = ResNet(Bottleneck, [3, 4, 23, 3], **kwargs)
+    return model
+
+
+def resnet152(**kwargs):
+    """Constructs a ResNet-101 model.
+    """
+    model = ResNet(Bottleneck, [3, 8, 36, 3], **kwargs)
+    return model
+
+
+def resnet200(**kwargs):
+    """Constructs a ResNet-101 model.
+    """
+    model = ResNet(Bottleneck, [3, 24, 36, 3], **kwargs)
+    return model

utils.py

@@ -0,0 +1,182 @@
+# import os
+import torch
+import resnet
+import numpy as np
+import tensorflow as tf
+# import nibabel as nib
+import SimpleITK as sitk
+import segmentation_models_3D as sm
+from torch import nn
+# from ttictoc import tic,toc
+from skimage import morphology
+from keras import backend as K
+from scipy import ndimage as ndi
+from keras.models import load_model
+from patchify import patchify, unpatchify
+
+# from matplotlib import pyplot as plt
+# from matplotlib.widgets import Slider
+
+# Función que retorna modelo 3D U-Net para extracción de cerebro
+def import_3d_unet(path_3d_unet):
+    # Métricas de desempeño
+    def dice_coefficient(y_true, y_pred):
+        smoothing_factor = 1
+        flat_y_true = K.flatten(y_true)
+        flat_y_pred = K.flatten(y_pred)
+        return (2. * K.sum(flat_y_true * flat_y_pred) + smoothing_factor) / (K.sum(flat_y_true) + K.sum(flat_y_pred) + smoothing_factor)
+    
+    # Cargar modelo preentrenado
+    # with tf.device('/cpu:0'):
+    model = load_model(path_3d_unet, custom_objects={'dice_coefficient':dice_coefficient, 'iou_score':sm.metrics.IOUScore(threshold=0.5)})
+    return model
+    
+    
+# Función que caraga imagen en formato nifti, aplica filtro N4 y normaliza imagen
+def load_img(path):
+    # Lectura de MRI T1 formato nifti
+    inputImage = sitk.ReadImage(path, sitk.sitkFloat32)
+
+    return inputImage, sitk.GetArrayFromImage(inputImage).astype(np.float32)
+
+# Función que remueve 
+def brain_stripping(inputImage, model_unet):
+    """----------------------Preprocesamiento imagen MRI-----------------------"""
+    image = inputImage
+    
+    # N4 Bias Field Correction
+    maskImage = sitk.OtsuThreshold(inputImage, 0, 1, 200)
+    corrector = sitk.N4BiasFieldCorrectionImageFilter()
+    corrected_image = corrector.Execute(image, maskImage)
+    log_bias_field = corrector.GetLogBiasFieldAsImage(inputImage)
+    corrected_image_full_resolution = inputImage / sitk.Exp(log_bias_field)
+    
+    #Normalización
+    image_normalized = sitk.GetArrayFromImage(corrected_image_full_resolution)
+    image_normalized = (image_normalized-np.min(image_normalized))/(np.max(image_normalized)-np.min(image_normalized))
+    image_normalized = image_normalized.astype(np.float32)
+    
+    # Redimención
+    mri_image = np.transpose(image_normalized)
+    mri_image = np.append(mri_image, np.zeros((192-mri_image.shape[0],256,256,)), axis=0)
+    
+    # Rotación
+    mri_image = mri_image.astype(np.float32)
+    mri_image = np.rot90(mri_image, axes=(1,2))
+
+    # Volume sampling
+    mri_patches = patchify(mri_image, (64, 64, 64), step=64)
+
+    """--------------------Predicción de máscara de cerebro--------------------"""
+    # Máscara de cerebro para cada volúmen
+    mask_patches = []
+
+    for i in range(mri_patches.shape[0]):
+      for j in range(mri_patches.shape[1]):
+        for k in range(mri_patches.shape[2]):
+           single_patch = np.expand_dims(mri_patches[i,j,k,:,:,:], axis=0)
+           single_patch_prediction = model_unet.predict(single_patch)
+           single_patch_prediction_th = (single_patch_prediction[0,:,:,:,0] > 0.5).astype(np.uint8)
+           mask_patches.append(single_patch_prediction_th)
+
+    # Conversión a numpy array
+    predicted_patches = np.array(mask_patches)
+
+    # Reshape para proceso de reconstrucción
+    predicted_patches_reshaped = np.reshape(predicted_patches, 
+                                            (mri_patches.shape[0], mri_patches.shape[1], mri_patches.shape[2],
+                                             mri_patches.shape[3], mri_patches.shape[4], mri_patches.shape[5]) )
+
+    # Reconstrucción máscara
+    reconstructed_mask = unpatchify(predicted_patches_reshaped, mri_image.shape)
+
+    # Suavizado máscara
+    corrected_mask = ndi.binary_closing(reconstructed_mask, structure=morphology.ball(2)).astype(np.uint8)
+
+    # Eliminación de volumenes ruido
+    no_noise_mask = corrected_mask.copy()
+    mask_labeled = morphology.label(corrected_mask, background=0, connectivity=3)
+    label_count = np.unique(mask_labeled, return_counts=True)
+    brain_label = np.argmax(label_count[1][1:]) + 1
+
+    no_noise_mask[np.where(mask_labeled != brain_label)] = 0
+
+    # Elimicación huecos y hendiduras
+    filled_mask = ndi.binary_closing(no_noise_mask, structure=morphology.ball(12)).astype(np.uint8)
+
+    """-------------------------Extracción de cerebro--------------------------"""
+    # Aplicar máscara a imagen mri
+    mri_brain = np.multiply(mri_image,filled_mask)
+    
+    return mri_brain
+
+# Función que retorna modelo MedNet
+def create_mednet(weight_path, device_ids): 
+    # Clase para agregar capa totalmente conectada
+    class simci_net(nn.Module):
+        def __init__(self):
+            super(simci_net, self).__init__()
+            
+            self.pretrained_model = resnet.resnet50(sample_input_D=192, sample_input_H=256, sample_input_W=256, num_seg_classes=2, no_cuda = False)
+            self.pretrained_model.conv_seg = nn.Sequential(nn.AdaptiveMaxPool3d(output_size=(1, 1, 1)),
+                                                           nn.Flatten(start_dim=1))
+            
+            
+        def forward(self, x):
+            x = self.pretrained_model(x)   
+            
+            return x
+    
+    # Path con pesos preentrenados
+    weight_path = weight_path
+    
+    # Lista de GPUs para utilizar
+    device_ids = device_ids 
+    
+    # Generar red
+    simci_model = simci_net()
+    
+    # Distribuir en varias GPUs
+    simci_model = torch.nn.DataParallel(simci_model, device_ids = device_ids)
+    simci_model.to(f'cuda:{simci_model.device_ids[0]}')
+    
+    # Diccionario state
+    net_dict = simci_model.state_dict()
+    
+    # Cargar pesos
+    weight = torch.load(weight_path, map_location=torch.device(f'cuda:{simci_model.device_ids[0]}'))
+    
+    # Transferencia de aprendizaje
+    pretrain_dict = {}
+    
+    for k, v in weight['state_dict'].items():
+        if k.replace("module.", "module.pretrained_model.") in net_dict.keys():
+            pretrain_dict[k.replace("module.", "module.pretrained_model.")] = v     
+    
+    # pretrain_dict = {k.replace("module.", ""): v for k, v in weight['state_dict'].items() if k.replace("module.", "") in net_dict.keys()}
+    net_dict.update(pretrain_dict)
+    simci_model.load_state_dict(net_dict)
+    
+    # Bloqueo de parametros mednet
+    for param in simci_model.module.pretrained_model.parameters():
+        param.requires_grad = False
+        
+    simci_model.eval() # Modelo en modo evaluación
+        
+    return simci_model
+
+# Función que extrae características de cerebro
+def get_features(brain, mednet_model):
+    with torch.no_grad():
+        # Convertir a tensor
+        data = torch.from_numpy(np.expand_dims(np.expand_dims(brain,axis=0), axis=0))
+        
+        # Enviar imagen a GPU
+        data = data.to(f'cuda:{mednet_model.device_ids[0]}')
+        
+        # Extraer Características
+        features = mednet_model(data) # Forward
+        features = features.cpu().numpy()
+    
+        torch.cuda.empty_cache()
+    return features