ajout modèle quantifié

app/main.py

@@ -5,7 +5,7 @@ from pydantic import BaseModel
 from typing import Union
 import base64
 
-from app.model import load_model, predict_with_model
+from app.model import load_model, predict_with_model,get_heatmap
 import os
 import threading
 import time
@@ -32,18 +32,16 @@ def startup():
 
 
 class ImagePayload(BaseModel):
-    image: str  # chaîne encodée en base64
-
+    image: str
+    predicted_class_index: int
 
 @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
@@ -61,12 +59,11 @@ async def predict(request: Request,
             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)
+        prediction = predict_with_model(model_config, image_bytes)
 
         # Pour l’instant : réponse simulée
         return prediction
@@ -76,6 +73,48 @@ async def predict(request: Request,
         raise HTTPException(status_code=500, detail=str(e))
 
 
+
+
+
+@app.post("/heatmap")
+async def predict_heatmap(
+    request: Request,
+    payload: Union[ImagePayload, None] = None,
+    file: UploadFile = File(None),
+    predicted_class_index: int = Query(None)
+):
+    logger.info("🔁 Requête reçue pour heatmap")
+    
+    try:
+        if file is not None:
+            image_bytes = await file.read()
+            logger.debug(f"✅ Image reçue via multipart : {file.filename} — {len(image_bytes)} octets")
+            if predicted_class_index is None:
+                raise HTTPException(status_code=400, detail="predicted_class_index requis en query avec fichier multipart")
+
+        elif payload is not None:
+            image_bytes = base64.b64decode(payload.image)
+            predicted_class_index = payload.predicted_class_index
+            logger.debug(f"✅ Image reçue en JSON base64 : {len(image_bytes)} octets, class={predicted_class_index}")
+
+        else:
+            raise HTTPException(status_code=400, detail="Aucune image reçue")
+
+        models = load_model()
+        if not models:
+            raise HTTPException(status_code=500, detail="Aucun modèle chargé.")
+        model_config = models[0]
+
+        heatmap = get_heatmap(model_config, image_bytes, predicted_class_index)
+
+        return {"heatmap": heatmap}
+
+    except Exception as e:
+        logger.error("❌ Erreur heatmap", exc_info=True)
+        raise HTTPException(status_code=500, detail=str(e))
+
+
+
 @app.get("/health")
 def health_check():
     return {

app/model.py

@@ -6,7 +6,6 @@ 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
@@ -31,10 +30,179 @@ logger = logging.getLogger(__name__)
 confidence_threshold=0.55
 entropy_threshold=2
 
+
+
+
+class TFLiteDynamicModel:
+    def __init__(self, tflite_path, img_size=224):
+        logger.info(f"🚀 Chargement du modèle TFLite depuis : {tflite_path}")
+        self.img_size = img_size
+        self.interpreter = tf.lite.Interpreter(model_path=tflite_path)
+        self.interpreter.allocate_tensors()
+
+        input_details = self.interpreter.get_input_details()
+        output_details = self.interpreter.get_output_details()
+
+        self.input_index = input_details[0]['index']
+        self.input_dtype = input_details[0]['dtype']
+        self.input_scale, self.input_zero_point = input_details[0]['quantization']
+        self.output_index = output_details[0]['index']
+
+        logger.info(f"🔍 Input tensor index : {self.input_index}, dtype : {self.input_dtype}, scale : {self.input_scale}, zero_point : {self.input_zero_point}")
+        logger.info(f"🔍 Output tensor index : {self.output_index}")
+
+
+    def preprocess(self, pil_image):
+        logger.info(f"🎨 Prétraitement image, redimension à {self.img_size}x{self.img_size}")
+        img = pil_image.resize((self.img_size, self.img_size))
+        img = np.array(img)
+
+        # 📸 Gestion des images grayscale ou RGBA
+        if img.ndim == 2:  # Grayscale -> RGB
+            logger.debug("⚪ Image grayscale détectée, conversion en RGB")
+            img = np.stack([img] * 3, axis=-1)
+        elif img.shape[-1] == 4:  # RGBA -> RGB
+            logger.debug("🖼️ Image RGBA détectée, suppression canal alpha")
+            img = img[..., :3]
+
+        if self.input_dtype in [np.uint8, np.int8]:
+            logger.info("🗜️ Modèle quantifié PTQ détecté (entrée int8 ou uint8)")
+
+            # Pas de division par 255 ici ! On quantifie directement selon l'échelle et le zéro-point
+            img = img.astype(np.float32)
+            img = img / self.input_scale + self.input_zero_point
+
+            # On clip selon le type
+            if self.input_dtype == np.uint8:
+                img = np.clip(img, 0, 255)
+            else:  # np.int8
+                img = np.clip(img, -128, 127)
+
+            img = img.astype(self.input_dtype)
+
+        else:
+            logger.info("🌊 Modèle dynamique ou float32 détecté (entrée float32 normalisée)")
+            img = img.astype(self.input_dtype)  # Normalisation classique
+
+        input_data = np.expand_dims(img, axis=0)
+        logger.info(f"✅ Image prétraitée avec forme {input_data.shape} et dtype {input_data.dtype}")
+        return input_data
+
+
+    def preprocess_old(self, pil_image):
+        logger.info(f"🎨 Prétraitement image, redimension à {self.img_size}x{self.img_size}")
+        img = pil_image.resize((self.img_size, self.img_size))
+        img = np.array(img).astype(np.float32)
+
+        if img.ndim == 2:  # grayscale -> RGB
+            logger.debug("⚪ Image grayscale détectée, conversion en RGB")
+            img = np.stack([img]*3, axis=-1)
+        elif img.shape[-1] == 4:  # RGBA -> RGB
+            logger.debug("🖼️ Image RGBA détectée, suppression canal alpha")
+            img = img[..., :3]
+
+        if self.input_dtype in [np.uint8, np.int8]:
+            if self.input_scale > 0:
+                logger.debug(f"⚙️ Application quantification dynamique avec scale {self.input_scale} et zero_point {self.input_zero_point}")
+                img = img / 255.0
+                img = img / self.input_scale + self.input_zero_point
+                img = np.clip(img, 0, 255 if self.input_dtype == np.uint8 else 127)
+            img = img.astype(self.input_dtype)
+        else:
+            img = img.astype(self.input_dtype)
+
+        input_data = np.expand_dims(img, axis=0)
+        logger.info(f"✅ Image prétraitée avec forme {input_data.shape} et dtype {input_data.dtype}")
+        return input_data
+
+    
+
+    def predict_dyna(self, pil_image):
+        logger.info("⚡ Début de prédiction (modèle dynamique ou float32)")
+
+        # Prétraitement
+        logger.info("🔄 Prétraitement de l'image en cours")
+        input_data = self.preprocess(pil_image)
+        logger.debug(f"✅ Image prétraitée - Shape : {input_data.shape} - Dtype : {input_data.dtype}")
+
+        # Injection des données dans le modèle
+        logger.info("📥 Injection des données dans le modèle")
+        self.interpreter.set_tensor(self.input_index, input_data)
+
+        # Invocation du modèle
+        logger.info("🚀 Exécution du modèle TFLite")
+        self.interpreter.invoke()
+
+        # Récupération de la sortie
+        logger.info("📤 Récupération des résultats bruts")
+        output_data = self.interpreter.get_tensor(self.output_index)
+        logger.debug(f"✅ Logits récupérés - Shape : {output_data.shape} - Dtype : {output_data.dtype}")
+
+        # Calcul des probabilités
+        logger.info("🧮 Calcul des probabilités")
+        probas=output_data[0]
+        logger.debug(f"✅ Probabilités : {probas}")
+
+    
+        logger.info("🎯 Prédiction terminée")
+
+        return  probas
+
+
+    def predict_ptq(self, pil_image):
+        logger.info("⚡ Début de prédiction")
+        
+        # Prétraitement
+        logger.info("🔄 Prétraitement de l'image en cours")
+        input_data = self.preprocess(pil_image)
+        logger.debug(f"✅ Image prétraitée - Shape : {input_data.shape} - Dtype : {input_data.dtype}")
+
+        # Injection des données dans le modèle
+        logger.info("📥 Injection des données dans le modèle")
+        self.interpreter.set_tensor(self.input_index, input_data)
+
+        # Invocation du modèle
+        logger.info("🚀 Exécution du modèle TFLite")
+        self.interpreter.invoke()
+
+        # Récupération de la sortie
+        logger.info("📤 Récupération des résultats bruts")
+        output_details = self.interpreter.get_output_details()[0]
+        output_data = self.interpreter.get_tensor(output_details['index'])
+        logger.debug(f"✅ Logits quantifiés récupérés - Shape : {output_data.shape} - Dtype : {output_data.dtype}")
+
+        # Paramètres de quantification
+        output_scale, output_zero_point = output_details['quantization']
+        logger.debug(f"ℹ️ Paramètres de quantification - Scale: {output_scale}, Zero Point: {output_zero_point}")
+
+        # Déquantification
+        logger.info("🔓 Déquantification des logits")
+        logits = (output_data.astype(np.float32) - output_zero_point) * output_scale
+        logger.debug(f"✅ Logits déquantifiés : {logits}")
+
+        # Calcul des probabilités
+        logger.info("🧮 Calcul des probabilités avec softmax")
+        probas = logits[0]
+        logger.debug(f"✅ Probabilités : {probas}")
+
+        logger.info("🎯 Prédiction terminée")
+
+        return probas
+    
+    def predict (self, pil_image):
+        if self.input_dtype in [np.uint8, np.int8]:
+            logger.info("🗜️ Modèle quantifié PTQ détecté")
+            return self.predict_ptq(pil_image)
+        else:
+            logger.info("🌊 Modèle dynamique ou float32 détecté")
+            return self.predict_dyna(pil_image)
+
+
 class ModelStruct(TypedDict):
     model_name: str
     model: tf.keras.Model
     gradcam_model:tf.keras.Model
+    fast_model:TFLiteDynamicModel
     preprocess_input: Callable[[np.ndarray], Any]
     target_size: tuple[int, int]
     last_conv_layer:str
@@ -47,11 +215,13 @@ def load_model() -> list[ModelStruct]:
     if _model_cache is None:
         print("📦 Chargement du modèle EfficientNetV2M...")
         model = tf.keras.models.load_model("model/best_efficientnetv2m_gradcam.keras", compile=False)
+        fast_model=TFLiteDynamicModel("model/efficientnetv2m_float16.tflite", img_size=480)
 
         _model_cache = [{
             "model_name": "EfficientNetV2M",
             "model": model,
             "gradcam_model": model, 
+            "fast_model":fast_model,
             "preprocess_input": effnet_preprocess,
             "target_size": (480, 480),
             "last_conv_layer": "block7a_expand_conv",
@@ -111,6 +281,7 @@ def compute_gradcam(model, image_array, class_index=None, layer_name=None,gradca
     return cam
 
  
+
 def preprocess_image(image_bytes, target_size, preprocess_input):
     try:
         logger.info("📤 Lecture des bytes et conversion en image PIL")
@@ -151,52 +322,84 @@ def compute_entropy_safe(probas):
     return entropy
 
 
-def predict_with_model(config, image_bytes: bytes,show_heatmap=False):
+def get_heatmap(config, image_bytes: bytes,predicted_class_index):
+    result={}
+    try:
+        _,raw_input = preprocess_image(image_bytes,config["target_size"],config["preprocess_input"])
+        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"] = []
+    return result
+
+def predict_with_model(config, image_bytes: bytes):
    
-    input_array,raw_input = preprocess_image(image_bytes,config["target_size"],config["preprocess_input"])
+    #input_array,raw_input = preprocess_image(image_bytes,config["target_size"],config["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("🤖 Lancement de la prédiction avec le modèle")
-    preds = config["model"].predict(input_array)
-    logger.debug(f"📈 Prédictions brutes : {preds[0].tolist()}")
+    preds = config["fast_model"].predict(image)
+    logger.info(f"📈 Prédictions brutes : {preds.tolist()}")
 
-    predicted_class_index = int(np.argmax(preds[0]))
-    confidence = float(preds[0][predicted_class_index])
+    predicted_class_index = int(np.argmax(preds))
+    confidence = float(np.max(preds))
     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}")
+    logger.info(f"✅ Prédiction : classe={predicted_class_index}, confiance={confidence:.4f},entropy={entropy:.4f}")
 
-    result= {
-        "preds": preds[0].tolist(),
+    return  {
+        "preds": preds.tolist(),
         "predicted_class": predicted_class_index,
         "confidence": confidence,
-        "entropy":entropy,
-        "is_uncertain_model":is_uncertain_model
+        "entropy":entropy
     }
-    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"])
+def predict_with_model_old(config, image_bytes: bytes):
+   
+    #input_array,raw_input = preprocess_image(image_bytes,config["target_size"],config["preprocess_input"])
 
-            elapsed_time = time.time() - start_time
-            logger.info(f"✅ Heatmap générée en {elapsed_time:.2f} secondes")
+    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("🤖 Lancement de la prédiction avec le modèle")
+    preds = config["fast_model"].predict(image)
+    logger.info(f"📈 Prédictions brutes : {preds[0].tolist()}")
 
-            # 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"] = []
+    
+    predicted_class_index = int(np.argmax(preds[0]))
+    confidence = float(preds[0][predicted_class_index])
+    entropy=float(compute_entropy_safe(preds))
+    logger.info(f"✅ Prédiction : classe={predicted_class_index}, confiance={confidence:.4f},entropy={entropy:.4f}")
 
+    return  {
+        "preds": preds[0].tolist(),
+        "predicted_class": predicted_class_index,
+        "confidence": confidence,
+        "entropy":entropy
+    }
 
-    return result

app/utils.py

@@ -30,7 +30,7 @@ def register_with_orchestrator():
         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"}
+            json={"model_name": MODEL_NAME, "model_type": MODEL_TYPE,"url": f"{OWN_URL}"}
         )
         if response.status_code == 200:
             logger.info("✅ Modèle enregistré avec succès")

model/efficientnetv2m_float16.tflite

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:9f42e7fa1fa94a3115df85c6721b1ebef563feca717fba1922ba632dcc658794
+size 106340288