YOLO — DevIA Notes

À quoi ça sert

YOLO résout le problème de la détection d'objets : pas juste classifier une image (« c'est un chat »), mais trouver tous les objets présents, les localiser avec une boîte englobante (bounding box), et leur attribuer une classe et un score de confiance.

Vidéosurveillance : compter des personnes, détecter des intrusions, suivre des véhicules.
Industrie : contrôle qualité sur une chaîne de production (défauts, pièces manquantes).
Mobilité : voitures autonomes, détection de piétons, panneaux de signalisation.
Sport / analyse vidéo : tracking de joueurs, de balles.
Drones et robotique : navigation guidée par la vision.

Classification, détection, segmentation : la différence

Classification répond à « qu'est-ce qu'il y a sur l'image ? » — un seul label pour toute l'image. Détection répond à « quoi et où ? » — une boîte par objet, plusieurs objets possibles. Segmentation va plus loin : un masque pixel par pixel autour de chaque objet. YOLO sait faire les trois depuis la v8.

L'idée derrière « You Only Look Once »

Avant YOLO (2015), les détecteurs comme R-CNN procédaient en deux étapes : d'abord proposer ~2000 régions candidates dans l'image, puis classifier chacune. Lent (plusieurs secondes par image), inutilisable en temps réel.

L'idée de Joseph Redmon : traiter la détection comme un problème de régression unique. On découpe l'image en grille, et un seul passage dans un réseau de neurones prédit en même temps :

les coordonnées des boîtes (x, y, largeur, hauteur),
la probabilité qu'il y ait un objet dans chaque cellule,
la classe la plus probable de cet objet.

D'où le nom : une seule passe sur l'image, contre plusieurs pour R-CNN. Résultat à l'époque : 45 images/seconde au lieu de ~0.5. Le temps réel devient atteignable.

Le compromis vitesse / précision

Historiquement YOLO sacrifiait un peu de précision (notamment sur les petits objets) pour gagner en vitesse. À partir de YOLOv4/v5, l'écart s'est largement réduit — les versions modernes sont à la fois rapides et très précises, et battent la plupart des concurrents sur les benchmarks COCO.

L'évolution des versions

YOLO est devenu une famille de modèles, parfois maintenue par des équipes différentes. Les jalons à connaître :

YOLOv1–v3 (2015–2018) — Joseph Redmon, papiers fondateurs. L'auteur abandonne la recherche en 2020 pour raisons éthiques (usages militaires).
YOLOv4 (2020) — Alexey Bochkovskiy reprend le flambeau. Optimisations massives sur l'entraînement.
YOLOv5 (2020) — Ultralytics, première version en PyTorch accessible, polémique car pas de papier de recherche associé. Devient rapidement le standard industriel.
YOLOv6, v7, YOLOX — variantes parallèles d'autres équipes.
YOLOv8 (2023) — Ultralytics, refonte complète, ajoute segmentation, pose, classification.
YOLOv9, v10, v11, v12, v13 — itérations rapides, meilleurs scores sur COCO à chaque génération. YOLOv11 et YOLOv13 (Ultralytics) sont aujourd'hui les choix par défaut pour un projet pratique.

Une famille, pas un modèle

Quand on dit « YOLO », on parle aujourd'hui d'une architecture de référence avec plusieurs implémentations concurrentes. La plus utilisée en pratique reste celle d'Ultralytics : une seule lib Python qui couvre v3, v5, v8, v11… avec la même API.

Un exemple d'usage

Détecter ce qu'il y a sur une image en 4 lignes avec Ultralytics :

python

from ultralytics import YOLO

# Charger un modèle pré-entraîné sur COCO (80 classes courantes)
model = YOLO("yolo11n.pt")   # n = nano, le plus léger

# Détecter sur une image (URL, chemin, ou même une webcam)
results = model("chien_velo.jpg")

# Sauvegarder l'image annotée et afficher les résultats
results[0].save("sortie.jpg")
print(results[0].boxes)   # boîtes + classes + scores

Au premier appel, Ultralytics télécharge le poids du modèle (yolo11n.pt, ~5 Mo). Tu obtiens en sortie une image avec des rectangles autour de chaque objet détecté, et un tableau structuré contenant les coordonnées, la classe et la confiance.

How-to : installer et utiliser YOLO

Installer Ultralytics

On reste dans la logique UV. La lib ultralytics embarque tout : modèles, entraînement, export, CLI.
bash
```
uv add ultralytics
```
Sur GPU NVIDIA, installe en plus la version CUDA de PyTorch — sinon tout tournera (lentement) sur CPU. Vérifie après installation :
python
```
import torch
print(torch.cuda.is_available())   # True si GPU détecté
```
Choisir une taille de modèle

Chaque version YOLO existe en plusieurs tailles. Plus c'est gros, plus c'est précis mais lent. Le suffixe indique la taille :
- yolo11n.pt — nano, ~5 Mo, idéal mobile / edge.
- yolo11s.pt — small, bon compromis.
- yolo11m.pt — medium.
- yolo11l.pt — large.
- yolo11x.pt — extra large, précision max.
Conseil : commence avec n ou s pour prototyper, monte en taille si la précision n'est pas suffisante.

Faire une inférence (prédire sur une image)

python

from ultralytics import YOLO

model = YOLO("yolo11n.pt")

# Inférence — accepte image, URL, dossier, vidéo, webcam (0)
results = model("image.jpg", conf=0.5)

for r in results:
    for box in r.boxes:
        cls = int(box.cls[0])
        name = model.names[cls]              # nom de classe
        conf = float(box.conf[0])         # confiance 0-1
        xyxy = box.xyxy[0].tolist()         # [x1, y1, x2, y2]
        print(f"{name} ({conf:.2f}) → {xyxy}")

Le paramètre conf=0.5 filtre les détections sous 50% de confiance. C'est le bon réglage par défaut, à descendre si tu rates des objets, à monter si tu as trop de faux positifs.

Détecter sur une vidéo ou la webcam

python

# Vidéo → sauvegarde annotée
model("video.mp4", save=True)

# Webcam en temps réel
model(0, show=True)              # 0 = première webcam

# Stream sur un flux RTSP (caméra IP)
model("rtsp://192.168.1.10:554/stream", stream=True)

Entraîner sur ton propre dataset

C'est là que YOLO devient vraiment utile : reconnaître tes objets (pièces industrielles, produits, animaux spécifiques…). Il faut un dataset au format YOLO : un dossier d'images et un fichier .txt par image avec les annotations.
yaml (data.yaml)
```
path: ./mon_dataset
train: images/train
val: images/val

names:
  0: chat
  1: chien
  2: lapin
```
python
```
from ultralytics import YOLO

model = YOLO("yolo11n.pt")   # on part du pré-entraîné

model.train(
    data="data.yaml",
    epochs=50,
    imgsz=640,
    batch=16,
)
```
On utilise du transfer learning : on part des poids pré-entraînés sur COCO et on les ré-entraîne sur le dataset perso. Beaucoup plus rapide et précis que partir de zéro. Quelques centaines d'images annotées suffisent souvent pour un bon résultat.
Annoter ses images

Pour créer le dataset, il faut dessiner les boîtes à la main. Les outils gratuits les plus utilisés :
- Roboflow — web, le plus simple, gère l'export au format YOLO directement.
- CVAT — open source, auto-hébergeable, plus puissant.
- LabelImg — outil desktop minimaliste, idéal pour quelques centaines d'images.
Exporter le modèle pour la production

Le format .pt (PyTorch) est pratique en développement, mais on l'exporte souvent en ONNX ou TensorRT pour la prod — plus rapide, indépendant de PyTorch.
python
```
model.export(format="onnx")        # portable, CPU/GPU
model.export(format="tensorrt")    # max perf sur GPU NVIDIA
model.export(format="coreml")      # iOS / Mac
```

Aide-mémoire

python (inférence)

from ultralytics import YOLO
model = YOLO("yolo11n.pt")
results = model("img.jpg", conf=0.5)
results[0].save("out.jpg")

python (entraînement)

model.train(data="data.yaml", epochs=50, imgsz=640)
model.val()                       # évaluer sur le set de validation
model.export(format="onnx")

bash (CLI Ultralytics)

yolo predict model=yolo11n.pt source=img.jpg
yolo train model=yolo11n.pt data=data.yaml epochs=50
yolo val model=runs/detect/train/weights/best.pt
yolo export model=best.pt format=onnx

python (autres tâches)

YOLO("yolo11n-seg.pt")     # segmentation (masques)
YOLO("yolo11n-pose.pt")    # pose (squelette humain)
YOLO("yolo11n-cls.pt")     # classification simple

YOLO et le reste de l'écosystème

MLflow — tracker les entraînements YOLO (loss, mAP, hyperparamètres) et versionner les poids comme artefacts. Ultralytics a une intégration MLflow native via settings["mlflow"] = True.
FastAPI — exposer un modèle YOLO entraîné derrière une API : on reçoit une image en POST, on renvoie les boîtes en JSON.
Streamlit — l'outil parfait pour démontrer un modèle YOLO : uploader une image, afficher les détections, ajuster le seuil de confiance avec un slider.
Docker — Ultralytics fournit des images officielles avec CUDA pré-installé. Indispensable pour déployer sur un serveur GPU sans s'arracher les cheveux sur les pilotes.
Prefect — orchestrer un pipeline de ré-entraînement périodique : récupérer les nouvelles images annotées, lancer le training, évaluer, promouvoir le modèle s'il bat l'ancien.

Licence : attention en production

Ultralytics YOLO (v5, v8, v11, v13…) est sous AGPL-3.0. C'est libre pour la recherche et les projets open source, mais si tu intègres YOLO dans un produit commercial fermé, il faut acheter une licence Ultralytics Enterprise. À garder en tête avant un déploiement client. Alternative : YOLOX (Apache 2.0).

Pour aller plus loin

Site officiel : docs.ultralytics.com
Dépôt GitHub : github.com/ultralytics/ultralytics
Papier YOLOv1 original (2015) : arxiv.org/abs/1506.02640
Roboflow (annotation + datasets publics) : roboflow.com
Dataset COCO (80 classes courantes utilisées par les modèles pré-entraînés) : cocodataset.org

À quoi ça sert

L'idée derrière « You Only Look Once »

L'évolution des versions

Un exemple d'usage

How-to : installer et utiliser YOLO

Installer Ultralytics

Choisir une taille de modèle

Faire une inférence (prédire sur une image)

Détecter sur une vidéo ou la webcam

Entraîner sur ton propre dataset

Annoter ses images

Exporter le modèle pour la production

Aide-mémoire

YOLO et le reste de l'écosystème

Pour aller plus loin