🤖 YOLOv8 – Le Guide Ultime

YOLO (You Only Look Once) est une famille d'architectures de réseaux de neurones (IA) pour la détection d'objets en temps réel (Computer Vision).

Sa philosophie (créée par Joseph Redmon) a révolutionné la détection en 2015. Au lieu de "regarder" une image des centaines de fois (comme les anciens "R-CNN"), YOLO "regarde" l'image une seule fois ("Only Look Once").

Le "Single-Stage Detector"

Ancienne méthode (Two-Stage, ex: R-CNN) :
1. Proposer des "régions" (boîtes) où un objet *pourrait* se trouver (lent).
2. Lancer un classificateur sur *chaque* boîte proposée (très lent).

Méthode YOLO (Single-Stage) :
1. Divise l'image en une grille (ex: 13x13).
2. En *une seule passe* (un seul "forward pass" du réseau), chaque cellule de la grille prédit :
   a) Les "Bounding Boxes" (BBox) qu'elle contient.
   b) La "confiance" (score) pour chaque boîte.
   c) La "classe" (ex: "chien", "chat") pour chaque boîte.

Résultat : C'est *extrêmement* rapide, capable de tourner en temps réel (> 30 FPS) sur des GPUs modernes.

YOLOv8 est la 8ème itération de YOLO. Il est développé et maintenu par la société Ultralytics (qui a aussi fait le très populaire YOLOv5).

Ce n'est pas *juste* un modèle, c'est un framework complet (une "brique logicielle") qui gère l'entraînement, la validation, l'inférence, et l'exportation.

Les 3 Nouveautés Clés de YOLOv8 (vs v5/v7)

L'API ultralytics

La plus grande force de YOLOv8 est sa simplicité d'utilisation. Ultralytics fournit une seule API unifiée (en CLI et Python) pour tout faire :

# 1. Interface en Ligne de Commande (CLI)
$ yolo predict model=yolov8n.pt source=...
$ yolo train data=coco.yaml model=yolov8n.pt epochs=100

# 2. Interface Python
from ultralytics import YOLO
model = YOLO('yolov8n.pt')
results = model.predict(source=...)

L'architecture de tous les "YOLO" modernes est divisée en 3 parties :

Diagramme d'Architecture (Conceptuel)

(Image 640x640)
      |
      ▼
+---------------------+
| 1. BACKBONE         | (ex: C2f, CSPDarknet)
| (Extracteur de features)
+---------------------+
      |
      | (Features "grossières" (sémantique) -> P5)
      | (Features "fines" (détails) -> P3)
      ▼
+---------------------+
| 2. NECK             | (ex: PANet, FPN)
| (Mélangeur de features)
+---------------------+
      |
      | (Features P3, P4, P5 "riches")
      ▼
+---------------------+
| 3. HEAD (Detection) | (Anchor-Free, Decoupled)
| (Prédit BBox + Classe)
+---------------------+
      |
      ▼
(Sortie: [BBox], [Classes], [Masques])

YOLOv8 n'est pas *un* modèle, c'est un framework qui gère 5 tâches de Computer Vision, en utilisant la même architecture de base.

Exemple (yolo CLI)

# 1. Tâche: DETECT
$ yolo task=detect mode=predict model=yolov8n.pt source=image.jpg

# 2. Tâche: SEGMENT
# (Notez l'utilisation du modèle "-seg")
$ yolo task=segment mode=predict model=yolov8n-seg.pt source=image.jpg

# 3. Tâche: TRACK (sur une vidéo)
$ yolo task=detect mode=predict model=yolov8n.pt source=video.mp4 track

L'installation de YOLOv8 est gérée par pip. Le package officiel est ultralytics.

1. Installation (Python 3.8+)

# (Créez un venv d'abord !)
$ python3 -m venv venv
$ source venv/bin/activate

# 1. Installation de base (CPU)
(venv) $ pip install ultralytics

# 2. (Optionnel) Pour le support GPU (NVIDIA)
#    (Assurez-vous que CUDA (ex: 11.8) est installé !)
(venv) $ pip install torch torchvision torchaudio --index-url https://download.pytorch.org/whl/cu118
(venv) $ pip install ultralytics

2. Vérification

L'installation vous donne deux choses :

• La commande yolo (CLI).
• La librairie ultralytics (Python).

# 1. Vérifier la CLI
$ yolo check
# (Affiche la configuration, si le GPU est détecté, etc.)

# 2. Vérifier le Python
$ python
>>> from ultralytics import YOLO
>>> (Pas d'erreur = OK)

YOLOv8 propose 5 tailles de modèles ("plugins"), de "Nano" (n) à "Extra Large" (x). Le choix est un compromis (trade-off) :

• yolov8n.pt (Nano) : Ultra-rapide, faible précision (mAP). Idéal pour CPU, Raspberry Pi, mobile.
• yolov8x.pt (Large/Extra) : Très lent, haute précision (mAP). Idéal pour le "batch processing" sur un gros GPU.
• yolov8m.pt (Medium) : Le "bon compromis" pour un GPU (ex: NVIDIA RTX 3060).

Tableau Comparatif (Tâche: Détection, Dataset: COCO)

mAP (mean Average Precision) : Le "score" de précision (plus c'est haut, mieux c'est).

Vitesse (FPS) : FPS = 1000 / (Temps en ms).
Ex: yolov8n sur GPU A100 -> 1000 / 0.99 = 1010 FPS (Temps réel massif).
Ex: yolov8m sur CPU -> 1000 / 280 = 3.5 FPS (Pas temps réel).

Le mode predict (ou detect) de la CLI yolo est le moyen le plus simple de tester un modèle.

Arguments Clés (CLI)

Exemples de Commandes

# 1. Détection simple sur une image, sauvegarde le résultat
$ yolo predict model=yolov8n.pt source="bus.jpg" save

# 2. Détection sur une vidéo, affiche le live, confiance à 50%
$ yolo predict model=yolov8m.pt source="video.mp4" show conf=0.5

# 3. Segmentation sur une webcam (source 0)
$ yolo task=segment predict model=yolov8s-seg.pt source=0 show

# 4. Tracking sur un flux RTSP (caméra IP)
$ yolo task=detect predict model=yolov8n.pt source="rtsp://..." track

Pour intégrer YOLO dans une application (ex: FastAPI, Flask), on utilise l'API Python YOLO().

Traitement des results

La méthode model(source) (ou model.predict()) renvoie une liste d'objets Results (un par image/frame).

L'objet Results contient les prédictions dans des attributs (ex: .boxes, .masks, .keypoints).

Exemple (Détection)

import cv2 # (Nécessite 'pip install opencv-python')
from ultralytics import YOLO

# 1. Charger le modèle
model = YOLO("yolov8n.pt") # (Télécharge si non-trouvé)

# 2. Charger la source (image)
image_path = "bus.jpg"
image = cv2.imread(image_path)

# 3. Lancer l'inférence
#    (stream=True est meilleur pour la vidéo/générateurs)
results = model(image) 

# 4. Itérer sur les résultats (ici, 1 seul résultat)
for res in results:
    
    # 'res.names' est le dict {0: 'person', 1: 'bicycle', ...}
    class_names = res.names
    
    # 'res.boxes' contient les Bounding Boxes
    for box in res.boxes:
        
        # --- Accès aux données ---
        # (Les .data[0] sont des Tensors PyTorch, on les convertit)
        
        # Coordonnées (x1, y1, x2, y2)
        x1, y1, x2, y2 = box.xyxy[0].cpu().numpy().astype(int)
        
        # Confiance
        conf = box.conf[0].cpu().numpy()
        
        # Classe (ID)
        cls_id = int(box.cls[0].cpu().numpy())
        cls_name = class_names[cls_id]
        
        # 5. Dessiner sur l'image (avec OpenCV)
        if conf > 0.5:
            cv2.rectangle(image, (x1, y1), (x2, y2), (0, 255, 0), 2)
            cv2.putText(image, f"{cls_name} {conf:.2f}", (x1, y1 - 10), 
                        cv2.FONT_HERSHEY_SIMPLEX, 0.5, (0, 255, 0), 2)

# 6. Sauvegarder/Afficher
cv2.imwrite("result.jpg", image)

Pour entraîner YOLO sur vos *propres* objets, vous devez formater vos données (le "dataset") d'une manière très spécifique.

1. Le Fichier data.yaml (Le "Manifeste")

C'est le fichier principal. Il dit à YOLO où trouver les images et ce que représentent les classes.

# /home/user/projets/mon_dataset/data.yaml

# 1. Chemins (relatifs au fichier .yaml, ou absolus)
path: /home/user/projets/mon_dataset
train: images/train  # -> /home/user/projets/mon_dataset/images/train
val:   images/val    # -> /home/user/projets/mon_dataset/images/val
test:  images/test   # (Optionnel)

# 2. Noms des classes (L'ORDRE EST CRUCIAL)
#    (Ici, 'chat' est l'ID 0, 'chien' est l'ID 1)
names:
  0: chat
  1: chien

2. Le Format des Labels (.txt)

Pour chaque image (ex: img1.jpg), il doit y avoir un fichier .txt (img1.txt) avec le *même nom* dans le dossier labels/.

Structure : images/train/img1.jpg <-> labels/train/img1.txt

Chaque ligne du .txt est un objet, au format (normalisé 0-1) :

[classe_id] [x_centre] [y_centre] [largeur] [hauteur]

Exemple (img1.txt)

# (Contenu de img1.txt)
# (L'image contient 1 chien et 1 chat)

# Un chien (classe_id 1) au centre (0.5, 0.5), 30% de large, 50% de haut
1 0.50 0.50 0.30 0.50

# Un chat (classe_id 0) en haut à gauche (0.2, 0.2), 10% de large, 15% de haut
0 0.20 0.20 0.10 0.15

Outil "Plugin" : Personne n'écrit ces fichiers à la main. On utilise un outil d'annotation (ex: Roboflow, CVAT, LabelImg) qui génère ces .txt et le data.yaml pour vous.

L'entraînement (Training) est le processus de "Transfer Learning". On ne part pas de zéro. On part d'un modèle pré-entraîné (ex: yolov8n.pt, entraîné sur COCO) et on le "spécialise" (fine-tune) sur nos propres données (ex: "chats" et "chiens").

CLI vs Python

$ yolo task=detect \
       mode=train \
       model=yolov8n.pt \      # (Le "poids" de départ)
       data=data.yaml \        # (Notre dataset)
       epochs=100 \            # (Combien de fois voir le dataset)
       imgsz=640 \             # (Taille d'image)
       batch=16 \              # (Nb images par batch GPU)
       name=mon_super_modele   # (Nom du dossier de sortie)

from ultralytics import YOLO

# 1. Charger le modèle de départ
model = YOLO('yolov8n.pt')

# 2. Lancer l'entraînement
results = model.train(
    data='data.yaml',
    epochs=100,
    imgsz=640,
    batch=16,
    name='mon_super_modele'
)

# 3. (Optionnel) Valider le modèle
results = model.val()

Sortie (Le Dossier runs/detect/mon_super_modele)

L'entraînement génère un dossier contenant :

• weights/ : Les modèles !
  - best.pt : (Le meilleur mAP). C'est celui-ci qu'on utilise en production.
  - last.pt : Le dernier (pour reprendre l'entraînement).
• Graphiques (.png) : results.png (courbes mAP, loss...), confusion_matrix.png.

Le fichier .pt (PyTorch) est parfait pour l'entraînement, mais il est *mauvais* pour la production. Il dépend de Python et PyTorch.

Pour la production (ex: en C++, C#, ou Python optimisé), on *exporte* le modèle dans un format "agnostique" (interopérable).

Exemple (CLI)

# 1. Exporter le modèle 'best.pt' au format ONNX
$ yolo export model=runs/detect/mon_super_modele/weights/best.pt format=onnx

# (Crée 'best.onnx')

# 2. Exporter en TensorRT (NVIDIA), en FP16 (plus rapide, moins précis)
$ yolo export model=best.pt format=engine half=True

# (Crée 'best.engine')

YOLOv8 est le moteur, mais l'écosystème (les "addons") est ce qui le rend utilisable en production.

Addons Incontournables (Plugins)

Exemples de Projets