Update app.py

app.py

@@ -3,68 +3,111 @@ import numpy as np
 import cv2
 from keras.models import load_model
 
-# Load the trained models
+import tensorflow as tf
+from tensorflow import keras
+
+# Cargar el modelo entrenado
 model1 = load_model('./isatron_v3.h5')
-# model2 = load_model('./Isatron_v2.h5')
 
-# Print the loaded models
-print(model1)
-# print(model2)
+# Función para encontrar la última capa convolucional
+def find_last_conv_layer(model):
+    for layer in reversed(model.layers):
+        if 'conv' in layer.name:
+            return layer.name
+    raise ValueError("No se encontró una capa convolucional en el modelo.")
+
+# Obtener el nombre de la última capa convolucional
+last_conv_layer_name = find_last_conv_layer(model1)
+print("Última capa convolucional:", last_conv_layer_name)
 
-# Define image size and labels
+# Definir tamaño de imagen y etiquetas
 img_size1 = 150
-# img_size2 = 224
 labels = ['PNEUMONIA', 'NORMAL']
 
 def load_and_preprocess_image1(img):
-    # Convert Gradio image (PIL Image) to numpy array
+    # Convertir imagen de Gradio (PIL Image) a array numpy
     img = np.array(img)
-    # Convert RGB to grayscale
+    # Convertir de RGB a escala de grises
     img = cv2.cvtColor(img, cv2.COLOR_RGB2GRAY)
-    # Resize image to the required input size
+    # Redimensionar imagen al tamaño requerido
     img = cv2.resize(img, (img_size1, img_size1))
-    # Reshape image for model input
+    # Reformatear imagen para entrada del modelo
     img = img.reshape(-1, img_size1, img_size1, 1)
-    # Normalize image
+    # Normalizar imagen
     img = img / 255.0
     return img
 
-# def load_and_preprocess_image2(img):
-#     # Convert Gradio image (PIL Image) to numpy array
-#     img = np.array(img)
-#     # Convert RGB to grayscale
-#     img = cv2.cvtColor(img, cv2.COLOR_RGB2GRAY)
-#     # Resize image to the required input size
-#     img = cv2.resize(img, (img_size2, img_size2))
-#     # Reshape image for model input
-#     img = img.reshape(-1, img_size2, img_size2, 1)
-#     # Normalize image
-#     img = img / 255.0
-#     return img
+def make_gradcam_heatmap(img_array, model, last_conv_layer_name, pred_index=None):
+    # Crear un modelo que mapee la imagen de entrada a las activaciones
+    # de la última capa convolucional y las predicciones
+    grad_model = keras.models.Model(
+        [model.inputs], [model.get_layer(last_conv_layer_name).output, model.output]
+    )
+
+    # Calcular el gradiente de la clase predicha con respecto a las activaciones
+    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
+
+def overlay_heatmap(heatmap, img, alpha=0.4):
+    # 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)
+    # Convertir imagen a BGR
+    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
+    overlayed_img = cv2.cvtColor(overlayed_img, cv2.COLOR_BGR2RGB)
+    return overlayed_img
 
 def image_classifier1(img):
-    # Preprocess the image
-    img = load_and_preprocess_image1(img)
-    # Perform prediction using model1
-    prediction = model1.predict(img)[0][0]  # Assuming your model outputs a single probability
-    # Return the prediction
-    return {'PNEUMONIA': prediction, 'NORMAL': 1-prediction}  # Invert the prediction for Gradio
-
-# def image_classifier2(img):
-#     # Preprocess the image
-#     img = load_and_preprocess_image2(img)
-#     # Perform prediction using model2
-#     prediction = model2.predict(img)[0][0]  # Assuming your model outputs a single probability
-#     # Return the prediction
-#     return {'PNEUMONIA': 1-prediction, 'NORMAL': prediction}  # Invert the prediction for Gradio
-
-# Create Gradio interfaces for each model
-demo_model1 = gr.Interface(fn=image_classifier1, inputs="image", outputs="label", title="IsaTron V2")
-# demo_model2 = gr.Interface(fn=image_classifier2, inputs="image", outputs="label", title="Pneumonia Detection - Model 2")
-
-# gr.Parallel(demo_model1, demo_model2).launch(share=True)
-# Launch the interfaces simultaneously
+    # Mantener la imagen original para superponer
+    orig_img = np.array(img)
+    # Preprocesar la imagen
+    img_array = load_and_preprocess_image1(img)
+    # Realizar predicción usando model1
+    preds = model1.predict(img_array)
+    prediction = preds[0][0]  # Suponiendo que el modelo devuelve una probabilidad
+    # Determinar el índice de la clase predicha
+    pred_index = int(prediction > 0.5)
+    # Generar mapa de calor
+    heatmap = make_gradcam_heatmap(img_array, model1, last_conv_layer_name, pred_index=pred_index)
+    # Superponer mapa de calor en la imagen original
+    overlayed_img = overlay_heatmap(heatmap, orig_img)
+    # Retornar la imagen superpuesta y los porcentajes de predicción
+    prediction_percentage = {'PNEUMONIA': float(prediction), 'NORMAL': float(1 - prediction)}
+    return overlayed_img, prediction_percentage
+
+# Crear interfaz Gradio
+demo_model1 = gr.Interface(
+    fn=image_classifier1,
+    inputs="image",
+    outputs=[gr.outputs.Image(type="numpy"), "label"],
+    title="IsaTron V2 con Mapa de Calor"
+)
+
+# Ejecutar la interfaz
 if __name__ == "__main__":
-    # demo_model1.launch(share=True)
     demo_model1.launch(share=True)
-