Vai al contenuto

YOLOE: Vedere Qualunque Cosa in Tempo Reale

Introduzione

Opzioni di Prompting di YOLOE

YOLOE (Real-Time Seeing Anything) è un nuovo progresso nei modelli YOLO zero-shot e promptable, progettato per il rilevamento e la segmentazione open-vocabulary. A differenza dei precedenti modelli YOLO limitati a categorie fisse, YOLOE utilizza prompt di testo, immagini o vocabolario interno, consentendo il rilevamento in tempo reale di qualsiasi classe di oggetti. Costruito su YOLOv10 e ispirato a YOLO-World, YOLOE raggiunge prestazioni zero-shot all'avanguardia con un impatto minimo su velocità e precisione.



Guarda: Come utilizzare YOLOE con il pacchetto Ultralytics python: Vocabolario aperto e vedere qualsiasi cosa in tempo reale 🚀

Rispetto ai precedenti modelli YOLO, YOLOE aumenta significativamente l'efficienza e la precisione. Migliora di +3.5 AP rispetto a YOLO-Worldv2 su LVIS utilizzando solo un terzo delle risorse di addestramento e raggiungendo velocità di inferenza 1,4 volte superiori. Ottimizzato su COCO, YOLOE-v8-large supera YOLOv8-L di 0.1 mAP, utilizzando quasi 4 volte meno tempo di addestramento. Ciò dimostra l'eccezionale equilibrio tra precisione, efficienza e versatilità di YOLOE. Le sezioni seguenti esplorano l'architettura di YOLOE, i confronti dei benchmark e l'integrazione con il framework Ultralytics.

Panoramica dell'architettura

Architettura YOLOE

YOLOE mantiene la struttura standard di YOLO: un backbone convoluzionale (ad esempio, CSP-Darknet) per l'estrazione delle caratteristiche, un neck (ad esempio, PAN-FPN) per la fusione multi-scala e un head di rilevamento anchor-free, disaccoppiato (come in YOLOv8/YOLO11) che prevede indipendentemente objectness, classi e box. YOLOE introduce tre nuovi moduli che consentono il rilevamento open-vocabulary:

  • Allineamento Regione-Testo Riperametrabile (RepRTA): Supporta la detection guidata da testo affinando gli embedding di testo (ad esempio, da CLIP) tramite una piccola rete ausiliaria. In fase di inferenza, questa rete viene integrata nel modello principale, garantendo zero overhead. YOLO rileva quindi oggetti arbitrari etichettati con testo (ad esempio, un "semaforo" non visto) senza penalizzazioni di runtime.

  • Codificatore visual prompt attivato semanticamente (SAVPE): Abilita il rilevamento con prompt visuali tramite un branch di embedding leggero. Dato un'immagine di riferimento, SAVPE codifica le caratteristiche semantiche e di attivazione, condizionando il modello a rilevare oggetti visivamente simili: una capacità di rilevamento one-shot utile per loghi o parti specifiche.

  • Lazy Region-Prompt Contrast (LRPC): In modalità senza prompt, YOLOE esegue il riconoscimento open-set utilizzando embedding interni addestrati su ampi vocabolari (oltre 1200 categorie da LVIS e Objects365). Senza prompt o encoder esterni, YOLOE identifica gli oggetti tramite la ricerca di similarità degli embedding, gestendo in modo efficiente ampi spazi di etichette in fase di inferenza.

Inoltre, YOLOE integra la segmentazione delle istanze in tempo reale estendendo l'head di rilevamento con un branch di previsione della maschera (simile a YOLACT o YOLOv8-Seg), aggiungendo un overhead minimo.

Fondamentalmente, i moduli open-world di YOLOE non introducono alcun costo di inferenza quando utilizzati come un normale YOLO a set chiuso. Dopo il training, i parametri YOLOE possono essere ri-parametrizzati in un head YOLO standard, preservando FLOP e velocità identici (ad esempio, corrispondenti esattamente a YOLO11).

Modelli disponibili, attività supportate e modalità operative

Questa sezione descrive in dettaglio i modelli disponibili con i relativi pesi pre-addestrati specifici, le attività che supportano e la loro compatibilità con varie modalità operative come Inferenza, Validazione, Addestramento ed Esportazione, indicate con ✅ per le modalità supportate e ❌ per le modalità non supportate.

Modelli di Prompt Testuale/Visuale

Tipo di modello Pesi pre-addestrati Task supportati Inferenza Validazione Training Esportazione
YOLOE-11S yoloe-11s-seg.pt Segmentazione delle istanze
YOLOE-11M yoloe-11m-seg.pt Segmentazione delle istanze
YOLOE-11L yoloe-11l-seg.pt Segmentazione delle istanze
YOLOE-v8S yoloe-v8s-seg.pt Segmentazione delle istanze
YOLOE-v8M yoloe-v8m-seg.pt Segmentazione delle istanze
YOLOE-v8L yoloe-v8l-seg.pt Segmentazione delle istanze

Modelli senza prompt

Tipo di modello Pesi pre-addestrati Task supportati Inferenza Validazione Training Esportazione
YOLOE-11S-PF yoloe-11s-seg-pf.pt Segmentazione delle istanze
YOLOE-11M-PF yoloe-11m-seg-pf.pt Segmentazione delle istanze
YOLOE-11L-PF yoloe-11l-seg-pf.pt Segmentazione delle istanze
YOLOE-v8S-PF yoloe-v8s-seg-pf.pt Segmentazione delle istanze
YOLOE-v8M-PF yoloe-v8m-seg-pf.pt Segmentazione delle istanze
YOLOE-v8L-PF yoloe-v8l-seg-pf.pt Segmentazione delle istanze

Esempi di utilizzo

I modelli YOLOE sono facili da integrare nelle tue applicazioni Python. Ultralytics fornisce API Python e comandi CLI di facile utilizzo per semplificare lo sviluppo.

Utilizzo dell'addestramento

Fine-Tuning su dataset personalizzato

Puoi ottimizzare qualsiasi modello YOLOE pre-addestrato sul tuo set di dati YOLO personalizzato sia per attività di rilevamento che di segmentazione delle istanze.

Esempio

Segmentazione delle istanze

L'ottimizzazione di un checkpoint YOLOE pre-addestrato segue principalmente la procedura standard di addestramento YOLO. La differenza principale è il passaggio esplicito di YOLOEPESegTrainer come trainer parametro a model.train():

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

model = YOLOE("yoloe-11s-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
)

Rilevamento di oggetti

Tutti i modelli YOLOE pre-addestrati eseguono la segmentazione delle istanze per impostazione predefinita. Per utilizzare questi checkpoint pre-addestrati per l'addestramento di un modello di rilevamento, inizializza un modello di rilevamento da zero utilizzando la configurazione YAML, quindi carica il checkpoint di segmentazione pre-addestrato della stessa scala. Si noti che utilizziamo YOLOEPETrainer invece di YOLOEPESegTrainer poiché stiamo addestrando un modello di rilevamento:

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

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

# Load weights from a pretrained segmentation checkpoint (same scale)
model.load("yoloe-11s-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
)

L'analisi lineare ottimizza solo il ramo di classificazione congelando il resto del modello. Questo approccio è utile quando si lavora con dati limitati, in quanto previene l'overfitting sfruttando le caratteristiche apprese in precedenza adattando solo l'intestazione di classificazione.

Segmentazione delle istanze

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

# Load a pretrained segmentation model
model = YOLOE("yoloe-11s-seg.pt")

# Identify the head layer index
head_index = len(model.model.model) - 1

# Freeze all backbone and neck layers (i.e. everything before the head)
freeze = [str(i) for i in range(0, head_index)]

# Freeze parts of the segmentation head, keeping only the classification branch trainable
for name, child in model.model.model[-1].named_children():
    if "cv3" not in name:
        freeze.append(f"{head_index}.{name}")

# Freeze detection branch components
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",
    ]
)

# Train only the classification branch
results = model.train(
    data="coco128-seg.yaml",  # Segmentation dataset
    epochs=80,
    patience=10,
    trainer=YOLOEPESegTrainer,  # <- Important: use segmentation trainer
    freeze=freeze,
)

Rilevamento di oggetti

Per l'attività di rilevamento oggetti, il processo di addestramento è quasi lo stesso dell'esempio di segmentazione dell'istanza sopra, ma usiamo YOLOEPETrainer invece di YOLOEPESegTrainere inizializza il modello di rilevamento oggetti usando lo YAML e poi carica i pesi dal checkpoint di segmentazione dell'istanza pre-addestrato.

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

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

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

# Identify the head layer index
head_index = len(model.model.model) - 1

# Freeze all backbone and neck layers (i.e. everything before the head)
freeze = [str(i) for i in range(0, head_index)]

# Freeze parts of the segmentation head, keeping only the classification branch trainable
for name, child in model.model.model[-1].named_children():
    if "cv3" not in name:
        freeze.append(f"{head_index}.{name}")

# Freeze detection branch components
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",
    ]
)

# Train only the classification branch
results = model.train(
    data="coco128.yaml",  # Detection dataset
    epochs=80,
    patience=10,
    trainer=YOLOEPETrainer,  # <- Important: use detection trainer
    freeze=freeze,
)

Utilizzo della previsione

YOLOE supporta sia il prompting basato su testo che quello visivo. L'utilizzo dei prompt è semplice: basta passarli attraverso il predict method come mostrato di seguito:

Esempio

I prompt di testo consentono di specificare le classi che si desidera rilevare tramite descrizioni testuali. Il codice seguente mostra come è possibile utilizzare YOLOE per rilevare persone e autobus in un'immagine:

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()

I prompt visivi ti consentono di guidare il modello mostrandogli esempi visivi delle classi target, anziché descriverle nel testo.

Il visual_prompts l'argomento accetta un dizionario con due chiavi: bboxes e cls. Ogni riquadro di delimitazione in bboxes dovrebbe racchiudere strettamente un esempio dell'oggetto che si desidera che il modello rilevi e la voce corrispondente in cls specifica l'etichetta di classe per quella casella. Questo abbinamento indica al modello: "Ecco come appare la classe X, ora trovane altre simili."

ID classe (cls) in visual_prompts vengono utilizzati per associare ogni bounding box a una categoria specifica all'interno del tuo prompt. Non sono etichette fisse, ma identificatori temporanei che assegni a ciascun esempio. L'unico requisito è che gli ID delle classi siano sequenziali, a partire da 0. Questo aiuta il modello ad associare correttamente ogni box alla rispettiva classe.

Puoi fornire prompt visivi direttamente all'interno della stessa immagine su cui desideri eseguire l'inferenza. Ad esempio:

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()

Oppure puoi fornire esempi da un'immagine di riferimento separata utilizzando il refer_image argomento. In tal caso, il bboxes e cls in visual_prompts dovrebbe descrivere gli oggetti nell'immagine di riferimento, non l'immagine di destinazione su cui si stanno facendo le previsioni:

Nota

Se source è un video o uno stream, il modello utilizza automaticamente il primo frame come refer_image. Questo significa che il tuo visual_prompts vengono applicati a quel frame iniziale per aiutare il modello a capire cosa cercare nel resto del video. In alternativa, puoi passare esplicitamente qualsiasi frame specifico come refer_image per controllare quali esempi visivi il modello utilizza come riferimento.

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()

L'utilizzo di refer_image imposta anche le classi in modo permanente, quindi puoi eseguire previsioni senza dover fornire nuovamente gli stessi prompt visivi e esportare il modello mantenendo la capacità di rilevare le stesse classi anche dopo l'esportazione:

# After making prediction with `refer_image`, you can run predictions without passing visual_prompts again and still get the same classes back
results = model("ultralytics/assets/bus.jpg")

# Or export it to a different format while retaining the classes
model.export(format="onnx")

Puoi anche passare più immagini di destinazione per eseguire la predizione:

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()

YOLOE include anche varianti senza prompt dotate di un vocabolario integrato. Questi modelli non richiedono alcun prompt e funzionano come i modelli YOLO tradizionali. Invece di basarsi su etichette fornite dall'utente o esempi visivi, rilevano oggetti da un elenco predefinito di 4.585 classi in base al set di tag utilizzato dal Recognize Anything Model Plus (RAM++).

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()

Utilizzo di Val

La convalida del modello su un dataset è semplificata come segue:

Esempio

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")

Per impostazione predefinita, utilizza il set di dati fornito per estrarre gli embedding visivi per ogni categoria.

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)

In alternativa, potremmo utilizzare un altro dataset come dataset di riferimento per estrarre gli embedding visuali per ogni categoria. Si noti che questo dataset di riferimento deve avere esattamente le stesse categorie del dataset fornito.

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-pf.pt")  # or select yoloe-11s/m-seg-pf.pt for different sizes

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

Utilizzo dell'esportazione

Il processo di esportazione è simile ad altri modelli YOLO, con l'ulteriore flessibilità di gestire prompt testuali e visivi:

Esempio

from ultralytics import YOLOE

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

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

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()

Addestra Modelli Ufficiali

Prepara i set di dati

Nota

L'addestramento dei modelli YOLOE ufficiali necessita di annotazioni di segmento per i dati di addestramento, ecco lo script fornito dal team ufficiale che converte i set di dati in annotazioni di segmenti, alimentato da Modelli SAM2.1. Oppure puoi scaricare direttamente il file fornito Processed Segment Annotations nella seguente tabella fornita dal team ufficiale.

  • Dati di addestramento
Set di dati Tipo Esempi Box Annotazioni di rilevamento grezze Annotazioni di segmenti elaborati
Objects365v1 Rilevamento 609k 9621k objects365_train.json objects365_train_segm.json
GQA Grounding 621k 3681k final_mixed_train_no_coco.json final_mixed_train_no_coco_segm.json
Flickr30k Grounding 149k 641k final_flickr_separateGT_train.json final_flickr_separateGT_train_segm.json
  • Dati Val
Set di dati Tipo File di annotazione
LVIS minival Rilevamento minival.txt

Avvio dell'addestramento da zero

Nota

Visual Prompt i modelli vengono ottimizzati in base a modelli ben addestrati Text Prompt modelli.

Esempio

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

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"]),
)

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",
)

Dato che solo il SAVPE il modulo deve essere aggiornato durante l'addestramento. Conversione del modello Text-prompt ben addestrato in modello di rilevamento e adozione della pipeline di rilevamento con costi di addestramento inferiori. Nota: questo passaggio è facoltativo, puoi anche iniziare direttamente dalla segmentazione.

from ultralytics import YOLOE
from ultralytics.utils.patches import torch_load

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")

Avvia l'addestramento:

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

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"]),
)

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=YOLOESegVPTrainer,  # use YOLOEVPTrainer if converted to detection model
    device="0,1,2,3,4,5,6,7",
    freeze=freeze,
)

Riconverti al modello di segmentazione dopo l'addestramento. Necessario solo se hai convertito il modello di segmentazione in modello di rilevamento prima dell'addestramento.

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")

Simile all'addestramento con prompt visivi, per il modello senza prompt è necessario aggiornare solo l'embedding del prompt specializzato durante l'addestramento. Conversione del modello Text-prompt addestrato in un modello di rilevamento e adozione della pipeline di rilevamento con costi di addestramento inferiori. Nota: questo passaggio è opzionale, puoi anche iniziare direttamente dalla segmentazione.

from ultralytics import YOLOE
from ultralytics.utils.patches import torch_load

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")
Avvia l'addestramento:
from ultralytics import YOLOE

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"]),
)

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
)

Riconverti al modello di segmentazione dopo l'addestramento. Necessario solo se hai convertito il modello di segmentazione in modello di rilevamento prima dell'addestramento.

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")

Confronto delle prestazioni di YOLOE

YOLOE eguaglia o supera l'accuratezza dei modelli YOLO closed-set su benchmark standard come COCO, senza compromettere la velocità o le dimensioni del modello. La tabella seguente confronta YOLOE-L (basato su YOLO11) con i corrispondenti modelli YOLOv8 e YOLO11:

Modello COCO mAP50-95 Velocità di inferenza (T4) Parametri GFLOPs (640px)
YOLOv8-L (closed-set) 52.9% 9,06 ms (110 FPS) 43.7 M 165.2 B
YOLO11-L (closed-set) 53.5% 6.2 ms (130 FPS) 26.2 M 86.9 B
YOLOE-L (open-vocab) 52.6% 6.2 ms (130 FPS) 26.2 M 86.9 B

YOLO11-L e YOLOE-L hanno architetture identiche (moduli prompt disabilitati in YOLO11-L), il che si traduce in una velocità di inferenza identica e stime di GFLOP simili.

YOLOE-L raggiunge un mAP del 52,6%, superando YOLOv8-L (52,9%) con circa il 40% in meno di parametri (26M contro 43,7M). Elabora immagini 640×640 in 6,2 ms (161 FPS) rispetto ai 9,06 ms (110 FPS) di YOLOv8-L, evidenziando l'efficienza di YOLO11. Fondamentalmente, i moduli open-vocabulary di YOLOE non comportano alcun costo di inferenza, dimostrando un design "nessuno scambio di favori".

Per attività zero-shot e di trasferimento, YOLOE eccelle: su LVIS, YOLOE-small migliora rispetto a YOLO-Worldv2 di +3.5 AP utilizzando 3 volte meno risorse di addestramento. Anche il fine-tuning di YOLOE-L da LVIS a COCO ha richiesto 4 volte meno tempo di addestramento rispetto a YOLOv8-L, sottolineandone l'efficienza e l'adattabilità. YOLOE mantiene inoltre la velocità distintiva di YOLO, raggiungendo oltre 300 FPS su una GPU T4 e ~64 FPS su iPhone 12 tramite CoreML, ideale per implementazioni edge e mobili.

Nota

Condizioni di benchmark: I risultati di YOLOE provengono da modelli pre-addestrati su Objects365, GoldG e LVIS, quindi ottimizzati o valutati su COCO. Il leggero vantaggio mAP di YOLOE rispetto a YOLOv8 deriva da un ampio pre-addestramento. Senza questo training open-vocab, YOLOE corrisponde a modelli YOLO di dimensioni simili, affermando la sua accuratezza SOTA e la flessibilità open-world senza penalizzazioni delle prestazioni.

Confronto con i modelli precedenti

YOLOE introduce notevoli progressi rispetto ai precedenti modelli YOLO e ai rilevatori open-vocabulary:

  • YOLOE vs YOLOv5:
    YOLOv5 offriva un buon equilibrio tra velocità e accuratezza, ma richiedeva un retraining per le nuove classi e utilizzava head basati su anchor. Al contrario, YOLOE è anchor-free e rileva dinamicamente nuove classi. YOLOE, basandosi sui miglioramenti di YOLOv8, raggiunge una maggiore accuratezza (52.6% rispetto al ~50% mAP di YOLOv5 su COCO) e integra la segmentazione delle istanze, a differenza di YOLOv5.

  • YOLOE vs YOLOv8:
    YOLOE estende l'architettura riprogettata di YOLOv8, ottenendo un'accuratezza simile o superiore (52.6% mAP con ~26M di parametri rispetto al 52.9% con ~44M di parametri di YOLOv8-L). Riduce significativamente i tempi di training grazie a un pre-training più efficace. L'avanzamento chiave è la capacità open-world di YOLOE, che rileva oggetti non visti (ad esempio, "bird scooter" o "peace symbol") tramite prompt, a differenza del design closed-set di YOLOv8.

  • YOLOE vs YOLO11:
    YOLO11 migliora YOLOv8 con una maggiore efficienza e un minor numero di parametri (riduzione di circa il 22%). YOLOE eredita direttamente questi vantaggi, eguagliando la velocità di inferenza e il numero di parametri di YOLO11 (circa 26 milioni di parametri), aggiungendo al contempo il rilevamento e la segmentazione open-vocabulary. In scenari closed-set, YOLOE è equivalente a YOLO11, ma aggiunge in modo cruciale l'adattabilità per rilevare classi non viste, ottenendo YOLO11 + capacità open-world senza compromettere la velocità.

  • YOLOE vs i precedenti rilevatori open-vocabulary:
    I modelli open-vocab precedenti (GLIP, OWL-ViT, YOLO-World) si basavano fortemente sui transformer vision-language, il che portava a un'inferenza lenta. YOLOE li supera in accuratezza zero-shot (ad esempio, +3.5 AP rispetto a YOLO-Worldv2) pur funzionando 1.4 volte più velocemente con risorse di training significativamente inferiori. Rispetto agli approcci basati su transformer (ad esempio, GLIP), YOLOE offre un'inferenza di ordini di grandezza più veloce, colmando efficacemente il divario tra accuratezza ed efficienza nel rilevamento open-set.

In sintesi, YOLOE mantiene la rinomata velocità ed efficienza di YOLO, supera i predecessori in accuratezza, integra la segmentazione e introduce un potente rilevamento open-world, rendendolo straordinariamente versatile e pratico.

Casi d'uso e applicazioni

Il rilevamento e la segmentazione open-vocabulary di YOLOE consentono diverse applicazioni oltre ai tradizionali modelli a classe fissa:

  • Rilevamento oggetti in ambienti aperti:
    Ideale per scenari dinamici come la robotica, dove i robot riconoscono oggetti mai visti prima utilizzando dei prompt, o i sistemi di sicurezza che si adattano rapidamente a nuove minacce (ad esempio, oggetti pericolosi) senza dover essere riaddestrati.

  • Rilevamento Few-Shot e One-Shot:
    Utilizzando prompt visivi (SAVPE), YOLOE apprende rapidamente nuovi oggetti da singole immagini di riferimento, perfetto per l'ispezione industriale (identificazione istantanea di parti o difetti) o la sorveglianza personalizzata, consentendo ricerche visive con una configurazione minima.

  • Riconoscimento di vocabolari estesi e code lunghe:
    Dotato di un vocabolario di oltre 1000 classi, YOLOE eccelle in attività come il monitoraggio della biodiversità (rilevamento di specie rare), le collezioni museali, l'inventario al dettaglio o l'e-commerce, identificando in modo affidabile molte classi senza un'ampia formazione per classe.

  • Rilevamento e segmentazione interattivi:
    YOLOE supporta applicazioni interattive in tempo reale come ricerca di video/immagini, realtà aumentata (AR) e modifica intuitiva delle immagini, guidate da input naturali (testo o prompt visivi). Gli utenti possono isolare, identificare o modificare dinamicamente gli oggetti in modo preciso utilizzando le maschere di segmentazione.

  • Etichettatura automatica dei dati e bootstrapping:
    YOLOE facilita la creazione rapida di dataset fornendo bounding box iniziali e annotazioni di segmentazione, riducendo significativamente gli sforzi di etichettatura manuale. Particolarmente utile nell'analisi di grandi raccolte di media, dove può identificare automaticamente gli oggetti presenti, aiutando a costruire modelli specializzati più velocemente.

  • Segmentazione per qualsiasi oggetto:
    Estende le capacità di segmentazione a oggetti arbitrari tramite prompt, particolarmente utile per l'imaging medicale, la microscopia o l'analisi di immagini satellitari, identificando e segmentando automaticamente e con precisione le strutture senza modelli pre-addestrati specializzati. A differenza di modelli come SAM, YOLOE riconosce e segmenta simultaneamente gli oggetti in modo automatico, supportando attività come la creazione di contenuti o la comprensione della scena.

In tutti questi casi d'uso, il vantaggio principale di YOLOE è la versatilità, fornendo un modello unificato per il rilevamento, il riconoscimento e la segmentazione in scenari dinamici. La sua efficienza garantisce prestazioni in tempo reale su dispositivi con risorse limitate, ideale per la robotica, la guida autonoma, la difesa e altro ancora.

Suggerimento

Scegli la modalità di YOLOE in base alle tue esigenze:

  • Modalità closed-set: Per attività a classe fissa (massima velocità e precisione).
  • Modalità con prompt: Aggiungi rapidamente nuovi oggetti tramite prompt testuali o visivi.
  • Modalità open-set senza prompt: Rilevamento generale in molte categorie (ideale per la catalogazione e la scoperta).

Spesso, la combinazione di modalità, come la scoperta senza prompt seguita da prompt mirati, sfrutta appieno il potenziale di YOLOE.

Addestramento e Inferenza

YOLOE si integra perfettamente con la API Python di Ultralytics e la CLI, in modo simile ad altri modelli YOLO (YOLOv8, YOLO-World). Ecco come iniziare rapidamente:

Addestramento e inferenza con YOLOE

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

Qui, YOLOE si comporta come un rilevatore standard per impostazione predefinita, ma passa facilmente al rilevamento guidato specificando le classi (set_classes). I risultati contengono bounding box, maschere ed etichette.

# 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"

Prompt della CLI (classes) guida YOLOE in modo simile a set_classes. Il visual prompting (query basate su immagini) al momento richiede l'API Python.

Altre attività supportate

  • Convalida: Valuta facilmente l'accuratezza con model.val() oppure yolo val.
  • Esporta: Esporta modelli YOLOE (model.export()) a ONNX, TensorRT, ecc., facilitando la distribuzione.
  • Tracciamento: YOLOE supporta il tracciamento degli oggetti (yolo track) quando integrato, utile per tracciare le classi richieste nei video.

Nota

YOLOE include automaticamente maschere di segmentazione nei risultati dell'inferenza (results[0].masks), semplificando attività di precisione a livello di pixel come l'estrazione o la misurazione di oggetti senza la necessità di modelli separati.

Introduzione

Configura rapidamente YOLOE con Ultralytics seguendo questi passaggi:

  1. Installazione: Installa o aggiorna il pacchetto Ultralytics:

    pip install -U ultralytics
    
  2. Scarica i pesi di YOLOE: I modelli YOLOE pre-addestrati (ad esempio, YOLOE-v8-S/L, varianti YOLOE-11) sono disponibili nelle release GitHub di YOLOE. Scarica semplicemente il .pt file da caricare nella classe Ultralytics YOLO.

  3. Requisiti hardware:

    • Inferenza: GPU consigliata (NVIDIA con ≥4-8GB di VRAM). I modelli piccoli funzionano in modo efficiente su GPU edge (ad esempio, Jetson) o CPU a risoluzioni inferiori.
    • Addestramento: La messa a punto di YOLOE su dati personalizzati richiede in genere solo una GPU. L'ampio pre-addestramento a vocabolario aperto (LVIS/Objects365) utilizzato dagli autori ha richiesto una notevole potenza di calcolo (8× GPU RTX 4090).
  4. Configurazione: Le configurazioni YOLOE utilizzano i file YAML standard di Ultralytics. Le configurazioni predefinite (ad es. yoloe-11s-seg.yaml) in genere sono sufficienti, ma puoi modificare backbone, classi o dimensioni dell'immagine secondo necessità.

  5. Esecuzione di YOLOE:

    • Inferenza rapida (senza prompt):
      yolo predict model=yoloe-11s-seg-pf.pt source="image.jpg"
      
    • Rilevamento con prompt (esempio di prompt testuale):

      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. Suggerimenti per l'integrazione:

    • Nomi delle classi: Gli output predefiniti di YOLOE utilizzano le categorie LVIS; usa set_classes() per specificare le tue etichette.
    • Velocità: YOLOE non ha overhead a meno che non si utilizzino prompt. I prompt di testo hanno un impatto minimo; i prompt visivi leggermente di più.
    • Inferenza batch: Supportato direttamente (model.predict([img1, img2])). Per prompt specifici per l'immagine, esegui le immagini singolarmente.

La documentazione di Ultralytics fornisce ulteriori risorse. YOLOE ti consente di esplorare facilmente potenti funzionalità open-world all'interno del familiare ecosistema YOLO.

Suggerimento

Suggerimento Pro: Per massimizzare l'accuratezza zero-shot di YOLOE, esegui il fine-tuning dai checkpoint forniti anziché eseguire il training da zero. Utilizza parole chiave allineate con le etichette di training comuni (vedi le categorie LVIS) per migliorare l'accuratezza del rilevamento.

Citazioni e riconoscimenti

Se YOLOE ha contribuito alla tua ricerca o al tuo progetto, cita l'articolo originale di Ao Wang, Lihao Liu, Hui Chen, Zijia Lin, Jungong Han e Guiguang Ding della Tsinghua University:

@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},
}

Per approfondire, l'articolo originale di YOLOE è disponibile su arXiv. Il codice sorgente del progetto e le risorse aggiuntive sono accessibili tramite il loro repository GitHub.

FAQ

In che modo YOLOE differisce da YOLO-World?

Sebbene sia YOLOE che YOLO-World consentano il rilevamento a vocabolario aperto, YOLOE offre diversi vantaggi. YOLOE raggiunge un'accuratezza superiore di +3,5 AP su LVIS utilizzando 3 volte meno risorse di addestramento e funzionando 1,4 volte più velocemente di YOLO-Worldv2. YOLOE supporta anche tre modalità di prompting (testo, visiva e vocabolario interno), mentre YOLO-World si concentra principalmente sui prompt di testo. Inoltre, YOLOE include funzionalità di segmentazione delle istanze integrate, fornendo maschere precise a livello di pixel per gli oggetti rilevati senza costi aggiuntivi.

Posso usare YOLOE come un normale modello YOLO?

Sì, YOLOE può funzionare esattamente come un modello YOLO standard senza penalizzazioni delle prestazioni. Quando utilizzato in modalità closed-set (senza prompt), i moduli open-vocabulary di YOLOE vengono riparametrizzati nell'head di rilevamento standard, ottenendo velocità e precisione identiche ai modelli YOLO11 equivalenti. Questo rende YOLOE estremamente versatile: puoi usarlo come un rilevatore tradizionale per la massima velocità e poi passare alla modalità open-vocabulary solo quando necessario.

Quali tipi di prompt posso usare con YOLOE?

YOLOE supporta tre tipi di prompt:

  1. Prompt di testo: Specifica le classi di oggetti utilizzando il linguaggio naturale (ad esempio, "persona", "semaforo", "scooter per uccelli")
  2. Prompt visuali: Fornisci immagini di riferimento degli oggetti che vuoi rilevare
  3. Vocabolario interno: Utilizza il vocabolario integrato di YOLOE di oltre 1200 categorie senza prompt esterni

Questa flessibilità ti consente di adattare YOLOE a vari scenari senza riaddestrare il modello, rendendolo particolarmente utile per ambienti dinamici in cui i requisiti di rilevamento cambiano frequentemente.

In che modo YOLOE gestisce la segmentazione delle istanze?

YOLOE integra la segmentazione delle istanze direttamente nella sua architettura estendendo l'head di rilevamento con un branch di previsione della maschera. Questo approccio è simile a YOLOv8-Seg ma funziona per qualsiasi classe di oggetti richiesta. Le maschere di segmentazione sono incluse automaticamente nei risultati dell'inferenza e sono accessibili tramite results[0].masks. Questo approccio unificato elimina la necessità di modelli di rilevamento e segmentazione separati, semplificando i flussi di lavoro per le applicazioni che richiedono confini degli oggetti con precisione a livello di pixel.

In che modo YOLOE gestisce l'inferenza con prompt personalizzati?

Simile a YOLO-World, YOLOE supporta una strategia "prompt-then-detect" che utilizza un vocabolario offline per migliorare l'efficienza. Prompt personalizzati come didascalie o categorie di oggetti specifici sono pre-codificati e memorizzati come incorporamenti di vocabolario offline. Questo approccio semplifica il processo di rilevamento senza richiedere un nuovo addestramento. Puoi impostare dinamicamente questi prompt all'interno del modello per adattarlo a specifiche attività di rilevamento:

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()


📅 Creato 5 mesi fa ✏️ Aggiornato 11 giorni fa

Commenti