passage en full distribué

Dockerfile copy

@@ -1,39 +0,0 @@
-# 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

@@ -9,3 +9,5 @@ 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,11 @@
+import os
+
+ENV = os.getenv("API_ENV", "space")
+MODEL_NAME = os.getenv("MODEL_NAME", "EfficientNetV2M")
+
+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

@@ -1,33 +1,40 @@
+#main.py
 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"
-)
+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
 
-logger = logging.getLogger(__name__)
 
 
+logger.info(f"ENV :{ENV}")
 
 app = FastAPI()
 
 
-@app.on_event("startup")
+
 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),
@@ -42,16 +49,12 @@ async def predict(request: Request,
         # 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")
+            logger.debug(f"✅ 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")
+        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")
@@ -59,7 +62,10 @@ async def predict(request: Request,
 
         # Appel de ta logique de prédiction
         logger.debug("🔍 Appel du vote multi-modèles...")
-        model_config = load_model()[0]
+        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
@@ -72,4 +78,8 @@ async def predict(request: Request,
 
 @app.get("/health")
 def health_check():
-    return {"status": "ok"}
+    return {
+    "status": "ok",
+    "model_name": MODEL_NAME,
+    "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

@@ -28,7 +28,7 @@ logging.basicConfig(
     format="%(asctime)s [%(levelname)s] %(name)s: %(message)s"
 )
 logger = logging.getLogger(__name__)
-confidence_threshold=0.5
+confidence_threshold=0.55
 entropy_threshold=2
 
 class ModelStruct(TypedDict):

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
+
+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, "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)