Upload 2 files

app.py

@@ -0,0 +1,272 @@
+import gradio as gr
+from transformers import pipeline, AutoImageProcessor, AutoModelForObjectDetection
+from PIL import Image, ImageDraw, ImageFont
+import torch
+import spaces
+import numpy as np
+
+# Modèles disponibles sur Hugging Face Hub
+AVAILABLE_MODELS = {
+    "DETR ResNet-50": "facebook/detr-resnet-50",
+    "DETR ResNet-101": "facebook/detr-resnet-101", 
+    "Conditional DETR": "microsoft/conditional-detr-resnet-50",
+    "Table Transformer": "microsoft/table-transformer-detection",
+    "YOLOS Tiny": "hustvl/yolos-tiny",
+    "YOLOS Small": "hustvl/yolos-small",
+    "YOLOS Base": "hustvl/yolos-base",
+    "RT-DETR": "PekingU/rtdetr_r50vd_coco_o365",
+    "OWL-ViT": "google/owlvit-base-patch32"
+}
+
+# Cache pour éviter de recharger les modèles
+model_cache = {}
+
+def load_model(model_name):
+    """Charge un modèle avec cache"""
+    if model_name not in model_cache:
+        print(f"Chargement du modèle: {model_name}")
+        
+        if "owlvit" in model_name:
+            # OWL-ViT est un modèle de détection zero-shot
+            model_cache[model_name] = pipeline(
+                "zero-shot-object-detection", 
+                model=model_name,
+                device=0 if torch.cuda.is_available() else -1
+            )
+        else:
+            # Autres modèles de détection standard
+            model_cache[model_name] = pipeline(
+                "object-detection", 
+                model=model_name,
+                device=0 if torch.cuda.is_available() else -1
+            )
+    
+    return model_cache[model_name]
+
+@spaces.GPU
+def detect_objects(image, model_choice, confidence_threshold, custom_classes=""):
+    """Détection d'objets avec modèles transformers"""
+    
+    if image is None:
+        return None, "❌ Veuillez uploader une image"
+    
+    try:
+        # Charger le modèle sélectionné
+        model_id = AVAILABLE_MODELS[model_choice]
+        detector = load_model(model_id)
+        
+        # Traitement spécial pour OWL-ViT (zero-shot)
+        if "owlvit" in model_id.lower():
+            if not custom_classes.strip():
+                custom_classes = "person, car, dog, cat, chair, table, bottle, cup"
+            
+            class_list = [cls.strip() for cls in custom_classes.split(",")]
+            results = detector(image, candidate_labels=class_list)
+        else:
+            # Modèles de détection standard
+            results = detector(image)
+        
+        # Filtrer par seuil de confiance
+        filtered_results = [
+            obj for obj in results 
+            if obj['score'] >= confidence_threshold
+        ]
+        
+        # Dessiner les détections
+        annotated_image = draw_detections(image.copy(), filtered_results)
+        
+        # Créer le résumé
+        summary = create_summary(filtered_results, model_choice)
+        
+        return annotated_image, summary
+        
+    except Exception as e:
+        return image, f"❌ Erreur: {str(e)}"
+
+def draw_detections(image, detections):
+    """Dessine les boîtes de détection sur l'image"""
+    draw = ImageDraw.Draw(image)
+    
+    # Essayer de charger une police, sinon utiliser la police par défaut
+    try:
+        font = ImageFont.truetype("/usr/share/fonts/truetype/dejavu/DejaVuSans-Bold.ttf", 16)
+    except:
+        font = ImageFont.load_default()
+    
+    colors = [
+        "#FF6B6B", "#4ECDC4", "#45B7D1", "#96CEB4", "#FECA57", 
+        "#FF9FF3", "#54A0FF", "#5F27CD", "#00D2D3", "#FF9F43"
+    ]
+    
+    for i, detection in enumerate(detections):
+        box = detection['box']
+        label = detection['label']
+        score = detection['score']
+        
+        # Coordonnées de la boîte
+        x1, y1 = box['xmin'], box['ymin']
+        x2, y2 = box['xmax'], box['ymax']
+        
+        # Couleur pour cette classe
+        color = colors[i % len(colors)]
+        
+        # Dessiner la boîte
+        draw.rectangle([x1, y1, x2, y2], outline=color, width=3)
+        
+        # Texte du label
+        text = f"{label} ({score:.2f})"
+        
+        # Fond du texte
+        bbox = draw.textbbox((x1, y1-25), text, font=font)
+        draw.rectangle(bbox, fill=color)
+        
+        # Texte
+        draw.text((x1, y1-25), text, fill="white", font=font)
+    
+    return image
+
+def create_summary(detections, model_name):
+    """Crée un résumé des détections"""
+    if not detections:
+        return "🔍 Aucun objet détecté"
+    
+    summary = f"🎯 **{len(detections)} objets détectés** avec {model_name}\n\n"
+    
+    # Grouper par classe
+    class_counts = {}
+    for det in detections:
+        label = det['label']
+        score = det['score']
+        
+        if label not in class_counts:
+            class_counts[label] = []
+        class_counts[label].append(score)
+    
+    # Afficher le résumé
+    for label, scores in class_counts.items():
+        count = len(scores)
+        avg_score = sum(scores) / len(scores)
+        max_score = max(scores)
+        
+        summary += f"**{label}**: {count}x (confiance: {avg_score:.2f} avg, {max_score:.2f} max)\n"
+    
+    return summary
+
+# Interface Gradio
+with gr.Blocks(title="🤖 Object Detection avec Transformers", theme=gr.themes.Soft()) as demo:
+    
+    gr.Markdown("""
+    # 🤖 Object Detection avec Transformers
+    
+    Utilisez les meilleurs modèles de détection d'objets disponibles sur Hugging Face Hub !
+    
+    **✨ Fonctionnalités:**
+    - 🔄 Changement de modèle en temps réel
+    - 🎯 Seuil de confiance ajustable  
+    - 🏷️ Classes personnalisées (OWL-ViT)
+    - 📊 Résumé détaillé des détections
+    """)
+    
+    with gr.Row():
+        with gr.Column(scale=1):
+            # Input
+            image_input = gr.Image(
+                type="pil", 
+                label="📸 Image à analyser",
+                height=400
+            )
+            
+            # Sélection du modèle
+            model_dropdown = gr.Dropdown(
+                choices=list(AVAILABLE_MODELS.keys()),
+                value="DETR ResNet-50",
+                label="🤖 Modèle de détection",
+                info="Chaque modèle a ses spécialités"
+            )
+            
+            # Paramètres
+            confidence_slider = gr.Slider(
+                minimum=0.1,
+                maximum=1.0, 
+                value=0.5,
+                step=0.05,
+                label="🎯 Seuil de confiance minimum"
+            )
+            
+            # Classes personnalisées pour OWL-ViT
+            custom_classes_input = gr.Textbox(
+                label="🏷️ Classes personnalisées (pour OWL-ViT)",
+                placeholder="person, car, dog, bottle, phone",
+                info="Séparées par des virgules. Uniquement pour OWL-ViT."
+            )
+            
+            # Bouton de détection
+            detect_btn = gr.Button(
+                "🔍 Détecter les objets", 
+                variant="primary",
+                size="lg"
+            )
+        
+        with gr.Column(scale=1):
+            # Outputs
+            output_image = gr.Image(
+                label="📊 Résultats de détection",
+                height=400
+            )
+            
+            detection_summary = gr.Textbox(
+                label="📈 Résumé des détections",
+                lines=8,
+                max_lines=15
+            )
+    
+    # Event handlers
+    detect_btn.click(
+        fn=detect_objects,
+        inputs=[image_input, model_dropdown, confidence_slider, custom_classes_input],
+        outputs=[output_image, detection_summary]
+    )
+    
+    # Auto-detect en changeant de modèle
+    model_dropdown.change(
+        fn=detect_objects,
+        inputs=[image_input, model_dropdown, confidence_slider, custom_classes_input],
+        outputs=[output_image, detection_summary]
+    )
+    
+    with gr.Accordion("📚 Guide des modèles", open=False):
+        gr.Markdown("""
+        ## 🎯 Guide de sélection des modèles
+        
+        ### **DETR (Detection Transformer)**
+        - **ResNet-50**: Équilibre vitesse/précision ⚖️
+        - **ResNet-101**: Plus précis, plus lent 🎯
+        - **Conditional DETR**: Version optimisée 🚀
+        
+        ### **YOLOS (You Only Look Once Transformer)**
+        - **Tiny**: Ultra-rapide ⚡
+        - **Small**: Bon compromis 🎯  
+        - **Base**: Maximum de précision 🔍
+        
+        ### **OWL-ViT (Zero-shot Detection)**
+        - Détecte **n'importe quoi** que vous décrivez ! 🎨
+        - Tapez vos propres classes dans le champ "Classes personnalisées"
+        
+        ### **RT-DETR**
+        - Optimisé pour le temps réel ⚡
+        
+        ### **Table Transformer**  
+        - Spécialisé dans la détection de tableaux 📊
+        """)
+    
+    # Exemples
+    gr.Examples(
+        examples=[
+            ["example1.jpg", "DETR ResNet-50", 0.5, ""],
+            ["example2.jpg", "OWL-ViT", 0.3, "smartphone, laptop, coffee cup"],
+        ],
+        inputs=[image_input, model_dropdown, confidence_slider, custom_classes_input]
+    )
+
+if __name__ == "__main__":
+    demo.launch()

requirements.txt

@@ -0,0 +1,7 @@
+transformers>=4.30.0
+gradio>=5.38.2
+torch
+torchvision
+pillow
+numpy
+spaces