🚀 YOLOv5 – Le Guide Ultime

YOLOv5 (Juin 2020) est la version de YOLO qui a *tout changé* en termes d'accessibilité et de facilité d'utilisation.

Il n'a *pas* été créé par Joseph Redmon (l'auteur de v1-v3) ni par AlexeyAB (l'auteur de v4). Il a été créé par Glenn Jocher (Ultralytics).

La "Killer Feature" : 100% PyTorch

YOLOv3 et v4 étaient basés sur le framework Darknet (en C). C'était rapide, mais *très* difficile à installer (compiler le C, gérer CUDA...), à modifier (code C complexe), et à exporter.

YOLOv5 est une ré-implémentation complète (from scratch) de la philosophie YOLO, mais en Python (PyTorch).

Résultat :
1. Installation : pip install yolov5. C'est tout.
2. Facilité d'usage : Entraîner ou prédire est un simple python train.py.
3. Écosystème : Il s'intègre *nativement* avec tout l'écosystème Python/PyTorch (Jupyter, Pandas, ...).

Conclusion : v5 a rendu la détection SOTA accessible à des millions de développeurs Python qui ne voulaient pas (ou ne pouvaient pas) compiler du C.

En 2020, il y a eu une "guerre" des YOLO.
- Avril 2020 : YOLOv4 (AlexeyAB) sort. C'est le successeur "officiel" (Darknet/C) de v3.
- Juin 2020 : YOLOv5 (Ultralytics) sort. Il n'a *pas* de papier de recherche, c'est juste un repo GitHub PyTorch.

Au début, v5 a été critiqué (ce n'est pas "YOLOv5", c'est juste "Ultralytics-YOLO"). Mais au final, v5 a gagné la guerre de l'adoption.

Conclusion : v5 a gagné car il était 100x plus facile à utiliser pour la communauté (Python/Data Science) pour une performance similaire.

YOLOv5 a introduit la "mise à l'échelle" (scaling) des modèles (un "plugin" de design). Au lieu d'un seul modèle, v5 est une *famille* de 5 modèles, du plus petit (n) au plus grand (x), en jouant sur la *profondeur* et la *largeur* (filtres) du réseau.

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

Choix du "plugin" (modèle) :
yolov5s.pt (Small) est le choix par défaut (meilleur ratio vitesse/précision).
yolov5n.pt (Nano) est le choix pour les "edge devices" (Raspberry Pi, CPU).

L'architecture de YOLOv5 est très similaire à celle de YOLOv4 (qu'elle a "copiée" et portée en PyTorch). Elle utilise le triptyque "Backbone", "Neck", "Head".

Diagramme d'Architecture (Conceptuel)

(Input: Image 640x640x3)
      |
      ▼
+---------------------+
| 1. BACKBONE         | (CSPDarknet53)
| (Extracteur de features)
+---------------------+
      |
      | (Features P3, P4, P5)
      ▼
+---------------------+
| 2. NECK             | (PANet)
| (Mélangeur de features)
+---------------------+
      |
      | (Features "riches" P3, P4, P5)
      ▼
+---------------------+
| 3. HEAD (Detection) | (Style YOLOv3, Anchor-based)
| (Prédit BBox + Classe)
+---------------------+
      |
      ▼
(Sortie: 3 échelles de prédiction)

La vraie "magie" de YOLOv5 n'est pas tant son architecture (similaire à v4) que ses "plugins" (stratégies) d'entraînement.

1. Augmentation "Mosaic" (Le "plugin" visuel)

C'est le "plugin" d'augmentation le plus célèbre (hérité de v4). Au lieu de nourrir le réseau avec 1 image, on en "stitche" (coud) 4 (aléatoirement) en une seule.

Avantages :
1. Force le réseau à gérer des objets *partiels* (coupés).
2. Force le réseau à gérer des contextes *étranges* (un chat à côté d'une voiture).
3. Simule 4 images en 1 (batch-size effectif x4).

2. AutoAnchor

Problème (v3) : Les "Anchor Boxes" (tailles de boîtes par défaut) étaient *fixes* (calculées sur COCO). Si vous entraîniez sur des "visages" (très carrés), les "anchors" (rectangulaires) n'étaient pas bons.

Solution (v5) : Le "plugin" AutoAnchor. Avant *chaque* entraînement, v5 lance un algorithme (k-means) sur *votre* dataset (votre data.yaml) et *calcule* les 9 meilleurs "anchors" pour *vos* données. C'est 100% automatique.

3. Hyperparameter Evolution (--evolve)

Un "plugin" (addon) d'optimisation. Si vous lancez python train.py --evolve, v5 va entraîner 300 versions de votre modèle en utilisant un *algorithme génétique* pour trouver les meilleurs hyperparamètres (learning rate, momentum, augmentation...).

Contrairement à Darknet (C), l'installation de YOLOv5 (Python) est triviale.

(venv) $ pip install yolov5

# 1. Cloner le dépôt
$ git clone https://github.com/ultralytics/yolov5
$ cd yolov5

# 2. (Optionnel) Créer un venv
$ python3 -m venv venv
$ source venv/bin/activate

# 3. Installer les dépendances
(venv) $ pip install -r requirements.txt

Le script detect.py (inclus dans le git clone) est le "plugin" d'inférence CLI. (Note : YOLOv8 a unifié cela sous yolo predict).

Arguments Clés (detect.py)

Exemples de Commandes

# (Assurez-vous d'être dans le dossier 'yolov5/' et d'avoir activé le 'venv')

# 1. Détection simple sur une image (sauvegarde auto dans 'runs/detect/exp')
$ python detect.py --weights yolov5s.pt --source data/images/bus.jpg

# 2. Détection sur une webcam (source 0), confiance à 40%
$ python detect.py --weights yolov5m.pt --source 0 --conf 0.40

# 3. Détection sur un dossier, sauvegarde les crops, et nomme le run
$ python detect.py --weights best.pt --source ./mes_images/ \
    --save-crop --project mes_runs --name run_prod

Pour intégrer YOLOv5 dans une application (ex: FastAPI, Flask), on utilise l'API Python, via le "plugin" torch.hub.

Le "Hub" PyTorch

C'est la méthode "plugin" de PyTorch pour charger des modèles depuis un repo GitHub.

Exemple (detect.py en code)

import torch
import cv2

# 1. Charger le modèle (local ou depuis GitHub)
#    'custom' = charger des poids locaux
#    'path' = le .pt (best.pt ou yolov5s.pt)
#    (Si 'yolov5s', 'path' n'est pas requis)
model = torch.hub.load('ultralytics/yolov5', 'custom', path='yolov5s.pt')
# (Ou 'local', 'path=...')

# 2. (Optionnel) Configurer le modèle
model.conf = 0.5  # Confiance (NMS)
model.iou = 0.45  # IoU

# 3. Charger l'image (OpenCV ou PIL)
img = cv2.imread('bus.jpg') # (BGR)
img_rgb = cv2.cvtColor(img, cv2.COLOR_BGR2RGB) # (Convertit en RGB)

# 4. Inférence
results = model(img_rgb)

# 5. Parser les résultats (la partie "difficile")
#    'results.pandas()' est le "plugin" le plus simple

predictions = results.pandas().xyxy[0] 
# (Pandas DataFrame: [xmin, ymin, xmax, ymax, confidence, class_id, name])

for index, row in predictions.iterrows():
    print(f"Trouvé: {row['name']} (Conf: {row['confidence']:.2f})")
    
    # Dessiner la BBox
    x1, y1 = int(row['xmin']), int(row['ymin'])
    x2, y2 = int(row['xmax']), int(row['ymax'])
    cv2.rectangle(img, (x1, y1), (x2, y2), (0, 255, 0), 2)

cv2.imwrite("result_py.jpg", img)

Pour entraîner YOLOv5 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 à YOLOv5 où trouver les images et ce que représentent les classes.

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

# 1. Chemins (relatifs au dossier 'yolov5/' OU absolus)
path: ../mon_dataset  # (Optionnel)
train: images/train  # -> ../mon_dataset/images/train
val:   images/val    # -> ../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: yolov5s.pt, entraîné sur COCO) et on le "spécialise" (fine-tune) sur nos propres données (ex: "chats" et "chiens").

La Commande (train.py)

On utilise le script train.py (inclus dans le git clone).

$ python train.py \
    --data data/mon_dataset.yaml \  # (Le fichier manifeste)
    --weights yolov5s.pt \          # (Le "poids" de départ pour le Transfer Learning)
    --epochs 100 \                  # (Combien de fois voir le dataset)
    --batch-size 16 \               # (Nb images par batch GPU, ajuster à la VRAM)
    --imgsz 640 \                   # (Taille d'image (carré))
    --name yolov5s_custom          # (Nom du dossier de sortie)

Arguments Clés (Addons)

Sortie (Le Dossier runs/train/yolov5s_custom)

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, --resume).
• 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) via export.py.

Exemple (CLI)

# 1. Exporter le 'best.pt' au format ONNX
$ python export.py \
    --weights ./runs/train/yolov5s_custom/weights/best.pt \
    --include onnx \
    --imgsz 640

# (Crée 'best.onnx')

# 2. Exporter en TensorRT (NVIDIA), en FP16 (plus rapide)
$ python export.py --weights best.pt --include engine --half --imgsz 640 

# (Crée 'best.engine')

YOLOv5 (Ultralytics) a été le premier à intégrer des "plugins" (addons) SaaS de MLOps directement dans son code d'entraînement.

1. Weights & Biases (wandb) - Le "plugin" de Traking

W&B est le "Sentry" (voir 1.1 Sentry) de l'IA. C'est une plateforme SaaS pour le "Experiment Tracking".
YOLOv5 a une intégration *native* avec W&B. Si vous faites pip install wandb et wandb login :

1. train.py le détecte automatiquement.
2. Il *uploade* tout (live) vers le cloud W&B :
   - Les courbes (mAP, Loss, ...)
   - Les hyperparamètres (batch, lr...)
   - Les images (prédictions vs réalité)
   - Les poids (best.pt)

Résultat : Vous avez un dashboard complet de toutes vos expériences, vous permettant de comparer 100 "runs" pour trouver le meilleur.

2. Roboflow (Le "plugin" de Données)

Roboflow est la plateforme SaaS n°1 pour gérer les datasets de Computer Vision. C'est le "plugin" (l'addon) de gestion de données pour YOLO.

Fonctionnalités :
1. Annoter : Une UI web pour dessiner les BBox (ou Seg).
2. Augmenter : Applique des "plugins" d'augmentation (Blur, Flip, Cutout...).
3. Exporter : Génère le data.yaml et le .zip au format YOLOv5 (prêt à l'emploi).