Update app.py

app.py

@@ -62,47 +62,94 @@ def predict_single(image_pil, weights=(0.45, 0.25, 0.30)):
     }
 
 # ---- Grad-CAM ----
+# ---- Grad-CAM CORRIGÉ ----
 def make_gradcam(image_pil, model, last_conv_layer_name, class_index):
     input_size = model.input_shape[1:3]
     img_np = np.array(image_pil)
     img_resized = cv2.resize(img_np, input_size)
 
-    if 'xception' in model.name: preprocessor = preprocess_xception
-    elif 'resnet50' in model.name: preprocessor = preprocess_resnet
-    else: preprocessor = preprocess_densenet
+    if 'xception' in model.name: 
+        preprocessor = preprocess_xception
+    elif 'resnet50' in model.name: 
+        preprocessor = preprocess_resnet
+    else: 
+        preprocessor = preprocess_densenet
     
     img_array_preprocessed = preprocessor(np.expand_dims(img_resized, axis=0))
     
-    grad_model = Model(model.inputs, [model.get_layer(last_conv_layer_name).output, model.output])
+    # Vérification que la couche existe
+    try:
+        conv_layer = model.get_layer(last_conv_layer_name)
+    except ValueError:
+        print(f"Couche '{last_conv_layer_name}' non trouvée dans le modèle")
+        return img_resized
+    
+    grad_model = Model(model.inputs, [conv_layer.output, model.output])
     input_name = get_primary_input_name(model)
     input_for_model = {input_name: img_array_preprocessed}
 
     with tf.GradientTape() as tape:
         last_conv_layer_output, preds = grad_model(input_for_model, training=False)
-        if isinstance(preds, list): preds = preds[0]
+        if isinstance(preds, list): 
+            preds = preds[0]
         class_channel = preds[:, class_index]
 
     grads = tape.gradient(class_channel, last_conv_layer_output)
-    if grads is None: return img_resized
+    
+    # Vérifications de sécurité
+    if grads is None:
+        print("Gradients sont None - retour de l'image originale")
+        return img_resized
+    
+    # Vérifier les valeurs NaN ou inf
+    if tf.reduce_any(tf.math.is_nan(grads)) or tf.reduce_any(tf.math.is_inf(grads)):
+        print("Gradients contiennent des NaN/inf - retour de l'image originale")
+        return img_resized
 
-    pooled_grads = tf.reduce_mean(grads, axis=(0, 1))
+    pooled_grads = tf.reduce_mean(grads, axis=(0, 1, 2))
     last_conv_layer_output = last_conv_layer_output[0]
     
+    # Calcul de la heatmap
     heatmap = last_conv_layer_output @ pooled_grads[..., tf.newaxis]
     heatmap = tf.squeeze(heatmap)
-    heatmap = tf.maximum(heatmap, 0) / (tf.math.reduce_max(heatmap) + 1e-8)
-    heatmap = heatmap.numpy()
-
-    # ===== CORRECTION FINALE ET CRUCIALE =====
-    # On redimensionne la heatmap (ex: 7x7) à la taille de l'image (ex: 224x224)
-    heatmap = cv2.resize(heatmap, (img_resized.shape[1], img_resized.shape[0]))
-    # =======================================
-
-    heatmap = np.uint8(255 * heatmap)
-    heatmap = cv2.applyColorMap(heatmap, cv2.COLORMAP_JET)
     
+    # Normalisation sécurisée
+    heatmap = tf.maximum(heatmap, 0)
+    max_val = tf.math.reduce_max(heatmap)
+    
+    if max_val == 0:
+        print("Heatmap max est 0 - création d'une heatmap neutre")
+        heatmap = tf.ones_like(heatmap) * 0.5
+    else:
+        heatmap = heatmap / max_val
+    
+    heatmap_np = heatmap.numpy()
+    
+    # Vérifications finales avant resize
+    if heatmap_np.size == 0:
+        print("Heatmap vide - retour de l'image originale")
+        return img_resized
+    
+    if np.any(np.isnan(heatmap_np)) or np.any(np.isinf(heatmap_np)):
+        print("Heatmap contient des NaN/inf après conversion - retour de l'image originale")
+        return img_resized
+    
+    # Redimensionnement sécurisé
+    try:
+        # S'assurer que heatmap_np est en float32 et dans [0,1]
+        heatmap_np = np.clip(heatmap_np.astype(np.float32), 0, 1)
+        heatmap_resized = cv2.resize(heatmap_np, (img_resized.shape[1], img_resized.shape[0]))
+    except cv2.error as e:
+        print(f"Erreur OpenCV resize: {e}")
+        return img_resized
+    
+    # Conversion finale
+    heatmap_uint8 = np.uint8(255 * heatmap_resized)
+    heatmap_colored = cv2.applyColorMap(heatmap_uint8, cv2.COLORMAP_JET)
+    
+    # Superposition
     img_bgr = cv2.cvtColor(img_resized, cv2.COLOR_RGB2BGR)
-    superimposed_img = cv2.addWeighted(img_bgr, 0.6, heatmap, 0.4, 0)
+    superimposed_img = cv2.addWeighted(img_bgr, 0.6, heatmap_colored, 0.4, 0)
     
     return cv2.cvtColor(superimposed_img, cv2.COLOR_BGR2RGB)