first commit

.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"]

README.md

@@ -1,10 +1,13 @@
 ---
 title: Reco Efficientnet Api
-emoji: 🌖
-colorFrom: yellow
-colorTo: red
+emoji: 🏆
+colorFrom: red
+colorTo: gray
 sdk: docker
 pinned: false
+short_description: Reco EfficientNet API
 ---
 
 Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+
+export API_ENV=local &&  uvicorn app.main:app --host 0.0.0.0 --port 7861 --log-level debug

app/config.py

@@ -0,0 +1,12 @@
+import os
+
+ENV = os.getenv("API_ENV", "space")
+MODEL_NAME = os.getenv("MODEL_NAME", "EfficientNetV2M")
+MODEL_TYPE =os.getenv("MODEL_TYPE", "CNN")
+
+if ENV == "local":
+    ORCHESTRATOR_URL = "http://0.0.0.0:7860"
+    OWN_URL = "http://0.0.0.0:7861"
+else:
+    ORCHESTRATOR_URL = "https://rkonan-reco-orchestrator-api.hf.space"
+    OWN_URL = "https://rkonan-reco-efficientnet-api.hf.space"

app/log.py

@@ -0,0 +1,15 @@
+# log.py
+import logging
+
+logger = logging.getLogger("model_api")
+logger.setLevel(logging.DEBUG)
+
+formatter = logging.Formatter(
+    "%(asctime)s - %(name)s - %(levelname)s - %(message)s"
+)
+
+console_handler = logging.StreamHandler()
+console_handler.setFormatter(formatter)
+
+if not logger.handlers:
+    logger.addHandler(console_handler)

app/main.py

@@ -0,0 +1,86 @@
+#main.py
+from fastapi import FastAPI, UploadFile, File, HTTPException, Request,Query
+
+from pydantic import BaseModel
+from typing import Union
+import base64
+
+from app.model import load_model, predict_with_model
+import os
+import threading
+import time
+from app.utils import heartbeat,register_forever
+from app.log import logger
+from app.config import MODEL_NAME, ENV,MODEL_TYPE
+
+
+
+logger.info(f"ENV :{ENV}")
+
+app = FastAPI()
+
+
+
+def load_models_once():
+    _ = load_model()
+
+@app.on_event("startup")
+def startup():
+    load_models_once()
+    threading.Thread(target=register_forever, daemon=True).start()
+    threading.Thread(target=heartbeat, daemon=True).start()
+
+
+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(f"✅ Image reçue via multipart : {file.filename} — {len(image_bytes)} octets")
+
+        # Cas 2 : JSON base64
+        elif payload is not None:
+             image_bytes = base64.b64decode(payload.image)
+             logger.debug(f"✅ 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...")
+        models = load_model()
+        if not models:
+            raise HTTPException(status_code=500, detail="Aucun modèle chargé.")
+        model_config = models[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",
+    "model_name": MODEL_NAME,
+    "model_type":MODEL_TYPE,
+    "timestamp": time.time()
+}

app/main_old.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.55
+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

app/utils.py

@@ -0,0 +1,50 @@
+import requests
+import time
+from app.log import logger
+
+from app.config import MODEL_NAME, ORCHESTRATOR_URL, OWN_URL,MODEL_TYPE
+
+def heartbeat():
+    while True:
+        try:
+            response = requests.post(
+                f"{ORCHESTRATOR_URL}/heartbeat",
+                json={"model_name": MODEL_NAME},
+                timeout=5
+            )
+            if response.status_code == 200:
+                logger.info(f"💓 Heartbeat envoyé pour {MODEL_NAME}")
+                
+            elif response.status_code == 404:
+                logger.warning(f"⚠️ Modèle inconnu dans orchestrateur (404) → tentative de réenregistrement")
+                # Tentative de réenregistrement à chaud
+                register_with_orchestrator()
+            else:
+                logger.warning(f"⚠️ Heartbeat refusé ({response.status_code}) : {response.text}")
+        except Exception as e:
+            logger.error(f"❌ Erreur lors du heartbeat : {e}")
+        time.sleep(60)
+
+def register_with_orchestrator():
+    try:
+        logger.info(f"📡 Tentative d'enregistrement de {MODEL_NAME} à l'orchestrateur...")
+        response = requests.post(
+            f"{ORCHESTRATOR_URL}/register_model",
+            json={"model_name": MODEL_NAME, "model_type": MODEL_TYPE,"url": f"{OWN_URL}/predict"}
+        )
+        if response.status_code == 200:
+            logger.info("✅ Modèle enregistré avec succès")
+            return True
+        else:
+            logger.info(f"⚠️ Échec enregistrement : {response.text}")
+            return False
+    except Exception as e:
+        logger.info(f"❌ Erreur d'enregistrement : {e}")
+
+def register_forever(interval=30):
+    while True:
+        success = register_with_orchestrator()
+        if success:
+            break  # On arrête de réessayer
+        logger.info(f"⏳ Nouvel essai dans {interval} secondes...")
+        time.sleep(interval)

model/best_efficientnetv2m_gradcam.keras

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

requirements.txt

@@ -0,0 +1,97 @@
+absl-py==1.4.0
+aiohappyeyeballs==2.6.1
+aiohttp==3.12.13
+aiosignal==1.3.2
+annotated-types==0.7.0
+anyio==4.9.0
+asttokens==3.0.0
+astunparse==1.6.3
+attrs==25.3.0
+certifi==2025.6.15
+charset-normalizer==3.4.2
+click==8.2.1
+comm==0.2.2
+contourpy==1.3.2
+cycler==0.12.1
+debugpy==1.8.14
+decorator==5.2.1
+Deprecated==1.2.18
+dm-tree==0.1.9
+executing==2.2.0
+fastapi==0.115.12
+flatbuffers==25.2.10
+fonttools==4.58.4
+frozenlist==1.7.0
+gast==0.6.0
+google-pasta==0.2.0
+grpcio==1.73.0
+h11==0.16.0
+h5py==3.14.0
+idna==3.10
+imageio==2.37.0
+ipykernel==6.29.5
+ipython==9.3.0
+ipython_pygments_lexers==1.1.1
+jedi==0.19.2
+jupyter_client==8.6.3
+jupyter_core==5.8.1
+keras==3.10.0
+kiwisolver==1.4.8
+libclang==18.1.1
+Markdown==3.8
+markdown-it-py==3.0.0
+MarkupSafe==3.0.2
+matplotlib==3.10.3
+matplotlib-inline==0.1.7
+mdurl==0.1.2
+ml_dtypes==0.5.1
+multidict==6.4.4
+namex==0.1.0
+nest-asyncio==1.6.0
+numpy==1.26.4
+opencv-python==4.11.0.86
+opt_einsum==3.4.0
+optree==0.16.0
+packaging==25.0
+parso==0.8.4
+pexpect==4.9.0
+pillow==11.2.1
+platformdirs==4.3.8
+prompt_toolkit==3.0.51
+propcache==0.3.2
+protobuf==5.29.5
+psutil==7.0.0
+ptyprocess==0.7.0
+pure_eval==0.2.3
+pydantic==2.11.7
+pydantic_core==2.33.2
+Pygments==2.19.1
+pyparsing==3.2.3
+python-dateutil==2.9.0.post0
+python-multipart==0.0.20
+pyzmq==27.0.0
+requests==2.32.4
+rich==14.0.0
+scipy==1.16.0
+setuptools==80.9.0
+six==1.17.0
+sniffio==1.3.1
+stack-data==0.6.3
+starlette==0.46.2
+tensorboard==2.19.0
+tensorboard-data-server==0.7.2
+tensorflow==2.19.0
+tensorflow-model-optimization==0.8.0
+termcolor==3.1.0
+tf-keras-vis==0.8.7
+tornado==6.5.1
+traitlets==5.14.3
+typing-inspection==0.4.1
+typing_extensions==4.14.0
+urllib3==2.4.0
+uvicorn==0.34.3
+wcwidth==0.2.13
+Werkzeug==3.1.3
+wheel==0.45.1
+wrapt==1.17.2
+yarl==1.20.1