Entraîner YOLO v11 sur un dataset Roboflow : tutoriel pas-à-pas

📍 Article principal : Détection d’objets en 2026 : pipeline YOLO v11 + Ultralytics + Roboflow. Prérequis recommandé : Installer YOLO v11 et Ultralytics.

Entraîner YOLO v11 sur ses propres images est l’étape qui transforme un détecteur générique en outil métier utile. La pipeline naturelle en 2026 combine Roboflow pour la gestion des données et Ultralytics pour l’entraînement, parce que l’export Roboflow se charge directement dans model.train sans transformation. Ce tutoriel va vous faire passer de zéro image à un modèle YOLO11s entraîné sur vingt images de panneaux de signalisation, avec mAP et matrice de confusion à l’appui. La méthode reste identique pour des datasets de plusieurs milliers d’images — seuls les ordres de grandeur de temps changent.

Prérequis

• YOLO v11 installé et fonctionnel — voir le tutoriel d’installation lié plus haut.
• Un compte Roboflow gratuit (création immédiate sur app.roboflow.com/signup).
• Vingt à cinquante images représentatives du domaine que vous voulez détecter (photos prises au téléphone conviennent pour démarrer).
• Un GPU disponible (laptop avec RTX, ou notebook Colab/Kaggle si pas de GPU local).
• Niveau attendu : à l’aise en ligne de commande Python, pas besoin de connaître PyTorch.
• Temps estimé : 90 minutes pour la première itération (annotation comprise), 20 minutes pour les itérations suivantes.

Étape 1 — Créer un projet Roboflow

Avant de toucher à du code, il faut un espace centralisé pour stocker les images, gérer les annotations et générer des versions reproductibles du dataset. C’est exactement ce que Roboflow fournit dans son plan gratuit. Allez sur app.roboflow.com, connectez-vous, puis cliquez sur « Create New Project ». Choisissez le type Object Detection dans le menu déroulant, donnez un nom au projet (par exemple panneaux-test), nommez les classes que vous voulez détecter (par exemple stop, cedez, limitation-50), puis validez.

Roboflow vous redirige vers la vue projet vide. Le menu de gauche distingue trois grandes phases : Annotate (annoter), Dataset (constituer un dataset partitionné), Versions (créer des snapshots reproductibles avec augmentations). Cette structure correspond exactement au flux d’un projet ML rigoureux et explique en bonne partie l’attractivité de l’outil.

L’écran suivant doit afficher votre projet vide avec un compteur 0/0 images. Vous êtes prêt à uploader.

Étape 2 — Uploader et annoter les images

Cliquez sur Upload dans le menu de gauche, glissez-déposez les vingt à cinquante images depuis l’explorateur de fichiers. Roboflow accepte les JPEG, PNG, BMP, TIFF, WEBP. Pour des images de plus de 1920 px de côté, l’outil propose un redimensionnement automatique à l’upload — accepter, cela accélère l’annotation et réduit la taille du dataset sans perte de précision pour YOLO.

Une fois l’upload terminé, cliquez « Save and Continue », puis « Assign to me » pour démarrer l’annotation. L’interface d’annotation affiche une image à la fois ; tracez une boîte englobante autour de chaque objet à détecter en cliquant-glissant, puis sélectionnez la classe correspondante dans la liste à droite. Raccourcis utiles : Tab pour aller à l’image suivante, D pour dupliquer la dernière classe, Suppr pour effacer une boîte sélectionnée.

Conseil pratique : annotez d’abord cinq images de chaque classe puis arrêtez-vous. Lancez un premier entraînement avec ces 15-20 images, regardez les erreurs, et utilisez le mode Active Learning de Roboflow qui propose les images sur lesquelles le modèle hésite le plus. Cela coûte moins de temps qu’annoter d’un coup tout le lot, pour une qualité finale supérieure.

Une fois l’annotation terminée, vous voyez le compteur passer à 20/20 annotées dans le menu Annotate. Cliquez ensuite sur « Add Images to Dataset » en haut à droite. Roboflow propose une partition par défaut 70/20/10 (train/val/test). Acceptez-la pour un premier projet — vous reviendrez sur ce choix si nécessaire.

Étape 3 — Générer une version avec augmentations

L’étape Versions est ce qui rend Roboflow plus qu’un simple outil d’annotation. Elle fige un snapshot du dataset, applique des augmentations à la volée, et permet de re-télécharger exactement le même set des mois plus tard. Cliquez sur Versions puis « Create New Version ». La page liste plusieurs étapes optionnelles : preprocessing (resize, grayscale), augmentations (rotation, flip, blur, noise, hue, brightness, mosaic), partition.

Pour un premier essai, accepter le resize automatique à 640×640 (taille native YOLO v11), activer trois augmentations modérées — Horizontal Flip (sauf si vos classes sont sensibles au sens, par exemple texte), Brightness ±15%, Blur jusqu’à 1,5 px — puis cliquer « Generate ». Roboflow va générer trois variantes par image source, ce qui multiplie par trois le dataset effectif vu par le modèle pendant l’entraînement.

Le bouton « Generate » lance le traitement (quelques secondes pour vingt images). À la fin, la version est créée et accessible dans le menu Versions avec un identifiant numérique.

Étape 4 — Télécharger le dataset depuis le notebook d’entraînement

Plutôt que de cliquer pour télécharger un ZIP, on script le téléchargement avec l’API Python officielle. Cela garantit la reproductibilité et permet de regénérer un dataset avec une seule commande lors d’une réexécution du pipeline. Récupérez d’abord votre clé API privée : cliquez sur l’icône Settings en bas à gauche, puis API. Copiez la valeur de « Private API Key » et stockez-la dans une variable d’environnement (jamais en dur dans le code) :

# Linux / macOS
export ROBOFLOW_API_KEY="votre_cle_ici"

# Windows PowerShell
$env:ROBOFLOW_API_KEY="votre_cle_ici"

Installez ensuite le SDK Roboflow dans le même environnement virtuel que YOLO :

pip install roboflow

Puis téléchargez la version souhaitée. Le code suivant va dans un fichier download_dataset.py à la racine du projet :

import os
from roboflow import Roboflow

rf = Roboflow(api_key=os.environ["ROBOFLOW_API_KEY"])
project = rf.workspace("votre-workspace").project("panneaux-test")
dataset = project.version(1).download("yolov11")
print("Dataset téléchargé dans :", dataset.location)

Lancer python download_dataset.py. La sortie attendue affiche une barre de progression de téléchargement puis « Dataset téléchargé dans : ./panneaux-test-1 ». Le répertoire généré contient les sous-dossiers train/, valid/, test/ avec images et labels au format YOLO, ainsi qu’un fichier data.yaml qui décrit les classes — exactement ce que model.train attend en entrée.

Étape 5 — Lancer le premier entraînement

Avec le dataset prêt et YOLO v11 installé, l’entraînement tient en quatre lignes Python. Créez un fichier train.py :

from ultralytics import YOLO

# On part des poids COCO pré-entraînés pour bénéficier du transfert d'apprentissage
model = YOLO("yolo11s.pt")

# 100 époques, taille d'image 640, batch automatique, AMP par défaut
results = model.train(
    data="./panneaux-test-1/data.yaml",
    epochs=100,
    imgsz=640,
    batch=16,
    device=0,
    project="runs/train",
    name="panneaux-v1"
)

Lancez python train.py. Sur une RTX 3060 12 Go avec un dataset de 20 images annotées, l’entraînement prend environ 8 minutes. La sortie défile à chaque époque avec les métriques en cours : box_loss, cls_loss, dfl_loss qui doivent descendre, et P, R, mAP50, mAP50-95 qui doivent monter. À la fin, Ultralytics imprime un résumé et sauvegarde les poids finaux dans runs/train/panneaux-v1/weights/best.pt (meilleurs poids selon la mAP de validation) et last.pt (derniers poids quel que soit leur score).

Si le mAP50 final dépasse 0,8 sur un dataset de 20 images, c’est probablement du sur-apprentissage — le modèle a mémorisé les images de validation par chance. Sur un dataset si petit, viser une mAP50 entre 0,4 et 0,7 est plus réaliste, et la vraie mesure viendra avec plus d’images.

Étape 6 — Évaluer le modèle et inspecter les erreurs

L’entraînement seul ne dit pas grand-chose ; ce qui compte, c’est la matrice de confusion et les images mal détectées. Ultralytics génère ces artéfacts automatiquement. Allez dans runs/train/panneaux-v1/ et ouvrez confusion_matrix.png — la diagonale doit être nettement plus chargée que les autres cellules. Ouvrez aussi val_batch0_pred.jpg pour visualiser les prédictions sur le jeu de validation : les boîtes en couleur correspondent aux détections du modèle, comparez-les visuellement aux vraies annotations dans val_batch0_labels.jpg.

Pour évaluer formellement sur le jeu de validation :

from ultralytics import YOLO
model = YOLO("runs/train/panneaux-v1/weights/best.pt")
metrics = model.val(data="./panneaux-test-1/data.yaml")
print("mAP50:", metrics.box.map50, " mAP50-95:", metrics.box.map)

La sortie affiche les métriques par classe et la moyenne globale. Si une classe a un mAP très bas (par exemple 0,2 alors que les autres sont à 0,7), c’est un signal pour ajouter des images de cette classe à Roboflow et regénérer une version 2.

Erreurs fréquentes

Tutoriels associés

• Fine-tuning YOLO v11 sur un dataset métier — pour pousser la mAP au-delà du premier essai.
• Exporter YOLO v11 en ONNX et TensorRT — pour le déploiement.

Pour aller plus loin

• 🔝 Retour à la vue d’ensemble : Pipeline YOLO v11 + Ultralytics + Roboflow
• Documentation training Ultralytics : docs.ultralytics.com/modes/train
• Roboflow Python SDK : docs.roboflow.com/api-reference/python-package
• Roboflow Universe : universe.roboflow.com

Une fois ce premier entraînement validé, la suite consiste soit à pousser la précision via le fine-tuning ciblé, soit à exporter le modèle vers la cible de déploiement.