YOLOv10 et YOLOv11 : Les Dernières Versions de YOLO

Les versions 10 et 11 de YOLO apportent des améliorations significatives en termes de performance, de précision et de fonctionnalités.

1. YOLOv10

1.1 Caractéristiques Principales

# Installation de YOLOv10
pip install ultralytics

# Import
from ultralytics import YOLO

# Chargement du modèle YOLOv10
model_v10 = YOLO('yolov10n.pt')  # Nano
model_v10_s = YOLO('yolov10s.pt')  # Small
model_v10_m = YOLO('yolov10m.pt')  # Medium
model_v10_l = YOLO('yolov10l.pt')  # Large
model_v10_x = YOLO('yolov10x.pt')  # XLarge

1.2 Améliorations

1. Architecture

   • Nouvelle architecture de backbone optimisée
   • Meilleure gestion des caractéristiques multi-échelles
   • Réduction de la latence d’inférence

2. Performance

   • Vitesse d’inférence augmentée de 15%
   • Précision améliorée de 5%
   • Consommation mémoire optimisée

3. Fonctionnalités

   • Support amélioré de la détection d’objets petits
   • Meilleure gestion des occlusions
   • Détection en temps réel optimisée

2. YOLOv11

2.1 Caractéristiques Principales

# Installation de YOLOv11
pip install ultralytics

# Import
from ultralytics import YOLO

# Chargement du modèle YOLOv11
model_v11 = YOLO('yolov11n.pt')  # Nano
model_v11_s = YOLO('yolov11s.pt')  # Small
model_v11_m = YOLO('yolov11m.pt')  # Medium
model_v11_l = YOLO('yolov11l.pt')  # Large
model_v11_x = YOLO('yolov11x.pt')  # XLarge

2.2 Améliorations

1. Architecture

   • Nouvelle architecture de backbone avec attention
   • Meilleure gestion des caractéristiques spatiales
   • Optimisation pour les appareils mobiles

2. Performance

   • Vitesse d’inférence augmentée de 25%
   • Précision améliorée de 8%
   • Consommation mémoire réduite de 20%

3. Fonctionnalités

   • Support de la détection 3D
   • Meilleure gestion des scènes complexes
   • Détection en temps réel ultra-optimisée

3. Comparaison des Versions

3.1 Métriques de Performance

def compare_versions():
    # Configuration
    test_image = "path/to/test/image.jpg"
    
    # Test des différentes versions
    versions = {
        'v8': YOLO('yolov8n.pt'),
        'v10': YOLO('yolov10n.pt'),
        'v11': YOLO('yolov11n.pt')
    }
    
    results = {}
    for version, model in versions.items():
        # Mesure du temps d'inférence
        start_time = time.time()
        results[version] = model(test_image)
        inference_time = time.time() - start_time
        
        print(f"YOLO{version}:")
        print(f"Temps d'inférence: {inference_time:.2f}s")
        print(f"Nombre de détections: {len(results[version][0].boxes)}")
        print(f"Précision moyenne: {results[version][0].boxes.conf.mean():.2f}")

3.2 Tableau Comparatif

Version	Vitesse	Précision	Mémoire	Fonctionnalités
v8	Base	Base	Base	Base
v10	+15%	+5%	-10%	+2 nouvelles
v11	+25%	+8%	-20%	+4 nouvelles

4. Applications Pratiques

4.1 Détection en Temps Réel

def real_time_detection():
    # Initialisation
    cap = cv2.VideoCapture(0)
    model = YOLO('yolov11n.pt')  # Utilisation de YOLOv11
    
    while cap.isOpened():
        success, frame = cap.read()
        if not success:
            continue
        
        # Détection avec YOLOv11
        results = model(frame)
        
        # Visualisation
        annotated_frame = results[0].plot()
        
        # Affichage
        cv2.imshow('YOLOv11 Detection', annotated_frame)
        
        if cv2.waitKey(1) & 0xFF == ord('q'):
            break
    
    cap.release()
    cv2.destroyAllWindows()

4.2 Détection 3D (YOLOv11)

def detection_3d():
    # Initialisation
    model = YOLO('yolov11-3d.pt')
    
    # Détection 3D
    results = model('path/to/3d_scene.pcd')
    
    # Visualisation
    for result in results:
        # Points 3D
        points = result.points
        # Boîtes 3D
        boxes = result.boxes_3d
        
        # Visualisation avec Open3D
        vis = o3d.visualization.Visualizer()
        vis.create_window()
        
        # Ajout des points et boîtes
        vis.add_geometry(points)
        for box in boxes:
            vis.add_geometry(box)
        
        vis.run()
        vis.destroy_window()

5. Bonnes Pratiques

1. Choix de la Version

   • v8 pour les applications basiques
   • v10 pour les applications avancées
   • v11 pour les applications innovantes

2. Optimisation

   • Utiliser l’accélération GPU
   • Ajuster les seuils de confiance
   • Optimiser la taille du batch

3. Déploiement

   • Exporter dans le format approprié
   • Utiliser l’accélération matérielle
   • Implémenter un système de cache

Conclusion

Points clés :

• Améliorations significatives des performances
• Nouvelles fonctionnalités avancées
• Support optimisé des appareils mobiles
• Détection 3D avec YOLOv11

Recommandations :

• Choisir la version selon les besoins
• Optimiser les performances
• Utiliser l’accélération matérielle
• Implémenter une gestion robuste des erreurs