Update app.py

app.py

@@ -160,105 +160,95 @@ def find_last_dense_layer(model):
     raise ValueError("Aucune couche Dense trouvée dans le modèle.")
 
 # ---- GRAD-CAM ----
-# ---- GESTION ASYNCHRONE / ÉTAT ----
-current_image = None
-current_predictions = None
-
-# ---- Fonctions pour l'UI Gradio ----
-def quick_predict_ui(image_pil):
-    global current_image, current_predictions
-    if image_pil is None:
-        return "Veuillez uploader une image.", None, None
+def make_gradcam(image_pil, model, last_conv_layer_name, class_index):
+    if model is None: return np.array(image_pil)
     try:
-        current_image = image_pil
-        all_preds = predict_single(image_pil)
-        current_predictions = all_preds
-        ensemble_probs = all_preds["ensemble"]
-
-        # Débogage : Afficher les probabilités brutes
-        print("Probabilités brutes (ensemble):", ensemble_probs)
-        print("Somme des probabilités brutes:", ensemble_probs.sum())
-
-        # Vérification et normalisation explicite si nécessaire
-        if ensemble_probs.sum() > 1.0:  # Si les probabilités dépassent 1, renormaliser
-            ensemble_probs = _renorm_safe(ensemble_probs)
-            print("Probabilités renormées:", ensemble_probs)
-            print("Somme après renorm:", ensemble_probs.sum())
-
-        top_class_idx = int(np.argmax(ensemble_probs))
-        top_class_name = CLASS_NAMES[top_class_idx]
-        global_diag = diagnosis_map[top_class_name]
-
-        # Conversion en pourcentages pour le DataFrame
-        confidences = {CLASS_NAMES[i]: float(ensemble_probs[i] * 100) for i in range(len(CLASS_NAMES))}  # En pourcentages
-        df = pd.DataFrame.from_dict(confidences, orient='index', columns=['Probabilité']).reset_index().rename(columns={'index': 'Classe'})
-        df = df.sort_values(by='Probabilité', ascending=False)
-
-        # Ajout d'une colonne pour les étiquettes avec pourcentages
-        df['Pourcentage'] = df['Probabilité'].apply(lambda x: f"{x:.1f}%")
-
-        # Génération du graphique avec texte dynamique
-        fig = px.bar(df, 
-                     x="Classe", 
-                     y="Probabilité", 
-                     color="Probabilité",
-                     color_continuous_scale=px.colors.sequential.Viridis,
-                     title="Probabilités par classe",
-                     text="Pourcentage")  # Utilise la colonne Pourcentage pour les étiquettes
-
-        # Définir textposition comme une liste personnalisée
-        text_positions = []
-        for val in df['Probabilité']:
-            if val <= 10:  # Si la probabilité est ≤ 10%, texte à l'extérieur
-                text_positions.append("outside")
-            else:  # Sinon, texte à l'intérieur
-                text_positions.append("inside")
-        fig.update_traces(textposition=text_positions)  # Appliquer les positions personnalisées
+        input_size = model.input_shape[1:3]
+        bb_name = _guess_backbone_name(model)
+        print(f"Backbone détecté: {bb_name}")
+        
+        if 'xception' in model.name.lower(): 
+            preprocessor = preprocess_xception
+        elif 'resnet50' in model.name.lower(): 
+            preprocessor = preprocess_resnet
+        elif 'densenet' in model.name.lower():
+            preprocessor = preprocess_densenet
+        else:
+            print("Préprocesseur non reconnu - utilisation de preprocess_densenet par défaut")
+            preprocessor = preprocess_densenet
 
-        fig.update_layout(xaxis_title="", yaxis_title="Probabilité (%)", height=400)
+        img_np = np.array(image_pil.convert("RGB"))
+        img_resized = cv2.resize(img_np, input_size)
+        img_array_preprocessed = preprocessor(np.expand_dims(img_resized, axis=0))
 
-        return f"{global_diag} ({top_class_name.upper()})", fig, None
-    except Exception as e:
-        print(f"Erreur dans quick_predict_ui: {e}")
-        return f"Erreur: {e}", None, None
+        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
 
-def generate_gradcam_ui():
-    global current_image, current_predictions
-    if current_image is None or current_predictions is None:
-        return None, 0
-    try:
-        ensemble_probs = current_predictions["ensemble"]
-        top_class_idx = int(np.argmax(ensemble_probs))
+        dense_layer = find_last_dense_layer(model)
+        
+        grad_model = Model(model.inputs, [conv_layer.output, model.output])
 
-        candidates = []
-        if model_xcept is not None: candidates.append(("xception", model_xcept, current_predictions["xception"][top_class_idx]))
-        if model_resnet50 is not None: candidates.append(("resnet50", model_resnet50, current_predictions["resnet50"][top_class_idx]))
-        if model_densenet is not None: candidates.append(("densenet201", model_densenet, current_predictions["densenet201"][top_class_idx]))
+        input_name = get_primary_input_name(model)
+        input_for_model = {input_name: img_array_preprocessed}
 
-        if not candidates:
-            return None, 0
+        with tf.GradientTape() as tape:
+            last_conv_layer_output, preds = grad_model(input_for_model, training=False)
+            if isinstance(preds, list): 
+                preds = preds[0]
+            class_channel = preds[:, int(class_index)]
 
-        # Génération asynchrone avec progression
-        progress = 0
-        yield None, progress  # Initialisation
-        progress = 10
-        yield None, progress  # Sélection du modèle
-        explainer_model_name, explainer_model, conf = max(candidates, key=lambda t: t[2])
-        explainer_layer = LAST_CONV_LAYERS.get(explainer_model_name)
+        grads = tape.gradient(class_channel, last_conv_layer_output)
         
-        status = f"🎯 Génération Grad-CAM avec {explainer_model_name} (confiance: {conf:.1%})..."
-        print(status)
-        progress = 30
-        yield None, progress  # Début du calcul
-        gradcam_img = make_gradcam(current_image, explainer_model, explainer_layer, class_index=top_class_idx)
+        if grads is None:
+            print("⚠️ Gradients sont None - retour de l'image originale.")
+            return img_resized
         
-        progress = 100
-        yield gradcam_img, progress  # Fin
+        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, 2))
+        last_conv_layer_output = last_conv_layer_output[0]
+        
+        heatmap = last_conv_layer_output @ pooled_grads[..., tf.newaxis]
+        heatmap = tf.squeeze(heatmap)
+        
+        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()
+        
+        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
+        
+        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]))
+        heatmap_uint8 = np.uint8(255 * heatmap_resized)
+        heatmap_colored = cv2.applyColorMap(heatmap_uint8, cv2.COLORMAP_JET)
+        
+        img_bgr = cv2.cvtColor(img_resized, cv2.COLOR_RGB2BGR)
+        superimposed_img = cv2.addWeighted(img_bgr, 0.6, heatmap_colored, 0.4, 0)
+        
+        return cv2.cvtColor(superimposed_img, cv2.COLOR_BGR2RGB)
     except Exception as e:
-        print(f"❌ Erreur dans generate_gradcam_ui: {e}")
+        print(f"❌ Erreur inattendue dans make_gradcam: {e}")
         import traceback; traceback.print_exc()
-        yield None, 0
+        return np.array(image_pil)
 
 # ---- GESTION ASYNCHRONE / ÉTAT ----
 current_image = None
@@ -338,7 +328,7 @@ def generate_gradcam_ui():
         if not candidates:
             return None, 0
 
-        # Simulation de progression avec des étapes
+        # Génération asynchrone avec progression
         progress = 0
         yield None, progress  # Initialisation
         progress = 10
@@ -358,7 +348,7 @@ def generate_gradcam_ui():
     except Exception as e:
         print(f"❌ Erreur dans generate_gradcam_ui: {e}")
         import traceback; traceback.print_exc()
-        yield None, 0"
+        yield None, 0
 
 # ---- INTERFACE GRADIO ----
 example_paths = ["ISIC_0024627.jpg", "ISIC_0025539.jpg", "ISIC_0031410.jpg"]