Update app.py

app.py

@@ -20,9 +20,8 @@ diagnosis_map = {
     'vasc': 'Bénin',
     'mel': 'Malin'
 }
-NUM_CLASSES = len(CLASS_NAMES)
 
-# ---- Téléchargement et chargement des modèles .keras ----
+# ---- Téléchargement modèles ----
 resnet_path = hf_hub_download(repo_id="ericjedha/resnet50", filename="Resnet50.keras")
 densenet_path = hf_hub_download(repo_id="ericjedha/densenet201", filename="Densenet201.keras")
 
@@ -39,129 +38,57 @@ def load_image(path, target_size):
     img = image.load_img(path, target_size=target_size)
     return image.img_to_array(img)
 
-# ---- Helpers robustes ----
-def to_numpy(y):
-    # Convertit n'importe quelle sortie (Tensor / list / ndarray) en ndarray 2D (batch, classes)
-    if isinstance(y, (list, tuple)):
-        y = y[0]
-    if isinstance(y, tf.Tensor):
-        y = y.numpy()
-    y = np.array(y)
-    if y.ndim == 1:
-        y = y[None, :]
-    return y
-
-def safe_preds(arr, target_len=NUM_CLASSES):
-    arr = to_numpy(arr)
-    # pad/trim pour garantir 7 classes
-    if arr.shape[1] < target_len:
-        pad = np.zeros((arr.shape[0], target_len - arr.shape[1]), dtype=arr.dtype)
-        arr = np.concatenate([arr, pad], axis=1)
-    elif arr.shape[1] > target_len:
-        arr = arr[:, :target_len]
-    return arr
-
+# ---- Wrapper robuste pour prédictions ----
 def get_primary_input_name(model):
-    # Essaie de retrouver un nom d'input si le modèle l'exige
-    try:
-        if hasattr(model, "input_names") and model.input_names:
-            return model.input_names[0]
-    except Exception:
-        pass
-    try:
-        # ex: 'input_layer:0' -> 'input_layer'
-        name = model.inputs[0].name
-        if ":" in name:
-            name = name.split(":")[0]
-        return name
-    except Exception:
-        return None
+    """Retourne le vrai nom d'input du modèle Keras."""
+    if isinstance(model.inputs, list) and hasattr(model.inputs[0], "name"):
+        return model.inputs[0].name.split(":")[0]
+    return None
 
 def safe_forward(model, x):
-    """
-    Fait passer x dans model en essayant plusieurs formats d'appel,
-    pour contourner les modèles sauvegardés avec un input nommé (ex: 'input_layer').
-    Retourne un np.ndarray (batch, classes).
-    """
-    # On s'assure du dtype float32 pour TF/OpenCV
+    """Forward pass qui évite les crashs liés aux noms d’inputs."""
     if isinstance(x, np.ndarray):
         x = x.astype(np.float32, copy=False)
 
-    # 1) Appel direct en mode fonctionnel
-    try:
-        y = model(x, training=False)
-        return safe_preds(y)
-    except Exception:
-        pass
+    input_name = get_primary_input_name(model)
 
-    # 2) predict standard
     try:
-        y = model.predict(x, verbose=0)
-        return safe_preds(y)
-    except Exception:
-        pass
-
-    # 3) Essayer avec nom d'input
-    input_name = get_primary_input_name(model)
-    if input_name is not None:
-        try:
-            y = model({input_name: x}, training=False)
-            return safe_preds(y)
-        except Exception:
-            pass
-        try:
-            y = model.predict({input_name: x}, verbose=0)
-            return safe_preds(y)
-        except Exception:
-            pass
-
-    # Dernier recours: lever une erreur claire
-    raise RuntimeError("Impossible de faire l'inférence: le modèle exige peut-être un input nommé et incompatible.")
+        if input_name:
+            return model({input_name: x}, training=False).numpy()
+        else:
+            return model(x, training=False).numpy()
+    except Exception as e:
+        print(f"[safe_forward] Erreur avec {model.name}: {e}")
+        return np.zeros((1, len(CLASS_NAMES)))  # fallback
 
 # ---- Prédiction single image ----
 def predict_single(img_path, weights=(0.45, 0.25, 0.30)):
-    bx = preprocess_xception(np.expand_dims(load_image(img_path, (299, 299)), axis=0).astype(np.float32))
-    br = preprocess_resnet(np.expand_dims(load_image(img_path, (224, 224)), axis=0).astype(np.float32))
-    bd = preprocess_densenet(np.expand_dims(load_image(img_path, (224, 224)), axis=0).astype(np.float32))
+    bx = preprocess_xception(np.expand_dims(load_image(img_path, (299, 299)), axis=0))
+    br = preprocess_resnet(np.expand_dims(load_image(img_path, (224, 224)), axis=0))
+    bd = preprocess_densenet(np.expand_dims(load_image(img_path, (224, 224)), axis=0))
 
-    pred_x = safe_forward(model_xcept,    bx)
+    pred_x = safe_forward(model_xcept, bx)
     pred_r = safe_forward(model_resnet50, br)
     pred_d = safe_forward(model_densenet, bd)
 
-    preds = weights[0]*pred_x + weights[1]*pred_r + weights[2]*pred_d
+    preds = (weights[0] * pred_x + weights[1] * pred_r + weights[2] * pred_d)
 
-    # boost MEL avec DenseNet si index OK
-    mel_idx = label_to_index.get('mel', None)
-    if mel_idx is not None and mel_idx < preds.shape[1] and mel_idx < pred_d.shape[1]:
-        preds[:, mel_idx] = 0.5*preds[:, mel_idx] + 0.5*pred_d[:, mel_idx]
+    # Boost MEL avec DenseNet
+    mel_idx = label_to_index['mel']
+    preds[:, mel_idx] = (0.5 * preds[:, mel_idx] + 0.5 * pred_d[:, mel_idx])
 
     return preds[0]
 
-# ---- Grad-CAM ultra-robuste ----
-def make_gradcam(img_path, model, last_conv_layer_name=None, class_index=None):
+# ---- Grad-CAM ----
+def make_gradcam(img_path, model, last_conv_layer_name="conv5_block32_concat", class_index=None):
     img = image.load_img(img_path, target_size=(224, 224))
-    img_array = image.img_to_array(img).astype(np.float32)
+    img_array = image.img_to_array(img)
     input_array = np.expand_dims(img_array, axis=0)
-    input_array = preprocess_densenet(input_array).astype(np.float32)
+    input_array = preprocess_densenet(input_array)
 
-    # Classe cible
     if class_index is None:
         preds = safe_forward(model, input_array)
-        class_index = int(np.argmax(preds[0]))
-
-    # Trouver automatiquement la dernière conv si besoin
-    if last_conv_layer_name is None:
-        for layer in reversed(model.layers):
-            try:
-                out = getattr(layer, "output", None)
-                shp = getattr(out, "shape", None)
-                if shp is not None and hasattr(shp, "__len__") and len(shp) == 4 and "conv" in layer.name:
-                    last_conv_layer_name = layer.name
-                    break
-            except Exception:
-                continue
-        if last_conv_layer_name is None:
-            raise ValueError("Impossible de trouver une couche convolutionnelle pour Grad-CAM.")
+        class_index = np.argmax(preds[0])
 
     grad_model = Model(
         inputs=model.inputs,
@@ -169,34 +96,24 @@ def make_gradcam(img_path, model, last_conv_layer_name=None, class_index=None):
     )
 
     with tf.GradientTape() as tape:
-        conv_outputs, predictions = grad_model(input_array)
-        if isinstance(predictions, (list, tuple)):
-            predictions = predictions[0]
-        predictions = tf.convert_to_tensor(predictions)
+        conv_outputs, predictions = grad_model(input_array, training=False)
         loss = predictions[:, class_index]
 
-    grads = tape.gradient(loss, conv_outputs)[0]                  # (H, W, C)
-    pooled_grads = tf.reduce_mean(grads, axis=(0, 1))            # (C,)
-    conv_map = conv_outputs[0]                                   # (H, W, C)
+    grads = tape.gradient(loss, conv_outputs)[0]
+    pooled_grads = tf.reduce_mean(grads, axis=(0, 1, 2))
 
-    # Heatmap TF -> normalisation
-    heatmap_tf = tf.reduce_sum(conv_map * pooled_grads, axis=-1) # (H, W)
-    heatmap_tf = tf.nn.relu(heatmap_tf)
-    max_val = tf.reduce_max(heatmap_tf)
-    heatmap_tf = tf.where(max_val > 0, heatmap_tf / (max_val + 1e-6), tf.ones_like(heatmap_tf))
+    conv_outputs = conv_outputs[0]
+    heatmap = conv_outputs @ pooled_grads[..., tf.newaxis]
+    heatmap = tf.squeeze(heatmap)
+    heatmap = np.maximum(heatmap, 0) / (np.max(heatmap) + 1e-6)
 
-    # En numpy float32 pour OpenCV
-    heatmap = heatmap_tf.numpy().astype(np.float32)
-    if not np.isfinite(heatmap).all():
-        heatmap = np.nan_to_num(heatmap, nan=0.0, posinf=1.0, neginf=0.0)
-
-    heatmap = cv2.resize(heatmap, (224, 224))
-    heatmap_u8 = np.uint8(np.clip(255 * heatmap, 0, 255))
-    heatmap_color = cv2.applyColorMap(heatmap_u8, cv2.COLORMAP_JET)
+    heatmap = cv2.resize(heatmap.numpy(), (224, 224))
+    heatmap = np.uint8(255 * heatmap)
+    heatmap = cv2.applyColorMap(heatmap, cv2.COLORMAP_JET)
 
     superimposed_img = cv2.addWeighted(
         cv2.cvtColor(img_array.astype("uint8"), cv2.COLOR_RGB2BGR),
-        0.6, heatmap_color, 0.4, 0
+        0.6, heatmap, 0.4, 0
     )
     return cv2.cvtColor(superimposed_img, cv2.COLOR_BGR2RGB)
 
@@ -205,29 +122,33 @@ def gradio_predict(image_file):
     try:
         probs = predict_single(image_file)
 
-        # Tri + barplot data
         sorted_idx = np.argsort(-probs)
         sorted_labels = [CLASS_NAMES[i].upper() for i in sorted_idx]
-        sorted_probs = (probs[sorted_idx] * 100).astype(float)
+        sorted_probs = probs[sorted_idx] * 100
 
-        benign_prob = float(sum(probs[i] for i, cls in enumerate(CLASS_NAMES) if diagnosis_map[cls] == "Bénin"))
-        malign_prob = float(sum(probs[i] for i, cls in enumerate(CLASS_NAMES) if diagnosis_map[cls] == "Malin"))
+        benign_prob = sum(probs[i] for i, cls in enumerate(CLASS_NAMES) if diagnosis_map[cls] == "Bénin")
+        malign_prob = sum(probs[i] for i, cls in enumerate(CLASS_NAMES) if diagnosis_map[cls] == "Malin")
         global_diag = "Bénin" if benign_prob >= malign_prob else "Malin"
 
-        bar_plot_data = {"x": sorted_labels, "y": sorted_probs.tolist()}
+        bar_data = {"Classes": sorted_labels, "Probabilité (%)": sorted_probs.tolist()}
 
-        # Grad-CAM (DenseNet)
-        top_class = int(np.argmax(probs))
+        # Grad-CAM sur la meilleure classe
+        top_class = np.argmax(probs)
         gradcam_img = make_gradcam(image_file, model_densenet, class_index=top_class)
 
-        return global_diag, bar_plot_data, gradcam_img
+        return global_diag, gr.BarPlot.update(
+            value=bar_data,
+            x="Classes", y="Probabilité (%)",
+            title="Distribution des classes"
+        ), gradcam_img
 
     except Exception as e:
         print("Erreur dans gradio_predict :", e)
-        # Toujours renvoyer des types valides pour éviter JSONDecodeError côté Gradio
-        return "Erreur", {"x": [], "y": []}, None
+        return "Erreur", None, None
 
 # ---- Gradio UI ----
+examples = ["exemple1.jpg", "exemple2.jpg", "exemple3.jpg"]
+
 demo = gr.Interface(
     fn=gradio_predict,
     inputs=gr.Image(type="filepath", label="Uploader une image de lésion"),
@@ -236,11 +157,10 @@ demo = gr.Interface(
         gr.BarPlot(label="Probabilités par classe"),
         gr.Image(label="Visualisation Grad-CAM")
     ],
-    examples=[],  # éviter les erreurs de cache sur Spaces
-    title="Analyse de lésions cutanées (Ensemble + Grad-CAM)",
-    description="Prédiction Bénin/Malin avec explication visuelle."
+    examples=examples,
+    title="Analyse de lésions cutanées (Ensemble de modèles + Grad-CAM)",
+    description="Cet outil propose une prédiction de la nature de la lésion (Bénin/Malin) avec explication visuelle."
 )
 
 if __name__ == "__main__":
-    # Sur Hugging Face Spaces, share=True n'est pas supporté.
     demo.launch()