YOLOE : Tout voir en temps réel

Introduction

YOLOE (Real-Time Seeing Anything) est une nouvelle avancée dans les modèles YOLO sans prise de vue et avec invite, conçus pour la détection et la segmentation de vocabulaire ouvert. Contrairement aux modèles YOLO précédents limités à des catégories fixes, YOLOE utilise du texte, des images ou des invites de vocabulaire interne, ce qui permet de détecter en temps réel n'importe quelle classe d'objet. Construit sur la base de YOLOv10 et inspiré par YOLO, YOLOE atteint des performances de pointe en matière d'absence de cliché, avec un impact minimal sur la vitesse et la précision.

Regarder : Comment utiliser YOLOE avec le packagePython Ultralytics : Open Vocabulary & Real-Time Seeing Anything 🚀 (Vocabulaire ouvert et visualisation en temps réel)

Par rapport aux modèles YOLO précédents, YOLOE améliore considérablement l'efficacité et la précision. Il s'améliore de +3,5 AP par rapport à YOLO sur LVIS tout en utilisant seulement un tiers des ressources de formation et en atteignant des vitesses d'inférence 1,4× plus rapides. Affiné sur COCO, YOLOE-v8-large surpasse YOLOv8 de 0,1 mAP, en utilisant près de 4 fois moins de temps d'apprentissage. Cela démontre l'équilibre exceptionnel entre la précision, l'efficacité et la polyvalence de YOLOE. Les sections ci-dessous présentent l'architecture de YOLOE, les comparaisons de points de repère et l'intégration avec le logiciel Ultralytics Ultralytics.

Aperçu de l'architecture

YOLOE conserve la structure standard de YOLO - une colonne vertébrale convolutionnelle (par exemple, CSP-Darknet) pour l'extraction des caractéristiques, un cou (par exemple, PAN-FPN) pour la fusion multi-échelle, et une tête de détection découplée et sans ancrage (comme dans YOLO11) prédisant l'objet, les classes et les boîtes de manière indépendante. YOLOE introduit trois nouveaux modules permettant la détection de vocabulaires ouverts :

• Alignement région-texte re-paramétrable (RepRTA): prend en charge la détection à partir d'un texte en affinant l'intégration du texte (par exemple, à partir de CLIP) par l'intermédiaire d'un petit réseau auxiliaire. Lors de l'inférence, ce réseau est intégré au modèle principal, ce qui permet d'éviter toute surcharge. YOLOE détecte ainsi des objets arbitraires étiquetés dans le texte (par exemple, un "feu de circulation" non vu) sans pénalités d'exécution.

• Encodeur de messages visuels activés par la sémantique (SAVPE) : Permet la détection visuelle par le biais d'une branche d'intégration légère. À partir d'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 en une seule fois utile pour les logos ou les pièces spécifiques.

• Contraste Région-Prompt paresseux (LRPC): En mode sans invite, YOLOE effectue la reconnaissance d'ensembles ouverts à l'aide d'encastrements internes formés sur de vastes vocabulaires (plus de 1200 catégories de LVIS et Objects365). Sans invites ou encodeurs externes, YOLOE identifie les objets par le biais d'une recherche de similarité d'encastrement, gérant efficacement de grands espaces d'étiquettes lors de l'inférence.

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

De manière cruciale, les modules du monde ouvert de YOLOE n' introduisent aucun coût d'inférence lorsqu'ils sont utilisés comme un YOLO classique à ensemble fermé. Après l'entraînement, les paramètres de YOLOE peuvent être re-paramétrés dans une tête YOLO standard, en préservant des FLOPs et une vitesse identiques (par exemple, l'appariement des données de YOLO11 exactement).

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 les différents modes de fonctionnement tels que l'inférence, la validation, l'entraînement et l'exportation, désignés par ✅ pour les modes pris en charge et ❌ pour les modes non pris en charge.

Modèles d'invites textuelles et visuelles

Prompt Modèles gratuits

Exemples d'utilisation

Les modèles YOLOE sont faciles à intégrer dans vos applications Python . Ultralytics fournit une APIPython conviviale et des commandesCLI pour rationaliser le développement.

Utilisation des trains

Ajustement fin sur un ensemble de données personnalisé

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

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

model.train(
    data="coco128-seg.yaml",
    epochs=80,
    close_mosaic=10,
    batch=128,
    optimizer="AdamW",
    lr0=1e-3,
    warmup_bias_lr=0.0,
    weight_decay=0.025,
    momentum=0.9,
    workers=4,
    device="0",
    trainer=YOLOEPESegTrainer,
)

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

model = YOLOE("yoloe-11s-seg.pt")
head_index = len(model.model.model) - 1
freeze = [str(f) for f in range(0, head_index)]
for name, child in model.model.model[-1].named_children():
    if "cv3" not in name:
        freeze.append(f"{head_index}.{name}")

freeze.extend(
    [
        f"{head_index}.cv3.0.0",
        f"{head_index}.cv3.0.1",
        f"{head_index}.cv3.1.0",
        f"{head_index}.cv3.1.1",
        f"{head_index}.cv3.2.0",
        f"{head_index}.cv3.2.1",
    ]
)

model.train(
    data="coco128-seg.yaml",
    epochs=2,
    close_mosaic=0,
    batch=16,
    optimizer="AdamW",
    lr0=1e-3,
    warmup_bias_lr=0.0,
    weight_decay=0.025,
    momentum=0.9,
    workers=4,
    device="0",
    trainer=YOLOEPESegTrainer,
    freeze=freeze,
)

Prévoir l'utilisation

YOLOE supports both text-based and visual prompting. Using prompts is straightforward—just pass them through the predict comme indiqué ci-dessous :

from ultralytics import YOLOE

# Initialize a YOLOE model
model = YOLOE("yoloe-11l-seg.pt")  # or select yoloe-11s/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.
names = ["person", "bus"]
model.set_classes(names, model.get_text_pe(names))

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

# Show results
results[0].show()

import numpy as np

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

# Initialize a YOLOE model
model = YOLOE("yoloe-11l-seg.pt")

# Define visual prompts using bounding boxes and their corresponding class IDs.
# Each box highlights an example of the object you want the model to detect.
visual_prompts = dict(
    bboxes=np.array(
        [
            [221.52, 405.8, 344.98, 857.54],  # Box enclosing person
            [120, 425, 160, 445],  # Box enclosing glasses
        ],
    ),
    cls=np.array(
        [
            0,  # ID to be assigned for person
            1,  # ID to be assigned for glassses
        ]
    ),
)

# Run inference on an image, using the provided visual prompts as guidance
results = model.predict(
    "ultralytics/assets/bus.jpg",
    visual_prompts=visual_prompts,
    predictor=YOLOEVPSegPredictor,
)

# Show results
results[0].show()

import numpy as np

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

# Initialize a YOLOE model
model = YOLOE("yoloe-11l-seg.pt")

# Define visual prompts based on a separate reference image
visual_prompts = dict(
    bboxes=np.array([[221.52, 405.8, 344.98, 857.54]]),  # Box enclosing person
    cls=np.array([0]),  # ID to be assigned for person
)

# Run prediction on a different image, using reference image to guide what to look for
results = model.predict(
    "ultralytics/assets/zidane.jpg",  # Target image for detection
    refer_image="ultralytics/assets/bus.jpg",  # Reference image used to get visual prompts
    visual_prompts=visual_prompts,
    predictor=YOLOEVPSegPredictor,
)

# Show results
results[0].show()

import numpy as np

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

# Initialize a YOLOE model
model = YOLOE("yoloe-11l-seg.pt")

# Define visual prompts using bounding boxes and their corresponding class IDs.
# Each box highlights an example of the object you want the model to detect.
visual_prompts = dict(
    bboxes=[
        np.array(
            [
                [221.52, 405.8, 344.98, 857.54],  # Box enclosing person
                [120, 425, 160, 445],  # Box enclosing glasses
            ],
        ),
        np.array([[150, 200, 1150, 700]]),
    ],
    cls=[
        np.array(
            [
                0,  # ID to be assigned for person
                1,  # ID to be assigned for glasses
            ]
        ),
        np.array([0]),
    ],
)

# Run inference on multiple image, using the provided visual prompts as guidance
results = model.predict(
    ["ultralytics/assets/bus.jpg", "ultralytics/assets/zidane.jpg"],
    visual_prompts=visual_prompts,
    predictor=YOLOEVPSegPredictor,
)

# Show results
results[0].show()

from ultralytics import YOLOE

# Initialize a YOLOE model
model = YOLOE("yoloe-11l-seg-pf.pt")

# Run prediction. No prompts required.
results = model.predict("path/to/image.jpg")

# Show results
results[0].show()

Utilisation du val

from ultralytics import YOLOE

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

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

from ultralytics import YOLOE

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

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

from ultralytics import YOLOE

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

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

from ultralytics import YOLOE

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

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

La validation d'un modèle sur un ensemble de données est simplifiée comme suit :

Train Modèles officiels

Préparer les ensembles de données

• Données sur les trains

• Données de valeur

Lancer une formation à partir de zéro

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

data = dict(
    train=dict(
        yolo_data=["Objects365.yaml"],
        grounding_data=[
            dict(
                img_path="../datasets/flickr/full_images/",
                json_file="../datasets/flickr/annotations/final_flickr_separateGT_train_segm.json",
            ),
            dict(
                img_path="../datasets/mixed_grounding/gqa/images",
                json_file="../datasets/mixed_grounding/annotations/final_mixed_train_no_coco_segm.json",
            ),
        ],
    ),
    val=dict(yolo_data=["lvis.yaml"]),
)

model = YOLOE("yoloe-11l-seg.yaml")
model.train(
    data=data,
    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",
)

import torch

from ultralytics import YOLOE

det_model = YOLOE("yoloe-11l.yaml")
state = torch.load("yoloe-11l-seg.pt")
det_model.load(state["model"])
det_model.save("yoloe-11l-seg-det.pt")

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

data = dict(
    train=dict(
        yolo_data=["Objects365.yaml"],
        grounding_data=[
            dict(
                img_path="../datasets/flickr/full_images/",
                json_file="../datasets/flickr/annotations/final_flickr_separateGT_train_segm.json",
            ),
            dict(
                img_path="../datasets/mixed_grounding/gqa/images",
                json_file="../datasets/mixed_grounding/annotations/final_mixed_train_no_coco_segm.json",
            ),
        ],
    ),
    val=dict(yolo_data=["lvis.yaml"]),
)

model = YOLOE("yoloe-11l-seg.pt")
# replace to yoloe-11l-seg-det.pt if converted to detection model
# model = YOLOE("yoloe-11l-seg-det.pt")

# freeze every layer except of the savpe module.
head_index = len(model.model.model) - 1
freeze = list(range(0, head_index))
for name, child in model.model.model[-1].named_children():
    if "savpe" not in name:
        freeze.append(f"{head_index}.{name}")

model.train(
    data=data,
    batch=128,
    epochs=2,
    close_mosaic=2,
    optimizer="AdamW",
    lr0=16e-3,
    warmup_bias_lr=0.0,
    weight_decay=0.025,
    momentum=0.9,
    workers=4,
    trainer=YOLOEVPTrainer,
    device="0,1,2,3,4,5,6,7",
    freeze=freeze,
)

from copy import deepcopy

from ultralytics import YOLOE

model = YOLOE("yoloe-11l-seg.yaml")
model.load("yoloe-11l-seg.pt")

vp_model = YOLOE("yoloe-11l-vp.pt")
model.model.model[-1].savpe = deepcopy(vp_model.model.model[-1].savpe)
model.eval()
model.save("yoloe-11l-seg.pt")

import torch

from ultralytics import YOLOE

det_model = YOLOE("yoloe-11l.yaml")
state = torch.load("yoloe-11l-seg.pt")
det_model.load(state["model"])
det_model.save("yoloe-11l-seg-det.pt")

from ultralytics import YOLOE

data = dict(
    train=dict(
        yolo_data=["Objects365.yaml"],
        grounding_data=[
            dict(
                img_path="../datasets/flickr/full_images/",
                json_file="../datasets/flickr/annotations/final_flickr_separateGT_train_segm.json",
            ),
            dict(
                img_path="../datasets/mixed_grounding/gqa/images",
                json_file="../datasets/mixed_grounding/annotations/final_mixed_train_no_coco_segm.json",
            ),
        ],
    ),
    val=dict(yolo_data=["lvis.yaml"]),
)

model = YOLOE("yoloe-11l-seg.pt")
# replace to yoloe-11l-seg-det.pt if converted to detection model
# model = YOLOE("yoloe-11l-seg-det.pt")

# freeze layers.
head_index = len(model.model.model) - 1
freeze = [str(f) for f in range(0, head_index)]
for name, child in model.model.model[-1].named_children():
    if "cv3" not in name:
        freeze.append(f"{head_index}.{name}")

freeze.extend(
    [
        f"{head_index}.cv3.0.0",
        f"{head_index}.cv3.0.1",
        f"{head_index}.cv3.1.0",
        f"{head_index}.cv3.1.1",
        f"{head_index}.cv3.2.0",
        f"{head_index}.cv3.2.1",
    ]
)

model.train(
    data=data,
    batch=128,
    epochs=1,
    close_mosaic=1,
    optimizer="AdamW",
    lr0=2e-3,
    warmup_bias_lr=0.0,
    weight_decay=0.025,
    momentum=0.9,
    workers=4,
    trainer=YOLOEPEFreeTrainer,
    device="0,1,2,3,4,5,6,7",
    freeze=freeze,
    single_cls=True,  # this is needed
)

from copy import deepcopy

from ultralytics import YOLOE

model = YOLOE("yoloe-11l-seg.pt")
model.eval()

pf_model = YOLOE("yoloe-11l-seg-pf.pt")
names = ["object"]
tpe = model.get_text_pe(names)
model.set_classes(names, tpe)
model.model.model[-1].fuse(model.model.pe)

model.model.model[-1].cv3[0][2] = deepcopy(pf_model.model.model[-1].cv3[0][2]).requires_grad_(True)
model.model.model[-1].cv3[1][2] = deepcopy(pf_model.model.model[-1].cv3[1][2]).requires_grad_(True)
model.model.model[-1].cv3[2][2] = deepcopy(pf_model.model.model[-1].cv3[2][2]).requires_grad_(True)
del model.model.pe
model.save("yoloe-11l-seg-pf.pt")

Comparaison des performances de YOLOE

YOLOE atteint ou dépasse la précision des modèles YOLO fermés sur des critères de référence standard tels que COCO, sans compromettre la vitesse ou la taille du modèle. Le tableau ci-dessous compare YOLOE-L (construit sur YOLO11) avec les modèles correspondants de YOLOv8 et YOLO11 :

^† YOLO11 et YOLOE-L ont des architectures identiques (modules prompts désactivés dans YOLO11), ce qui se traduit par une vitesse d'inférence identique et des estimations de GFLOPs similaires.

YOLOE-L atteint 52,6 % de mAP, dépassant YOLOv8(52,9 %) avec environ 40 % de paramètres en moins (26M contre 43,7M). Il traite des images 640×640 en 6,2 ms (161 FPS) contre 9,06 ms (110 FPS) pour YOLOv8, ce qui souligne l'efficacité de YOLO11. Les modules de vocabulaire ouvert de YOLOE n'entraînent aucun coût d'inférence, ce qui démontre qu'il n'y a pas de compromis gratuit.

Pour les tâches de zéro-coup et de transfert, YOLOE excelle : sur LVIS, YOLOE-small améliore YOLO de +3,5 AP en utilisant 3× moins de ressources de formation. Le réglage fin de YOLOE-L de LVIS à COCO a également nécessité 4 fois moins de temps de formation que YOLOv8, ce qui souligne son efficacité et sa capacité d'adaptation. YOLOE conserve la vitesse qui a fait la réputation de YOLO, atteignant plus de 300 FPS sur un GPU T4 et ~64 FPS sur l'iPhone 12 via CoreML, ce qui est idéal pour les déploiements en périphérie et mobiles.

Comparaison avec les modèles précédents

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

• YOLOE vs YOLOv5:
  YOLOv5 offrait un bon équilibre vitesse/précision mais nécessitait un réapprentissage pour les nouvelles classes et utilisait des têtes basées sur des ancres. En revanche, YOLOE est dépourvu d'ancres et détecte dynamiquement les nouvelles classes. YOLOE, s'appuyant sur les améliorations de YOLOv8, atteint une plus grande précision (52,6 % contre ~50 % pour YOLOv5 sur COCO) et intègre la segmentation des instances, contrairement à YOLOv5.

• YOLOE vs YOLOv8:
  YOLOE s'étend YOLOv8et atteint une précision similaire ou supérieure(52,6 % mAP avec ~26 millions de paramètres contre 52,9 % avec ~44 millions de paramètres pour YOLOv8). Il réduit considérablement le temps de formation grâce à un pré-entraînement plus efficace. La principale avancée est la capacité du monde ouvert de YOLOE, qui détecte des objets non vus (par exemple,"bird scooter" ou"peace symbol") à l'aide de messages-guides, contrairement à la conception en plateau fermé de YOLOv8.

• YOLOE vs YOLO11:
  YOLO11 améliore YOLOv8 avec une efficacité accrue et moins de paramètres (~22% de réduction). YOLOE hérite directement de ces gains, en égalant la vitesse d'inférence et le nombre de paramètres de YOLO11(~26M paramètres), tout en ajoutant la détection et la segmentation du vocabulaire ouvert. Dans les scénarios fermés, YOLOE est équivalent à YOLO11, mais ajoute de façon cruciale la capacité d'adaptation pour détecter les classes non vues, réalisant ainsi YOLO11 + la capacité du monde ouvert sans compromettre la vitesse.

• YOLOE par rapport aux précédents détecteurs de vocabulaire ouvert :
  Les modèles de vocabulaire ouvert précédents (GLIP, OWL-ViT, YOLO) s'appuyaient fortement sur des transformateurs vision-langage, ce qui entraînait une inférence lente. YOLOE les surpasse en termes de précision (par exemple, +3,5 AP par rapport à YOLO) tout en fonctionnant 1,4 fois plus vite avec des ressources d'entraînement nettement inférieures. Comparé aux approches basées sur les transformateurs (par exemple, GLIP), YOLOE offre une inférence plus rapide de plusieurs ordres de grandeur, comblant ainsi le fossé entre la précision et l'efficacité dans la détection des ensembles ouverts.

En résumé, YOLOE conserve la rapidité et l'efficacité reconnues de YOLO, surpasse ses prédécesseurs en termes de précision, intègre la segmentation et introduit une puissante détection en monde ouvert, ce qui le rend particulièrement polyvalent et pratique.

Cas d'utilisation et applications

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

• Détection d'objets dans un monde ouvert :
  Idéal pour les scénarios dynamiques tels que la robotique, où les robots reconnaissent des objets inédits à l'aide de messages-guides, ou les systèmes de sécurité qui s'adaptent rapidement aux nouvelles menaces (par exemple, les objets dangereux) sans avoir à se recycler.

• Détection de quelques images et d'une seule image :
  Grâce à des messages visuels (SAVPE), YOLOE apprend rapidement de nouveaux objets à partir d'images de référence uniques, ce qui est parfait pour l'inspection industrielle (identification instantanée des pièces ou des défauts) ou la surveillance personnalisée, permettant des recherches visuelles avec une configuration minimale.

• Vocabulaire étendu et reconnaissance à longue traîne :
  Doté d'un vocabulaire de plus de 1000 classes, YOLOE excelle dans des tâches telles que la surveillance de la biodiversité (détection d'espèces rares), les collections de musées, l'inventaire des magasins de détail ou le commerce électronique, en identifiant de manière fiable de nombreuses classes sans avoir besoin d'une formation approfondie par classe.

• Détection et segmentation interactives :
  YOLOE prend en charge des applications interactives en temps réel telles que la recherche de vidéos ou d'images, la réalité augmentée (RA) et l'édition intuitive d'images, pilotées par des entrées naturelles (texte ou invites visuelles). Les utilisateurs peuvent isoler, identifier ou éditer des objets de manière dynamique et précise à l'aide de masques de segmentation.

• Étiquetage automatisé des données et amorçage :
  YOLOE facilite la création rapide d'ensembles de données en fournissant une boîte de délimitation initiale et des annotations de segmentation, ce qui réduit considérablement les efforts d'étiquetage humain. Il est particulièrement utile pour l'analyse de grandes collections de médias, où il peut identifier automatiquement les objets présents, ce qui permet de construire plus rapidement des modèles spécialisés.

• Segmentation pour n'importe quel objet :
  Étend les capacités de segmentation à des objets arbitraires par le biais d'invites, ce qui est particulièrement utile pour l'imagerie médicale, la microscopie ou l'analyse d'images satellites, en identifiant automatiquement et en segmentant avec précision les structures sans modèle spécialisé préformé. Contrairement aux modèles tels que SAMYOLOE reconnaît et segmente simultanément les objets de manière automatique, ce qui facilite la création de contenu ou la compréhension des scènes.

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

Formation et inférence

YOLOE s'intègre parfaitement à l'APIPython d 'Ultralytics et à son CLIYOLO s'intègre parfaitement à l'API Python et à la CLI d'Ultralytics, comme les autres modèles YOLO YOLOv8, YOLO). Voici comment démarrer rapidement :

from ultralytics import YOLO

# Load pre-trained YOLOE model and train on custom data
model = YOLO("yoloe-11s-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

# Training YOLOE on custom dataset
yolo train model=yoloe-11s-seg.pt data=path/to/data.yaml epochs=50 imgsz=640

# Inference with text prompts
yolo predict model=yoloe-11s-seg.pt source="test_images/street.jpg" classes="person,bus"

Autres tâches prises en charge

• Validation : Évaluez facilement la précision avec model.val() ou yolo val.
• Exporter : Exporter les modèles YOLOE (model.export()) à ONNX, TensorRT, etc., ce qui facilite le déploiement.
• Suivi : YOLOE prend en charge le suivi des objets (yolo track) lorsqu'il est intégré, ce qui est utile pour suivre les classes invitées dans les vidéos.

Pour commencer

Configurez rapidement YOLOE avec Ultralytics en suivant les étapes suivantes :

1. Installation: Installer ou mettre à jour le paquet Ultralytics :

   pip install -U ultralytics
   

2. Télécharger les poids YOLOE: Les modèles YOLOE pré-entraînés (par exemple, YOLOE-v8-S/L, YOLOE-11 variantes) sont disponibles à partir des versions GitHub de YOLOE. Il suffit de télécharger le modèle .pt à charger dans la classeYOLO d'Ultralytics .

3. Exigences matérielles:

   • Inférence: GPU recommandéNVIDIA avec ≥4-8GB VRAM). Les petits modèles s'exécutent efficacement sur des GPU périphériques (par exemple, Jetson) ou des CPU à des résolutions inférieures.
   • Formation: Le réglage fin de YOLOE sur des données personnalisées ne nécessite généralement qu'un seul GPU. Le pré-entraînement extensif du vocabulaire ouvert (LVIS/Objects365) utilisé par les auteurs a nécessité un calcul important (8× RTX 4090 GPU).

4. Configuration: Les configurations de YOLOE utilisent des fichiers YAML standard d'Ultralytics . Les configurations par défaut (par exemple, yoloe-11s-seg.yaml) suffisent généralement, mais vous pouvez modifier la colonne vertébrale, les classes ou la taille de l'image selon vos besoins.

5. Courir YOLOE:

   • Déduction rapide (sans délai) :

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

   • Détection guidée (exemple d'invite de texte) :

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

6. Conseils d'intégration:

   • Nom des classes: Les sorties YOLOE par défaut utilisent les catégories LVIS ; utiliser set_classes() pour spécifier vos propres étiquettes.
   • Rapidité: YOLOE n'a pas de frais généraux à moins d'utiliser des messages-guides. Les messages-guides textuels ont un impact minimal ; les messages-guides visuels ont un impact légèrement plus important.
   • Inférence par lots: Pris en charge directement (model.predict([img1, img2])). Pour les invites spécifiques aux images, exécutez les images individuellement.

La documentationUltralytics fournit des ressources supplémentaires. YOLOE vous permet d'explorer facilement les puissantes capacités du monde ouvert dans l'écosystème familier de YOLO .

Citations et remerciements

Si YOLOE a contribué à votre recherche ou à votre projet, veuillez citer l'article original rédigé par Ao Wang, Lihao Liu, Hui Chen, Zijia Lin, Jungong Han et Guiguang Ding de l'université de 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 d'informations, l'article original de YOLOE est disponible sur arXiv. Le code source du projet et des ressources supplémentaires sont accessibles via le dépôt GitHub.

FAQ

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

Bien que YOLOE et YOLO permettent tous deux la détection de vocabulaires ouverts, YOLOE présente plusieurs avantages. YOLOE atteint une précision de +3,5 AP sur LVIS tout en utilisant 3× moins de ressources de formation et en fonctionnant 1,4× plus vite que YOLO. YOLOE prend également en charge trois modes d'incitation (textuelle, visuelle et vocabulaire interne), alors que YOLO se concentre principalement sur les incitations textuelles. En outre, YOLOE comprend des capacités de segmentation d'instances intégrées, fournissant des masques précis au pixel près pour les objets détectés sans surcharge supplémentaire.

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

Oui, YOLOE peut fonctionner exactement comme un modèle YOLO standard sans pénalité de performance. Lorsqu'ils sont utilisés en mode fermé (sans invites), les modules de vocabulaire ouvert de YOLOE sont re-paramétrés dans la tête de détection standard, ce qui permet d'obtenir une vitesse et une précision identiques à celles des modèles YOLO11 équivalents. Cela rend YOLOE extrêmement polyvalent : vous pouvez l'utiliser comme un détecteur traditionnel pour une vitesse maximale et passer en mode vocabulaire ouvert uniquement lorsque c'est nécessaire.

Quels types de messages-guides puis-je utiliser avec YOLOE ?

YOLOE prend en charge trois types d'invites :

1. Invitations textuelles: Spécifier des classes d'objets en utilisant le langage naturel (par exemple, "personne", "feu de circulation", "scooter des oiseaux").
2. Invitations visuelles: Fournir des images de référence des objets à détecter
3. Vocabulaire interne: Utilisez le vocabulaire intégré de YOLOE (plus de 1200 catégories) sans aide extérieure.

Cette flexibilité vous permet d'adapter YOLOE à différents scénarios sans avoir à réapprendre le modèle, ce qui le rend particulièrement utile dans les environnements dynamiques où les exigences en matière de détection changent fréquemment.

Comment YOLOE gère-t-il la segmentation des instances ?

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 à celle de YOLOv8 mais fonctionne pour toute classe d'objet incitée. Les masques de segmentation sont automatiquement inclus dans les résultats de l'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, ce qui permet de rationaliser les flux de travail pour les applications nécessitant des limites d'objet précises au pixel près.

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

Comme YOLO, YOLOE prend en charge une stratégie de type "demander puis détecter" qui utilise un vocabulaire hors ligne pour améliorer l'efficacité. Les invites personnalisées, telles que les légendes ou les catégories d'objets spécifiques, sont préencodées et stockées sous forme d'enchâssements de vocabulaire hors ligne. Cette approche rationalise le processus de détection sans nécessiter de réapprentissage. Vous pouvez 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-11s-seg.pt")

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

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

# Show results
results[0].show()

📅C réé il y a 1 mois ✏️ Mis à jour il y a 1 jour

Commentaires