Update app.py

app.py

@@ -27,56 +27,93 @@ app.add_middleware(
 )
 
 # --- ÉTAT DU MODÈLE ---
-print("⚠️ Démarrage du chargement du modèle Marqo-FashionSigLIP...")
+print("⚠️ Démarrage du chargement du modèle...")
 model = None
 processor = None
-model_loading = False
 model_loaded = False
 model_error = None
 
-def load_fashion_model():
-    global model, processor, model_loading, model_loaded, model_error
+# Modèles disponibles (garantis de fonctionner)
+AVAILABLE_MODELS = {
+    "siglip-base": {
+        "name": "google/siglip-base-patch16-224",
+        "type": "siglip",
+        "description": "SigLIP base - Excellente précision"
+    },
+    "clip-fashion": {
+        "name": "patrickjohncyh/fashion-clip", 
+        "type": "clip",
+        "description": "CLIP spécialisé mode"
+    },
+    "openclip": {
+        "name": "laion/CLIP-ViT-B-32-laion2B-s34B-b79K",
+        "type": "clip", 
+        "description": "OpenCLIP performant"
+    }
+}
+
+SELECTED_MODEL = "siglip-base"  # ← MODÈLE GARANTI
+
+def load_model():
+    global model, processor, model_loaded, model_error
     
-    model_loading = True
     try:
-        from transformers import AutoModel, AutoProcessor
-        
-        model_name = "Marqo/Marqo-FashionSigLIP-Classification"
+        from transformers import AutoModel, AutoProcessor, AutoTokenizer, CLIPModel, CLIPProcessor
         
-        print("📦 Téléchargement du modèle... (cela peut prendre 5-10 minutes)")
+        model_info = AVAILABLE_MODELS[SELECTED_MODEL]
+        model_name = model_info["name"]
         
-        # Charger le modèle SigLIP
-        model = AutoModel.from_pretrained(
-            model_name,
-            cache_dir="/tmp/cache",
-            torch_dtype=torch.float16,
-            trust_remote_code=True
-        )
+        print(f"📦 Chargement du modèle: {model_name}")
+        print(f"📝 Description: {model_info['description']}")
         
-        processor = AutoProcessor.from_pretrained(
-            model_name,
-            trust_remote_code=True
-        )
+        if model_info["type"] == "siglip":
+            # Charger SigLIP
+            model = AutoModel.from_pretrained(
+                model_name,
+                cache_dir="/tmp/cache",
+                torch_dtype=torch.float16
+            )
+            processor = AutoProcessor.from_pretrained(model_name)
+            
+        else:
+            # Charger CLIP
+            model = CLIPModel.from_pretrained(
+                model_name,
+                cache_dir="/tmp/cache",
+                torch_dtype=torch.float16
+            )
+            processor = CLIPProcessor.from_pretrained(model_name)
         
-        print("✅ Modèle Marqo-FashionSigLIP chargé avec succès !")
+        print(f"✅ Modèle {model_name} chargé avec succès !")
         model_loaded = True
-        model_loading = False
         
     except Exception as e:
-        print(f"❌ Erreur chargement modèle: {e}")
-        model_error = str(e)
-        model_loading = False
-        import traceback
-        traceback.print_exc()
+        model_error = f"Erreur avec {SELECTED_MODEL}: {str(e)}"
+        print(f"❌ {model_error}")
+        # Essayer le modèle suivant en cas d'erreur
+        try_next_model()
 
-# Démarrer le chargement IMMÉDIATEMENT
-load_fashion_model()
+def try_next_model():
+    """Essaye le modèle suivant si le premier échoue"""
+    global SELECTED_MODEL
+    models = list(AVAILABLE_MODELS.keys())
+    current_index = models.index(SELECTED_MODEL)
+    
+    if current_index < len(models) - 1:
+        SELECTED_MODEL = models[current_index + 1]
+        print(f"🔄 Essai du modèle suivant: {SELECTED_MODEL}")
+        load_model()
+    else:
+        print("❌ Tous les modèles ont échoué")
 
-# Catégories de mode
+# Démarrer le chargement
+load_model()
+
+# Catégories de mode adaptées
 categories = [
-    "t-shirt", "dress", "jeans", "shirt", "skirt", 
-    "sneakers", "handbag", "jacket", "shorts", "sweater",
-    "coat", "high heels", "blouse", "boots", "hat"
+    "a t-shirt", "a dress", "jeans", "a shirt", "a skirt", 
+    "sneakers", "a handbag", "a jacket", "shorts", "a sweater",
+    "a coat", "high heels", "a blouse", "boots", "a hat"
 ]
 
 @app.get("/")
@@ -84,74 +121,82 @@ def read_root():
     return {
         "message": "Fashion Classification API is running!", 
         "status": "OK",
-        "model_status": "loaded" if model_loaded else "loading" if model_loading else "error",
-        "model_name": "Marqo-FashionSigLIP-Classification"
+        "model_loaded": model_loaded,
+        "current_model": SELECTED_MODEL,
+        "model_name": AVAILABLE_MODELS[SELECTED_MODEL]["name"] if model_loaded else "loading"
     }
 
 @app.get("/health")
 def health_check():
     return {
         "model_loaded": model_loaded,
-        "model_loading": model_loading,
         "model_error": model_error,
-        "status": "ready" if model_loaded else "loading" if model_loading else "error",
-        "model_name": "Marqo-FashionSigLIP-Classification",
+        "current_model": SELECTED_MODEL,
+        "model_details": AVAILABLE_MODELS[SELECTED_MODEL] if model_loaded else None,
+        "available_models": list(AVAILABLE_MODELS.keys()),
+        "status": "ready" if model_loaded else "error",
         "timestamp": time.time()
     }
 
 @app.post("/analyze")
 async def analyze_image(file: UploadFile = File(...)):
-    # Vérifier si le modèle est chargé
     if not model_loaded:
-        if model_loading:
-            raise HTTPException(status_code=423, detail="Model still loading. Please wait 5-10 minutes and check /health")
-        else:
-            raise HTTPException(status_code=500, detail=f"Model failed to load: {model_error}")
-    
-    if model is None or processor is None:
-        raise HTTPException(status_code=500, detail="Model not available")
+        raise HTTPException(status_code=423, detail="Model not loaded yet. Please check /health")
     
     try:
         # Lire et préparer l'image
         contents = await file.read()
         image = Image.open(io.BytesIO(contents)).convert("RGB")
-        image = image.resize((384, 384))
-        
-        # Traitement avec SigLIP
-        inputs = processor(
-            text=categories,
-            images=image,
-            return_tensors="pt",
-            padding=True,
-            truncation=True,
-            max_length=64,
-        )
-        
-        device = next(model.parameters()).device
-        inputs = {k: v.to(device) for k, v in inputs.items()}
+        image = image.resize((224, 224))  # Taille standard
         
-        with torch.no_grad():
-            outputs = model(**inputs)
+        # Traitement selon le type de modèle
+        if SELECTED_MODEL == "siglip-base":
+            # SigLIP processing
+            inputs = processor(
+                text=categories,
+                images=image,
+                return_tensors="pt",
+                padding=True,
+                truncation=True
+            )
+            
+            with torch.no_grad():
+                outputs = model(**inputs)
+            
+            logits_per_image = outputs.logits_per_image
+            probs = torch.sigmoid(logits_per_image)
+            
+        else:
+            # CLIP processing
+            inputs = processor(
+                text=categories,
+                images=image,
+                return_tensors="pt",
+                padding=True,
+                truncation=True
+            )
+            
+            with torch.no_grad():
+                outputs = model(**inputs)
+            
+            logits_per_image = outputs.logits_per_image
+            probs = torch.softmax(logits_per_image, dim=1)
         
-        logits_per_image = outputs.logits_per_image
-        probs = torch.sigmoid(logits_per_image)
         probs = probs.cpu().numpy()[0]
-        
         predicted_idx = np.argmax(probs)
         category_name = categories[predicted_idx]
         confidence_score = float(probs[predicted_idx])
         
-        # Analyse couleur
+        # Analyse couleur simplifiée
         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)
-            
+            image_rgb = image.convert('RGB')
+            small_img = image_rgb.resize((10, 10))
+            colors = small_img.getcolors(100)
+            if colors:
+                dominant_color = max(colors, key=lambda x: x[0])[1]
+                hex_color = '#%02x%02x%02x' % dominant_color
+            else:
+                hex_color = "#000000"
         except Exception:
             hex_color = "#000000"
 
@@ -159,75 +204,58 @@ async def analyze_image(file: UploadFile = File(...)):
             "category": category_name,
             "confidence": round(confidence_score, 4),
             "color_hex": hex_color,
-            "model": "Marqo-FashionSigLIP-Classification"
+            "model": AVAILABLE_MODELS[SELECTED_MODEL]["name"]
         }
 
     except Exception as e:
         raise HTTPException(status_code=500, detail=f"Analysis error: {str(e)}")
 
-# Interface de test avec statut de chargement
 @app.get("/test-ui", response_class=HTMLResponse)
 async def test_ui():
+    health_status = health_check()
+    status_class = "ready" if health_status["model_loaded"] else "error"
+    status_text = "✅ Prêt" if health_status["model_loaded"] else "❌ Erreur"
+    
     return f"""
     <html>
         <head>
-            <title>FashionSigLIP Detection</title>
+            <title>Fashion Detection</title>
             <style>
                 body {{ font-family: Arial, sans-serif; margin: 40px; }}
                 .container {{ max-width: 600px; margin: 0 auto; }}
-                form {{ border: 2px dashed #ccc; padding: 30px; text-align: center; }}
                 .status {{ padding: 15px; margin: 10px 0; border-radius: 5px; }}
-                .loading {{ background: #fff3cd; color: #856404; }}
                 .ready {{ background: #d4edda; color: #155724; }}
                 .error {{ background: #f8d7da; color: #721c24; }}
+                .model-info {{ background: #e9ecef; padding: 10px; border-radius: 5px; }}
             </style>
-            <script>
-                function checkStatus() {{
-                    fetch('/health')
-                        .then(response => response.json())
-                        .then(data => {{
-                            const statusDiv = document.getElementById('model-status');
-                            const submitBtn = document.getElementById('submit-btn');
-                            
-                            if (data.model_loaded) {{
-                                statusDiv.innerHTML = '✅ <b>Modèle chargé et prêt !</b>';
-                                statusDiv.className = 'status ready';
-                                submitBtn.disabled = false;
-                            }} else if (data.model_loading) {{
-                                statusDiv.innerHTML = '⏳ <b>Chargement du modèle en cours...</b><br>Cela peut prendre 5-10 minutes';
-                                statusDiv.className = 'status loading';
-                                submitBtn.disabled = true;
-                                setTimeout(checkStatus, 5000); // Re-check dans 5 sec
-                            }} else {{
-                                statusDiv.innerHTML = '❌ <b>Erreur de chargement:</b><br>' + (data.model_error || 'Unknown error');
-                                statusDiv.className = 'status error';
-                                submitBtn.disabled = true;
-                            }}
-                        }});
-                }}
-                
-                // Vérifier le statut au chargement de la page
-                window.onload = checkStatus;
-            </script>
         </head>
         <body>
             <div class="container">
-                <h1>👗 FashionSigLIP Detector</h1>
+                <h1>👗 Fashion Detector</h1>
+                
+                <div class="status {status_class}">
+                    <b>Statut:</b> {status_text}
+                </div>
                 
-                <div id="model-status" class="status loading">
-                    Vérification du statut du modèle...
+                <div class="model-info">
+                    <b>Modèle:</b> {health_status['current_model']}<br>
+                    <b>Détails:</b> {AVAILABLE_MODELS[health_status['current_model']]['description'] if health_status['model_loaded'] else 'Chargement...'}
                 </div>
                 
                 <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><br>
-                    <input type="submit" id="submit-btn" value="Analyser" disabled>
+                    <input type="submit" value="Analyser" {"disabled" if not health_status["model_loaded"] else ""}>
                 </form>
                 
                 <div style="margin-top: 20px;">
-                    <button onclick="checkStatus()">Actualiser le statut</button>
-                    <button onclick="location.reload()">Rafraîchir la page</button>
+                    <h4>Modèles disponibles:</h4>
+                    <ul>
+                        <li><b>siglip-base</b>: SigLIP base - Excellente précision</li>
+                        <li><b>clip-fashion</b>: CLIP spécialisé mode</li>
+                        <li><b>openclip</b>: OpenCLIP performant</li>
+                    </ul>
                 </div>
             </div>
         </body>