First commit

app.py

@@ -0,0 +1,126 @@
+import streamlit as st
+from PIL import Image
+import numpy as np
+import cv2
+import tensorflow as tf
+from utils.model import Unet_3
+
+st.header("Segmentación de pulmón con Rayos X")
+
+
+st.markdown(
+    """
+Este es un demo para la clase de Platzi, utilizando un módelo de segmentación desarrollado como parte de mi trabajo de grado.
+
+Más Información del modelo se puede encontrar en el siguiente artículo:
+
+https://www.sciencedirect.com/science/article/pii/S2666827021000694?via%3Dihub
+
+"""
+)
+
+## Creamos la función del modelo con tensorflow
+model=Unet_3()
+
+model.load_weights("utils/weights/Unet_finetune_v3.h5")
+
+## Permitimos a la usuaria cargar una imagen
+archivo_imagen = st.file_uploader("Sube aquí tu imagen.", type=["png", "jpg", "jpeg"])
+
+## Si una imagen tiene más de un canal entonces se convierte a escala de grises (1 canal)
+def convertir_one_channel(img):
+    if len(img.shape) > 2:
+        img = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)
+        return img
+    else:
+        return img
+
+
+def convertir_rgb(img):
+    if len(img.shape) == 2:
+        img = cv2.cvtColor(img, cv2.COLOR_GRAY2RGB)
+        return img
+    else:
+        return img
+
+
+## Manipularemos la interfaz para que podamos usar imágenes ejemplo
+## Si el usuario da click en un ejemplo entonces el modelo correrá con él
+ejemplos = ["Lung_1.png", "Lung_2.png", "Lung_3.png","Lung_4.png"]
+path="assets/Examples/"
+## Creamos tres columnas; en cada una estará una imagen ejemplo
+col1, col2, col3, col4 = st.columns(4)
+with col1:
+    ## Se carga la imagen y se muestra en la interfaz
+    ex = Image.open(path+ejemplos[0])
+    st.image(ex, width=200)
+    ## Si oprime el botón entonces usaremos ese ejemplo en el modelo
+    if st.button("Corre este ejemplo 1"):
+        archivo_imagen = path+ejemplos[0]
+
+with col2:
+    ex1 = Image.open(path+ejemplos[1])
+    st.image(ex1, width=200)
+    if st.button("Corre este ejemplo 2"):
+        archivo_imagen = path+ejemplos[1]
+
+with col3:
+    ex2 = Image.open(path+ejemplos[2])
+    st.image(ex2, width=200)
+    if st.button("Corre este ejemplo 3"):
+        archivo_imagen = path+ejemplos[2]
+
+with col4:
+    ex2 = Image.open(path+ejemplos[3])
+    st.image(ex2, width=200)
+    if st.button("Corre este ejemplo 4"):
+        archivo_imagen = path+ejemplos[3]
+
+## Si tenemos una imagen para ingresar en el modelo entonces
+## la procesamos e ingresamos al modelo
+if archivo_imagen is not None:
+    ## Cargamos la imagen con PIL, la mostramos y la convertimos a un array de NumPy
+    img = Image.open(archivo_imagen)
+    st.image(img, width=850)
+    img = np.asarray(img)
+
+    #Variables estadisticas de las imagenes con las que se entrenó
+    mean_seg=0.5397013
+    std_seg=0.21162419
+
+    ## Procesamos la imagen para ingresarla al modelo
+    img_cv = convertir_one_channel(img)
+    #Normalizacion
+    maxi=np.max(img_cv)
+    mini=np.min(img_cv)
+    img_N=(img_cv-mini)/(maxi-mini)
+    #Estandarizacion
+    img_P=(img_N-mean_seg)/std_seg
+    
+    ## Ingresamos el array de NumPy al modelo
+    mask=model.predict(np.expand_dims(np.expand_dims(img_P,axis=-1),axis=0))
+    #mask=np.resize(mask,(224,224))
+    predicted=np.array(mask>0.5).astype(int)
+    img_seg_1=img*mask
+
+    ## Regresamos la imagen a su forma original y agregamos las máscaras de la segmentación
+    predicted = cv2.resize(
+        predicted, (img.shape[1], img.shape[0]), interpolation=cv2.INTER_LANCZOS4
+    )
+    mask = np.uint8(predicted * 255)  #
+    _, mask = cv2.threshold(
+        mask, thresh=0, maxval=255, type=cv2.THRESH_BINARY + cv2.THRESH_OTSU
+    )
+    kernel = np.ones((5, 5), dtype=np.float32)
+    mask = cv2.morphologyEx(mask, cv2.MORPH_OPEN, kernel, iterations=1)
+    mask = cv2.morphologyEx(mask, cv2.MORPH_CLOSE, kernel, iterations=1)
+    cnts, hieararch = cv2.findContours(mask, cv2.RETR_TREE, cv2.CHAIN_APPROX_SIMPLE)
+    output = cv2.drawContours(convertir_one_channel(img), cnts, -1, (255, 0, 0), 3)
+
+    ## Si obtuvimos exitosamente un resultadod entonces lo mostramos en la interfaz
+    if output is not None:
+        st.subheader("Segmentación:")
+        st.write(output.shape)
+        st.image(output, width=850)
+
+st.markdown("Gracias por usar nuestro demo! Nos vemos pronto")

requirements.txt

@@ -0,0 +1,5 @@
+tensorflow
+numpy
+Pillow
+scipy
+opencv-python

utils/metrics.py

@@ -0,0 +1,26 @@
+
+from tensorflow.keras import backend as K
+from tensorflow.keras.losses import binary_crossentropy
+import numpy as np
+import tensorflow as tf
+
+
+
+def dice_coef(y_true, y_pred):
+  smooth = 1
+  intersection = K.sum(K.abs(y_true * y_pred), axis=-1)
+  return (2. * intersection + smooth) / (K.sum(K.square(y_true),-1) + K.sum(K.square(y_pred),-1) + smooth)
+
+def dice_coef_loss(y_true, y_pred):
+  return 1-dice_coef(y_true, y_pred)
+
+def iou(y_true, y_pred):
+    def f(y_true, y_pred):
+        intersection = (y_true * y_pred).sum()
+        smooth = 1
+        union = y_true.sum() + y_pred.sum() - intersection
+        x = (intersection + smooth) / (union + smooth)
+        x = x.astype(np.float32)
+        return x
+    return tf.numpy_function(f, [y_true, y_pred], tf.float32)
+

utils/model.py

@@ -0,0 +1,66 @@
+import tensorflow as tf
+from metrics import *
+
+
+
+#Modelo Segmentacion
+def Unet_3():
+  inputs = tf.keras.layers.Input(shape=(224, 224, 1), name='input')
+  #s = tf.keras.layers.Lambda(lambda x: x / 255)(inputs)
+
+  #Contraction path
+  c1 = tf.keras.layers.Conv2D(64, (3, 3), activation='relu', kernel_initializer='he_normal', padding='same')(inputs)
+  c1 = tf.keras.layers.Dropout(0.1)(c1)
+  c1 = tf.keras.layers.Conv2D(64, (3, 3), activation='relu', kernel_initializer='he_normal', padding='same')(c1)
+  p1 = tf.keras.layers.MaxPooling2D((2, 2))(c1)
+
+  c2 = tf.keras.layers.Conv2D(128, (3, 3), activation='relu', kernel_initializer='he_normal', padding='same')(p1)
+  c2 = tf.keras.layers.Dropout(0.1)(c2)
+  c2 = tf.keras.layers.Conv2D(128, (3, 3), activation='relu', kernel_initializer='he_normal', padding='same')(c2)
+  p2 = tf.keras.layers.MaxPooling2D((2, 2))(c2)
+  
+  c3 = tf.keras.layers.Conv2D(256, (3, 3), activation='relu', kernel_initializer='he_normal', padding='same')(p2)
+  c3 = tf.keras.layers.Dropout(0.2)(c3)
+  c3 = tf.keras.layers.Conv2D(256, (3, 3), activation='relu', kernel_initializer='he_normal', padding='same')(c3)
+  p3 = tf.keras.layers.MaxPooling2D((2, 2))(c3)
+  
+  c4 = tf.keras.layers.Conv2D(512, (3, 3), activation='relu', kernel_initializer='he_normal', padding='same')(p3)
+  c4 = tf.keras.layers.Dropout(0.2)(c4)
+  c4 = tf.keras.layers.Conv2D(512, (3, 3), activation='relu', kernel_initializer='he_normal', padding='same')(c4)
+  p4 = tf.keras.layers.MaxPooling2D(pool_size=(2, 2))(c4)
+  
+  c5 = tf.keras.layers.Conv2D(1024, (3, 3), activation='relu', kernel_initializer='he_normal', padding='same')(p4)
+  c5 = tf.keras.layers.Dropout(0.3)(c5)
+  c5 = tf.keras.layers.Conv2D(1024, (3, 3), activation='relu', kernel_initializer='he_normal', padding='same')(c5)
+
+  #Expansive path 
+  u6 = tf.keras.layers.Conv2DTranspose(512, (2, 2), strides=(2, 2), padding='same')(c5)
+  u6 = tf.keras.layers.concatenate([u6, c4])
+  c6 = tf.keras.layers.Conv2D(512, (3, 3), activation='relu', kernel_initializer='he_normal', padding='same')(u6)
+  c6 = tf.keras.layers.Dropout(0.2)(c6)
+  c6 = tf.keras.layers.Conv2D(512, (3, 3), activation='relu', kernel_initializer='he_normal', padding='same')(c6)
+  
+  u7 = tf.keras.layers.Conv2DTranspose(256, (2, 2), strides=(2, 2), padding='same')(c6)
+  u7 = tf.keras.layers.concatenate([u7, c3])
+  c7 = tf.keras.layers.Conv2D(256, (3, 3), activation='relu', kernel_initializer='he_normal', padding='same')(u7)
+  c7 = tf.keras.layers.Dropout(0.2)(c7)
+  c7 = tf.keras.layers.Conv2D(256, (3, 3), activation='relu', kernel_initializer='he_normal', padding='same')(c7)
+  
+  u8 = tf.keras.layers.Conv2DTranspose(128, (2, 2), strides=(2, 2), padding='same')(c7)
+  u8 = tf.keras.layers.concatenate([u8, c2])
+  c8 = tf.keras.layers.Conv2D(128, (3, 3), activation='relu', kernel_initializer='he_normal', padding='same')(u8)
+  c8 = tf.keras.layers.Dropout(0.1)(c8)
+  c8 = tf.keras.layers.Conv2D(128, (3, 3), activation='relu', kernel_initializer='he_normal', padding='same')(c8)
+  
+  u9 = tf.keras.layers.Conv2DTranspose(64, (2, 2), strides=(2, 2), padding='same')(c8)
+  u9 = tf.keras.layers.concatenate([u9, c1], axis=3)
+  c9 = tf.keras.layers.Conv2D(64, (3, 3), activation='relu', kernel_initializer='he_normal', padding='same')(u9)
+  c9 = tf.keras.layers.Dropout(0.1)(c9)
+  c9 = tf.keras.layers.Conv2D(64, (3, 3), activation='relu', kernel_initializer='he_normal', padding='same')(c9)
+  
+  outputs = tf.keras.layers.Conv2D(1, (1, 1), activation='sigmoid')(c9)
+  
+  model = tf.keras.Model(inputs=[inputs], outputs=[outputs])
+  model.compile(optimizer='adam', loss=dice_coef_loss, metrics=['accuracy',dice_coef,iou,])
+  print('Modelo importado correctamente')
+  return model

utils/weights/Unet_finetune_v3.h5

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:a50e633c4159865871d47b43b3ba4e33f81ed89ef7a57ea802b1e518ba56194e
+size 372596200