Update app.py

app.py

@@ -1,74 +1,136 @@
-import gradio as gr
+import os
+os.environ["KERAS_BACKEND"] = "jax"
+
 import numpy as np
-import tensorflow as tf
+import gradio as gr
 import cv2
-import matplotlib.pyplot as plt
-from tensorflow.keras.applications.xception import preprocess_input, decode_predictions
+import tensorflow as tf
+import keras
+from keras.models import Model
+from keras.preprocessing import image
 
-# Charger le modèle
-model = tf.keras.models.load_model("Xception-Baseline.keras")
+# ---- Configuration ----
+CLASS_NAMES = ['akiec', 'bcc', 'bkl', 'df', 'nv', 'vasc', 'mel']
+label_to_index = {name: i for i, name in enumerate(CLASS_NAMES)}
+diagnosis_map = {
+    'akiec': 'Bénin',
+    'bcc': 'Malin',
+    'bkl': 'Bénin',
+    'df': 'Bénin',
+    'nv': 'Bénin',
+    'vasc': 'Bénin',
+    'mel': 'Malin'
+}
 
-# Nom de la dernière couche convolutive
-last_conv_layer_name = "block14_sepconv2_act"
+# ---- Chargement modèles ----
+model_xcept    = keras.saving.load_model("Xception.keras", compile=False)
+model_resnet50 = keras.saving.load_model("hf://ericjedha/resnet50")
+model_densenet = keras.saving.load_model("hf://ericjedha/densenet201")
 
-# Fonction Grad-CAM
-def make_gradcam_heatmap(img_array, model, last_conv_layer_name, pred_index=None):
-    grad_model = tf.keras.models.Model(
-        [model.inputs],
-        [model.get_layer(last_conv_layer_name).output, model.output]
-    )
+# ---- Préprocesseurs ----
+from tensorflow.keras.applications.xception import preprocess_input as preprocess_xception
+from tensorflow.keras.applications.resnet50 import preprocess_input as preprocess_resnet
+from tensorflow.keras.applications.densenet import preprocess_input as preprocess_densenet
+
+def load_image(path, target_size):
+    img = image.load_img(path, target_size=target_size)
+    return image.img_to_array(img)
+
+# ---- 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)
+
+    preds = (weights[0] * pred_x + weights[1] * pred_r + weights[2] * pred_d)
+
+    # 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 ----
+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)
+    input_array = np.expand_dims(img_array, axis=0)
+    input_array = preprocess_densenet(input_array)
+
+    if class_index is None:
+        preds = model.predict(input_array)
+        class_index = np.argmax(preds[0])
+
+    grad_model = Model(inputs=model.inputs, outputs=[
+        model.get_layer(last_conv_layer_name).output,
+        model.output
+    ])
 
     with tf.GradientTape() as tape:
-        conv_outputs, predictions = grad_model(img_array)
-        if pred_index is None:
-            pred_index = tf.argmax(predictions[0])
-        class_channel = predictions[:, pred_index]
+        conv_outputs, predictions = grad_model(input_array)
+        loss = predictions[:, class_index]
 
-    grads = tape.gradient(class_channel, conv_outputs)
+    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 = tf.maximum(heatmap, 0) / tf.math.reduce_max(heatmap)
-    return heatmap.numpy(), predictions.numpy()
+    heatmap = np.maximum(heatmap, 0) / (np.max(heatmap) + 1e-6)
 
-# Superposition de la heatmap
-def overlay_heatmap(original_img, heatmap, alpha=0.4):
-    heatmap = cv2.resize(heatmap, (original_img.shape[1], original_img.shape[0]))
+    heatmap = cv2.resize(heatmap.numpy(), (224, 224))
     heatmap = np.uint8(255 * heatmap)
-    heatmap_color = cv2.applyColorMap(heatmap, cv2.COLORMAP_JET)
-    superimposed_img = cv2.addWeighted(heatmap_color, alpha, original_img, 1 - alpha, 0)
-    return superimposed_img
+    heatmap = cv2.applyColorMap(heatmap, cv2.COLORMAP_JET)
+
+    superimposed_img = cv2.addWeighted(
+        cv2.cvtColor(img_array.astype("uint8"), cv2.COLOR_RGB2BGR), 
+        0.6, heatmap, 0.4, 0
+    )
+    return cv2.cvtColor(superimposed_img, cv2.COLOR_BGR2RGB)
+
+# ---- Fonction Gradio ----
+def gradio_predict(image_file):
+    probs = predict_single(image_file)
+
+    sorted_idx = np.argsort(-probs)
+    sorted_labels = [CLASS_NAMES[i].upper() for i in sorted_idx]
+    sorted_probs = probs[sorted_idx] * 100
 
-# Fonction principale pour Gradio
-def gradcam_interface(img):
-    # Convertir l'image
-    img_resized = cv2.resize(img, (299, 299))
-    img_rgb = cv2.cvtColor(img_resized, cv2.COLOR_BGR2RGB)
-    input_array = preprocess_input(np.expand_dims(img_rgb.astype(np.float32), axis=0))
+    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"
 
-    # Générer heatmap
-    heatmap, preds = make_gradcam_heatmap(input_array, model, last_conv_layer_name)
+    bar_data = {"Classes": sorted_labels, "Probabilité (%)": sorted_probs.tolist()}
 
-    # Décodage prédiction (si modèle pré-entraîné sur ImageNet, sinon adapter)
-    class_idx = np.argmax(preds[0])
-    confidence = preds[0][class_idx]
-    decoded = f"Classe prédite : {class_idx} | Confiance : {confidence:.2f}"
+    # Grad-CAM sur la meilleure classe
+    top_class = np.argmax(probs)
+    gradcam_img = make_gradcam(image_file, model_densenet, class_index=top_class)
 
-    # Appliquer la heatmap
-    heatmap_overlay = overlay_heatmap(img_resized, heatmap)
+    return global_diag, gr.BarPlot.update(value=bar_data, x="Classes", y="Probabilité (%)", title="Distribution des classes"), gradcam_img
 
-    return heatmap_overlay, decoded
+# ---- Gradio UI ----
+examples = [
+    "exemple1.jpg",
+    "exemple2.jpg",
+    "exemple3.jpg"
+]
 
-# Interface Gradio
 demo = gr.Interface(
-    fn=gradcam_interface,
-    inputs=gr.Image(type="numpy", label="Image"),
+    fn=gradio_predict,
+    inputs=gr.Image(type="filepath", label="Uploader une image de lésion"),
     outputs=[
-        gr.Image(type="numpy", label="Grad-CAM"),
-        gr.Text(label="Prédiction")
+        gr.Label(label="Diagnostic global"),
+        gr.BarPlot(label="Probabilités par classe"),
+        gr.Image(label="Visualisation Grad-CAM")
     ],
-    title="Grad-CAM Visualizer - Xception"
+    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."
 )
 
-demo.launch()
+if __name__ == "__main__":
+    demo.launch()