Update app.py

app.py

@@ -1,284 +1,49 @@
 import gradio as gr
+from transformers import ViTImageProcessor, ViTForImageClassification
 from PIL import Image
-import numpy as np
-import pandas as pd
-from datasets import load_dataset
-import random
-
-print("🚀 Chargement du dataset Fashion Product Images...")
-
-# 📦 CHARGEMENT DU DATASET
-try:
-    ds = load_dataset("ashraq/fashion-product-images-small")
-    print("✅ Dataset chargé avec succès!")
-    
-    # Conversion en DataFrame
-    df = ds['train'].to_pandas()
-    
-    # 🎯 FILTRAGE POUR VÊTEMENTS UNIQUEMENT
-    VETEMENTS_TYPES = [
-        'Tshirts', 'Shirts', 'Pants', 'Jeans', 'Dresses', 'Skirts',
-        'Jackets', 'Coats', 'Sweaters', 'Tops', 'Shorts', 'Leggings',
-        'Blazers', 'Sweatshirts', 'Trousers', 'Blouses', 'Tracksuits'
-    ]
-    
-    fashion_df = df[
-        (df['masterCategory'] == 'Apparel') & 
-        (df['articleType'].isin(VETEMENTS_TYPES))
-    ].copy()
-    
-    # Nettoyage
-    fashion_df = fashion_df[[
-        'id', 'productDisplayName', 'articleType', 
-        'baseColour', 'season', 'usage'
-    ]].dropna()
-    
-    # 🗺️ TRADUCTION FRANÇAISE
-    FRENCH_MAP = {
-        'Tshirts': '👕 T-shirt', 'Shirts': '👔 Chemise',
-        'Pants': '👖 Pantalon', 'Jeans': '👖 Jean',
-        'Dresses': '👗 Robe', 'Skirts': '👗 Jupe',
-        'Jackets': '🧥 Veste', 'Coats': '🧥 Manteau',
-        'Sweaters': '🧥 Pull', 'Tops': '👕 Haut',
-        'Shorts': '🩳 Short', 'Leggings': '🧘‍♀️ Legging',
-        'Blazers': '👔 Blazer', 'Sweatshirts': '🧥 Sweat',
-        'Trousers': '👖 Pantalon', 'Blouses': '👚 Blouse',
-        'Tracksuits': '🏃‍♂️ Survêtement'
-    }
-    
-    fashion_df['articleType'] = fashion_df['articleType'].map(
-        lambda x: FRENCH_MAP.get(x, f"👔 {x}")
-    )
-    
-    print(f"✅ {len(fashion_df)} vêtements dans le dataset")
-    
-except Exception as e:
-    print(f"❌ Erreur chargement dataset: {e}")
-    fashion_df = None
-
-# 🔍 FONCTIONS D'ANALYSE AMÉLIORÉES
-def detect_garment_type(image):
-    """Détection précise du type de vêtement"""
-    try:
-        if isinstance(image, str):
-            img = Image.open(image)
-        else:
-            img = image
-        
-        width, height = img.size
-        aspect_ratio = width / height
-        
-        # 🔍 DÉTECTION BEAUCOUP PLUS PRÉCISE
-        if aspect_ratio > 2.2:
-            return "👗 Robe", 92, "forme longue caractéristique"
-        elif aspect_ratio > 1.8:
-            return "🧥 Manteau", 89, "silhouette allongée"
-        elif aspect_ratio > 1.4:
-            return "👔 Chemise", 88, "ratio classique chemise"
-        elif aspect_ratio > 1.1:
-            return "👕 T-shirt", 91, "format carré typique"
-        elif aspect_ratio > 0.9:
-            return "🧥 Veste", 87, "proportions équilibrées"
-        elif aspect_ratio > 0.7:
-            return "🧥 Pull", 85, "format légèrement vertical"
-        elif aspect_ratio > 0.6:
-            return "👖 Pantalon", 94, "verticalité des pantalons"
-        elif aspect_ratio > 0.5:
-            return "👖 Jean", 95, "coupe spécifique jeans"
-        elif aspect_ratio > 0.4:
-            return "🩳 Short", 90, "format court caractéristique"
-        elif aspect_ratio > 0.3:
-            return "🧘‍♀️ Legging", 88, "très grande verticalité"
-        else:
-            return "👔 Vêtement", 75, "format non standard"
-            
-    except Exception as e:
-        print(f"Erreur détection: {e}")
-        return "👔 Vêtement", 70, "erreur d'analyse"
-
-def generate_realistic_scores(detected_type, base_score=80):
-    """Génère des scores réalistes et variés"""
-    # Score de base selon le type détecté
-    type_scores = {
-        "👗 Robe": 85, "🧥 Manteau": 82, "👔 Chemise": 88,
-        "👕 T-shirt": 90, "🧥 Veste": 84, "🧥 Pull": 83,
-        "👖 Pantalon": 92, "👖 Jean": 94, "🩳 Short": 89,
-        "🧘‍♀️ Legging": 86
-    }
-    
-    base_score = type_scores.get(detected_type, base_score)
-    
-    # Retourne 3 scores réalistes et variés
-    return [
-        base_score + random.randint(2, 8),      # Meilleur score
-        base_score - random.randint(3, 10),     # Score moyen
-        base_score - random.randint(10, 20)     # Score plus bas
-    ]
-
-def get_smart_recommendations(detected_type, detected_confidence):
-    """Retourne des recommandations intelligentes"""
-    try:
-        if fashion_df is None:
-            return []
-        
-        # Mapping des types similaires
-        type_associations = {
-            "👗 Robe": ["👗 Robe", "👗 Jupe"],
-            "🧥 Manteau": ["🧥 Manteau", "🧥 Veste"],
-            "👔 Chemise": ["👔 Chemise", "👔 Blazer"],
-            "👕 T-shirt": ["👕 T-shirt", "👕 Haut", "🧥 Sweat"],
-            "🧥 Veste": ["🧥 Veste", "🧥 Manteau", "👔 Blazer"],
-            "🧥 Pull": ["🧥 Pull", "🧥 Sweat", "🧥 Cardigan"],
-            "👖 Pantalon": ["👖 Pantalon", "👖 Jean"],
-            "👖 Jean": ["👖 Jean", "👖 Pantalon"],
-            "🩳 Short": ["🩳 Short", "🏀 Sport"],
-            "🧘‍♀️ Legging": ["🧘‍♀️ Legging", "🏀 Sport"]
-        }
-        
-        # Types à rechercher
-        search_types = type_associations.get(detected_type, ["👔 Vêtement"])
-        
-        # Filtrer le dataset
-        similar_df = fashion_df[fashion_df['articleType'].isin(search_types)]
-        
-        if len(similar_df) < 3:
-            similar_df = fashion_df  # Fallback
-            
-        # Prendre 3 échantillons
-        sample = similar_df.sample(min(3, len(similar_df)))
-        
-        # Générer des scores réalistes
-        scores = generate_realistic_scores(detected_type, detected_confidence)
-        
-        recommendations = []
-        for i, (_, row) in enumerate(sample.iterrows()):
-            recommendations.append({
-                'name': row['productDisplayName'],
-                'type': row['articleType'],
-                'color': row['baseColour'],
-                'season': row['season'],
-                'similarity': scores[i] if i < len(scores) else random.randint(70, 85)
-            })
-        
-        return recommendations
-        
-    except Exception as e:
-        print(f"Erreur recommandations: {e}")
-        return []
-
-def analyze_clothing(image):
-    """Analyse principale avec résultats propres"""
-    try:
-        if image is None:
-            return "❌ Veuillez uploader une image de vêtement"
-        
-        # 🔍 DÉTECTION PRÉCISE
-        detected_type, confidence, reason = detect_garment_type(image)
-        
-        # 📊 RECOMMANDATIONS INTELLIGENTES
-        recommendations = get_smart_recommendations(detected_type, confidence)
-        
-        if not recommendations:
-            return "❌ Aucune donnée disponible pour l'analyse"
-        
-        # 🎯 PRÉPARATION DES RÉSULTATS
-        output = f"## 🔍 RÉSULTAT DE L'ANALYSE\n\n"
-        
-        output += f"**Type de vêtement détecté :** {detected_type}\n"
-        output += f"**Niveau de confiance :** {confidence}%\n"
-        output += f"*({reason})*\n\n"
-        
-        output += "### 🎯 MEILLEURES CORRESPONDANCES :\n\n"
-        
-        for i, item in enumerate(recommendations, 1):
-            output += f"**{i}. {item['name']}**\n"
-            output += f"- Type : {item['type']}\n"
-            output += f"- Couleur : {item['color']}\n"
-            output += f"- Saison : {item['season']}\n"
-            output += f"- Similarité : {item['similarity']}%\n\n"
-        
-        # 📈 MEILLEURE CORRESPONDANCE
-        best_match = recommendations[0]
-        output += "### 🏆 MEILLEURE CORRESPONDANCE :\n"
-        output += f"**{best_match['name']}**\n"
-        output += f"{best_match['type']} - {best_match['color']}\n"
-        output += f"**Score : {best_match['similarity']}%**\n\n"
-        
-        # 💡 INFORMATIONS UTILES
-        output += "### 📊 NOTRE BASE DE DONNÉES :\n"
-        output += f"- {len(fashion_df)} vêtements référencés\n"
-        output += f"- {fashion_df['articleType'].nunique()} types différents\n"
-        output += f"- {fashion_df['baseColour'].nunique()} couleurs disponibles\n\n"
-        
-        output += "### 💡 POUR AMÉLIORER LA PRÉCISION :\n"
-        output += "• Prenez la photo sur fond uni\n"
-        output += "• Assurez-vous d'un bon éclairage\n"
-        output += "• Cadrez uniquement le vêtement\n"
-        output += "• Évitez les angles complexes\n"
-        
-        return output
-        
-    except Exception as e:
-        return f"❌ Erreur lors de l'analyse : {str(e)}"
-
-# 🎨 INTERFACE SIMPLIFIÉE ET PROPRE
-with gr.Blocks(title="Analyseur de Vêtements", theme=gr.themes.Soft()) as demo:
-    
-    gr.Markdown("""
-    # 👗 ANALYSEUR DE VÊTEMENTS
-    *Reconnaissance précise basée sur une intelligence artificielle*
-    """)
-    
-    with gr.Row():
-        with gr.Column(scale=1):
-            gr.Markdown("### 📤 UPLOADER UN VÊTEMENT")
-            image_input = gr.Image(
-                type="pil",
-                label="Sélectionnez votre vêtement",
-                height=300,
-                sources=["upload"],
-            )
-            
-            gr.Markdown("""
-            ### 💡 CONSEILS :
-            ✅ Photo nette et bien cadrée  
-            ✅ Fond uni de préférence  
-            ✅ Bon éclairage  
-            ✅ Un seul vêtement visible  
-            """)
-            
-            analyze_btn = gr.Button("🔍 Analyser le vêtement", variant="primary")
-            clear_btn = gr.Button("🧹 Nouvelle image", variant="secondary")
-        
-        with gr.Column(scale=2):
-            gr.Markdown("### 📊 RÉSULTATS DE L'ANALYSE")
-            output_text = gr.Markdown(
-                value="⬅️ Uploader un vêtement pour commencer l'analyse"
-            )
-    
-    # 🎮 INTERACTIONS
-    analyze_btn.click(
-        fn=analyze_clothing,
-        inputs=[image_input],
-        outputs=output_text
-    )
-    
-    clear_btn.click(
-        fn=lambda: (None, "⬅️ Prêt pour une nouvelle analyse"),
-        inputs=[],
-        outputs=[image_input, output_text]
-    )
-    
-    image_input.upload(
-        fn=analyze_clothing,
-        inputs=[image_input],
-        outputs=output_text
-    )
-
-# ⚙️ LANCEMENT
-if __name__ == "__main__":
-    demo.launch(
-        server_name="0.0.0.0",
-        server_port=7860,
-        share=False
-    )
+import torch
+
+# --- CHANGEMENT CRITIQUE : Charger VOTRE modèle fine-tuné ---
+model_name = "MODLI/vit-fashion-classifier"  # <--- REMPLACER par votre modèle entraîné
+processor = ViTImageProcessor.from_pretrained(model_name)
+model = ViTForImageClassification.from_pretrained(model_name)
+
+# Fonction de prédiction avec seuil de confiance
+def predict(image):
+    # Pré-traiter l'image exactement comme pendant l'entraînement
+    inputs = processor(images=image, return_tensors="pt")
+    
+    # Prédire
+    with torch.no_grad():
+        outputs = model(**inputs)
+        logits = outputs.logits
+    
+    # Appliquer softmax pour obtenir les probabilités
+    probabilities = torch.nn.functional.softmax(logits, dim=-1)[0]
+    top_probs, top_indices = torch.topk(probabilities, 5)  # Top 5 predictions
+    
+    # Formater les résultats
+    predictions = []
+    for i, (prob, idx) in enumerate(zip(top_probs, top_indices)):
+        pred_label = model.config.id2label[idx.item()]
+        confidence = prob.item()
+        # N'afficher que si la confiance est > 5%
+        if confidence > 0.05 or i == 0:  # Toujours afficher la première même si faible
+            predictions.append((pred_label, f"{confidence:.2%}"))
+    
+    return predictions
+
+# Interface Gradio
+title = "Fashion Item Classifier"
+description = "Upload an image of a clothing item, and I will classify it."
+
+demo = gr.Interface(
+    fn=predict,
+    inputs=gr.Image(type="pil", label="Upload Clothing Item"),
+    outputs=gr.Label(label="Predictions", num_top_classes=5),
+    title=title,
+    description=description,
+    examples=[["path_to_example_image_1.jpg"], ["path_to_example_image_2.jpg"]], # Ajoutez des exemples
+)
+
+demo.launch(debug=True)