YOLOE: Real-Time Seeing Anything

Introduzione

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

Rispetto ai precedenti modelli YOLO, YOLOE aumenta significativamente l'efficienza e l'accuratezza. 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 più rapide. 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 di YOLOE tra accuratezza, efficienza e versatilità. Le sezioni seguenti esplorano l'architettura di YOLOE, i confronti con i benchmark e l'integrazione con il framework Ultralytics.

Panoramica dell'architettura

YOLOE mantiene la struttura standard YOLO: una backbone convoluzionale (es. CSP-Darknet) per l'estrazione delle caratteristiche, un neck (es. PAN-FPN) per la fusione multi-scala e una head di rilevamento decoupled e anchor-free (come in YOLOv8/YOLO11) che predice indipendentemente objectness, classi e box. YOLOE introduce tre nuovi moduli che consentono il rilevamento a vocabolario aperto:

• Re-parameterizable Region-Text Alignment (RepRTA): Supporta il rilevamento tramite prompt testuale affinando i text embeddings (es. da CLIP) tramite una piccola rete ausiliaria. Durante l'inferenza, questa rete viene integrata nel modello principale, garantendo zero overhead. YOLOE rileva così oggetti etichettati con testo arbitrario (es. "semaforo" non visto) senza penalità in fase di runtime.

• Semantic-Activated Visual Prompt Encoder (SAVPE): Abilita il rilevamento tramite prompt visivo 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 one-shot detection utile per loghi o parti specifiche.

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

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

Fondamentalmente, i moduli open-world di YOLOE non introducono costi di inferenza quando vengono utilizzati come un normale YOLO a classe chiusa. Dopo l'addestramento, i parametri di YOLOE possono essere ri-parametrizzati in una head YOLO standard, preservando identici FLOP e velocità (corrispondendo esattamente a YOLO11).

Modelli disponibili, task supportati e modalità operative

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

Modelli con Prompt Testuale/Visivo

Modelli Prompt Free

Esempi di utilizzo

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

Utilizzo per l'addestramento

Fine-Tuning su un dataset personalizzato

Puoi effettuare il fine-tuning di qualsiasi modello YOLOE pre-addestrato sul tuo dataset YOLO personalizzato sia per compiti di rilevamento che di segmentazione di istanze.

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
)

Utilizzo di Predict

YOLOE supporta sia il prompt testuale che quello visivo. Utilizzare i prompt è semplice: passali attraverso il metodo predict come mostrato di seguito:

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

Utilizzo di Val

La validazione del modello su un dataset è snellita come segue:

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

Utilizzo dell'esportazione

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

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

Addestra Modelli Ufficiali

Prepara i dataset

• Dati di addestramento

• Dati di validazione

Avvio dell'addestramento da zero

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

Confronto delle prestazioni di YOLOE

YOLOE eguaglia o supera la precisione dei modelli YOLO a insieme chiuso su benchmark standard come COCO e LVIS, senza compromettere la velocità o le dimensioni del modello. La tabella sottostante confronta YOLOE-L (basato su YOLO11) e YOLOE26-L (basato su YOLO26) con i corrispondenti modelli a insieme chiuso:

^† YOLOE-L condivide l'architettura di YOLO11-L e YOLOE26-L condivide l'architettura di YOLO26-L, con conseguente velocità di inferenza e GFLOP simili.

YOLOE26-L raggiunge il 36,8% di LVIS mAP con 32,3M di parametri e 88,3B di FLOP, elaborando immagini 640×640 a 6,2 ms (161 FPS) su GPU T4. Questo migliora il 35,2% di LVIS mAP di YOLOE-L mantenendo la stessa velocità di inferenza. Fondamentalmente, i moduli a vocabolario aperto di YOLOE non comportano alcun costo di inferenza, dimostrando un design a "compromesso senza gratuità".

Per le attività zero-shot, YOLOE26 supera significativamente i precedenti rilevatori a vocabolario aperto: su LVIS, YOLOE26-S raggiunge il 29,9% di mAP, superando YOLO-World-S di +11,4 AP, mentre YOLOE26-L raggiunge il 36,8% di mAP, superando YOLO-World-L di +10,0 AP. YOLOE26 mantiene un'inferenza efficiente a 161 FPS su GPU T4, ideale per applicazioni a vocabolario aperto in tempo reale.

Confronto con i modelli precedenti

YOLOE introduce notevoli progressi rispetto ai precedenti modelli YOLO e ai rilevatori a vocabolario aperto:

• YOLOE vs YOLOv5: YOLOv5 offriva un buon equilibrio velocità-precisione ma richiedeva il riaddestramento per nuove classi e utilizzava head basate su anchor. Al contrario, YOLOE è senza anchor e rileva dinamicamente nuove classi. YOLOE, basandosi sui miglioramenti di YOLOv8, raggiunge una precisione superiore (52,6% vs ~50% di 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, raggiungendo una precisione simile o superiore (52,6% mAP con ~26M di parametri vs il 52,9% con ~44M di parametri di YOLOv8-L). Riduce significativamente il tempo di addestramento grazie a un pre-addestramento più forte. Il progresso chiave è la capacità open-world di YOLOE, che rileva oggetti non visti (ad esempio, "monopattino elettrico" o "simbolo della pace") tramite prompt, a differenza del design a insieme chiuso di YOLOv8.

• YOLOE vs YOLO11: YOLO11 migliora YOLOv8 con una maggiore efficienza e un minor numero di parametri (riduzione di ~22%). YOLOE eredita direttamente questi guadagni, eguagliando la velocità di inferenza e il conteggio dei parametri di YOLO11 (~26M di parametri), aggiungendo al contempo rilevamento e segmentazione a vocabolario aperto. Negli scenari a insieme chiuso, YOLOE è equivalente a YOLO11, ma aggiunge fondamentalmente l'adattabilità per rilevare classi non viste, ottenendo YOLO11 + capacità open-world senza compromettere la velocità.

• YOLOE26 vs YOLOE (basato su YOLO11): YOLOE26 si basa sull'architettura di YOLO26, ereditandone il design end-to-end senza NMS per un'inferenza più rapida. Su LVIS, YOLOE26-L raggiunge il 36,8% di mAP, migliorando il 35,2% di mAP di YOLOE-L. YOLOE26 offre tutte e cinque le scale di modello (N/S/M/L/X) rispetto alle tre di YOLOE (S/M/L), offrendo maggiore flessibilità per diversi scenari di distribuzione.

• YOLOE26 vs precedenti rilevatori a vocabolario aperto: I modelli a vocabolario aperto precedenti (GLIP, OWL-ViT, YOLO-World) facevano molto affidamento sui transformer visione-linguaggio, portando a un'inferenza lenta. Su LVIS, YOLOE26-S raggiunge il 29,9% di mAP (+11,4 AP rispetto a YOLO-World-S) e YOLOE26-L raggiunge il 36,8% di mAP (+10,0 AP rispetto a YOLO-World-L), mantenendo un'inferenza in tempo reale a 161 FPS su GPU T4. Rispetto agli approcci basati su transformer (ad es. GLIP), YOLOE26 offre un'inferenza più veloce di ordini di grandezza, colmando efficacemente il divario tra precisione ed efficienza nel rilevamento a insieme aperto.

In sintesi, YOLOE e YOLOE26 mantengono la rinomata velocità ed efficienza di YOLO, superano i predecessori in precisione, integrano la segmentazione e introducono un potente rilevamento open-world. YOLOE26 fa avanzare ulteriormente l'architettura con l'inferenza end-to-end senza NMS di YOLO26, rendendolo ideale per applicazioni a vocabolario aperto in tempo reale.

Casi d'uso e applicazioni

Il rilevamento e la segmentazione a vocabolario aperto di YOLOE consentono diverse applicazioni oltre ai tradizionali modelli a classi fisse:

• Rilevamento oggetti Open-World: Ideale per scenari dinamici come la robotica, dove i robot riconoscono oggetti precedentemente non visti utilizzando prompt, o i sistemi di sicurezza che si adattano rapidamente a nuove minacce (ad es. articoli pericolosi) senza riaddestramento.

• 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 a vocabolario ampio e Long-Tail: Dotato di un vocabolario di oltre 1000 classi, YOLOE eccelle in attività come il monitoraggio della biodiversità (rilevamento di specie rare), collezioni museali, inventario retail o e-commerce, identificando in modo affidabile molte classi senza un esteso addestramento per singola classe.

• Rilevamento e segmentazione interattivi: YOLOE supporta applicazioni interattive in tempo reale come il recupero ricercabile di video/immagini, la realtà aumentata (AR) e l'intuitivo editing di immagini, guidati 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 dati automatizzata e Bootstrapping: YOLOE facilita la creazione rapida di dataset fornendo annotazioni iniziali di bounding box e segmentazione, riducendo significativamente gli sforzi di etichettatura umana. Particolarmente prezioso nell'analisi di grandi raccolte multimediali, 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 vantaggioso per l'imaging medico, la microscopia o l'analisi di immagini satellitari, identificando e segmentando automaticamente e precisamente le strutture senza modelli pre-addestrati specializzati. A differenza di modelli come SAM, YOLOE riconosce e segmenta simultaneamente gli oggetti automaticamente, aiutando in 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 oltre.

Addestramento e inferenza

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

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

Altre attività supportate

• Validazione: Valuta facilmente la precisione con model.val() o yolo val.
• Esportazione: Esporta i modelli YOLOE (model.export()) in ONNX, TensorRT, ecc., facilitando la distribuzione.
• Tracciamento: YOLOE supporta il tracciamento degli oggetti (yolo track) quando integrato, utile per tracciare classi guidate da prompt nei video.

Introduzione

Configura rapidamente YOLOE con Ultralytics seguendo questi passaggi:

1. Installazione: Installa o aggiorna il pacchetto Ultralytics:

   pip install -U ultralytics

2. Download dei pesi di YOLOE: I modelli YOLOE pre-addestrati (ad es. YOLOE-v8-S/L, varianti YOLOE-11) sono disponibili dalle release di GitHub di YOLOE. Basta scaricare il file .pt desiderato da caricare nella classe YOLO di Ultralytics.

3. Requisiti hardware:

   • Inferenza: GPU consigliata (NVIDIA con ≥4-8GB di VRAM). I modelli piccoli funzionano in modo efficiente su GPU edge (ad es. Jetson) o CPU a risoluzioni inferiori. Per un'inferenza ad alte prestazioni su workstation compatte, consulta la nostra guida NVIDIA DGX Spark.
   • Addestramento: Il fine-tuning di YOLOE su dati personalizzati richiede solitamente una sola 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 di YOLOE utilizzano file YAML standard di Ultralytics. Le configurazioni predefinite (ad es. yoloe-26s-seg.yaml) di solito 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-26s-seg-pf.pt source="image.jpg"

   • Rilevamento con prompt (esempio di prompt di testo):

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

6. Suggerimenti per l'integrazione:

   • Nomi delle classi: Gli output predefiniti di YOLOE utilizzano categorie LVIS; usa set_classes() per specificare le tue etichette.
   • Velocità: YOLOE non ha overhead a meno che non si utilizzino i prompt. I prompt di testo hanno un impatto minimo; quelli visivi leggermente di più.
   • Comportamento NMS: YOLOE utilizza automaticamente agnostic_nms=True durante la previsione, unendo le caselle sovrapposte tra le classi. Questo previene rilevamenti duplicati quando lo stesso oggetto corrisponde a più categorie nell'ampio vocabolario di YOLOE (oltre 1200 classi LVIS). Puoi sovrascriverlo passando esplicitamente agnostic_nms=False.
   • Inferenza batch: Supportata direttamente (model.predict([img1, img2])). Per prompt specifici per immagine, esegui le immagini singolarmente.

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

Citazioni e ringraziamenti

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 ulteriori letture, l'articolo originale su YOLOE è disponibile su arXiv. Il codice sorgente del progetto e ulteriori risorse sono accessibili tramite il loro repository GitHub.

FAQ

In cosa differisce YOLOE da YOLO-World?

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

Posso usare YOLOE come un normale modello YOLO?

Sì, YOLOE può funzionare esattamente come un modello YOLO standard senza penalità di prestazioni. Quando utilizzato in modalità a insieme chiuso (senza prompt), i moduli a vocabolario aperto di YOLOE vengono ri-parametrizzati nell'head di rilevamento standard, risultando in una velocità e precisione identiche ai modelli YOLO11 equivalenti. Ciò rende YOLOE estremamente versatile: puoi usarlo come un rilevatore tradizionale per la massima velocità e poi passare alla modalità a vocabolario aperto solo quando necessario.

Che tipi di prompt posso usare con YOLOE?

YOLOE supporta tre tipi di prompt:

1. Prompt di testo: Specifica le classi degli oggetti utilizzando il linguaggio naturale (ad es. "persona", "semaforo", "monopattino elettrico")
2. Prompt visivi: Fornisci immagini di riferimento degli oggetti che vuoi rilevare
3. Vocabolario interno: Usa 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.

Come gestisce YOLOE la segmentazione delle istanze?

YOLOE integra la segmentazione delle istanze direttamente nella sua architettura estendendo l'head di rilevamento con un ramo di previsione delle maschere. Questo approccio è simile a YOLOv8-Seg ma funziona per qualsiasi classe di oggetto con prompt. Le maschere di segmentazione sono automaticamente incluse nei risultati di inferenza e possono essere 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 contorni degli oggetti precisi a livello di pixel.

Come gestisce YOLOE 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 vengono pre-codificati e memorizzati come embedding di vocabolario offline. Questo approccio semplifica il processo di rilevamento senza richiedere riaddestramento. Puoi impostare dinamicamente questi prompt all'interno del modello per adattarlo ad attività di rilevamento specifiche:

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