Update app.py

app.py

@@ -1,218 +1,42 @@
 import gradio as gr
 import numpy as np
-import cv2
-from tensorflow.keras.models import load_model
 import tensorflow as tf
-from tensorflow import keras
-
-# Cargar el modelo entrenado
-MODEL_PATH = 'Isatron_v2.h5'
-model = load_model(MODEL_PATH)
-
-# Función para encontrar la última capa convolucional
-def find_last_conv_layer(model):
-    """Encuentra la última capa convolucional en el modelo"""
-    for layer in reversed(model.layers):
-        if 'conv' in layer.name.lower():
-            return layer.name
-    raise ValueError("No se encontró una capa convolucional en el modelo.")
-
-# Obtener el nombre de la última capa convolucional
-try:
-    last_conv_layer_name = find_last_conv_layer(model)
-    print(f"Última capa convolucional encontrada: {last_conv_layer_name}")
-except ValueError as e:
-    print(f"Advertencia: {e}")
-    last_conv_layer_name = None
-
-# Definir tamaño de imagen (tu modelo usa 224x224)
-IMG_SIZE = 224
-
-def load_and_preprocess_image(img):
-    """Preprocesa la imagen para el modelo"""
-    # Convertir imagen de Gradio (PIL Image) a array numpy
-    img = np.array(img)
-    
-    # Si la imagen es RGB, convertir a escala de grises si el modelo lo requiere
-    # Tu modelo parece usar RGB (224, 224, 3), así que mantenemos RGB
-    if len(img.shape) == 2:  # Si es escala de grises
-        img = cv2.cvtColor(img, cv2.COLOR_GRAY2RGB)
-    
-    # Redimensionar imagen al tamaño requerido
-    img = cv2.resize(img, (IMG_SIZE, IMG_SIZE))
-    
-    # Normalizar imagen
-    img = img / 255.0
-    
-    # Expandir dimensiones para batch
-    img = np.expand_dims(img, axis=0)
-    
-    return img
-
-def make_gradcam_heatmap(img_array, model, last_conv_layer_name, pred_index=None):
-    """Genera un mapa de calor Grad-CAM"""
-    if last_conv_layer_name is None:
-        return None
-    
-    try:
-        # Crear un modelo que mapee la imagen de entrada a las activaciones
-        grad_model = keras.models.Model(
-            [model.inputs], 
-            [model.get_layer(last_conv_layer_name).output, model.output]
-        )
-
-        # Calcular el gradiente de la clase predicha
-        with tf.GradientTape() as tape:
-            last_conv_layer_output, preds = grad_model(img_array)
-            if pred_index is None:
-                pred_index = np.argmax(preds[0])
-            class_channel = preds[:, pred_index]
-
-        # Calcular los gradientes
-        grads = tape.gradient(class_channel, last_conv_layer_output)
-
-        # Pooling global de los gradientes
-        pooled_grads = tf.reduce_mean(grads, axis=(0, 1, 2))
-
-        # Multiplicar cada canal por su importancia
-        last_conv_layer_output = last_conv_layer_output[0]
-        heatmap = last_conv_layer_output @ pooled_grads[..., tf.newaxis]
-        heatmap = tf.squeeze(heatmap)
-
-        # Normalizar el mapa de calor entre 0 y 1
-        heatmap = tf.maximum(heatmap, 0) / tf.reduce_max(heatmap)
-        heatmap = heatmap.numpy()
-        
-        return heatmap
-    except Exception as e:
-        print(f"Error generando Grad-CAM: {e}")
-        return None
-
-def overlay_heatmap(heatmap, img, alpha=0.4):
-    """Superpone el mapa de calor en la imagen original"""
-    # Redimensionar mapa de calor al tamaño de la imagen
-    heatmap = cv2.resize(heatmap, (img.shape[1], img.shape[0]))
-    
-    # Convertir mapa de calor a RGB
-    heatmap = np.uint8(255 * heatmap)
-    heatmap = cv2.applyColorMap(heatmap, cv2.COLORMAP_JET)
-    
-    # Asegurar que img esté en formato correcto
-    if len(img.shape) == 2:  # Escala de grises
-        img = cv2.cvtColor(img, cv2.COLOR_GRAY2BGR)
-    elif img.shape[2] == 3:  # RGB
-        img = cv2.cvtColor(img, cv2.COLOR_RGB2BGR)
-    
-    # Aplicar mapa de calor a la imagen original
-    overlayed_img = heatmap * alpha + img
-    overlayed_img = np.uint8(overlayed_img)
-    
-    # Convertir de nuevo a RGB para Gradio
-    overlayed_img = cv2.cvtColor(overlayed_img, cv2.COLOR_BGR2RGB)
-    
-    return overlayed_img
-
-def image_classifier(img):
-    """Función principal de clasificación con Grad-CAM"""
-    # Mantener la imagen original para superponer
-    orig_img = np.array(img)
-    
-    # Preprocesar la imagen
-    img_array = load_and_preprocess_image(img)
-    
-    # Realizar predicción
-    preds = model.predict(img_array, verbose=0)
-    
-    # Tu modelo devuelve [Normal, Neumonía]
-    normal_prob = float(preds[0][0])
-    pneumonia_prob = float(preds[0][1])
-    
-    # Determinar el índice de la clase predicha
-    pred_index = np.argmax(preds[0])
-    
-    # Generar mapa de calor si es posible
-    if last_conv_layer_name:
-        heatmap = make_gradcam_heatmap(img_array, model, last_conv_layer_name, pred_index=pred_index)
-        if heatmap is not None:
-            overlayed_img = overlay_heatmap(heatmap, orig_img)
-        else:
-            overlayed_img = orig_img
-    else:
-        overlayed_img = orig_img
-    
-    # Preparar resultado de predicción
-    prediction_result = {
-        'NORMAL': normal_prob,
-        'NEUMONÍA': pneumonia_prob
-    }
-    
-    return overlayed_img, prediction_result
-
-# Crear interfaz Gradio mejorada
-demo = gr.Interface(
-    fn=image_classifier,
-    inputs=gr.Image(type="pil", label="Subir imagen de rayos X"),
-    outputs=[
-        gr.Image(type="numpy", label="Imagen con Mapa de Calor (Grad-CAM)"),
-        gr.Label(label="Predicción", num_top_classes=2)
-    ],
-    title="<h1 style='text-align: center;'>IsaTron V2: Herramienta de Apoyo al Diagnóstico de Neumonía</h1>",
-    description="""
-    <div style='text-align: justify;'>
-    IsaTron es una herramienta de inteligencia artificial desarrollada con redes neuronales convolucionales (CNN) 
-    para apoyar el diagnóstico de neumonía pediátrica a partir de imágenes de rayos X de tórax. La IA analiza las 
-    imágenes y produce un mapa de calor Grad-CAM que resalta las áreas de mayor relevancia para la predicción del 
-    modelo, lo cual ayuda a los profesionales de la salud a visualizar mejor las zonas potencialmente afectadas.
-    </div>
-    <br>
-    <div style='text-align: justify;'>
-    <strong>⚠️ Advertencia Importante:</strong> IsaTron está diseñado exclusivamente como una herramienta de apoyo 
-    al diagnóstico y NO reemplaza una evaluación médica profesional. Es crucial que los resultados generados por 
-    esta herramienta sean interpretados por personal de salud calificado. Esta herramienta no debe utilizarse para 
-    tomar decisiones clínicas sin la supervisión de un médico especialista.
-    </div>
-    """,
-    examples=[
-        ['1normal.jpeg'],
-        ['image1_pneumonia_virus.jpeg'],
-        ['image1_pneumonia_bacteria.jpeg'],
-        ['image2_normal.jpeg'],
-        ['image2_pneumonia_bacteria.jpeg'],
-        ['image3_normal.jpeg'],
-        ['image4_normal.jpeg']
-    ],
-    article="""
-    <div style='text-align: justify;'>
-    <h3>Sobre IsaTron</h3>
-    <p>
-    Este proyecto utiliza tecnologías avanzadas de inteligencia artificial, incluyendo redes neuronales 
-    convolucionales (CNN) y Grad-CAM (Gradient-weighted Class Activation Mapping), para mejorar la 
-    interpretabilidad de los resultados. IsaTron ha sido entrenado con imágenes médicas de rayos X de tórax 
-    y es capaz de predecir neumonía con un alto grado de confianza.
-    </p>
-    <p>
-    <strong>Grad-CAM</strong> permite visualizar qué regiones de la imagen son más importantes para la decisión 
-    del modelo, proporcionando transparencia en el proceso de clasificación y ayudando a los profesionales 
-    médicos a comprender mejor el razonamiento de la IA.
-    </p>
-    <p>
-    Los resultados obtenidos deben ser confirmados por un médico especialista para realizar un diagnóstico 
-    clínico adecuado. Para más información sobre el proyecto, visite: 
-    <a href="https://repositorio.unbosque.edu.co/handle/20.500.12495/9514" target="_blank">
-    Repositorio Institucional Universidad El Bosque
-    </a>
-    </p>
-    </div>
-    <br>
-    <div style='text-align: center;'>
-    <p><strong>IsaTron V2 - Desarrollado por Jeysshon Bustos</strong></p>
-    <p>Universidad El Bosque © 2022-2024</p>
-    </div>
-    """,
-    theme=gr.themes.Soft(),
-    allow_flagging="never"
+from tensorflow.keras.models import load_model
+from tensorflow.keras.preprocessing import image
+MODEL_ISATRON_JEY = 'modelo_isatron_jeysshonl.h5'
+cnn_model = load_model(MODEL_ISATRON_JEY)
+def make_prediction(test_image):
+    test_image = image.load_img(test_image, target_size=(224, 224))
+    test_image = image.img_to_array(test_image) / 255.
+    test_image = np.expand_dims(test_image, axis=0)
+    result = cnn_model.predict(test_image)
+    return {"Normal": str(result[0][0]), "Neumonia": str(result[0][1])}
+# Actualización del tipo de entrada de imagen
+image_input = gr.Image(type="filepath")
+description = ("El modelo IsaTron es una Red Neuronal Convolucional (CNN) diseñada como un método de apoyo medico "
+               "para el diagnóstico en imágenes radiológicas de neumonía pediátrica. Isatron arroja un porcentaje para "
+               "lograr interpretar la radiografía torácica. En la parte inferior encontrará unas imágenes que pueden "
+               "ser usadas para ejemplificar el funcionamiento del modelo. "
+               "https://repositorio.unbosque.edu.co/handle/20.500.12495/9514")
+examples = [
+    ['1normal.jpeg'],
+    ['image1_pneumonia_virus.jpeg'],
+    ['image1_pneumonia_bacteria.jpeg'],
+    ['image2_normal.jpeg'],
+    ['image2_pneumonia_bacteria.jpeg'],
+    ['image3_normal.jpeg'],
+    ['image4_normal.jpeg'],
+]
+article = "<p style='text-align: center'><span style='font-size: 15pt;'>IsaTron . Jeysshon Bustos . 2022. </span></p>"
+interface = gr.Interface(
+    fn=make_prediction,
+    inputs=image_input,
+    outputs='label',
+    title="Modelo (CNN) IsaTron",
+    description=description,
+    article=article,
+    examples=examples
 )
+interface.launch(share=True)
 
-# Ejecutar la interfaz
-if __name__ == "__main__":
-    demo.launch(share=True)
+quiero mejorarlo a esta version