Update app.py

app.py

@@ -1,184 +1,191 @@
-import os, cv2, time, numpy as np
-import tensorflow as tf
-from tensorflow.keras.applications import (
-    Xception, ResNet50, DenseNet201,
-    xception, resnet50, densenet
-)
-from tensorflow.keras.preprocessing import image as keras_image
 import gradio as gr
+import numpy as np
 import matplotlib.pyplot as plt
-
-# --- GPU setup ---
-gpus = tf.config.list_physical_devices("GPU")
-if gpus:
-    try:
-        for gpu in gpus:
-            tf.config.experimental.set_memory_growth(gpu, True)
-        print("✅ GPU activé :", gpus)
-    except RuntimeError as e:
-        print("⚠️ Erreur GPU:", e)
-else:
-    print("❌ Aucun GPU détecté.")
-
-# --- Utils ---
-def _update_progress(progress, start, end, desc, steps=20, delay=0.01):
-    """Anime la barre de progression de start→end en plusieurs ticks"""
-    if progress is None: 
+import cv2
+import tensorflow as tf
+from tensorflow.keras.models import load_model
+import os
+
+# -----------------------
+# Chargement des modèles
+# -----------------------
+MODELS_DIR = "models"
+AVAILABLE_MODELS = {
+    "ResNet50": os.path.join(MODELS_DIR, "resnet50.h5"),
+    "EfficientNetB0": os.path.join(MODELS_DIR, "efficientnetb0.h5"),
+    "MobileNetV2": os.path.join(MODELS_DIR, "mobilenetv2.h5"),
+}
+loaded_models = {}
+current_preds = {}
+
+# -----------------------
+# Progress helper
+# -----------------------
+def _update_progress(progress, step, total=100, desc=None):
+    """Met à jour la barre de progression uniformisée (0-100)."""
+    if progress is None:
         return
-    for i in range(steps+1):
-        val = start + (end-start)*i/steps
-        try:
-            progress(val/100, desc=desc)
-        except Exception:
-            try:
-                progress(val/100, desc)
-            except:
-                pass
-        time.sleep(delay)
-
-# --- Models ---
-model_xcept, model_resnet50, model_densenet = None, None, None
-try: model_xcept = Xception(weights="imagenet"); print("Xception OK")
-except Exception as e: print("Xception KO", e)
-try: model_resnet50 = ResNet50(weights="imagenet"); print("ResNet50 OK")
-except Exception as e: print("ResNet50 KO", e)
-try: model_densenet = DenseNet201(weights="imagenet"); print("DenseNet201 OK")
-except Exception as e: print("DenseNet KO", e)
-
-LAST_CONV_LAYERS = {"xception":"block14_sepconv2_act",
-                    "resnet50":"conv5_block3_out",
-                    "densenet201":"conv5_block32_concat"}
-
-# --- Preprocess ---
-def preprocess_input(img_path, model_name):
-    img_size = {"xception":299, "resnet50":224, "densenet201":224}[model_name]
-    img = keras_image.load_img(img_path, target_size=(img_size,img_size))
-    x = keras_image.img_to_array(img)
-    x = np.expand_dims(x, axis=0)
-    if model_name=="xception": return xception.preprocess_input(x)
-    if model_name=="resnet50": return resnet50.preprocess_input(x)
-    return densenet.preprocess_input(x)
-
-def decode_preds(preds, model_name, top=3):
-    if model_name=="xception": return xception.decode_predictions(preds, top=top)[0]
-    if model_name=="resnet50": return resnet50.decode_predictions(preds, top=top)[0]
-    return densenet.decode_predictions(preds, top=top)[0]
-
-# --- GradCAM ---
-def make_gradcam(img_pil, model, last_conv, class_idx, progress=None):
     try:
-        _update_progress(progress,0,25,"Prétraitement image")
-        input_size = model.input_shape[1:3]
-        img_resized = img_pil.resize(input_size)
-        x = np.expand_dims(np.array(img_resized).astype("float32"),0)
-        preprocess_fn = (xception.preprocess_input if x.shape[1]==299 
-                         else resnet50.preprocess_input)
-        x = preprocess_fn(x)
-
-        _update_progress(progress,25,50,"Calcul gradients")
-        grad_model = tf.keras.models.Model([model.inputs],
-                                           [model.get_layer(last_conv).output,
-                                            model.output])
-        with tf.GradientTape() as tape:
-            conv_outputs, preds = grad_model(x)
-            loss = preds[:, class_idx]
-        grads = tape.gradient(loss, conv_outputs)
-        pooled = tf.reduce_mean(grads, axis=(0,1,2)).numpy()
-        conv_out = conv_outputs[0].numpy()
-        heatmap = np.dot(conv_out, pooled)
-        heatmap = np.maximum(heatmap,0)/np.max(heatmap)
-
-        _update_progress(progress,50,75,"Génération heatmap")
-        heatmap = cv2.resize(heatmap, img_pil.size)
-        heatmap = np.uint8(255*heatmap)
-        heatmap = cv2.applyColorMap(heatmap, cv2.COLORMAP_JET)
-
-        _update_progress(progress,75,100,"Fusion image/heatmap")
-        img_bgr = cv2.cvtColor(np.array(img_pil), cv2.COLOR_RGB2BGR)
-        superimposed = cv2.addWeighted(img_bgr,0.6,heatmap,0.4,0)
-        return cv2.cvtColor(superimposed, cv2.COLOR_BGR2RGB)
-    except Exception as e:
-        print("GradCAM Error:",e)
-        return np.array(img_pil)
-
-# --- Global state ---
-current_image=None
-current_preds=None
-
-# --- Prediction ---
-def quick_predict_ui(img_pil, progress=gr.Progress()):
-    global current_image, current_preds
-    if img_pil is None: return {}, plt.figure(), "❌ Aucune image"
-
-    current_image = img_pil
-    current_preds={}
-    results, fig = {}, plt.figure()
-    ax=fig.add_subplot(111)
-
-    for model_name, model in [("xception",model_xcept),
-                              ("resnet50",model_resnet50),
-                              ("densenet201",model_densenet)]:
-        if model is None: continue
-        _update_progress(progress,0,30,f"Prédiction {model_name}")
-        tmp="tmp.jpg"; img_pil.save(tmp)
-        x = preprocess_input(tmp, model_name)
-        preds = model.predict(x,verbose=0)
-        current_preds[model_name]=preds[0]
-        top = decode_preds(preds, model_name, top=3)
-        for cls,desc,prob in top: results[desc]=float(prob)
-        ax.barh([desc for _,desc,prob in top],
-                [prob for _,desc,prob in top], label=model_name)
-        _update_progress(progress,30,100,f"{model_name} terminé")
-
-    # ensemble
-    if len(current_preds)>1:
-        avg = np.mean(list(current_preds.values()),axis=0)
-        current_preds["ensemble"]=avg
-        idx=np.argmax(avg)
-        label=f"Ensemble : {idx} ({avg[idx]:.2%})"
+        val = float(step) / float(total)
+        val = min(max(val, 0.0), 1.0)
+    except Exception:
+        val = 0.0
+    try:
+        if desc:
+            progress(val, desc=desc)
+        else:
+            progress(val)
+    except Exception:
+        pass
+
+# -----------------------
+# Prétraitement
+# -----------------------
+def preprocess_image(image, target_size=(224, 224)):
+    img = cv2.resize(image, target_size)
+    img = img / 255.0
+    return np.expand_dims(img, axis=0)
+
+# -----------------------
+# Grad-CAM
+# -----------------------
+def make_gradcam(model, img_array, layer_name, progress=None):
+    _update_progress(progress, 10, desc="Préparation...")
+    grad_model = tf.keras.models.Model(
+        [model.inputs], [model.get_layer(layer_name).output, model.output]
+    )
+
+    with tf.GradientTape() as tape:
+        conv_outputs, predictions = grad_model(img_array)
+        pred_index = tf.argmax(predictions[0])
+        loss = predictions[:, pred_index]
+
+    _update_progress(progress, 40, desc="Calcul des gradients...")
+
+    grads = tape.gradient(loss, conv_outputs)
+    pooled_grads = tf.reduce_mean(grads, axis=(0, 1, 2))
+    conv_outputs = conv_outputs[0]
+
+    _update_progress(progress, 70, desc="Génération de la heatmap...")
+
+    heatmap = tf.reduce_mean(tf.multiply(pooled_grads, conv_outputs), axis=-1)
+    heatmap = np.maximum(heatmap, 0)
+    heatmap /= np.max(heatmap) if np.max(heatmap) != 0 else 1
+
+    heatmap = cv2.resize(heatmap, (img_array.shape[2], img_array.shape[1]))
+    heatmap = np.uint8(255 * heatmap)
+    heatmap = cv2.applyColorMap(heatmap, cv2.COLORMAP_JET)
+
+    _update_progress(progress, 90, desc="Application overlay...")
+
+    superimposed_img = heatmap * 0.4 + img_array[0] * 255
+    _update_progress(progress, 100, desc="✅ Grad-CAM terminé !")
+
+    return np.uint8(superimposed_img)
+
+# -----------------------
+# UI : prédiction rapide
+# -----------------------
+def quick_predict_ui(image, model_names, progress=gr.Progress()):
+    global current_preds
+    current_preds = {}
+    if image is None:
+        return "⚠️ Pas d'image", None, None
+
+    _update_progress(progress, 5, desc="Prétraitement...")
+    img_array = preprocess_image(image)
+
+    fig, ax = plt.subplots()
+    ax.set_title("Prédictions modèles")
+    bar_labels, bar_values = [], []
+
+    step = 30
+    for idx, name in enumerate(model_names):
+        _update_progress(progress, 5 + step * (idx+1) / len(model_names),
+                         desc=f"Prédiction avec {name}...")
+
+        if name not in loaded_models:
+            loaded_models[name] = load_model(AVAILABLE_MODELS[name])
+        model = loaded_models[name]
+
+        preds = model.predict(img_array, verbose=0)[0]
+        current_preds[name] = preds
+        bar_labels.append(name)
+        bar_values.append(float(np.max(preds)))
+
+    _update_progress(progress, 70, desc="Agrégation...")
+
+    if len(current_preds) > 1:
+        avg = np.mean(list(current_preds.values()), axis=0)
+        current_preds["ensemble"] = avg
+        idx = np.argmax(avg)
+        label = f"Ensemble : {idx} ({avg[idx]:.2%})"
     else:
-        label="Prédiction modèle unique"
+        label = "Prédiction modèle unique"
 
-    ax.legend(); plt.tight_layout()
-    return {"label":label}, fig, "✅ Prédictions terminées"
+    ax.bar(bar_labels, bar_values)
+    ax.set_ylabel("Confiance max")
 
-# --- GradCAM UI ---
-def generate_gradcam_ui(progress=gr.Progress()):
-    global current_image,current_preds
-    if current_image is None or current_preds is None:
-        return None,"❌ Pas d'image/prédiction"
-    try:
-        ensemble=current_preds.get("ensemble")
-        if ensemble is None: return None,"❌ Pas d'Ensemble"
-        class_idx=int(np.argmax(ensemble))
-        candidates=[]
-        if model_xcept: candidates.append(("xception",model_xcept,current_preds["xception"][class_idx]))
-        if model_resnet50: candidates.append(("resnet50",model_resnet50,current_preds["resnet50"][class_idx]))
-        if model_densenet: candidates.append(("densenet201",model_densenet,current_preds["densenet201"][class_idx]))
-        if not candidates: return None,"❌ Aucun modèle dispo"
-        name,model,conf=max(candidates,key=lambda t:t[2])
-        layer=LAST_CONV_LAYERS[name]
-        gradcam=make_gradcam(current_image,model,layer,class_idx,progress=progress)
-        return gradcam,f"✅ GradCAM {name} ({conf:.1%})"
-    except Exception as e:
-        return None,f"❌ Erreur: {e}"
-
-# --- UI ---
-with gr.Blocks(title="Diag rapide") as demo:
+    _update_progress(progress, 100, desc="✅ Prédiction terminée !")
+
+    return label, fig, "✅ Prédictions terminées"
+
+# -----------------------
+# UI : Grad-CAM
+# -----------------------
+def generate_gradcam_ui(image, explainer_model_name, progress=gr.Progress()):
+    if image is None:
+        return None, "⚠️ Pas d'image"
+
+    _update_progress(progress, 0, desc="Démarrage Grad-CAM...")
+
+    if explainer_model_name not in loaded_models:
+        loaded_models[explainer_model_name] = load_model(AVAILABLE_MODELS[explainer_model_name])
+    model = loaded_models[explainer_model_name]
+
+    img_array = preprocess_image(image)
+    _update_progress(progress, 20, desc=f"Génération Grad-CAM ({explainer_model_name})...")
+
+    layer_name = None
+    for lname in reversed([l.name for l in model.layers]):
+        if "conv" in lname or "block" in lname:
+            layer_name = lname
+            break
+    if not layer_name:
+        return None, "⚠️ Pas de couche conv trouvée"
+
+    cam_img = make_gradcam(model, img_array, layer_name, progress=progress)
+
+    _update_progress(progress, 100, desc="✅ Grad-CAM généré !")
+
+    return cam_img, "✅ Grad-CAM généré"
+
+# -----------------------
+# Interface Gradio
+# -----------------------
+with gr.Blocks() as demo:
     gr.Markdown("## 🧠 Diagnostic IA avec Grad-CAM")
+
     with gr.Row():
-        with gr.Column(scale=1):
-            input_img=gr.Image(type="pil",label="🩻 Image à analyser")
-            btn_predict=gr.Button("⚡ Analyse rapide")
-            btn_gradcam=gr.Button("🎨 Générer Grad-CAM")
-        with gr.Column(scale=2):
-            out_label=gr.Label()
-            out_plot=gr.Plot()
-            out_grad=gr.Image()
-            out_status=gr.Textbox(label="Statut",interactive=False)
-    btn_predict.click(quick_predict_ui,inputs=input_img,
-                      outputs=[out_label,out_plot,out_status])
-    btn_gradcam.click(generate_gradcam_ui,inputs=[],
-                      outputs=[out_grad,out_status])
+        with gr.Column():
+            img_input = gr.Image(label="Image à analyser", type="numpy")
+            model_selector = gr.CheckboxGroup(choices=list(AVAILABLE_MODELS.keys()),
+                                              value=["ResNet50"], label="Modèles à utiliser")
+            btn_predict = gr.Button("⚡ Analyse rapide")
+            btn_gradcam = gr.Button("🎨 Générer Grad-CAM")
+
+        with gr.Column():
+            label_out = gr.Label(label="Étiquette")
+            plot_out = gr.Plot(label="Histogramme")
+            status_out = gr.Textbox(label="Statut")
+
+    gradcam_out = gr.Image(label="Grad-CAM")
+
+    btn_predict.click(fn=quick_predict_ui,
+                      inputs=[img_input, model_selector],
+                      outputs=[label_out, plot_out, status_out])
+    btn_gradcam.click(fn=generate_gradcam_ui,
+                      inputs=[img_input, model_selector],
+                      outputs=[gradcam_out, status_out])
 
 demo.launch()