YOLOE : Voir n'importe quoi en temps réel

Introduction

YOLOE (Real-Time Seeing Anything) est une nouvelle avancée dans les modèles YOLO zero-shot et pilotables par prompt, conçue pour la détection et la segmentation à vocabulaire ouvert. Contrairement aux modèles YOLO précédents limités à des catégories fixes, YOLOE utilise des prompts textuels, imagés ou un vocabulaire interne, permettant la détection en temps réel de n'importe quelle classe d'objets. Construit sur YOLOv10 et inspiré par YOLO-World, YOLOE atteint des performances zero-shot de pointe avec un impact minimal sur la vitesse et la précision.

Par rapport aux anciens modèles YOLO, YOLOE améliore considérablement l'efficacité et la précision. Il progresse de +3,5 AP par rapport à YOLO-Worldv2 sur LVIS tout en utilisant seulement un tiers des ressources d'entraînement et en atteignant une vitesse d'inférence 1,4× plus rapide. Fine-tuné sur COCO, YOLOE-v8-large surpasse YOLOv8-L de 0,1 mAP, en utilisant près de 4× moins de temps d'entraînement. Cela démontre l'équilibre exceptionnel de YOLOE en termes de précision, d'efficacité et de polyvalence. Les sections ci-dessous explorent l'architecture de YOLOE, les comparaisons de benchmarks et l'intégration avec le framework Ultralytics.

Aperçu de l'architecture

YOLOE conserve la structure standard YOLO : un backbone convolutionnel (par ex. CSP-Darknet) pour l'extraction de caractéristiques, un neck (par ex. PAN-FPN) pour la fusion multi-échelle, et une head de détection découplée et sans ancres (comme dans YOLOv8/YOLO11) prédisant indépendamment l'objectness, les classes et les boîtes. YOLOE introduit trois nouveaux modules permettant la détection à vocabulaire ouvert :

• Re-parameterizable Region-Text Alignment (RepRTA) : Prend en charge la détection par prompt textuel en affinant les embeddings de texte (par ex. depuis CLIP) via un petit réseau auxiliaire. À l'inférence, ce réseau est intégré au modèle principal, garantissant une surcharge nulle. YOLOE détecte ainsi des objets étiquetés par texte arbitraire (par ex. "feu de circulation" non vu) sans pénalités à l'exécution.

• Semantic-Activated Visual Prompt Encoder (SAVPE) : Permet la détection par prompt visuel via une branche d'embedding légère. Étant donné une image de référence, SAVPE encode les caractéristiques sémantiques et d'activation, conditionnant le modèle à détecter des objets visuellement similaires — une capacité de détection one-shot utile pour les logos ou des parties spécifiques.

• Lazy Region-Prompt Contrast (LRPC) : En mode sans prompt, YOLOE effectue une reconnaissance en ensemble ouvert en utilisant des embeddings internes entraînés sur de vastes vocabulaires (1200+ catégories de LVIS et Objects365). Sans prompts ou encodeurs externes, YOLOE identifie les objets via une recherche de similarité d'embeddings, gérant efficacement de vastes espaces d'étiquettes à l'inférence.

De plus, YOLOE intègre la segmentation d'instance en temps réel en étendant la head de détection avec une branche de prédiction de masque (similaire à YOLACT ou YOLOv8-Seg), ajoutant une surcharge minimale.

Surtout, les modules open-world de YOLOE n'introduisent aucun coût d'inférence lorsqu'ils sont utilisés comme un YOLO classique en ensemble fermé. Après l'entraînement, les paramètres de YOLOE peuvent être re-paramétrés dans une head YOLO standard, préservant des FLOPs et une vitesse identiques (par ex. correspondant exactement à YOLO11).

Modèles disponibles, tâches prises en charge et modes de fonctionnement

Cette section détaille les modèles disponibles avec leurs poids pré-entraînés spécifiques, les tâches qu'ils prennent en charge et leur compatibilité avec divers modes opérationnels tels que Inférence, Validation, Entraînement et Exportation, notés par ✅ pour les modes pris en charge et ❌ pour les modes non pris en charge.

Modèles avec Prompts Textuels/Visuels

Modèles sans Prompt

Exemples d'utilisation

Les modèles YOLOE sont faciles à intégrer dans tes applications Python. Ultralytics fournit une Python API et des commandes CLI conviviales pour simplifier le développement.

Utilisation pour l'entraînement

Fine-tuning sur un dataset personnalisé

Tu peux fine-tuner n'importe quel modèle YOLOE pré-entraîné sur ton dataset YOLO personnalisé pour des tâches de détection et de segmentation d'instance.

from ultralytics import YOLOE
from ultralytics.models.yolo.yoloe import YOLOEPESegTrainer

model = YOLOE("yoloe-26s-seg.pt")

# Fine-tune on your segmentation dataset
results = model.train(
    data="coco128-seg.yaml",  # Segmentation dataset
    epochs=80,
    patience=10,
    trainer=YOLOEPESegTrainer,  # <- Important: use segmentation trainer
)

from ultralytics import YOLOE
from ultralytics.models.yolo.yoloe import YOLOEPETrainer

# Initialize a detection model from a config
model = YOLOE("yoloe-26s.yaml")

# Load weights from a pretrained segmentation checkpoint (same scale)
model.load("yoloe-26s-seg.pt")

# Fine-tune on your detection dataset
results = model.train(
    data="coco128.yaml",  # Detection dataset
    epochs=80,
    patience=10,
    trainer=YOLOEPETrainer,  # <- Important: use detection trainer
)

Utilisation de la prédiction

YOLOE prend en charge le prompting textuel et visuel. L'utilisation des prompts est simple — passe-les simplement via la méthode predict comme illustré ci-dessous :

from ultralytics import YOLOE

# Initialize a YOLOE model
model = YOLOE("yoloe-26l-seg.pt")  # or yoloe-26s/m-seg.pt for different sizes

# Set text prompt to detect person and bus. You only need to do this once after you load the model.
model.set_classes(["person", "bus"])

# Run detection on the given image
results = model.predict("path/to/image.jpg")

# Show results
results[0].show()

Utilisation de la validation

La validation du modèle sur un jeu de données est simplifiée comme suit :

from ultralytics import YOLOE

# Create a YOLOE model
model = YOLOE("yoloe-26l-seg.pt")  # or yoloe-26s/m-seg.pt for different sizes

# Conduct model validation on the COCO128-seg example dataset
metrics = model.val(data="coco128-seg.yaml")

Utilisation de l'exportation

Le processus d'exportation est similaire aux autres modèles YOLO, avec la flexibilité ajoutée de gérer les prompts textuels et visuels :

from ultralytics import YOLOE

# Select yoloe-26s/m-seg.pt for different sizes
model = YOLOE("yoloe-26l-seg.pt")

# Configure the set_classes() before exporting the model
model.set_classes(["person", "bus"])

export_model = model.export(format="onnx")
model = YOLOE(export_model)

# Run detection on the given image
results = model.predict("path/to/image.jpg")

# Show results
results[0].show()

Entraîner des modèles officiels

Préparer les jeux de données

• Données d'entraînement

• Données de validation

Lancer l'entraînement à partir de zéro

from ultralytics import YOLOE
from ultralytics.models.yolo.yoloe import YOLOESegTrainerFromScratch

# Option 1: Use Python dictionary
data = dict(
    train=dict(
        yolo_data=["Objects365.yaml"],
        grounding_data=[
            dict(
                img_path="flickr/full_images/",
                json_file="flickr/annotations/final_flickr_separateGT_train_segm.json",
            ),
            dict(
                img_path="mixed_grounding/gqa/images",
                json_file="mixed_grounding/annotations/final_mixed_train_no_coco_segm.json",
            ),
        ],
    ),
    val=dict(yolo_data=["lvis.yaml"]),
)

# Option 2: Use YAML file (yoloe_data.yaml)
# train:
#   yolo_data:
#     - Objects365.yaml
#   grounding_data:
#     - img_path: flickr/full_images/
#       json_file: flickr/annotations/final_flickr_separateGT_train_segm.json
#     - img_path: mixed_grounding/gqa/images
#       json_file: mixed_grounding/annotations/final_mixed_train_no_coco_segm.json
# val:
#   yolo_data:
#     - lvis.yaml

model = YOLOE("yoloe-26l-seg.yaml")
model.train(
    data=data,  # or data="yoloe_data.yaml" if using YAML file
    batch=128,
    epochs=30,
    close_mosaic=2,
    optimizer="AdamW",
    lr0=2e-3,
    warmup_bias_lr=0.0,
    weight_decay=0.025,
    momentum=0.9,
    workers=4,
    trainer=YOLOESegTrainerFromScratch,
    device="0,1,2,3,4,5,6,7",
)

Comparaison des performances de YOLOE

YOLOE égale ou surpasse la précision des modèles YOLO à classes fermées sur des benchmarks standards comme COCO et LVIS, sans compromettre la vitesse ou la taille du modèle. Le tableau ci-dessous compare YOLOE-L (basé sur YOLO11) et YOLOE26-L (basé sur YOLO26) aux modèles à classes fermées correspondants :

^† YOLOE-L partage l'architecture de YOLO11-L et YOLOE26-L partage celle de YOLO26-L, ce qui se traduit par une vitesse d'inférence et un nombre de GFLOPs similaires.

YOLOE26-L atteint 36,8 % de mAP sur LVIS avec 32,3 M de paramètres et 88,3 B de FLOPs, traitant des images de 640×640 à 6,2 ms (161 FPS) sur un GPU T4. Cela représente une amélioration par rapport aux 35,2 % de mAP sur LVIS de YOLOE-L tout en maintenant la même vitesse d'inférence. Plus important encore, les modules à vocabulaire ouvert de YOLOE n'induisent aucun coût d'inférence, illustrant une conception « sans compromis de performance ».

Pour les tâches zero-shot, YOLOE26 surpasse nettement les détecteurs à vocabulaire ouvert précédents : sur LVIS, YOLOE26-S atteint 29,9 % de mAP, dépassant YOLO-World-S de +11,4 AP, tandis que YOLOE26-L atteint 36,8 % de mAP, dépassant YOLO-World-L de +10,0 AP. YOLOE26 maintient une inférence efficace à 161 FPS sur un GPU T4, idéal pour les applications en temps réel à vocabulaire ouvert.

Comparaison avec les modèles précédents

YOLOE introduit des avancées notables par rapport aux modèles YOLO et détecteurs à vocabulaire ouvert antérieurs :

• YOLOE vs YOLOv5 : YOLOv5 offrait un bon équilibre entre vitesse et précision, mais nécessitait un ré-entraînement pour les nouvelles classes et utilisait des têtes basées sur des ancres. À l'inverse, YOLOE est sans ancres et détecte dynamiquement de nouvelles classes. S'appuyant sur les améliorations de YOLOv8, YOLOE atteint une meilleure précision (52,6 % contre ~50 % de mAP pour YOLOv5 sur COCO) et intègre la segmentation d'instance, contrairement à YOLOv5.

• YOLOE vs YOLOv8 : YOLOE étend l'architecture redessinée de YOLOv8, atteignant une précision similaire ou supérieure (52,6 % de mAP avec ~26 M de paramètres contre 52,9 % avec ~44 M de paramètres pour YOLOv8-L). Il réduit significativement le temps d'entraînement grâce à un pré-entraînement plus robuste. L'avancée majeure est la capacité en monde ouvert de YOLOE, détectant des objets non vus (par exemple, une « trottinette électrique » ou un « symbole de paix ») via des prompts, contrairement à la conception à classes fermées de YOLOv8.

• YOLOE vs YOLO11 : YOLO11 améliore YOLOv8 avec une efficacité accrue et moins de paramètres (réduction de ~22 %). YOLOE hérite directement de ces gains, égalant la vitesse d'inférence et le nombre de paramètres de YOLO11 (~26 M de paramètres), tout en ajoutant la détection et la segmentation à vocabulaire ouvert. Dans les scénarios à classes fermées, YOLOE est équivalent à YOLO11, mais il ajoute surtout une adaptabilité permettant de détecter des classes inédites, atteignant les performances de YOLO11 + une capacité en monde ouvert sans compromettre la vitesse.

• YOLOE26 vs YOLOE (basé sur YOLO11) : YOLOE26 s'appuie sur l'architecture de YOLO26, héritant de sa conception de bout en bout sans NMS pour une inférence plus rapide. Sur LVIS, YOLOE26-L atteint 36,8 % de mAP, surpassant les 35,2 % de mAP de YOLOE-L. YOLOE26 propose les cinq échelles de modèles (N/S/M/L/X) par rapport aux trois de YOLOE (S/M/L), offrant plus de flexibilité pour différents scénarios de déploiement.

• YOLOE26 vs détecteurs à vocabulaire ouvert précédents : Les anciens modèles à vocabulaire ouvert (GLIP, OWL-ViT, YOLO-World) dépendaient fortement des transformers vision-langage, ce qui ralentissait l'inférence. Sur LVIS, YOLOE26-S atteint 29,9 % de mAP (+11,4 AP par rapport à YOLO-World-S) et YOLOE26-L atteint 36,8 % de mAP (+10,0 AP par rapport à YOLO-World-L), tout en maintenant une inférence en temps réel à 161 FPS sur un GPU T4. Comparé aux approches basées sur des transformers (ex. GLIP), YOLOE26 offre une inférence nettement plus rapide, comblant efficacement l'écart entre précision et efficacité dans la détection en classes ouvertes.

En résumé, YOLOE et YOLOE26 conservent la vitesse et l'efficacité renommées de YOLO, surpassent leurs prédécesseurs en précision, intègrent la segmentation et introduisent une puissante détection en monde ouvert. YOLOE26 fait progresser l'architecture avec une inférence de bout en bout sans NMS issue de YOLO26, ce qui le rend idéal pour les applications temps réel à vocabulaire ouvert.

Cas d'utilisation et applications

La détection et la segmentation à vocabulaire ouvert de YOLOE permettent diverses applications au-delà des modèles traditionnels à classes fixes :

• Détection d'objets en monde ouvert : Idéal pour les scénarios dynamiques comme la robotique, où les robots reconnaissent des objets jamais vus auparavant à l'aide de prompts, ou les systèmes de sécurité qui s'adaptent rapidement aux nouvelles menaces (par exemple, des objets dangereux) sans ré-entraînement.

• Détection Few-Shot et One-Shot : En utilisant des prompts visuels (SAVPE), YOLOE apprend rapidement de nouveaux objets à partir d'images de référence uniques—parfait pour l'inspection industrielle (identifier des pièces ou des défauts instantanément) ou la surveillance personnalisée, permettant des recherches visuelles avec une configuration minimale.

• Reconnaissance à large vocabulaire et longue traîne : Doté d'un vocabulaire de plus de 1000 classes, YOLOE excelle dans des tâches comme le suivi de la biodiversité (détection d'espèces rares), les collections de musées, l'inventaire de détail, ou l'e-commerce, identifiant de manière fiable de nombreuses classes sans entraînement intensif par classe.

• Détection et segmentation interactives : YOLOE prend en charge des applications interactives en temps réel telles que la recherche vidéo/image, la réalité augmentée (AR) et l'édition d'image intuitive, pilotées par des entrées naturelles (textes ou prompts visuels). Les utilisateurs peuvent isoler, identifier ou éditer dynamiquement des objets avec précision grâce aux masques de segmentation.

• Étiquetage automatique de données et bootstrapping : YOLOE facilite la création rapide de datasets en fournissant des annotations initiales de boîtes englobantes et de segmentation, réduisant significativement les efforts d'étiquetage humain. Particulièrement précieux pour l'analyse de grandes collections multimédias, où il peut identifier automatiquement les objets présents, aidant à construire des modèles spécialisés plus rapidement.

• Segmentation pour tout objet : Étend les capacités de segmentation à des objets arbitraires grâce à des prompts—particulièrement bénéfique pour l'imagerie médicale, la microscopie ou l'analyse d'imagerie satellite, en identifiant et segmentant automatiquement des structures sans modèles pré-entraînés spécialisés. Contrairement aux modèles comme SAM, YOLOE reconnaît et segmente simultanément les objets automatiquement, facilitant des tâches comme la création de contenu ou la compréhension de scène.

Dans tous ces cas d'utilisation, l'avantage principal de YOLOE est sa polyvalence, offrant un modèle unifié pour la détection, la reconnaissance et la segmentation dans des scénarios dynamiques. Son efficacité assure des performances en temps réel sur des appareils aux ressources limitées, idéal pour la robotique, la conduite autonome, la défense et bien plus encore.

Entraînement et inférence

YOLOE s'intègre parfaitement avec l'API Python Ultralytics et la CLI, tout comme les autres modèles YOLO (YOLOv8, YOLO-World). Voici comment démarrer rapidement :

from ultralytics import YOLO

# Load pretrained YOLOE model and train on custom data
model = YOLO("yoloe-26s-seg.pt")
model.train(data="path/to/data.yaml", epochs=50, imgsz=640)

# Run inference using text prompts ("person", "bus")
model.set_classes(["person", "bus"])
results = model.predict(source="test_images/street.jpg")
results[0].save()  # save annotated output

Autres tâches prises en charge

• Validation : Évalue facilement la précision avec model.val() ou yolo val.
• Exportation : Exporte les modèles YOLOE (model.export()) vers ONNX, TensorRT, etc., facilitant le déploiement.
• Suivi (Tracking) : YOLOE prend en charge le suivi d'objets (yolo track) lorsqu'il est intégré, utile pour suivre des classes avec prompts dans des vidéos.

Démarrage rapide

Configure rapidement YOLOE avec Ultralytics en suivant ces étapes :

1. Installation : Installe ou mets à jour le package Ultralytics :

   pip install -U ultralytics

2. Téléchargement des poids YOLOE : Les modèles YOLOE pré-entraînés (ex. YOLOE-v8-S/L, variantes YOLOE-11) sont disponibles dans les releases GitHub de YOLOE. Télécharge simplement le fichier .pt souhaité pour le charger dans la classe YOLO d'Ultralytics.

3. Configuration matérielle requise :

   • Inférence : GPU recommandé (NVIDIA avec ≥4-8 Go de VRAM). Les petits modèles fonctionnent efficacement sur les GPU Edge (ex. Jetson) ou les CPU à des résolutions inférieures. Pour une inférence haute performance sur des stations de travail compactes, consulte notre guide NVIDIA DGX Spark.
   • Entraînement : L'affinage de YOLOE sur des données personnalisées nécessite généralement un seul GPU. Le pré-entraînement approfondi à vocabulaire ouvert (LVIS/Objects365) utilisé par les auteurs a nécessité une puissance de calcul importante (8× GPU RTX 4090).

4. Configuration : Les configurations YOLOE utilisent des fichiers YAML Ultralytics standard. Les configurations par défaut (ex. yoloe-26s-seg.yaml) suffisent généralement, mais tu peux modifier le backbone, les classes ou la taille de l'image selon tes besoins.

5. Exécution de YOLOE :

   • Inférence rapide (sans prompt) :

     yolo predict model=yoloe-26s-seg-pf.pt source="image.jpg"

   • Détection avec prompts (exemple de prompt textuel) :

     from ultralytics import YOLO
     
     model = YOLO("yoloe-26s-seg.pt")
     model.set_classes(["bowl", "apple"])
     results = model.predict("kitchen.jpg")
     results[0].save()

6. Conseils d'intégration :

   • Noms de classes : Les sorties YOLOE par défaut utilisent les catégories LVIS ; utilise set_classes() pour spécifier tes propres étiquettes.
   • Vitesse : YOLOE n'a aucun surcoût, sauf en cas d'utilisation de prompts. Les prompts textuels ont un impact minimal ; les prompts visuels un peu plus.
   • Comportement NMS : YOLOE utilise automatiquement agnostic_nms=True pendant la prédiction, fusionnant les boîtes qui se chevauchent entre les classes. Cela empêche les détections en double lorsque le même objet correspond à plusieurs catégories dans le large vocabulaire de YOLOE (plus de 1200 classes LVIS). Tu peux outrepasser cela en passant agnostic_nms=False explicitement.
   • Inférence par lot : Prise en charge directement (model.predict([img1, img2])). Pour des prompts spécifiques à chaque image, traite les images individuellement.

La documentation Ultralytics fournit des ressources supplémentaires. YOLOE te permet d'explorer facilement de puissantes capacités en monde ouvert au sein de l'écosystème YOLO familier.

Citations et remerciements

Si YOLOE a contribué à tes recherches ou à ton projet, merci de citer l'article original de Ao Wang, Lihao Liu, Hui Chen, Zijia Lin, Jungong Han et Guiguang Ding de l'Université Tsinghua :

@misc{wang2025yoloerealtimeseeing,
      title={YOLOE: Real-Time Seeing Anything},
      author={Ao Wang and Lihao Liu and Hui Chen and Zijia Lin and Jungong Han and Guiguang Ding},
      year={2025},
      eprint={2503.07465},
      archivePrefix={arXiv},
      primaryClass={cs.CV},
      url={https://arxiv.org/abs/2503.07465},
}

Pour aller plus loin, l'article original sur YOLOE est disponible sur arXiv. Le code source du projet et des ressources supplémentaires sont accessibles via leur dépôt GitHub.

FAQ

En quoi YOLOE diffère-t-il de YOLO-World ?

Bien que YOLOE et YOLO-World permettent la détection à vocabulaire ouvert, YOLOE offre plusieurs avantages. YOLOE atteint une précision supérieure de +3,5 AP sur LVIS tout en utilisant 3× moins de ressources d'entraînement et en étant 1,4× plus rapide que YOLO-Worldv2. YOLOE prend également en charge trois modes de prompts (texte, visuel et vocabulaire interne), tandis que YOLO-World se concentre principalement sur les prompts textuels. De plus, YOLOE inclut des capacités de segmentation d'instance intégrées, fournissant des masques de précision au pixel près pour les objets détectés sans surcoût supplémentaire.

Puis-je utiliser YOLOE comme un modèle YOLO standard ?

Oui, YOLOE peut fonctionner exactement comme un modèle YOLO standard sans aucune pénalité de performance. Lorsqu'il est utilisé en mode classes fermées (sans prompts), les modules à vocabulaire ouvert de YOLOE sont reparamétrés dans la tête de détection standard, ce qui donne une vitesse et une précision identiques aux modèles YOLO11 équivalents. Cela rend YOLOE extrêmement polyvalent : tu peux l'utiliser comme un détecteur traditionnel pour une vitesse maximale, puis passer au mode vocabulaire ouvert uniquement lorsque nécessaire.

Quels types de prompts puis-je utiliser avec YOLOE ?

YOLOE prend en charge trois types de prompts :

1. Prompts textuels : Spécifie les classes d'objets en utilisant le langage naturel (ex. « personne », « feu de signalisation », « trottinette »)
2. Prompts visuels : Fournis des images de référence des objets que tu souhaites détecter
3. Vocabulaire interne : Utilise le vocabulaire intégré de YOLOE de plus de 1200 catégories sans prompts externes

Cette flexibilité te permet d'adapter YOLOE à divers scénarios sans ré-entraîner le modèle, ce qui le rend particulièrement utile pour les environnements dynamiques où les besoins de détection changent fréquemment.

Comment YOLOE gère-t-il la segmentation d'instance ?

YOLOE intègre la segmentation d'instance directement dans son architecture en étendant la tête de détection avec une branche de prédiction de masques. Cette approche est similaire à YOLOv8-Seg mais fonctionne pour toute classe d'objet avec prompt. Les masques de segmentation sont automatiquement inclus dans les résultats d'inférence et sont accessibles via results[0].masks. Cette approche unifiée élimine le besoin de modèles de détection et de segmentation séparés, rationalisant les flux de travail pour les applications nécessitant des contours d'objets précis au pixel près.

Comment YOLOE gère-t-il l'inférence avec des prompts personnalisés ?

Similaire à YOLO-World, YOLOE prend en charge une stratégie de « prompt-puis-détecte » qui utilise un vocabulaire hors ligne pour améliorer l'efficacité. Les prompts personnalisés comme des légendes ou des catégories d'objets spécifiques sont pré-encodés et stockés sous forme d'embeddings de vocabulaire hors ligne. Cette approche simplifie le processus de détection sans nécessiter de ré-entraînement. Tu peux définir dynamiquement ces prompts au sein du modèle pour l'adapter à des tâches de détection spécifiques :

from ultralytics import YOLO

# Initialize a YOLOE model
model = YOLO("yoloe-26s-seg.pt")

# Define custom classes
model.set_classes(["person", "bus"])

# Execute prediction on an image
results = model.predict("path/to/image.jpg")

# Show results
results[0].show()