Update app.py

app.py

@@ -57,10 +57,8 @@ def predict_single(image_pil, weights=(0.45, 0.25, 0.30)):
     preds_ensemble[:, mel_idx] = (0.5 * preds_ensemble[:, mel_idx] + 0.5 * pred_d[:, mel_idx])
     
     return {
-        "ensemble": preds_ensemble[0],
-        "xception": pred_x[0],
-        "resnet50": pred_r[0],
-        "densenet201": pred_d[0]
+        "ensemble": preds_ensemble[0], "xception": pred_x[0],
+        "resnet50": pred_r[0], "densenet201": pred_d[0]
     }
 
 # ---- Grad-CAM ----
@@ -95,6 +93,11 @@ def make_gradcam(image_pil, model, last_conv_layer_name, class_index):
     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)
     
@@ -103,52 +106,51 @@ def make_gradcam(image_pil, model, last_conv_layer_name, class_index):
     
     return cv2.cvtColor(superimposed_img, cv2.COLOR_BGR2RGB)
 
-# ---- Fonction Gradio (avec la logique de diagnostic corrigée) ----
+# ---- Fonction Gradio (avec gestion d'erreur pour Grad-CAM) ----
 def gradio_predict(image_pil):
     if image_pil is None: return "Veuillez uploader une image.", None, None
     try:
         all_preds = predict_single(image_pil)
         ensemble_probs = all_preds["ensemble"]
         
-        # ===== NOUVELLE LOGIQUE DE DIAGNOSTIC (bien meilleure) =====
-        # 1. On trouve la classe avec le plus haut score
         top_class_idx = np.argmax(ensemble_probs)
         top_class_name = CLASS_NAMES[top_class_idx]
-        
-        # 2. Le diagnostic global est celui de cette classe unique
         global_diag = diagnosis_map[top_class_name]
-        # ==========================================================
         
-        # Préparation du bar plot (inchangé)
         confidences = {CLASS_NAMES[i]: float(ensemble_probs[i]) for i in range(len(CLASS_NAMES))}
         df = pd.DataFrame.from_dict(confidences, orient='index', columns=['Probabilité'])
         df = df.sort_values(by='Probabilité', ascending=False)
         df.index.name = "Classe"
         df = df.reset_index()
 
-        # Logique Grad-CAM dynamique (inchangée, elle utilisait déjà le top_class_idx)
-        model_confidences = {
-            "xception": all_preds["xception"][top_class_idx],
-            "resnet50": all_preds["resnet50"][top_class_idx],
-            "densenet201": all_preds["densenet201"][top_class_idx]
-        }
-        explainer_model_name = max(model_confidences, key=model_confidences.get)
-
-        model_map = {"xception": model_xcept, "resnet50": model_resnet50, "densenet201": model_densenet}
-        layer_map = {
-            "xception": "block14_sepconv2_act",
-            "resnet50": "conv5_block3_out",
-            "densenet201": "relu"
-        }
-        
-        explainer_model = model_map[explainer_model_name]
-        explainer_layer = layer_map[explainer_model_name]
-        
-        gradcam_img = make_gradcam(image_pil, explainer_model, explainer_layer, class_index=top_class_idx)
+        # --- BLOC GRAD-CAM SÉCURISÉ ---
+        gradcam_img = None # Initialisation à None
+        try:
+            model_confidences = {
+                "xception": all_preds["xception"][top_class_idx],
+                "resnet50": all_preds["resnet50"][top_class_idx],
+                "densenet201": all_preds["densenet201"][top_class_idx]
+            }
+            explainer_model_name = max(model_confidences, key=model_confidences.get)
+
+            model_map = {"xception": model_xcept, "resnet50": model_resnet50, "densenet201": model_densenet}
+            layer_map = {"xception": "block14_sepconv2_act", "resnet50": "conv5_block3_out", "densenet201": "relu"}
+            
+            explainer_model = model_map[explainer_model_name]
+            explainer_layer = layer_map[explainer_model_name]
+            
+            print(f"Génération du Grad-CAM avec le modèle '{explainer_model_name}' sur la couche '{explainer_layer}'.")
+            gradcam_img = make_gradcam(image_pil, explainer_model, explainer_layer, class_index=top_class_idx)
+        except Exception as e:
+            print(f"--- ERREUR LORS DE LA GÉNÉRATION DE GRAD-CAM (le reste de l'app continue) ---")
+            print(e)
+            # gradcam_img reste à None, Gradio affichera une boîte vide
+        # --- FIN DU BLOC SÉCURISÉ ---
 
         return global_diag, df, gradcam_img
+        
     except Exception as e:
-        print(f"Erreur dans gradio_predict : {e}")
+        print(f"Erreur majeure dans gradio_predict : {e}")
         import traceback
         traceback.print_exc()
         return "Erreur lors du traitement de l'image.", None, None
@@ -157,8 +159,7 @@ def gradio_predict(image_pil):
 example_paths = ["exemple1.jpg", "exemple2.jpg", "exemple3.jpg"]
 with gr.Blocks(theme=gr.themes.Soft()) as demo:
     gr.Markdown("# Analyse de lésions cutanées (Ensemble de modèles + Grad-CAM)")
-    gr.Markdown("Cet outil propose une prédiction de la nature de la lésion (Bénin/Malin) avec explication visuelle dynamique. "
-                "Le diagnostic global est déterminé par la classe unique ayant le score le plus élevé.")
+    gr.Markdown("Cet outil propose une prédiction de la nature de la lésion (Bénin/Malin) avec explication visuelle dynamique.")
     with gr.Row():
         with gr.Column(scale=1):
             input_image = gr.Image(type="pil", label="Uploader une image de lésion")