Update app.py

app.py

@@ -4,84 +4,253 @@ os.environ['HF_HOME'] = '/tmp/cache'
 os.environ['TORCH_HOME'] = '/tmp/cache'
 
 from fastapi import FastAPI, File, UploadFile
+from fastapi.middleware.cors import CORSMiddleware
 from fastapi.responses import HTMLResponse
 from PIL import Image
 import torch
 import io
+import colorthief
+import tempfile
+import numpy as np
 
-app = FastAPI(title="Fashion Detection API")
+app = FastAPI(title="Fashion Classification API")
 
-# Modèle et processor (chargement différé)
+# Middleware CORS
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=["*"],
+    allow_credentials=True,
+    allow_methods=["*"],
+    allow_headers=["*"],
+    expose_headers=["*"]
+)
+
+# --- CHARGE LE MODÈLE MARQO FASHIONSIGLIP ---
+print("⚠️ Démarrage du chargement du modèle Marqo-FashionSigLIP...")
 model = None
 processor = None
 
-def load_model():
+def load_fashion_model():
     global model, processor
     try:
-        from transformers import CLIPModel, CLIPProcessor
-        model_name = "Marqo/marqo-fashionCLIP"
-        model = CLIPModel.from_pretrained(model_name)
-        processor = CLIPProcessor.from_pretrained(model_name)
-        print("✅ Modèle chargé!")
+        from transformers import AutoModel, AutoProcessor
+        
+        model_name = "Marqo/Marqo-FashionSigLIP-Classification"
+        
+        # Charger le modèle SigLIP spécialisé fashion
+        model = AutoModel.from_pretrained(
+            model_name,
+            cache_dir="/tmp/cache",
+            torch_dtype=torch.float16,  # Moins de mémoire
+            trust_remote_code=True
+        )
+        
+        processor = AutoProcessor.from_pretrained(
+            model_name,
+            trust_remote_code=True
+        )
+        
+        print("✅ Modèle Marqo-FashionSigLIP chargé avec succès !")
+        print(f"📍 Modèle device: {next(model.parameters()).device}")
+        
     except Exception as e:
-        print(f"❌ Erreur: {e}")
+        print(f"❌ Erreur chargement modèle: {e}")
+        import traceback
+        traceback.print_exc()
+
+# Catégories de mode pour SigLIP (adaptées au modèle)
+categories = [
+    "t-shirt", "dress", "jeans", "shirt", "skirt", 
+    "sneakers", "handbag", "jacket", "shorts", "sweater",
+    "coat", "high heels", "blouse", "boots", "hat"
+]
 
 @app.on_event("startup")
-async def startup():
+async def startup_event():
     import threading
-    threading.Thread(target=load_model).start()
-
-categories = ["t-shirt", "dress", "jeans", "shirt", "skirt", "jacket", "sweater"]
+    thread = threading.Thread(target=load_fashion_model)
+    thread.daemon = True
+    thread.start()
 
 @app.get("/")
-def home():
-    return {"message": "API running", "status": "OK"}
+def read_root():
+    return {"message": "Fashion Classification API is running!", "status": "OK"}
+
+@app.get("/health")
+def health_check():
+    return {
+        "model_loaded": model is not None,
+        "processor_loaded": processor is not None,
+        "status": "ready" if model and processor else "loading",
+        "model_name": "Marqo-FashionSigLIP-Classification"
+    }
 
 @app.post("/analyze")
-async def analyze(file: UploadFile = File(...)):
-    if not model or not processor:
-        return {"error": "Model loading..."}
+async def analyze_image(file: UploadFile = File(...)):
+    if model is None or processor is None:
+        return {"error": "Model not loaded yet. Please check /health endpoint."}
     
     try:
-        # Lire image
-        image = Image.open(io.BytesIO(await file.read())).convert("RGB")
-        image.thumbnail((256, 256))
+        # Lire et préparer l'image
+        contents = await file.read()
+        image = Image.open(io.BytesIO(contents)).convert("RGB")
+        
+        # Redimensionner pour SigLIP
+        image = image.resize((384, 384))
         
-        # Méthode SIMPLE et FIABLE
-        results = {}
-        for category in categories:
-            inputs = processor(
-                text=[category],
-                images=image,
-                return_tensors="pt",
-                padding=True,
-                truncation=True
-            )
-            with torch.no_grad():
-                outputs = model(**inputs)
-                results[category] = outputs.logits_per_image.item()
+        # --- TRAITEMENT AVEC SIGLIP ---
+        # Préparer les inputs
+        inputs = processor(
+            text=categories,
+            images=image,
+            return_tensors="pt",
+            padding=True,
+            truncation=True,
+            max_length=64,
+            return_overflowing_tokens=False
+        )
         
-        # Trouver le meilleur résultat
-        best_category = max(results, key=results.get)
-        confidence = results[best_category]
+        # Déplacer sur le device du modèle
+        device = next(model.parameters()).device
+        inputs = {k: v.to(device) for k, v in inputs.items()}
         
+        # Inférence
+        with torch.no_grad():
+            outputs = model(**inputs)
+        
+        # SigLIP utilise des logits différents
+        logits_per_image = outputs.logits_per_image
+        
+        # Convertir en probabilités
+        probs = torch.sigmoid(logits_per_image)  # SigLIP utilise sigmoid, pas softmax!
+        probs = probs.cpu().numpy()[0]
+        
+        # Trouver la meilleure catégorie
+        predicted_idx = np.argmax(probs)
+        category_name = categories[predicted_idx]
+        confidence_score = float(probs[predicted_idx])
+        
+        # --- ANALYSE COULEUR ---
+        try:
+            with tempfile.NamedTemporaryFile(suffix='.jpg', delete=False) as tmp:
+                image.save(tmp, format='JPEG')
+                tmp_path = tmp.name
+            
+            color_thief = colorthief.ColorThief(tmp_path)
+            dominant_color = color_thief.get_color(quality=1)
+            hex_color = '#%02x%02x%02x' % dominant_color
+            
+            os.unlink(tmp_path)
+            
+        except Exception as color_error:
+            print(f"⚠️ Erreur analyse couleur: {color_error}")
+            hex_color = "#000000"
+
+        # --- RÉSULTATS DÉTAILLÉS ---
+        top_categories = []
+        for i, (cat, prob) in enumerate(zip(categories, probs)):
+            if prob > 0.1:  # Seuil minimal
+                top_categories.append({
+                    "category": cat,
+                    "score": round(float(prob), 4)
+                })
+        
+        # Trier par score décroissant
+        top_categories.sort(key=lambda x: x["score"], reverse=True)
+        top_5 = top_categories[:5]
+
         return {
-            "category": best_category,
-            "confidence": round(confidence, 4),
-            "color_hex": "#000000"  # Couleur basique pour l'instant
+            "top_prediction": {
+                "category": category_name,
+                "confidence": round(confidence_score, 4),
+                "color_hex": hex_color
+            },
+            "top_categories": top_5,
+            "model": "Marqo-FashionSigLIP-Classification"
         }
-        
+
     except Exception as e:
-        return {"error": str(e)}
+        return {"error": f"Erreur lors de l'analyse: {str(e)}"}
 
-@app.get("/ui", response_class=HTMLResponse)
-def ui():
+# Interface de test
+@app.get("/test-ui", response_class=HTMLResponse)
+async def test_ui():
     return """
-    <html><body>
-        <h1>Fashion Detector</h1>
-        <form action="/analyze" method="post" enctype="multipart/form-data">
-            <input type="file" name="file" accept="image/*">
-            <input type="submit" value="Analyze">
-        </form>
-    </body></html>
+    <html>
+        <head>
+            <title>FashionSigLIP Detection</title>
+            <style>
+                body { 
+                    font-family: Arial, sans-serif; 
+                    margin: 40px; 
+                    background: linear-gradient(135deg, #667eea 0%, #764ba2 100%);
+                    color: white;
+                }
+                .container { 
+                    max-width: 600px; 
+                    margin: 0 auto; 
+                    background: rgba(255, 255, 255, 0.1);
+                    padding: 30px;
+                    border-radius: 15px;
+                    backdrop-filter: blur(10px);
+                }
+                form { 
+                    border: 2px dashed rgba(255, 255, 255, 0.3); 
+                    padding: 30px; 
+                    text-align: center; 
+                    margin-bottom: 20px;
+                }
+                input[type="file"] { 
+                    margin: 15px 0; 
+                    padding: 10px;
+                    background: rgba(255, 255, 255, 0.2);
+                    border: none;
+                    border-radius: 5px;
+                    color: white;
+                }
+                input[type="submit"] { 
+                    background: #ff6b6b; 
+                    color: white; 
+                    padding: 12px 25px; 
+                    border: none; 
+                    cursor: pointer; 
+                    border-radius: 25px;
+                    font-weight: bold;
+                    transition: background 0.3s;
+                }
+                input[type="submit"]:hover {
+                    background: #ee5a52;
+                }
+                .result { 
+                    margin-top: 20px; 
+                    padding: 20px; 
+                    background: rgba(255, 255, 255, 0.1);
+                    border-radius: 10px;
+                }
+            </style>
+        </head>
+        <body>
+            <div class="container">
+                <h1>👗 FashionSigLIP Detector</h1>
+                <p>Powered by Marqo/Marqo-FashionSigLIP-Classification</p>
+                
+                <form action="/analyze" method="post" enctype="multipart/form-data">
+                    <h3>Uploader une image de vêtement :</h3>
+                    <input type="file" name="file" accept="image/*" required>
+                    <br>
+                    <input type="submit" value="Analyser la mode ���">
+                </form>
+                
+                <div class="result">
+                    <h3>📊 Résultats :</h3>
+                    <p>Les résultats apparaîtront ici après analyse...</p>
+                </div>
+                
+                <div style="margin-top: 20px; font-size: 12px; opacity: 0.7;">
+                    <p>Modèle : Marqo-FashionSigLIP-Classification</p>
+                    <p>Spécialisé dans la classification de vêtements</p>
+                </div>
+            </div>
+        </body>
+    </html>
     """