Update app.py

app.py

@@ -71,7 +71,6 @@ def health_check():
 async def classify_fashion(image_data: dict):
     """
     Endpoint pour Lovable - accepte une URL d'image
-    Format attendu: {"imageUrl": "https://example.com/image.jpg"}
     """
     try:
         if not model or not processor:
@@ -82,15 +81,15 @@ async def classify_fashion(image_data: dict):
         if not image_url:
             raise HTTPException(status_code=400, detail="imageUrl is required")
         
-        # Télécharger l'image depuis l'URL
+        # Télécharger l'image
         response = requests.get(image_url, timeout=30)
         response.raise_for_status()
         
         # Ouvrir et préparer l'image
         image = Image.open(BytesIO(response.content)).convert("RGB")
-        image.thumbnail((512, 512))
+        image = image.resize((224, 224))  # Taille standard pour CLIP
         
-        # Préparer toutes les catégories en anglais
+        # Préparer les catégories
         all_english_categories = []
         category_mapping = {}
         
@@ -99,39 +98,47 @@ async def classify_fashion(image_data: dict):
             for en_cat in en_categories:
                 category_mapping[en_cat] = fr_cat
         
-        # Traitement avec padding pour éviter l'erreur tensor
-        inputs = processor(
-            text=all_english_categories,
-            images=image,
-            return_tensors="pt",
-            padding=True,  # ← CORRECTION IMPORTANTE
-            truncation=True,
-            max_length=77,
-            return_overflowing_tokens=False
-        )
+        # === NOUVELLE APPROCHE : Traitement séquentiel ===
+        results = {}
         
-        # Déplacer sur GPU si disponible
-        if torch.cuda.is_available():
-            inputs = {k: v.cuda() for k, v in inputs.items()}
+        for category in all_english_categories:
+            try:
+                # Traiter chaque catégorie individuellement
+                inputs = processor(
+                    text=[category],  # Une seule catégorie à la fois
+                    images=image,
+                    return_tensors="pt",
+                    padding=True,
+                    truncation=True,
+                    max_length=77,
+                    return_overflowing_tokens=False
+                )
+                
+                with torch.no_grad():
+                    outputs = model(**inputs)
+                    results[category] = outputs.logits_per_image.item()
+                    
+            except Exception as e:
+                print(f"Erreur avec la catégorie {category}: {e}")
+                results[category] = -10.0  # Valeur très basse en cas d'erreur
         
-        with torch.no_grad():
-            outputs = model(**inputs)
-            logits_per_image = outputs.logits_per_image
-            probs = logits_per_image.softmax(dim=1)
-            
-            results = {cat: prob.item() for cat, prob in zip(all_english_categories, probs[0])}
+        # Trouver la meilleure catégorie
+        if not results:
+            raise HTTPException(status_code=500, detail="Aucun résultat obtenu")
         
-        # Trouver la catégorie avec le meilleur score
         best_english_category = max(results, key=results.get)
         confidence = results[best_english_category]
         
-        # Convertir en catégorie française
+        # Convertir le score en probabilité (approximative)
+        confidence_normalized = 1 / (1 + torch.exp(torch.tensor(-confidence))).item()
+        
+        # Catégorie française
         best_french_category = category_mapping.get(best_english_category, "autre")
         
         return {
             "success": True,
             "category": best_french_category,
-            "confidence": round(confidence, 4),
+            "confidence": round(confidence_normalized, 4),
             "colorHex": "#000000",
             "originalCategory": best_english_category,
             "method": "modli-api"