premier deploiemen

.dockerignore

@@ -0,0 +1,5 @@
+venv/
+__pycache__/
+*.py[cod]
+.DS_Store
+.env

.gitattributes

@@ -33,3 +33,8 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 *.zip filter=lfs diff=lfs merge=lfs -text
 *.zst filter=lfs diff=lfs merge=lfs -text
 *tfevents* filter=lfs diff=lfs merge=lfs -text
+model/ filter=lfs diff=lfs merge=lfs -text
+model/best_efficientnetv2m_gradcam.keras filter=lfs diff=lfs merge=lfs -text
+model/best_ResNet50V2_04_improved_target_augment.keras filter=lfs diff=lfs merge=lfs -text
+model/best_ResNet50V2_gradcam.keras filter=lfs diff=lfs merge=lfs -text
+model/best_EfficientNetV2M_03_improved_global_augment.keras filter=lfs diff=lfs merge=lfs -text

.gitignore

@@ -0,0 +1,19 @@
+# Environnements virtuels
+venv/
+.venv/
+env/
+.env/
+
+# Fichiers Python compilés
+app/__pycache__/
+*.pyc
+
+# Fichiers système
+.DS_Store
+
+# Configurations IDE
+.vscode/
+.idea/
+
+# Fichiers de logs
+*.log

Dockerfile

@@ -0,0 +1,39 @@
+# Image TensorFlow GPU (fonctionne aussi en CPU-only)
+FROM tensorflow/tensorflow:2.15.0-gpu
+
+# Installation des dépendances système supplémentaires
+RUN apt-get update && apt-get install -y \
+    libgl1-mesa-glx \
+    libglib2.0-0 \
+    && rm -rf /var/lib/apt/lists/*
+
+# Création de l'utilisateur user (requis par Hugging Face)
+RUN useradd -m -u 1000 user
+ENV HOME=/home/user
+ENV PATH=/home/user/.local/bin:$PATH
+
+# Définir le répertoire de travail
+WORKDIR $HOME/app
+
+# Copier les fichiers de requirements avec les bonnes permissions
+COPY --chown=user:user requirements.txt .
+
+# Passer à l'utilisateur user
+USER user
+
+# Installer les dépendances Python
+RUN pip install --no-cache-dir --upgrade pip && \
+    pip install --no-cache-dir -r requirements.txt
+
+# Copier le reste de l'application
+COPY --chown=user:user . .
+
+# Port requis par Hugging Face Spaces
+EXPOSE 7860
+
+# Variables d'environnement pour Hugging Face Spaces
+ENV PORT=7860
+ENV HOST=0.0.0.0
+
+# Commande de démarrage compatible HF Spaces
+CMD ["uvicorn", "app.main:app", "--host", "0.0.0.0", "--port", "7860", "--log-level", "info"]

Dockerfile copy

@@ -0,0 +1,39 @@
+# Image TensorFlow GPU (fonctionne aussi en CPU-only)
+FROM tensorflow/tensorflow:2.15.0-gpu
+
+# Installation des dépendances système supplémentaires
+RUN apt-get update && apt-get install -y \
+    libgl1-mesa-glx \
+    libglib2.0-0 \
+    && rm -rf /var/lib/apt/lists/*
+
+# Création de l'utilisateur user (requis par Hugging Face)
+RUN useradd -m -u 1000 user
+ENV HOME=/home/user
+ENV PATH=/home/user/.local/bin:$PATH
+
+# Définir le répertoire de travail
+WORKDIR $HOME/app
+
+# Copier les fichiers de requirements avec les bonnes permissions
+COPY --chown=user:user requirements.txt .
+
+# Passer à l'utilisateur user
+USER user
+
+# Installer les dépendances Python
+RUN pip install --no-cache-dir --upgrade pip && \
+    pip install --no-cache-dir -r requirements.txt
+
+# Copier le reste de l'application
+COPY --chown=user:user . .
+
+# Port requis par Hugging Face Spaces
+EXPOSE 7860
+
+# Variables d'environnement pour Hugging Face Spaces
+ENV PORT=7860
+ENV HOST=0.0.0.0
+
+# Commande de démarrage compatible HF Spaces
+CMD ["uvicorn", "app.main:app", "--host", "0.0.0.0", "--port", "7860", "--log-level", "info"]

app/main.py

@@ -0,0 +1,75 @@
+from fastapi import FastAPI, UploadFile, File, HTTPException, Request,Query
+import io
+from PIL import Image
+from io import BytesIO
+from pydantic import BaseModel
+from typing import Union
+from io import BytesIO
+import base64
+import logging
+import logging
+from app.model import load_model, predict_with_model
+# Configuration de base du logger
+logging.basicConfig(
+    level=logging.DEBUG,  # DEBUG pour voir tous les logs (INFO, WARNING, ERROR, etc.)
+    format="%(asctime)s - %(name)s - %(levelname)s - %(message)s"
+)
+
+logger = logging.getLogger(__name__)
+
+
+
+app = FastAPI()
+
+
+@app.on_event("startup")
+def load_models_once():
+    _ = load_model()
+
+class ImagePayload(BaseModel):
+    image: str  # chaîne encodée en base64
+@app.post("/predict")
+async def predict(request: Request,
+    file: UploadFile = File(None),
+    payload: Union[ImagePayload, None] = None,
+    show_heatmap: bool = Query(False, description="Afficher la heatmap"),
+    ):
+
+    logger.info("🔁 Requête reçue")
+    logger.info(f"✅ Show heatmap : {show_heatmap}")
+    
+    try:
+        # Cas 1 : multipart avec fichier
+        if file is not None:
+            image_bytes = await file.read()
+            logger.debug("✅ Image reçue via multipart :", file.filename, len(image_bytes), "octets")
+
+        # Cas 2 : JSON base64
+        elif await request.json():
+            body = await request.json()
+            if "image" not in body:
+                raise HTTPException(status_code=422, detail="Champ 'image' manquant.")
+            image_base64 = body["image"]
+            image_bytes = base64.b64decode(image_base64)
+            logger.debug("✅ Image décodée depuis base64 :", len(image_bytes), "octets")
+
+        else:
+            logger.info("⚠️ Aucune image reçue")
+            raise HTTPException(status_code=400, detail="Format de requête non supporté.")
+
+        # Appel de ta logique de prédiction
+        logger.debug("🔍 Appel du vote multi-modèles...")
+        model_config = load_model()[0]
+        prediction = predict_with_model(model_config, image_bytes, show_heatmap)
+
+        # Pour l’instant : réponse simulée
+        return prediction
+
+    except Exception as e:
+        logger.error("❌ Une erreur s'est produite", exc_info=True)
+        raise HTTPException(status_code=500, detail=str(e))
+
+
+@app.get("/health")
+def health_check():
+    return {"status": "ok"}

app/model.py

@@ -0,0 +1,202 @@
+import tensorflow as tf
+import numpy as np
+from PIL import Image
+import tensorflow as tf
+import logging
+import numpy as np
+from PIL import Image
+from keras.applications.efficientnet_v2 import preprocess_input as effnet_preprocess
+from keras.applications.resnet_v2 import preprocess_input as resnet_preprocess
+import io
+from tf_keras_vis.gradcam import Gradcam,GradcamPlusPlus
+from tf_keras_vis.utils import normalize
+
+import numpy as np
+import tensorflow as tf
+from tf_keras_vis.saliency import Saliency
+from tf_keras_vis.utils import normalize
+import numpy as np
+import tensorflow as tf
+from tf_keras_vis.saliency import Saliency
+from tf_keras_vis.utils import normalize
+import logging
+import time
+
+from typing import TypedDict, Callable, Any
+logging.basicConfig(
+    level=logging.INFO,  # ou logging.DEBUG
+    format="%(asctime)s [%(levelname)s] %(name)s: %(message)s"
+)
+logger = logging.getLogger(__name__)
+confidence_threshold=0.5
+entropy_threshold=2
+
+class ModelStruct(TypedDict):
+    model_name: str
+    model: tf.keras.Model
+    gradcam_model:tf.keras.Model
+    preprocess_input: Callable[[np.ndarray], Any]
+    target_size: tuple[int, int]
+    last_conv_layer:str
+    gradcam_type:str
+
+
+_model_cache: list[ModelStruct] | None = None
+def load_model() -> list[ModelStruct]:
+    global _model_cache
+    if _model_cache is None:
+        print("📦 Chargement du modèle EfficientNetV2M...")
+        model = tf.keras.models.load_model("model/best_efficientnetv2m_gradcam.keras", compile=False)
+
+        _model_cache = [{
+            "model_name": "EfficientNetV2M",
+            "model": model,
+            "gradcam_model": model, 
+            "preprocess_input": effnet_preprocess,
+            "target_size": (480, 480),
+            "last_conv_layer": "block7a_expand_conv",
+            "gradcam_type": "gradcam++"
+        }]
+    return _model_cache
+
+
+
+def compute_gradcam(model, image_array, class_index=None, layer_name=None,gradcam_type="gradcam"):
+    """
+    Calcule la carte Grad-CAM pour une image et un modèle Keras.
+
+    Args:
+        model: tf.keras.Model.
+        image_array: np.array (H, W, 3), float32, pré-traitée.
+        class_index: int ou None, index de la classe cible. Si None, classe prédite.
+        layer_name: str ou None, nom de la couche convolutionnelle à utiliser. Si None, dernière conv.
+
+    Returns:
+        gradcam_map: np.array (H, W), normalisée entre 0 et 1.
+    """
+    logging.info(f"Lancement calcul de la gradcam avec le type {gradcam_type}")
+
+    if image_array.ndim == 3:
+        input_tensor = np.expand_dims(image_array, axis=0)
+    else:
+        input_tensor = image_array
+    if gradcam_type=="gradcam++":
+        gradcam = GradcamPlusPlus(model, clone=False)
+    else: 
+        gradcam = Gradcam(model, clone=False)
+
+    def loss(output):
+        if class_index is None:
+            class_index_local = tf.argmax(output[0])
+        else:
+            class_index_local = class_index
+        return output[:, class_index_local]
+
+    # Choisir la couche à utiliser pour GradCAM
+    if layer_name is None:
+        # Si non spécifié, chercher la dernière couche conv 2D
+        for layer in reversed(model.layers):
+            if 'conv' in layer.name and len(layer.output_shape) == 4:
+                layer_name = layer.name
+                break
+        if layer_name is None:
+            raise ValueError("Aucune couche convolutionnelle 2D trouvée dans le modèle.")
+
+    cam = gradcam(loss, input_tensor, penultimate_layer=layer_name)
+    cam = cam[0]
+
+    # Normaliser entre 0 et 1
+    cam = normalize(cam)
+
+    return cam
+
+ 
+def preprocess_image(image_bytes, target_size, preprocess_input):
+    try:
+        logger.info("📤 Lecture des bytes et conversion en image PIL")
+        image = Image.open(io.BytesIO(image_bytes)).convert("RGB")
+    except Exception as e:
+        logger.exception("❌ Erreur lors de l'ouverture de l'image")
+        raise ValueError("Impossible de décoder l'image") from e
+
+    logger.info(f"📐 Redimensionnement de l'image à la taille {target_size}")
+    image = image.resize(target_size)
+    image_array = np.array(image).astype(np.float32)
+
+    logger.debug(f"🔍 Shape de l'image après conversion en tableau : {image_array.shape}")
+
+    if image_array.ndim != 3 or image_array.shape[-1] != 3:
+        logger.error(f"❌ Image invalide : shape={image_array.shape}")
+        raise ValueError("Image must have 3 channels (RGB)")
+
+    logger.info("🎨 Conversion et prétraitement de l'image")
+
+    # Préparation pour la prédiction
+    preprocessed_input = preprocess_input(image_array.copy())
+    preprocessed_input = np.expand_dims(preprocessed_input, axis=0)
+
+    # Préparation pour Grad-CAM (non prétraitée, mais batchifiée et en float32)
+    raw_input = np.expand_dims(image_array / 255.0, axis=0)  # Mise à l’échelle simple
+
+    logger.debug(f"🧪 Shape après ajout de la dimension batch : {preprocessed_input.shape}")
+    return preprocessed_input, raw_input
+
+
+
+def compute_entropy_safe(probas):
+    probas = np.array(probas)
+    # On garde uniquement les probabilités strictement positives
+    mask = probas > 0
+    entropy = -np.sum(probas[mask] * np.log(probas[mask]))
+    return entropy
+
+
+def predict_with_model(config, image_bytes: bytes,show_heatmap=False):
+   
+    input_array,raw_input = preprocess_image(image_bytes,config["target_size"],config["preprocess_input"])
+
+    logger.info("🤖 Lancement de la prédiction avec le modèle")
+    preds = config["model"].predict(input_array)
+    logger.debug(f"📈 Prédictions brutes : {preds[0].tolist()}")
+
+    predicted_class_index = int(np.argmax(preds[0]))
+    confidence = float(preds[0][predicted_class_index])
+    entropy=float(compute_entropy_safe(preds))
+    is_uncertain_model= (confidence<confidence_threshold) or (entropy>entropy_threshold)
+    logger.info(f"✅ Prédiction : classe={predicted_class_index}, confiance={confidence:.4f},entropy={entropy:.4f},is_uncertain_model={is_uncertain_model}")
+
+    result= {
+        "preds": preds[0].tolist(),
+        "predicted_class": predicted_class_index,
+        "confidence": confidence,
+        "entropy":entropy,
+        "is_uncertain_model":is_uncertain_model
+    }
+    if show_heatmap and not is_uncertain_model:
+        try:
+            logger.info("✅ Début de la génération de la heatmap")
+            start_time = time.time()
+
+            # Vérification des entrées
+            logger.info(f"🖼️ Image d'entrée shape: {raw_input.shape}")
+            logger.info(f"🎯 Index de classe prédite: {predicted_class_index}")
+            logger.info(f"🛠️ Dernière couche utilisée: {config['last_conv_layer']}")
+
+            # Calcul de la heatmap
+            heatmap = compute_gradcam(config["gradcam_model"], raw_input, class_index=predicted_class_index, layer_name=config["last_conv_layer"],gradcam_type=config["gradcam_type"])
+
+            elapsed_time = time.time() - start_time
+            logger.info(f"✅ Heatmap générée en {elapsed_time:.2f} secondes")
+
+            # Conversion en liste pour le JSON
+            result["heatmap"] = heatmap.tolist()
+
+        except Exception as e:
+            logger.error(f"❌ Erreur lors de la génération de la heatmap: {e}")
+            result["heatmap"] = []
+    else:
+        logger.info("ℹ️ Heatmap non générée (option désactivée ou modèle incertain)")
+        result["heatmap"] = []
+
+
+    return result

model/best_efficientnetv2m_gradcam.keras

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:303b262f1a720ec476e5521f0728843c90650dabbe0adfc7c7a5a33e6fd9e9d2
+size 216600984