Upload app.py

app.py

@@ -1,272 +1,217 @@
 import gradio as gr
-from transformers import pipeline, AutoImageProcessor, AutoModelForObjectDetection
+from transformers import pipeline
 from PIL import Image, ImageDraw, ImageFont
 import torch
 import spaces
 import numpy as np
+import cv2
 
-# Modèles disponibles sur Hugging Face Hub
-AVAILABLE_MODELS = {
+# Modèles optimisés pour le temps réel
+REALTIME_MODELS = {
+    "YOLOS Tiny (ultra-rapide)": "hustvl/yolos-tiny",
     "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"
+    "Conditional DETR": "microsoft/conditional-detr-resnet-50"
 }
 
-# Cache pour éviter de recharger les modèles
-model_cache = {}
+# Cache global pour le modèle
+current_detector = None
+current_model_name = None
 
-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]
+def load_detector(model_name):
+    """Charge le détecteur avec cache"""
+    global current_detector, current_model_name
+    
+    if current_model_name != model_name:
+        print(f"🔄 Chargement du modèle: {model_name}")
+        model_id = REALTIME_MODELS[model_name]
+        current_detector = pipeline(
+            "object-detection",
+            model=model_id,
+            device=0 if torch.cuda.is_available() else -1
+        )
+        current_model_name = model_name
+        print(f"✅ Modèle chargé: {model_name}")
+    
+    return current_detector
 
 @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"
+def process_webcam_frame(frame, model_choice, confidence_threshold):
+    """
+    Traite chaque frame de la webcam en temps réel
+    Cette fonction est appelée automatiquement pour chaque frame
+    """
+    if frame is None:
+        return frame
     
     try:
-        # Charger le modèle sélectionné
-        model_id = AVAILABLE_MODELS[model_choice]
-        detector = load_model(model_id)
+        # Charger le détecteur
+        detector = load_detector(model_choice)
         
-        # 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)
+        # Convertir numpy array en PIL Image si nécessaire
+        if isinstance(frame, np.ndarray):
+            # Gradio webcam donne du RGB
+            pil_image = Image.fromarray(frame)
         else:
-            # Modèles de détection standard
-            results = detector(image)
+            pil_image = frame
         
-        # Filtrer par seuil de confiance
-        filtered_results = [
-            obj for obj in results 
-            if obj['score'] >= confidence_threshold
+        # Redimensionner pour accélérer le traitement
+        original_size = pil_image.size
+        max_size = 640  # Réduire la taille pour plus de vitesse
+        
+        if max(original_size) > max_size:
+            ratio = max_size / max(original_size)
+            new_size = (int(original_size[0] * ratio), int(original_size[1] * ratio))
+            resized_image = pil_image.resize(new_size)
+        else:
+            resized_image = pil_image
+            ratio = 1.0
+        
+        # Détection sur l'image redimensionnée
+        detections = detector(resized_image)
+        
+        # Filtrer par confiance
+        filtered_detections = [
+            det for det in detections 
+            if det['score'] >= confidence_threshold
         ]
         
-        # Dessiner les détections
-        annotated_image = draw_detections(image.copy(), filtered_results)
+        # Redimensionner les coordonnées vers la taille originale
+        for det in filtered_detections:
+            if ratio != 1.0:
+                det['box']['xmin'] = int(det['box']['xmin'] / ratio)
+                det['box']['ymin'] = int(det['box']['ymin'] / ratio)
+                det['box']['xmax'] = int(det['box']['xmax'] / ratio)
+                det['box']['ymax'] = int(det['box']['ymax'] / ratio)
         
-        # Créer le résumé
-        summary = create_summary(filtered_results, model_choice)
+        # Dessiner les détections sur l'image originale
+        annotated_image = draw_detections_fast(pil_image, filtered_detections)
         
-        return annotated_image, summary
+        # Convertir back en numpy pour Gradio
+        return np.array(annotated_image)
         
     except Exception as e:
-        return image, f"❌ Erreur: {str(e)}"
+        print(f"❌ Erreur de traitement: {e}")
+        return frame
 
-def draw_detections(image, detections):
-    """Dessine les boîtes de détection sur l'image"""
+def draw_detections_fast(image, detections):
+    """Version optimisée pour dessiner les détections"""
+    if not detections:
+        return image
+    
     draw = ImageDraw.Draw(image)
     
-    # Essayer de charger une police, sinon utiliser la police par défaut
+    # Police par défaut pour la vitesse
     try:
-        font = ImageFont.truetype("/usr/share/fonts/truetype/dejavu/DejaVuSans-Bold.ttf", 16)
-    except:
         font = ImageFont.load_default()
+    except:
+        font = None
     
-    colors = [
-        "#FF6B6B", "#4ECDC4", "#45B7D1", "#96CEB4", "#FECA57", 
-        "#FF9FF3", "#54A0FF", "#5F27CD", "#00D2D3", "#FF9F43"
-    ]
+    colors = ["#FF6B6B", "#4ECDC4", "#45B7D1", "#96CEB4", "#FECA57"]
     
     for i, detection in enumerate(detections):
         box = detection['box']
         label = detection['label']
         score = detection['score']
         
-        # Coordonnées de la boîte
+        # Coordonnées
         x1, y1 = box['xmin'], box['ymin']
         x2, y2 = box['xmax'], box['ymax']
         
-        # Couleur pour cette classe
+        # Couleur
         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})"
+        # Boîte
+        draw.rectangle([x1, y1, x2, y2], outline=color, width=2)
         
-        # Fond du texte
-        bbox = draw.textbbox((x1, y1-25), text, font=font)
-        draw.rectangle(bbox, fill=color)
+        # Label avec score
+        text = f"{label} {score:.2f}"
         
-        # Texte
-        draw.text((x1, y1-25), text, fill="white", font=font)
+        # Fond du texte (simplifié)
+        if font:
+            bbox = draw.textbbox((x1, y1-20), text, font=font)
+            draw.rectangle(bbox, fill=color)
+            draw.text((x1, y1-20), text, fill="white", font=font)
+        else:
+            draw.text((x1, y1-15), text, fill=color)
     
     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:
+# Interface Gradio avec streaming
+with gr.Blocks(title="🎥 Détection Live", theme=gr.themes.Soft()) as demo:
     
     gr.Markdown("""
-    # 🤖 Object Detection avec Transformers
+    # 🎥 Détection d'Objets en Temps Réel
     
-    Utilisez les meilleurs modèles de détection d'objets disponibles sur Hugging Face Hub !
+    **Activez votre webcam** et voyez la détection se faire en direct !
     
-    **✨ 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
+    ⚡ **Optimisé pour la vitesse** avec des modèles légers
     """)
     
     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=2):
+            # Composant webcam avec streaming
+            webcam = gr.Interface(
+                fn=process_webcam_frame,
+                inputs=[
+                    gr.Image(sources=["webcam"], streaming=True, type="numpy"),
+                    gr.Dropdown(
+                        choices=list(REALTIME_MODELS.keys()),
+                        value="YOLOS Tiny (ultra-rapide)",
+                        label="🤖 Modèle (changement en direct)"
+                    ),
+                    gr.Slider(
+                        minimum=0.1,
+                        maximum=1.0,
+                        value=0.5,
+                        step=0.1,
+                        label="🎯 Seuil de confiance"
+                    )
+                ],
+                outputs=gr.Image(type="numpy", streaming=True),
+                live=True,  # ⭐ CRUCIAL: Active le mode live
+                title=None
             )
         
         with gr.Column(scale=1):
-            # Outputs
-            output_image = gr.Image(
-                label="📊 Résultats de détection",
-                height=400
-            )
+            gr.Markdown("""
+            ## 📊 Informations Live
             
-            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"],
+            ### 🎛️ Contrôles en temps réel:
+            - **Modèle**: Change instantanément
+            - **Confiance**: Ajuste le filtrage
+            - **Streaming**: Traitement frame par frame
+            
+            ### ⚡ Optimisations:
+            - Images redimensionnées à 640px
+            - Modèles légers prioritaires
+            - Cache intelligent des modèles
+            - Dessin optimisé
+            
+            ### 🎯 Modèles recommandés:
+            - **YOLOS Tiny**: Maximum de vitesse
+            - **DETR ResNet-50**: Bon équilibre
+            """)
+    
+    # Version alternative avec Interface simple
+    gr.Markdown("---")
+    gr.Markdown("## 🎥 Version Alternative (Interface Simple)")
+    
+    alternative_interface = gr.Interface(
+        fn=process_webcam_frame,
+        inputs=[
+            gr.Image(sources=["webcam"], streaming=True),
+            gr.Dropdown(
+                choices=list(REALTIME_MODELS.keys()),
+                value="YOLOS Tiny (ultra-rapide)"
+            ),
+            gr.Slider(0.1, 1.0, 0.5, step=0.1)
         ],
-        inputs=[image_input, model_dropdown, confidence_slider, custom_classes_input]
+        outputs=gr.Image(streaming=True),
+        live=True,  # ⭐ Mode live activé
+        title="Détection Webcam Live",
+        description="Cliquez sur la webcam pour démarrer le streaming live!"
     )
 
 if __name__ == "__main__":
-    demo.launch()
+    demo.launch()