YOLOv8 : Guide Complet pour la Détection d’Objets

YOLOv8 est la dernière version de l’algorithme YOLO (You Only Look Once), développé par Ultralytics. Il offre des performances améliorées et une API plus intuitive.

1. Installation et Configuration

# Installation des dépendances
pip install ultralytics opencv-python numpy

# Import des bibliothèques nécessaires
from ultralytics import YOLO
import cv2
import numpy as np

2. Modèles Disponibles

2.1 Chargement des Modèles

# Chargement des différents modèles
model_nano = YOLO('yolov8n.pt')  # Nano
model_small = YOLO('yolov8s.pt')  # Small
model_medium = YOLO('yolov8m.pt')  # Medium
model_large = YOLO('yolov8l.pt')  # Large
model_xlarge = YOLO('yolov8x.pt')  # XLarge

2.2 Comparaison des Modèles

def compare_models():
    # Configuration de base
    test_image = "path/to/test/image.jpg"
    
    # Test des différents modèles
    models = {
        'nano': model_nano,
        'small': model_small,
        'medium': model_medium,
        'large': model_large,
        'xlarge': model_xlarge
    }
    
    results = {}
    for name, model in models.items():
        # Mesure du temps d'inférence
        start_time = time.time()
        results[name] = model(test_image)
        inference_time = time.time() - start_time
        
        print(f"Modèle {name}:")
        print(f"Temps d'inférence: {inference_time:.2f}s")
        print(f"Nombre de détections: {len(results[name][0].boxes)}")

3. Détection d’Objets

3.1 Détection Simple

def detect_objects(image_path):
    # Chargement du modèle
    model = YOLO('yolov8n.pt')
    
    # Détection
    results = model(image_path)
    
    # Traitement des résultats
    for result in results:
        boxes = result.boxes
        for box in boxes:
            # Coordonnées de la boîte
            x1, y1, x2, y2 = box.xyxy[0]
            x1, y1, x2, y2 = int(x1), int(y1), int(x2), int(y2)
            
            # Confiance
            confidence = float(box.conf[0])
            
            # Classe
            class_id = int(box.cls[0])
            class_name = model.names[class_id]
            
            # Dessiner la boîte
            cv2.rectangle(image, (x1, y1), (x2, y2), (0, 255, 0), 2)
            
            # Ajouter le texte
            label = f"{class_name} {confidence:.2f}"
            cv2.putText(image, label, (x1, y1 - 10),
                       cv2.FONT_HERSHEY_SIMPLEX, 0.5, (0, 255, 0), 2)
    
    return image

3.2 Détection en Temps Réel

def real_time_detection():
    # Initialisation de la caméra
    cap = cv2.VideoCapture(0)
    
    # Chargement du modèle
    model = YOLO('yolov8n.pt')
    
    while cap.isOpened():
        success, frame = cap.read()
        if not success:
            continue
        
        # Détection
        results = model(frame)
        
        # Visualisation
        annotated_frame = results[0].plot()
        
        # Affichage
        cv2.imshow('YOLOv8 Detection', annotated_frame)
        
        if cv2.waitKey(1) & 0xFF == ord('q'):
            break
    
    cap.release()
    cv2.destroyAllWindows()

4. Segmentation

4.1 Segmentation d’Instance

def instance_segmentation():
    # Chargement du modèle de segmentation
    model = YOLO('yolov8n-seg.pt')
    
    # Segmentation
    results = model('path/to/image.jpg')
    
    # Visualisation
    for result in results:
        # Masques de segmentation
        masks = result.masks
        if masks is not None:
            for mask in masks:
                # Conversion du masque en image
                mask_array = mask.data.cpu().numpy()
                
                # Application du masque
                masked_image = cv2.bitwise_and(
                    image, image, mask=mask_array.astype(np.uint8)
                )
                
                # Affichage
                cv2.imshow('Segmentation', masked_image)

4.2 Segmentation en Temps Réel

def real_time_segmentation():
    # Initialisation
    cap = cv2.VideoCapture(0)
    model = YOLO('yolov8n-seg.pt')
    
    while cap.isOpened():
        success, frame = cap.read()
        if not success:
            continue
        
        # Segmentation
        results = model(frame)
        
        # Visualisation
        annotated_frame = results[0].plot()
        
        # Affichage
        cv2.imshow('YOLOv8 Segmentation', annotated_frame)
        
        if cv2.waitKey(1) & 0xFF == ord('q'):
            break
    
    cap.release()
    cv2.destroyAllWindows()

5. Classification

5.1 Classification d’Images

def image_classification():
    # Chargement du modèle de classification
    model = YOLO('yolov8n-cls.pt')
    
    # Classification
    results = model('path/to/image.jpg')
    
    # Traitement des résultats
    for result in results:
        # Probabilités des classes
        probs = result.probs
        
        # Classe prédite
        predicted_class = probs.top1
        confidence = probs.top1conf
        
        print(f"Classe prédite: {model.names[predicted_class]}")
        print(f"Confiance: {confidence:.2f}")

5.2 Classification en Temps Réel

def real_time_classification():
    # Initialisation
    cap = cv2.VideoCapture(0)
    model = YOLO('yolov8n-cls.pt')
    
    while cap.isOpened():
        success, frame = cap.read()
        if not success:
            continue
        
        # Classification
        results = model(frame)
        
        # Visualisation
        annotated_frame = results[0].plot()
        
        # Affichage
        cv2.imshow('YOLOv8 Classification', annotated_frame)
        
        if cv2.waitKey(1) & 0xFF == ord('q'):
            break
    
    cap.release()
    cv2.destroyAllWindows()

6. Entraînement Personnalisé

6.1 Préparation des Données

def prepare_training():
    # Configuration du dataset
    data_yaml = """
    path: dataset  # Chemin vers le dataset
    train: images/train  # Images d'entraînement
    val: images/val  # Images de validation
    
    # Classes
    names:
      0: person
      1: car
      2: truck
      # ... autres classes
    """
    
    # Sauvegarde de la configuration
    with open('data.yaml', 'w') as f:
        f.write(data_yaml)

6.2 Entraînement du Modèle

def train_model():
    # Chargement du modèle
    model = YOLO('yolov8n.pt')
    
    # Configuration de l'entraînement
    results = model.train(
        data='data.yaml',
        epochs=100,
        imgsz=640,
        batch=16,
        device='0',  # GPU
        workers=8,
        project='runs/train',
        name='exp'
    )

7. Optimisation et Déploiement

7.1 Export du Modèle

def export_model():
    # Chargement du modèle
    model = YOLO('yolov8n.pt')
    
    # Export dans différents formats
    model.export(format='onnx')  # ONNX
    model.export(format='engine')  # TensorRT
    model.export(format='coreml')  # CoreML
    model.export(format='tflite')  # TFLite

7.2 Optimisation des Performances

def optimize_performance():
    # Configuration pour de meilleures performances
    model = YOLO('yolov8n.pt')
    
    # Optimisation des paramètres
    results = model.predict(
        source='0',  # Caméra
        conf=0.25,  # Seuil de confiance
        iou=0.45,  # Seuil IoU
        agnostic_nms=True,  # NMS agnostique aux classes
        max_det=300,  # Nombre maximum de détections
        half=True  # Utilisation de la précision FP16
    )

8. Bonnes Pratiques

1. Choix du Modèle

   • Nano pour les appareils mobiles
   • Small/Medium pour les applications générales
   • Large/XLarge pour la précision maximale

2. Optimisation

   • Utiliser la précision FP16 pour les GPU
   • Ajuster les seuils de confiance et IoU
   • 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 :

• Performances améliorées
• API intuitive
• Support multiplateforme
• Export vers différents formats

Recommandations :

• Choisir le bon modèle selon les besoins
• Optimiser les performances
• Utiliser l’accélération matérielle
• Implémenter une gestion robuste des erreurs