Link to this sectionYOLOE : voir tout en temps réel#

Link to this sectionIntroduction#

YOLOE (Real-Time Seeing Anything) est une nouvelle avancée dans les modèles YOLO zero-shot et promptables, 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'objet. 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.

Comparé aux modèles YOLO antérieurs, 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 des vitesses d'inférence 1,4× plus rapides. Ajusté 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.

Link to this sectionVue d'ensemble de l'architecture#

YOLOE conserve la structure standard de YOLO : un backbone convolutif (par ex. CSP-Darknet) pour l'extraction de caractéristiques, un neck (par ex. PAN-FPN) pour la fusion multi-échelle, et une tête de détection sans ancres, découplée (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. issus de CLIP) via un petit réseau auxiliaire. Lors de 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 n'importe quel texte (par ex. "feu de circulation" non vu) sans pénalité de temps d'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 des 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 (open-set) 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 grands espaces d'étiquettes lors de l'inférence.

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

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

Link to this sectionModè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 de fonctionnement tels que l'Inférence, la Validation, l'Entraînement et l'Exportation, signalés par ✅ pour les modes pris en charge et ❌ pour les modes non pris en charge.

Link to this sectionModèles avec prompt texte/visuel#

Link to this sectionModèles sans prompt (Prompt Free)#

Link to this sectionExemples d'utilisation#

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

Link to this sectionUtilisation pour l'entraînement#

Link to this sectionFine-tuning sur un jeu de données personnalisé#

Tu peux effectuer un fine-tuning de n'importe quel modèle YOLOE pré-entraîné sur ton jeu de données YOLO personnalisé pour les 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
)

Link to this sectionUtilisation pour la prédiction#

YOLOE prend en charge à la fois les prompts textuels et visuels. Utiliser 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()

Link to this sectionUtilisation pour 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")

Link to this sectionUtilisation 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()

Link to this sectionEntraîner les modèles officiels#

Link to this sectionPréparer les jeux de données#

• Données d'entraînement

• Données de validation

Link to this sectionLancer 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",
)

Link to this sectionComparaison des performances de YOLOE#

YOLOE égale ou surpasse la précision des modèles YOLO à ensemble fermé sur des benchmarks standard 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 à ensemble fermé correspondants :

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

YOLOE26-L atteint 36,8 % de mAP 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 LVIS de YOLOE-L tout en conservant la même vitesse d'inférence. Surtout, les modules à vocabulaire ouvert de YOLOE n'entraînent aucun coût d'inférence, illustrant une conception "no free lunch trade-off".

Pour les tâches zero-shot, YOLOE26 surpasse considérablement 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 GPU T4, idéale pour les applications à vocabulaire ouvert en temps réel.

Link to this sectionComparaison avec les modèles précédents#

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

• YOLOE vs YOLOv5 : YOLOv5 offrait un bon équilibre vitesse-précision mais nécessitait un réentraînement pour les nouvelles classes et utilisait des têtes basées sur les ancres. À l'inverse, YOLOE est sans ancres (anchor-free) et détecte dynamiquement de nouvelles classes. YOLOE, s'appuyant sur les améliorations de YOLOv8, atteint une précision plus élevée (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 repensé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 fort. L'avancée clé est la capacité en milieu ouvert de YOLOE, détectant des objets inconnus (par ex. "bird scooter" ou "peace symbol") via des prompts, contrairement à la conception à ensemble fermé 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 à ensemble fermé, YOLOE est équivalent à YOLO11, mais ajoute surtout une adaptabilité pour détecter des classes inconnues, atteignant YOLO11 + capacité en milieu 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, une amélioration par rapport aux 35,2 % de mAP de YOLOE-L. YOLOE26 propose les cinq échelles de modèle (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 modèles à vocabulaire ouvert antérieurs (GLIP, OWL-ViT, YOLO-World) reposaient fortement sur des transformers vision-langage, menant à une inférence lente. 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 GPU T4. Comparé aux approches basées sur les transformers (par ex. GLIP), YOLOE26 offre une inférence plusieurs ordres de grandeur plus rapide, comblant efficacement le fossé précision-efficacité en détection en ensemble ouvert.

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

Link to this sectionCas 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 milieu ouvert (Open-World) : Idéal pour les scénarios dynamiques comme la robotique, où les robots reconnaissent des objets précédemment inconnus en utilisant des prompts, ou les systèmes de sécurité s'adaptant rapidement aux nouvelles menaces (par ex. 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 (identification instantanée de pièces ou défauts) ou la surveillance personnalisée, permettant des recherches visuelles avec une configuration minimale.

• Reconnaissance à large vocabulaire et longue traîne : Équipé 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 vente au détail ou le e-commerce, identifiant de manière fiable de nombreuses classes sans entraînement extensif 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 (RA), et l'édition d'image intuitive, pilotée par des entrées naturelles (textuelles ou visuelles). Les utilisateurs peuvent isoler, identifier ou modifier dynamiquement des objets avec précision en utilisant des masques de segmentation.

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

• Segmentation pour tout objet : Étends les capacités de segmentation à des objets arbitraires via des prompts—particulièrement bénéfique pour l'imagerie médicale, la microscopie, ou l'analyse d'imagerie satellite, identifiant et segmentant automatiquement et précisément les structures sans modèles pré-entraînés spécialisés. Contrairement à des modèles comme SAM, YOLOE reconnaît et segmente simultanément les objets automatiquement, aidant dans 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 une performance en temps réel sur des appareils à ressources limitées, idéale pour la robotique, la conduite autonome, la défense, et au-delà.

Link to this sectionEntraînement et inférence#

YOLOE s'intègre de manière transparente avec l'API Python Ultralytics et la CLI, de manière similaire aux 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

Link to this sectionAutres 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 incitées dans les vidéos.

Link to this sectionPour commencer#

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 (par ex. YOLOE-v8-S/L, variantes YOLOE-11) sont disponibles dans les versions 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 (par 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 ne nécessite généralement qu'un seul GPU. Le pré-entraînement extensif à vocabulaire ouvert (LVIS/Objects365) utilisé par les auteurs a nécessité une puissance de calcul substantielle (8× GPU RTX 4090).

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

5. Exécution de YOLOE :

   • Inférence rapide (sans prompt) :

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

   • Détection avec prompt (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 classe : Les sorties par défaut de YOLOE utilisent les catégories LVIS ; utilise set_classes() pour spécifier tes propres étiquettes.
   • Vitesse : YOLOE n'a pas de surcoût sauf si tu utilises des 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 (batch) : Prise en charge directement (model.predict([img1, img2])). Pour des prompts spécifiques à une image, exécute les images individuellement.

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

Link to this sectionCitations et remerciements#

Si YOLOE a contribué à ta recherche ou projet, merci de citer l'article original par 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 plus de lecture, l'article original de YOLOE est disponible sur arXiv. Le code source du projet et des ressources supplémentaires sont accessibles via leur référentiel GitHub.

Link to this sectionFAQ#

Link to this sectionEn quoi YOLOE diffère-t-il de YOLO-World ?#

Bien que YOLOE et YOLO-World permettent tous deux la détection à vocabulaire ouvert, YOLOE offre plusieurs avantages. YOLOE atteint une précision +3,5 AP plus élevée sur LVIS tout en utilisant 3 fois moins de ressources d'entraînement et en étant 1,4 fois plus rapide que YOLO-Worldv2. YOLOE prend également en charge trois modes de prompting (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 précis au pixel près pour les objets détectés sans surcoût additionnel.

Link to this sectionPuis-je utiliser YOLOE comme un modèle YOLO standard ?#

Oui, YOLOE peut fonctionner exactement comme un modèle YOLO standard sans pénalité de performance. Lorsqu'il est utilisé en mode ensemble fermé (sans prompts), les modules à vocabulaire ouvert de YOLOE sont reparamétrés dans la tête de détection standard, résultant en 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 basculer vers le mode vocabulaire ouvert uniquement quand c'est nécessaire.

Link to this sectionQuels 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 (par ex. "person", "traffic light", "bird scooter")
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, le rendant particulièrement utile pour les environnements dynamiques où les besoins de détection changent fréquemment.

Link to this sectionComment 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 masque. Cette approche est similaire à YOLOv8-Seg mais fonctionne pour n'importe quelle classe d'objet sollicitée. 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 distincts, rationalisant ainsi les flux de travail pour les applications nécessitant des contours d'objets précis au pixel près.

Link to this sectionComment YOLOE gère-t-il l'inférence avec des invites personnalisées ?#

Similairement à YOLO-World, YOLOE prend en charge une stratégie de « prompt-then-detect » (inviter puis détecter) qui utilise un vocabulaire hors ligne pour améliorer l'efficacité. Les invites personnalisées comme des légendes ou des catégories d'objets spécifiques sont pré-encodées et stockées en tant qu'embeddings de vocabulaire hors ligne. Cette approche rationalise le processus de détection sans nécessiter de réentraînement. Tu peux définir dynamiquement ces invites dans le 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()