Update app.py

app.py

@@ -4,180 +4,84 @@ 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
 
 app = FastAPI(title="Fashion Detection API")
 
-# Middleware CORS
-app.add_middleware(
-    CORSMiddleware,
-    allow_origins=["*"],
-    allow_credentials=True,
-    allow_methods=["*"],
-    allow_headers=["*"],
-    expose_headers=["*"]
-)
-
-# --- CHARGE LE MODÈLE MARQO FASHIONCLIP ---
-print("⚠️ Démarrage du chargement du modèle Marqo fashionCLIP...")
+# Modèle et processor (chargement différé)
 model = None
-tokenizer = None
 processor = None
 
-def load_marqo_model():
-    global model, tokenizer, processor
+def load_model():
+    global model, processor
     try:
-        from transformers import CLIPModel, CLIPTokenizer, CLIPImageProcessor
-        
+        from transformers import CLIPModel, CLIPProcessor
         model_name = "Marqo/marqo-fashionCLIP"
-        
-        # Charger les composants séparément
-        model = CLIPModel.from_pretrained(
-            model_name,
-            cache_dir="/tmp/cache",
-            torch_dtype=torch.float16
-        )
-        tokenizer = CLIPTokenizer.from_pretrained(model_name)
-        processor = CLIPImageProcessor.from_pretrained(model_name)
-        
-        print("✅ Modèle Marqo fashionCLIP chargé avec succès !")
+        model = CLIPModel.from_pretrained(model_name)
+        processor = CLIPProcessor.from_pretrained(model_name)
+        print("✅ Modèle chargé!")
     except Exception as e:
-        print(f"❌ Erreur chargement modèle Marqo: {e}")
+        print(f"❌ Erreur: {e}")
 
 @app.on_event("startup")
-async def startup_event():
+async def startup():
     import threading
-    thread = threading.Thread(target=load_marqo_model)
-    thread.daemon = True
-    thread.start()
+    threading.Thread(target=load_model).start()
 
-# Catégories fashion (textes courts)
-categories = [
-    "a t-shirt", "a dress", "jeans", "a shirt", "a skirt", 
-    "sneakers", "a handbag", "a jacket", "shorts", "a sweater"
-]
+categories = ["t-shirt", "dress", "jeans", "shirt", "skirt", "jacket", "sweater"]
 
 @app.get("/")
-def read_root():
-    return {"message": "Fashion Detection API is running!", "status": "OK"}
-
-@app.get("/health")
-def health_check():
-    return {
-        "model_loaded": model is not None,
-        "tokenizer_loaded": tokenizer is not None,
-        "processor_loaded": processor is not None,
-        "status": "ready" if all([model, tokenizer, processor]) else "loading"
-    }
+def home():
+    return {"message": "API running", "status": "OK"}
 
 @app.post("/analyze")
-async def analyze_image(file: UploadFile = File(...)):
-    if model is None or tokenizer is None or processor is None:
-        return {"error": "Model not loaded yet. Please wait or check /health endpoint."}
+async def analyze(file: UploadFile = File(...)):
+    if not model or not processor:
+        return {"error": "Model loading..."}
     
     try:
-        # Lire l'image
-        contents = await file.read()
-        image = Image.open(io.BytesIO(contents)).convert("RGB")
-        
-        # Réduire la taille
-        image.thumbnail((384, 384))
-        
-        # --- NOUVELLE APPROCHE SANS PROCESSOR BATCH ---
-        # 1. Préparer l'image
-        image_input = processor(images=image, return_tensors="pt")
-        
-        # 2. Préparer le texte - CHAQUE CATÉGORIE INDIVIDUELLEMENT
-        text_features_list = []
+        # Lire image
+        image = Image.open(io.BytesIO(await file.read())).convert("RGB")
+        image.thumbnail((256, 256))
         
+        # Méthode SIMPLE et FIABLE
+        results = {}
         for category in categories:
-            # Tokenizer chaque catégorie séparément
-            text_inputs = tokenizer(
-                category, 
-                return_tensors="pt", 
-                padding=True, 
-                truncation=True,
-                max_length=77
+            inputs = processor(
+                text=[category],
+                images=image,
+                return_tensors="pt",
+                padding=True,
+                truncation=True
             )
-            
             with torch.no_grad():
-                text_features = model.get_text_features(**text_inputs)
-                text_features_list.append(text_features)
-        
-        # 3. Get image features
-        with torch.no_grad():
-            image_features = model.get_image_features(**image_input)
+                outputs = model(**inputs)
+                results[category] = outputs.logits_per_image.item()
         
-        # 4. Calculer les similarités
-        similarities = []
-        for text_features in text_features_list:
-            # Normaliser les features
-            image_features_norm = image_features / image_features.norm(dim=-1, keepdim=True)
-            text_features_norm = text_features / text_features.norm(dim=-1, keepdim=True)
-            
-            # Calculer la similarité cosinus
-            similarity = (image_features_norm @ text_features_norm.T).squeeze()
-            similarities.append(similarity.item())
+        # Trouver le meilleur résultat
+        best_category = max(results, key=results.get)
+        confidence = results[best_category]
         
-        # 5. Convertir en probabilités
-        similarities_tensor = torch.tensor(similarities)
-        probs = torch.nn.functional.softmax(similarities_tensor, dim=0)
-        
-        # Trouver la catégorie prédite
-        predicted_class_idx = probs.argmax().item()
-        category_name = categories[predicted_class_idx]
-        confidence_score = probs[predicted_class_idx].item()
-
-        # 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"
-
         return {
-            "category": category_name,
-            "color_hex": hex_color,
-            "confidence": round(confidence_score, 4)
+            "category": best_category,
+            "confidence": round(confidence, 4),
+            "color_hex": "#000000"  # Couleur basique pour l'instant
         }
-
+        
     except Exception as e:
-        return {"error": f"Erreur lors de l'analyse: {str(e)}"}
+        return {"error": str(e)}
 
-# Interface de test SIMPLIFIÉE
-@app.get("/test-ui", response_class=HTMLResponse)
-async def test_ui():
+@app.get("/ui", response_class=HTMLResponse)
+def ui():
     return """
-    <html>
-        <head>
-            <title>Fashion Detection</title>
-            <style>
-                body { font-family: Arial, sans-serif; margin: 40px; text-align: center; }
-                form { border: 2px dashed #ccc; padding: 30px; display: inline-block; }
-            </style>
-        </head>
-        <body>
-            <h1>🎨 Fashion Detection</h1>
-            <form action="/analyze" method="post" enctype="multipart/form-data">
-                <input type="file" name="file" accept="image/*" required>
-                <br><br>
-                <input type="submit" value="Analyze">
-            </form>
-        </body>
-    </html>
+    <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>
     """