Update app.py

app.py

@@ -1,3 +1,6 @@
+import os
+#os.environ["KERAS_BACKEND"] = "jax"
+
 import numpy as np
 import gradio as gr
 import cv2
@@ -19,14 +22,16 @@ diagnosis_map = {
     'vasc': 'Bénin',
     'mel': 'Malin'
 }
+NUM_CLASSES = len(CLASS_NAMES)
 
-# ---- Chargement modèles ----
+# ---- Téléchargement des modèles depuis Hugging Face ----
 resnet_path = hf_hub_download(repo_id="ericjedha/resnet50", filename="Resnet50.keras")
 densenet_path = hf_hub_download(repo_id="ericjedha/densenet201", filename="Densenet201.keras")
 
-model_xcept    = keras.saving.load_model("Xception.keras", compile=False)  # si local
+# ---- Chargement modèles ----
 model_resnet50 = keras.saving.load_model(resnet_path, compile=False)
 model_densenet = keras.saving.load_model(densenet_path, compile=False)
+model_xcept    = keras.saving.load_model("Xception.keras", compile=False)
 
 # ---- Préprocesseurs ----
 from tensorflow.keras.applications.xception import preprocess_input as preprocess_xception
@@ -37,27 +42,32 @@ def load_image(path, target_size):
     img = image.load_img(path, target_size=target_size)
     return image.img_to_array(img)
 
+# ---- Sécurité sur les prédictions ----
+def safe_preds(pred_array, target_len=NUM_CLASSES):
+    pred_array = np.array(pred_array)
+    if pred_array.shape[1] < target_len:
+        zeros = np.zeros((pred_array.shape[0], target_len - pred_array.shape[1]))
+        pred_array = np.concatenate([pred_array, zeros], axis=1)
+    elif pred_array.shape[1] > target_len:
+        pred_array = pred_array[:, :target_len]
+    return pred_array
+
 # ---- 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))
     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 = model_xcept.predict(bx, verbose=0)
-    pred_r = model_resnet50.predict(br, verbose=0)
-    pred_d = model_densenet.predict(bd, verbose=0)
-
-    # ⚡ Assurer shape (1,7)
-    for p in [pred_x, pred_r, pred_d]:
-        if p.ndim == 1:
-            p = np.expand_dims(p, axis=0)
+    pred_x = safe_preds(model_xcept.predict(bx, verbose=0))
+    pred_r = safe_preds(model_resnet50.predict(br, verbose=0))
+    pred_d = safe_preds(model_densenet.predict(bd, verbose=0))
 
     preds = (weights[0] * pred_x + weights[1] * pred_r + weights[2] * pred_d)
 
-    # boost MEL avec DenseNet
-    mel_idx = label_to_index['mel']
-    if mel_idx < pred_d.shape[1]:
-        preds[:, mel_idx] = 0.5 * preds[:, mel_idx] + 0.5 * pred_d[:, mel_idx]
+    # boost MEL avec DenseNet si possible
+    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])
 
     return preds[0]
 
@@ -70,10 +80,7 @@ def make_gradcam(img_path, model, last_conv_layer_name="conv5_block32_concat", c
 
     if class_index is None:
         preds = model.predict(input_array)
-        if isinstance(preds, list):
-            preds = preds[0]
-        if preds.ndim == 1:
-            preds = np.expand_dims(preds, axis=0)
+        preds = np.array(preds)
         class_index = np.argmax(preds[0])
 
     grad_model = Model(inputs=model.inputs, outputs=[
@@ -83,24 +90,28 @@ def make_gradcam(img_path, model, last_conv_layer_name="conv5_block32_concat", c
 
     with tf.GradientTape() as tape:
         conv_outputs, predictions = grad_model(input_array)
+
+        # sécuriser predictions
+        if isinstance(predictions, list):
+            predictions = predictions[0]
         predictions = tf.convert_to_tensor(predictions)
-        if predictions.ndim == 1:
-            predictions = tf.expand_dims(predictions, axis=0)
-        loss = predictions[:, class_index]
 
-    grads = tape.gradient(loss, conv_outputs)[0]   # (H, W, C)
-    pooled_grads = tf.reduce_mean(grads, axis=(0, 1))  # (C,)
+        loss = predictions[:, class_index]
 
-    conv_outputs = conv_outputs[0]  # (H, W, C)
-    heatmap = tf.reduce_sum(conv_outputs * pooled_grads, axis=-1)  # (H, W)
+    grads = tape.gradient(loss, conv_outputs)[0]
+    pooled_grads = tf.reduce_mean(grads, axis=(0, 1, 2))
 
+    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)
+
     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),
+        cv2.cvtColor(img_array.astype("uint8"), cv2.COLOR_RGB2BGR), 
         0.6, heatmap, 0.4, 0
     )
     return cv2.cvtColor(superimposed_img, cv2.COLOR_BGR2RGB)
@@ -109,29 +120,23 @@ def make_gradcam(img_path, model, last_conv_layer_name="conv5_block32_concat", c
 def gradio_predict(image_file):
     probs = predict_single(image_file)
 
-    # Classe globale
+    sorted_idx = np.argsort(-probs)
+    sorted_labels = [CLASS_NAMES[i].upper() for i in sorted_idx]
+    sorted_probs = probs[sorted_idx] * 100
+
     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"
 
-    # BarPlot
-    sorted_idx = np.argsort(-probs)
-    sorted_labels = [CLASS_NAMES[i].upper() for i in sorted_idx]
-    sorted_probs = (probs[sorted_idx] * 100).tolist()
-    bar_data = {"Classes": sorted_labels, "Probabilité (%)": sorted_probs}
+    bar_data = {"Classes": sorted_labels, "Probabilité (%)": sorted_probs.tolist()}
 
-    # Grad-CAM
     top_class = np.argmax(probs)
     gradcam_img = make_gradcam(image_file, model_densenet, class_index=top_class)
 
-    return global_diag, bar_data, gradcam_img
+    return global_diag, gr.BarPlot.update(value=bar_data, x="Classes", y="Probabilité (%)", title="Distribution des classes"), gradcam_img
 
 # ---- Gradio UI ----
-examples = [
-    "exemple1.jpg",
-    "exemple2.jpg",
-    "exemple3.jpg"
-]
+examples = ["exemple1.jpg", "exemple2.jpg", "exemple3.jpg"]
 
 demo = gr.Interface(
     fn=gradio_predict,