Update app.py

app.py

@@ -3,6 +3,7 @@ import tensorflow as tf
 import numpy as np
 import cv2
 from tensorflow.keras.layers import DepthwiseConv2D
+from tensorflow.keras.models import Model
 from PIL import Image
 
 # Función personalizada para DepthwiseConv2D
@@ -38,28 +39,50 @@ labels = [
     'Urticaria Ronchas', 'Tumores Vasculares', 'Vasculitis', 'Verrugas Molusco'
 ]
 
-def generate_heatmap(image, prediction):
-    # Asegurarse de que image sea un array de NumPy
-    if not isinstance(image, np.ndarray):
-        image = np.array(image)
-
-    # Verificar la forma de la predicción para crear el heatmap
-    if prediction.ndim == 1:
-        heatmap = np.reshape(prediction, (1, -1))
-    else:
-        heatmap = np.mean(prediction, axis=-1)  # Promediar los canales de predicción
+# Función Grad-CAM para generar el mapa de calor de activación
+def grad_cam(model, img_array, last_conv_layer_name, pred_index=None):
+    grad_model = Model(
+        [model.inputs], [model.get_layer(last_conv_layer_name).output, model.output]
+    )
+
+    with tf.GradientTape() as tape:
+        last_conv_layer_output, preds = grad_model(img_array)
+        if pred_index is None:
+            pred_index = tf.argmax(preds[0])
+        class_channel = preds[:, pred_index]
+
+    # Calcula los gradientes de la salida de la clase respecto a la salida de la última capa convolucional
+    grads = tape.gradient(class_channel, last_conv_layer_output)
+
+    # Promediar sobre cada filtro
+    pooled_grads = tf.reduce_mean(grads, axis=(0, 1, 2))
+
+    # Ponderar cada filtro en el mapa de características de la última capa convolucional
+    last_conv_layer_output = last_conv_layer_output[0]
+    heatmap = last_conv_layer_output @ pooled_grads[..., tf.newaxis]
+    heatmap = tf.squeeze(heatmap)
+
+    # Normalizar entre 0 y 1 para el mapa de calor
+    heatmap = tf.maximum(heatmap, 0) / tf.math.reduce_max(heatmap)
+    return heatmap.numpy()
+
+def generate_heatmap(image, prediction, last_conv_layer_name="conv5_block3_out"):
+    # Redimensionar la imagen a (224, 224)
+    img_array = tf.image.resize(image, (224, 224))
+    img_array = tf.expand_dims(img_array, axis=0)  # Añadir una dimensión para el batch
+    
+    # Obtén el Grad-CAM para la clase predicha
+    heatmap = grad_cam(model, img_array, last_conv_layer_name)
     
-    # Aplicar transformaciones al heatmap
-    heatmap = np.maximum(heatmap, 0)  # Aplicar ReLU
-    heatmap /= np.max(heatmap)  # Normalizar
-    heatmap = np.uint8(255 * heatmap)  # Convertir a rango 0-255
-
     # Redimensionar el mapa de calor al tamaño de la imagen
     heatmap = cv2.resize(heatmap, (image.shape[1], image.shape[0]))
+
+    # Convertir el mapa de calor a un rango de 0 a 255 para aplicar color
+    heatmap = np.uint8(255 * heatmap)
     heatmap = cv2.applyColorMap(heatmap, cv2.COLORMAP_JET)
 
-    # Superponer el heatmap en la imagen original
-    superimposed_image = cv2.addWeighted(image, 0.6, heatmap, 0.4, 0)
+    # Superponer el mapa de calor en la imagen original
+    superimposed_image = cv2.addWeighted(np.array(image), 0.6, heatmap, 0.4, 0)
 
     # Convertir a formato PIL para mostrar en Gradio
     img_pil = Image.fromarray(superimposed_image)
@@ -72,7 +95,7 @@ def classify_image(image):
     prediction = model.predict(image_resized).flatten()
     confidences = {labels[i]: float(prediction[i]) for i in range(len(labels))}
     
-    # Generar mapa de calor
+    # Generar mapa de calor utilizando Grad-CAM
     heatmap_image = generate_heatmap(np.array(image), prediction)
     
     return confidences, heatmap_image