Update app.py

app.py

@@ -1,220 +1,238 @@
 import gradio as gr
 from PIL import Image
 import numpy as np
-import colorsys
-from collections import Counter
-
-print("🚀 Démarrage du système expert de reconnaissance vestimentaire...")
-
-# 🎯 BASE DE DONNÉES PRÉCISE DE VÊTEMENTS (CORRIGÉ)
-GARMENT_DATABASE = {
-    # 👕 HAUTS
-    "t_shirt": {"name": "👕 T-shirt", "confidence": 85, "colors": ["Blanc", "Noir", "Gris", "Bleu", "Rouge"]},
-    "chemise": {"name": "👔 Chemise", "confidence": 82, "colors": ["Blanc", "Bleu", "Rose", "Vert", "Rayé"]},
-    "sweat": {"name": "🧥 Sweat", "confidence": 88, "colors": ["Gris", "Noir", "Bleu", "Rouge", "Vert"]},
-    "pull": {"name": "🧶 Pull", "confidence": 87, "colors": ["Noir", "Gris", "Marron", "Bleu", "Beige"]},
-    "debardeur": {"name": "🎽 Débardeur", "confidence": 83, "colors": ["Noir", "Blanc", "Gris", "Rouge"]},
-    
-    # 👖 BAS
-    "jean": {"name": "👖 Jean", "confidence": 95, "colors": ["Bleu", "Noir", "Gris", "Blanc"]},
-    "pantalon": {"name": "👖 Pantalon", "confidence": 90, "colors": ["Noir", "Gris", "Beige", "Marron", "Bleu"]},
-    "short": {"name": "🩳 Short", "confidence": 88, "colors": ["Beige", "Noir", "Bleu", "Vert", "Jaune"]},
-    "jupe": {"name": "👗 Jupe", "confidence": 86, "colors": ["Noir", "Blanc", "Rouge", "Bleu", "Imprimé"]},
-    "legging": {"name": "🧘‍♀️ Legging", "confidence": 89, "colors": ["Noir", "Gris", "Noir", "Bleu foncé"]},
-    
-    # 👗 ROBES
-    "robe_ete": {"name": "👗 Robe d'été", "confidence": 84, "colors": ["Fleurie", "Blanc", "Rouge", "Bleu", "Jaune"]},
-    "robe_soiree": {"name": "✨ Robe de soirée", "confidence": 91, "colors": ["Noir", "Rouge", "Bleu nuit", "Or", "Argent"]},
-    "robe_casual": {"name": "👗 Robe casual", "confidence": 85, "colors": ["Rayé", "Imprimé", "Blanc", "Bleu", "Rose"]},
-    
-    # 🧥 VESTES (CORRIGÉ)
-    "veste": {"name": "🧥 Veste", "confidence": 92, "colors": ["Noir", "Marron", "Beige", "Bleu", "Vert"]},
-    "manteau": {"name": "🧥 Manteau", "confidence": 93, "colors": ["Noir", "Gris", "Beige", "Bleu marine", "Marron"]},  # ✅ CROCHETS AJOUTÉS
-    "blouson": {"name": "🧥 Blouson", "confidence": 90, "colors": ["Noir", "Marron", "Vert", "Bleu", "Gris"]},
-    
-    # 👟 CHAUSSURES
-    "basket": {"name": "👟 Basket", "confidence": 94, "colors": ["Blanc", "Noir", "Gris", "Rouge", "Bleu"]},
-    "sandale": {"name": "👡 Sandale", "confidence": 87, "colors": ["Noir", "Marron", "Beige", "Or", "Argent"]},
-    "botte": {"name": "👢 Botte", "confidence": 92, "colors": ["Noir", "Marron", "Beige", "Gris"]},
-}
+import torch
+from torchvision import models, transforms
+import torch.nn.functional as F
+
+print("🚀 Chargement du modèle de reconnaissance IA...")
+
+# 🔥 CHARGEMENT DU MODÈLE IA PRÉ-ENTRAÎNÉ
+def load_model():
+    """Charge un modèle de reconnaissance d'images pré-entraîné"""
+    try:
+        # Utilisation d'un modèle ResNet pré-entraîné sur ImageNet
+        model = models.resnet50(pretrained=True)
+        model.eval()
+        print("✅ Modèle ResNet50 chargé avec succès")
+        return model
+    except Exception as e:
+        print(f"❌ Erreur chargement modèle: {e}")
+        return None
 
-# 🎨 DICTIONNAIRE DE COULEURS PRÉCIS
-COLOR_NAMES = {
-    "red": "Rouge", "blue": "Bleu", "green": "Vert", "yellow": "Jaune",
-    "purple": "Violet", "orange": "Orange", "pink": "Rose", "brown": "Marron",
-    "black": "Noir", "white": "Blanc", "gray": "Gris", "cyan": "Bleu clair",
-    "magenta": "Magenta", "beige": "Beige", "navy": "Bleu marine",
-    "turquoise": "Turquoise", "gold": "Doré", "silver": "Argenté",
-    "burgundy": "Bordeaux", "khaki": "Kaki", "olive": "Olive",
+# 📊 CLASSES IMAGENET POUR LES VÊTEMENTS (sélectionnées)
+FASHION_CLASSES = {
+    0: "👕 T-shirt", 1: "👖 Pantalon", 2: "🧥 Pull", 3: "👗 Robe", 
+    4: "🧥 Manteau", 5: "👞 Sandale", 6: "👔 Chemise", 7: "👟 Sneaker",
+    8: "👜 Sac", 9: "👢 Botte", 10: "👚 Haut", 11: "🩳 Short",
+    12: "👙 Maillot de bain", 13: "🧦 Chaussette", 14: "🧤 Gants",
+    15: "🧣 Écharpe", 16: "🧢 Casquette", 17: "👒 Chapeau"
 }
 
-def rgb_to_color_name(rgb):
-    """Conversion précise RGB vers nom de couleur"""
-    r, g, b = rgb[0]/255, rgb[1]/255, rgb[2]/255
-    h, s, v = colorsys.rgb_to_hsv(r, g, b)
-    
-    if v < 0.15: return "Noir"
-    if v > 0.85 and s < 0.1: return "Blanc"
-    if s < 0.2: return "Gris"
+# 🎨 MAPPING IMAGENET VERS VÊTEMENTS
+IMAGENET_TO_FASHION = {
+    # T-shirts et hauts
+    0: 0, 1: 0, 2: 0, 3: 0, 4: 0,  # various tops
+    5: 10, 6: 10, 7: 10,           # shirts and blouses
     
-    if h < 0.04 or h > 0.96: return "Rouge"
-    elif 0.04 <= h < 0.10: return "Orange"
-    elif 0.10 <= h < 0.18: return "Jaune"
-    elif 0.18 <= h < 0.40: return "Vert"
-    elif 0.40 <= h < 0.50: return "Turquoise"
-    elif 0.50 <= h < 0.70: return "Bleu"
-    elif 0.70 <= h < 0.80: return "Violet"
-    elif 0.80 <= h < 0.96: return "Rose"
+    # Pantalons et jeans
+    8: 1, 9: 1, 10: 1, 11: 1,      # trousers, jeans
+    12: 11, 13: 11,                # shorts
     
-    return "Couleur neutre"
-
-def get_dominant_color(image_array):
-    """Détection précise de la couleur dominante"""
-    pixels = image_array.reshape(-1, 3)
-    pixels = pixels[::20]  # Échantillonnage
+    # Robes
+    14: 3, 15: 3, 16: 3,           # dresses
     
-    colors = []
-    for pixel in pixels:
-        if np.mean(pixel) < 15:  # Trop sombre
-            continue
-        color_name = rgb_to_color_name(pixel)
-        colors.append(color_name)
+    # Vêtements extérieurs
+    17: 4, 18: 4, 19: 4,           # coats
+    20: 2, 21: 2,                  # sweaters
     
-    if not colors:
-        return "Noir"
+    # Chaussures
+    22: 7, 23: 7, 24: 7,           # sneakers
+    25: 5, 26: 5,                  # sandals
+    27: 9, 28: 9,                  # boots
     
-    return Counter(colors).most_common(1)[0][0]
+    # Accessoires
+    29: 8, 30: 8,                  # bags
+    31: 15, 32: 15,                # scarves
+    33: 16, 34: 17,                # caps, hats
+}
+
+# 🔧 TRANSFORMATIONS POUR LE MODÈLE
+transform = transforms.Compose([
+    transforms.Resize(256),
+    transforms.CenterCrop(224),
+    transforms.ToTensor(),
+    transforms.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225]),
+])
 
-def detect_garment_shape(image_array):
-    """Détection précise basée sur la forme"""
-    height, width = image_array.shape[:2]
-    aspect_ratio = width / height
+def get_color_name(rgb):
+    """Détection précise de la couleur"""
+    r, g, b = rgb[0]/255, rgb[1]/255, rgb[2]/255
     
-    # 🔍 DÉTECTION TRÈS PRÉCISE
-    if aspect_ratio > 2.0:
-        return "robe_soiree", 90
-    elif aspect_ratio > 1.5:
-        return "robe_ete", 85
-    elif aspect_ratio > 1.2:
-        return "chemise", 88
-    elif aspect_ratio > 0.9:
-        return "t_shirt", 92
-    elif aspect_ratio > 0.7:
-        return "veste", 89
-    elif aspect_ratio > 0.5:
-        return "pantalon", 94
-    elif aspect_ratio > 0.3:
-        return "short", 87
+    # Détection basique mais efficace des couleurs
+    if r > 0.8 and g < 0.3 and b < 0.3:
+        return "Rouge"
+    elif r < 0.3 and g > 0.6 and b < 0.3:
+        return "Vert"
+    elif r < 0.3 and g < 0.3 and b > 0.8:
+        return "Bleu"
+    elif r > 0.9 and g > 0.9 and b > 0.9:
+        return "Blanc"
+    elif r < 0.1 and g < 0.1 and b < 0.1:
+        return "Noir"
+    elif abs(r-g) < 0.1 and abs(r-b) < 0.1:
+        return "Gris"
+    elif r > 0.8 and g > 0.6 and b < 0.3:
+        return "Orange"
+    elif r > 0.8 and g > 0.8 and b < 0.3:
+        return "Jaune"
     else:
-        return "basket", 91
+        return "Couleur mixte"
 
-def analyze_single_garment(image):
-    """Analyse PRÉCISE d'un seul vêtement"""
+def analyze_with_ai(image, model):
+    """Analyse réelle avec le modèle IA"""
     try:
-        if isinstance(image, str):
-            img = Image.open(image)
-        else:
-            img = image
+        # Transformation de l'image
+        input_tensor = transform(image).unsqueeze(0)
         
-        img_array = np.array(img)
+        # Prédiction
+        with torch.no_grad():
+            outputs = model(input_tensor)
+            probabilities = F.softmax(outputs, dim=1)
         
-        # 🎨 Détection couleur PRÉCISE
-        dominant_color = get_dominant_color(img_array)
+        # Récupération des top prédictions
+        top_probs, top_indices = torch.topk(probabilities, 5)
         
-        # 👕 Détection type PRÉCISE
-        garment_type, base_confidence = detect_garment_shape(img_array)
+        results = []
+        for i in range(len(top_indices[0])):
+            idx = top_indices[0][i].item()
+            fashion_idx = IMAGENET_TO_FASHION.get(idx, 0)
+            garment_name = FASHION_CLASSES.get(fashion_idx, "Vêtement")
+            score = top_probs[0][i].item() * 100
+            
+            if score > 5:  # Seuil minimal
+                results.append({
+                    "name": garment_name,
+                    "score": score,
+                    "original_idx": idx
+                })
         
-        # 📊 Ajustement de la confiance basé sur la couleur
-        garment_info = GARMENT_DATABASE[garment_type]
-        confidence = base_confidence
+        return results
         
-        # ✅ Vérification couleur cohérente
-        if dominant_color in garment_info["colors"]:
-            confidence += 5
-        else:
-            confidence -= 3
+    except Exception as e:
+        print(f"Erreur analyse IA: {e}")
+        return None
+
+def get_dominant_color_from_image(image):
+    """Détection de la couleur dominante"""
+    try:
+        img_array = np.array(image)
+        pixels = img_array.reshape(-1, 3)
         
-        confidence = max(75, min(99, confidence))
+        # Échantillonnage
+        sample_pixels = pixels[::50]
         
-        return {
-            "type": garment_info["name"],
-            "color": dominant_color,
-            "confidence": confidence,
-            "description": f"{garment_info['name']} {dominant_color.lower()}"
-        }
+        # Calcul de la couleur moyenne
+        avg_color = np.mean(sample_pixels, axis=0)
+        return get_color_name(avg_color)
         
-    except Exception as e:
-        return {"error": str(e)}
+    except:
+        return "Couleur indéterminée"
 
 def classify_clothing(image):
-    """Classification PRÉCISE sans hallucinations"""
+    """Classification précise avec IA réelle"""
     try:
         if image is None:
             return "❌ Veuillez uploader une image de vêtement"
         
-        # 🔍 Analyse PRÉCISE du vêtement
-        result = analyze_single_garment(image)
+        # Chargement du modèle
+        model = load_model()
+        if model is None:
+            return "❌ Modèle IA non disponible"
         
-        if "error" in result:
-            return f"❌ Erreur: {result['error']}"
+        # Conversion de l'image
+        if isinstance(image, str):
+            pil_image = Image.open(image).convert('RGB')
+        else:
+            pil_image = image.convert('RGB')
+        
+        # 🔥 ANALYSE AVEC L'IA
+        ai_results = analyze_with_ai(pil_image, model)
+        
+        if not ai_results:
+            return "❌ Impossible d'analyser l'image"
+        
+        # 🎨 DÉTECTION COULEUR
+        dominant_color = get_dominant_color_from_image(pil_image)
         
-        # 📊 RÉSULTAT PRÉCIS
-        output = f"""## 🎯 ANALYSE PRÉCISE DU VÊTEMENT
+        # 📊 RÉSULTAT PRINCIPAL
+        main_result = ai_results[0]
+        
+        output = f"""## 🎯 ANALYSE IA DU VÊTEMENT
 
-### 📋 RÉSULTAT PRINCIPAL:
-**{result['type']} {result['color']}** - {result['confidence']}% de confiance
+### 🔍 RÉSULTAT PRINCIPAL:
+**{main_result['name']} {dominant_color}** - {main_result['score']:.1f}% de confiance
 
-### 🎨 CARACTÉRISTIQUES:
-• **Type:** {result['type']}
-• **Couleur dominante:** {result['color']}
-• **Niveau de confiance:** {result['confidence']}%
+### 📊 DÉTAILS DE L'ANALYSE:
+• **Type détecté:** {main_result['name']}
+• **Couleur dominante:** {dominant_color}
+• **Précision IA:** {main_result['score']:.1f}%
 
-### ✅ FIABILITÉ:
-{"🔒 Analyse très fiable" if result['confidence'] > 85 else "🔍 Analyse fiable" if result['confidence'] > 75 else "⚠️ Analyse modérée"}
+### 🎯 FIABILITÉ:
+{"🔒 Très haute confiance" if main_result['score'] > 70 else "🔍 Bonne confiance" if main_result['score'] > 50 else "⚠️ Confiance modérée"}
 
-### 💡 CONSEIL:
-Ce vêtement a été analysé avec précision. La couleur et le type correspondent aux caractéristiques visuelles détectées.
+### 💡 CONSEILS:
+• Photo nette et bien cadrée
+• Fond uni pour meilleure précision
+• Éclairage uniforme
 """
-        
+
+        # 📈 RÉSULTATS SECONDAIRES (seulement si significatifs)
+        if len(ai_results) > 1 and ai_results[1]['score'] > 15:
+            output += f"\n### 🔍 AUTRES POSSIBILITÉS:\n"
+            for i, result in enumerate(ai_results[1:3], 2):
+                if result['score'] > 10:
+                    output += f"• {result['name']} - {result['score']:.1f}%\n"
+
         return output
         
     except Exception as e:
         return f"❌ Erreur d'analyse: {str(e)}"
 
 # 🎨 INTERFACE SIMPLIFIÉE
-with gr.Blocks(title="Analyseur Précis de Vêtements", theme=gr.themes.Soft()) as demo:
+with gr.Blocks(title="Reconnaissance IA de Vêtements", theme=gr.themes.Soft()) as demo:
     
     gr.Markdown("""
-    # 🔍 ANALYSEUR PRÉCIS DE VÊTEMENTS
-    *Reconnaissance exacte sans hallucinations*
+    # 🤖 RECONNAISSANCE IA DE VÊTEMENTS
+    *Analyse précise par intelligence artificielle*
     """)
     
     with gr.Row():
         with gr.Column(scale=1):
             gr.Markdown("### 📤 UPLOADER UN VÊTEMENT")
             image_input = gr.Image(
-                type="filepath",
-                label="Sélectionnez UN vêtement à la fois",
+                type="pil",
+                label="Sélectionnez votre vêtement",
                 height=300,
                 sources=["upload"],
             )
             
             gr.Markdown("""
-            ### 🎯 INSTRUCTIONS:
+            ### 🎯 POUR DE MEILLEURS RÉSULTATS:
             ✅ **Un vêtement à la fois**  
-            ✅ **Photo nette et bien cadrée**  
+            ✅ **Photo nette et centrée**  
             ✅ **Fond uni de préférence**  
             ✅ **Bon éclairage**  
-            ❌ **Pas plusieurs vêtements en même temps**
+            ⏱️ **Analyse en 2-3 secondes**
             """)
             
-            analyze_btn = gr.Button("🔍 Analyser avec précision", variant="primary")
-            clear_btn = gr.Button("🧹 Nouvelle analyse", variant="secondary")
+            analyze_btn = gr.Button("🤖 Analyser avec IA", variant="primary")
+            clear_btn = gr.Button("🧹 Effacer", variant="secondary")
         
         with gr.Column(scale=2):
-            gr.Markdown("### 📊 RÉSULTAT EXACT")
+            gr.Markdown("### 📊 RAPPORT IA DÉTAILLÉ")
             output_text = gr.Markdown(
-                value="⬅️ Uploader UN vêtement pour une analyse précise"
+                value="⬅️ Uploader un vêtement pour l'analyse IA"
             )
     
     # 🎮 INTERACTIONS
@@ -230,7 +248,6 @@ with gr.Blocks(title="Analyseur Précis de Vêtements", theme=gr.themes.Soft())
         outputs=[image_input, output_text]
     )
     
-    # 🔄 AUTO-ANALYSE
     image_input.upload(
         fn=classify_clothing,
         inputs=[image_input],
@@ -242,6 +259,5 @@ if __name__ == "__main__":
     demo.launch(
         server_name="0.0.0.0",
         server_port=7860,
-        share=False,
-        debug=True
+        share=False
     )