nouvelle version

app/main.py

@@ -34,10 +34,16 @@ class ImagePayload(BaseModel):
 async def predict(request: Request,
     file: UploadFile = File(None),
     payload: Union[ImagePayload, None] = None,
-    mode: str = Query("single", enum=["single", "voting"], description="Mode de prédiction"),
-    show_heatmap: bool = Query(False, description="Afficher la heatmap")):
+    mode: str = Query("single", enum=["single", "voting","automatic"], description="Mode de prédiction"),
+    show_heatmap: bool = Query(False, description="Afficher la heatmap"),
+    default_model: str = Query("efficientnetv2m", enum=["efficientnetv2m", "resnet50"], description="Model par défaut")
+    ):
+   
     logger.info("🔁 Requête reçue")
     logger.info(f"✅ Mode : {mode}")
+    logger.info(f"✅ Default model : {default_model}")
+    logger.info(f"✅ Show heatmap : {show_heatmap}")
+    
     try:
         # Cas 1 : multipart avec fichier
         if file is not None:
@@ -59,7 +65,7 @@ async def predict(request: Request,
 
         # Appel de ta logique de prédiction
         logger.debug("🔍 Appel du vote multi-modèles...")
-        prediction = await soft_voting(model_configs,image_bytes,mode,show_heatmap)
+        prediction = await soft_voting(model_configs,image_bytes,mode,show_heatmap,default_model)
 
         # Pour l’instant : réponse simulée
         return prediction

app/voting.py

@@ -51,7 +51,164 @@ def compute_js_divergence(all_probs):
 
 # Si js_divergence > 0.1 → Désaccord modéré
 
-async def soft_voting(model_configs,image_bytes: bytes,mode,show_heatmap):
+async def soft_voting(model_configs, image_bytes: bytes, mode, show_heatmap, default_model):
+    logger.info("🔁 Début de la prédiction multi-modèles")
+
+    all_probs = []
+    models = []
+    models_predictions = []
+    models_confidences = []
+    models_entropies = []
+    models_uncertainties = []
+    models_heatmaps = []
+
+    # On commence toujours par le modèle par défaut
+    default_config = next((config for config in model_configs if config["model_name"].lower() == default_model.lower()), None)
+
+    if default_config is None:
+        logger.error(f"❌ Modèle par défaut '{default_model}' introuvable dans les configurations.")
+        return None
+
+    async with aiohttp.ClientSession() as session:
+        # Prédiction avec le modèle par défaut
+        logger.info(f"🚀 Prédiction avec le modèle par défaut : {default_model}")
+        prediction = predict_with_model(default_config, image_bytes, show_heatmap)
+
+        all_probs.append(prediction["preds"])
+        logger.info(f" predicted_class: {prediction["predicted_class"]}")
+        models_predictions.append(prediction["predicted_class"])
+        models_confidences.append(prediction["confidence"])
+        models_entropies.append(prediction["entropy"])
+        models_uncertainties.append(prediction["is_uncertain_model"])
+        models.append(default_config["model_name"])
+
+        if show_heatmap:
+            heatmap = prediction.get("heatmap")
+            if heatmap and len(heatmap) > 0:
+                models_heatmaps.append(heatmap)
+            else:
+                logger.warning(f"⚠️ Heatmap vide ou invalide pour le modèle {default_config['model_name']}")
+
+        if not all_probs:
+            logger.warning("⚠️ Aucune prédiction reçue, vérifie les APIs appelées.")
+            raise Exception("No predictions received.")
+
+        mean_probs = np.mean(all_probs, axis=0)
+        final_class = int(np.argmax(mean_probs))
+        final_confidence = float(mean_probs[final_class])
+        entropy=float(compute_entropy_safe(mean_probs))
+        jsd_score = float(compute_js_divergence(all_probs))
+
+    
+        logger.debug(f"🧠 Moyenne des probabilités : {mean_probs.tolist()}")
+
+
+        # Mode 'single' : on s'arrête ici
+        if mode == "single":
+            is_global_uncertain=models_uncertainties[0]
+            logger.info("🛑 Mode 'single' activé, utilisation uniquement du modèle par défaut.")
+
+            logger.info(f"✅ Prediction terminé : classe={final_class}"
+                    f"confiance={final_confidence:.4f}\n"
+                    f"entropy={entropy:.4f}\n"
+                    f"jsd_score={jsd_score:.4f}\n"
+                    f"is_global_uncertain={is_global_uncertain}\n"
+                    )
+            return {
+            "predicted_class": final_class,
+            "confidence": final_confidence,
+            "entropy":entropy,
+            "jsd_score":jsd_score,
+            "models": models,
+            "is_global_uncertain":is_global_uncertain,
+            "models_predictions": models_predictions,
+            "models_confidences": models_confidences,
+            "models_entropies":models_entropies,
+            "models_uncertainties":models_uncertainties,
+            "models_heatmaps": models_heatmaps
+            
+            }
+
+        # Si mode == 'automatic' et confiance suffisante, on s'arrête
+        if mode == "automatic" and prediction["confidence"] >= 0.90:
+            is_global_uncertain=models_uncertainties[0]
+            logger.info(f"✅ Confiance élevée ({prediction['confidence']:.2f}), pas besoin de voter.")
+            logger.info(f"✅ Prediction terminé : classe={final_class}"
+                    f"confiance={final_confidence:.4f}\n"
+                    f"entropy={entropy:.4f}\n"
+                    f"jsd_score={jsd_score:.4f}\n"
+                    f"is_global_uncertain={is_global_uncertain}\n"
+                    )
+            return {
+                "predicted_class": final_class,
+                "confidence": final_confidence,
+                "entropy":entropy,
+                "jsd_score":jsd_score,
+                "models": models,
+                "is_global_uncertain":is_global_uncertain,
+                "models_predictions": models_predictions,
+                "models_confidences": models_confidences,
+                "models_entropies":models_entropies,
+                "models_uncertainties":models_uncertainties,
+                "models_heatmaps": models_heatmaps
+            
+            }
+
+        # Sinon, on continue avec tous les autres modèles (voting ou automatic avec faible confiance)
+        logger.info(f"🔍 Mode '{mode}' : Prédictions complémentaires en cours.")
+
+        for config in model_configs:
+            if config["model_name"].lower() == default_model.lower():
+                continue  # On a déjà traité le modèle par défaut
+
+            prediction = predict_with_model(config, image_bytes, show_heatmap)
+
+            all_probs.append(prediction["preds"])
+            models_predictions.append(prediction["predicted_class"])
+            models_confidences.append(prediction["confidence"])
+            models_entropies.append(prediction["entropy"])
+            models_uncertainties.append(prediction["is_uncertain_model"])
+            models.append(config["model_name"])
+
+            
+
+            if show_heatmap:
+                heatmap = prediction.get("heatmap")
+                if heatmap and len(heatmap) > 0:
+                    models_heatmaps.append(heatmap)
+                else:
+                    logger.warning(f"⚠️ Heatmap vide ou invalide pour le modèle {config['model_name']}")
+        
+        mean_probs = np.mean(all_probs, axis=0)
+        final_class = int(np.argmax(mean_probs))
+        final_confidence = float(mean_probs[final_class])
+        entropy=float(compute_entropy_safe(mean_probs))
+        jsd_score = float(compute_js_divergence(all_probs))
+
+        is_global_uncertain = any(models_uncertainties) and jsd_score > shannon_threashold
+        logger.info(f"✅ Prediction terminé : classe={final_class}"
+                    f"confiance={final_confidence:.4f}\n"
+                    f"entropy={entropy:.4f}\n"
+                    f"jsd_score={jsd_score:.4f}\n"
+                    f"is_global_uncertain={is_global_uncertain}\n"
+                    )
+        return {
+                "predicted_class": final_class,
+                "confidence": final_confidence,
+                "entropy":entropy,
+                "jsd_score":jsd_score,
+                "models": models,
+                "is_global_uncertain":is_global_uncertain,
+                "models_predictions": models_predictions,
+                "models_confidences": models_confidences,
+                "models_entropies":models_entropies,
+                "models_uncertainties":models_uncertainties,
+                "models_heatmaps": models_heatmaps
+            
+            }
+
+
+async def soft_voting_v1(model_configs,image_bytes: bytes,mode,show_heatmap,default_model):
     logger.info("🔁 Début du vote multi-modèles")
     all_probs = []
     models = []