YOLOE: vedere qualsiasi cosa in tempo reale

Introduzione

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

Guarda: Come utilizzare YOLOE con il pacchetto Ultralytics Python : Vocabolario aperto e visione in tempo reale di qualsiasi cosa 🚀

Rispetto ai modelli YOLO precedenti, YOLOE aumenta significativamente l'efficienza e l'accuratezza. Migliora di +3,5 AP rispetto a YOLO su LVIS, utilizzando solo un terzo delle risorse di addestramento e raggiungendo una velocità di inferenza 1,4 volte superiore. Messo a punto su COCO, YOLOE-v8-large supera YOLOv8 di 0,1 mAP, utilizzando un tempo di addestramento quasi 4 volte inferiore. Questo dimostra l'eccezionale equilibrio tra precisione, efficienza e versatilità di YOLOE. Le sezioni che seguono analizzano l'architettura di YOLOE, i confronti con i benchmark e l'integrazione con il programma Ultralytics Ultralytics.

Panoramica dell'architettura

YOLOE mantiene la struttura standard di YOLO : una spina dorsale convoluzionale (ad esempio, CSP-Darknet) per l'estrazione delle caratteristiche, un collo (ad esempio, PAN-FPN) per la fusione multiscala e una testa di rilevamento disaccoppiata e priva di ancore (come in YOLO11) che predice objectness, classi e box in modo indipendente. YOLOE introduce tre nuovi moduli che consentono il rilevamento di vocaboli aperti:

• Re-parameterizable Region-Text Alignment (RepRTA): supporta l'individuazione di testi suggeriti affinando le incorporazioni di testo (ad esempio, da CLIP) tramite una piccola rete ausiliaria. Al momento dell'inferenza, questa rete viene inserita nel modello principale, garantendo un overhead pari a zero. In questo modo, YOLOE rileva oggetti arbitrari etichettati con il testo (ad esempio, un "semaforo" non visto) senza penalizzazioni di runtime.

• Semantic-Activated Visual Prompt Encoder (SAVPE): Consente il rilevamento con sollecitazione visiva tramite un ramo di incorporazione leggero. Data un'immagine di riferimento, SAVPE codifica le caratteristiche semantiche e di attivazione, condizionando il modello a rilevare oggetti visivamente simili: una capacità di rilevamento in una sola volta, utile per loghi o parti specifiche.

• Contrasto pigro regione-prompt (LRPC): In modalità senza prompt, YOLOE esegue il riconoscimento di set aperti utilizzando embeddings interni addestrati su vocabolari di grandi dimensioni (oltre 1200 categorie da LVIS e Objects365). Senza suggerimenti o codificatori esterni, YOLOE identifica gli oggetti attraverso la ricerca della somiglianza tra gli embeddings, gestendo in modo efficiente ampi spazi di etichette durante l'inferenza.

Inoltre, YOLOE integra la segmentazione delle istanze in tempo reale estendendo la testa di rilevamento con un ramo di predizione della maschera (simile a YOLACT o YOLOv8), aggiungendo un overhead minimo.

In particolare, i moduli open-world di YOLOE non introducono alcun costo di inferenza se utilizzati come un normale YOLO a set chiuso. Dopo l'addestramento, i parametri di YOLOE possono essere ri-parametrizzati in una testa YOLO standard, conservando FLOP e velocità identiche (ad esempio, la corrispondenza con YOLO11 esattamente).

Modelli disponibili, attività supportate e modalità operative

Questa sezione illustra i modelli disponibili con i loro pesi specifici preaddestrati, i compiti che supportano e la loro compatibilità con varie modalità operative come Inferenza, Convalida, Addestramento ed Esportazione, indicate con ✅ per le modalità supportate e ❌ per le modalità non supportate.

Modelli di prompt testuale/visivo

Modelli gratuiti Prompt

Esempi di utilizzo

I modelli YOLOE sono facili da integrare nelle applicazioni Python . Ultralytics fornisce APIPython e comandiCLI di facile utilizzo per semplificare lo sviluppo.

Utilizzo del treno

Messa a punto su set di dati personalizzati

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

Prevedere l'utilizzo

YOLOE supports both text-based and visual prompting. Using prompts is straightforward—just pass them through the predict come mostrato di seguito:

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

Utilizzo di Val

from ultralytics import YOLOE

# Create a YOLOE model
model = YOLOE("yoloe-11l-seg.pt")  # or select yoloe-m/l-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-m/l-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-m/l-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-m/l-seg.pt for different sizes

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

La validazione del modello su un set di dati viene semplificata come segue:

Modelli ufficiali di treni

Preparare i set di dati

• Dati del treno

• Dati di valore

Avviare la formazione da zero

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

Confronto delle prestazioni di YOLOE

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

^† YOLO11 e YOLOE-L hanno architetture identiche (moduli prompt disabilitati in YOLO11), con conseguente velocità di inferenza identica e stime GFLOP simili.

YOLOE-L raggiunge il 52,6% di mAP, superando YOLOv8(52,9%) con circa il 40% di parametri in meno (26M contro 43,7M). Elabora immagini 640×640 in 6,2 ms (161 FPS) rispetto ai 9,06 ms (110 FPS) di YOLOv8, evidenziando l'efficienza di YOLO11. Inoltre, i moduli a vocabolario aperto di YOLOE non comportano alcun costo di inferenza, a dimostrazione di un design "no free lunch trade-off".

Per le attività a scatto zero e di trasferimento, YOLOE eccelle: su LVIS, YOLOE-small migliora rispetto a YOLO di +3,5 AP utilizzando 3 volte meno risorse di addestramento. Anche la messa a punto di YOLOE-L da LVIS a COCO ha richiesto un tempo di addestramento 4 volte inferiore rispetto a YOLOv8, sottolineando la sua efficienza e adattabilità. YOLOE mantiene inoltre la velocità tipica di YOLO, raggiungendo oltre 300 FPS su una GPU T4 e ~64 FPS su iPhone 12 tramite CoreML, ideale per le implementazioni edge e mobile.

Confronto con i modelli precedenti

YOLOE introduce notevoli progressi rispetto ai precedenti modelli YOLO e ai rilevatori di vocaboli aperti:

• YOLOE vs YOLOv5:
  YOLOv5 ha offerto un buon rapporto velocità-accuratezza, ma richiedeva una riqualificazione per le nuove classi e utilizzava teste basate su ancore. Al contrario, YOLOE è privo di ancore e rileva dinamicamente le nuove classi. YOLOE, basandosi sui miglioramenti di YOLOv8, raggiunge un'accuratezza maggiore (52,6% contro il ~50% di YOLOv5 su COCO) e integra la segmentazione delle istanze, a differenza di YOLOv5.
  

• YOLOE vs YOLOv8:
  YOLOE estende YOLOv8e raggiunge un'accuratezza simile o superiore(52,6% di mAP con ~26M parametri contro il 52,9% di YOLOv8 con ~44M parametri). Riduce significativamente il tempo di addestramento grazie a un pre-addestramento più intenso. Il progresso principale è rappresentato dalla capacità di YOLOE di rilevare oggetti non visti (ad esempio,"scooter con uccello" o"simbolo della pace") tramite prompt, a differenza del design a set chiuso di YOLOv8.
  

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

• YOLOE rispetto ai precedenti rilevatori di vocaboli aperti:
  I precedenti modelli di vocabolario aperto (GLIP, OWL-ViT, YOLO) si basavano pesantemente sui trasformatori del linguaggio della visione, con conseguente lentezza dell'inferenza. YOLOE li supera in termini di accuratezza a zero scatti (ad esempio, +3,5 AP rispetto a YOLO), mentre funziona 1,4 volte più velocemente con risorse di addestramento significativamente inferiori. Rispetto agli approcci basati su trasformatori (ad esempio, GLIP), YOLOE offre un'inferenza più veloce di ordini di grandezza, colmando efficacemente il divario di accuratezza ed efficienza nel rilevamento degli insiemi aperti.

In sintesi, YOLOE mantiene la rinomata velocità ed efficienza di YOLO, supera i predecessori in termini di accuratezza, integra la segmentazione e introduce un potente rilevamento open-world, rendendolo unico per versatilità e praticità.

Casi d'uso e applicazioni

Il rilevamento e la segmentazione del vocabolario aperto di YOLOE consentono diverse applicazioni al di là dei tradizionali modelli a classe fissa:

• Rilevamento di oggetti in un mondo aperto:
  Ideale per scenari dinamici come la robotica, in cui i robot riconoscono oggetti mai visti prima grazie a suggerimenti, o i sistemi di sicurezza che si adattano rapidamente a nuove minacce (ad esempio, oggetti pericolosi) senza bisogno di riqualificarsi.

• Rilevamento con pochi scatti e con un solo scatto:
  Utilizzando suggerimenti visivi (SAVPE), YOLOE apprende rapidamente nuovi oggetti da singole immagini di riferimento, perfette per l'ispezione industriale (identificazione immediata di parti o difetti) o per la sorveglianza personalizzata, consentendo ricerche visive con una configurazione minima.

• Riconoscimento di un ampio vocabolario e di una lunga coda:
  Dotato di un vocabolario di oltre 1000 classi, YOLOE eccelle in compiti come il monitoraggio della biodiversità (rilevamento di specie rare), le collezioni museali, l'inventario di vendita al dettaglio o il commercio elettronico, identificando in modo affidabile molte classi senza una formazione estesa per classe.

• Rilevamento e segmentazione interattivi:
  YOLOE supporta applicazioni interattive in tempo reale, come il recupero di video/immagini, la realtà aumentata (AR) e l'editing intuitivo delle immagini, guidato da input naturali (testo o messaggi visivi). Gli utenti possono isolare, identificare o modificare dinamicamente gli oggetti con precisione utilizzando maschere di segmentazione.

• Etichettatura automatica dei dati e bootstrapping:
  YOLOE facilita la creazione rapida di set di dati fornendo annotazioni iniziali di bounding box e segmentazione, riducendo in modo significativo gli sforzi di etichettatura umana. Particolarmente utile nell'analisi di grandi raccolte multimediali, dove può identificare automaticamente gli oggetti presenti, aiutando a costruire più rapidamente modelli specializzati.

• Segmentazione per qualsiasi oggetto:
  Estende le capacità di segmentazione a oggetti arbitrari attraverso suggerimenti - particolarmente utili per l'imaging medico, la microscopia o l'analisi di immagini satellitari- identificando automaticamente e segmentando con precisione le strutture senza modelli specializzati pre-addestrati. A differenza di modelli come SAMYOLOE riconosce e segmenta simultaneamente gli oggetti in modo automatico, 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à, in quanto fornisce 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, ideali per la robotica, la guida autonoma, la difesa e altro ancora.

Formazione e inferenza

YOLOE si integra perfettamente con l'APIPython di Ultralytics e con la CLIsimile agli altri modelli YOLO YOLOv8, YOLO). Ecco come iniziare rapidamente:

from ultralytics import YOLO

# Load pre-trained YOLOE model and train on custom data
model = YOLO("yoloe-11s.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.pt data=path/to/data.yaml epochs=50 imgsz=640

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

Altre attività supportate

• Convalida: Valutare facilmente l'accuratezza con model.val() o yolo val.
• Esportazione: Esportazione dei modelli YOLOE (model.export()) a ONNX, TensorRT e così via, facilitando la distribuzione.
• Tracciamento: YOLOE supporta il tracciamento degli oggetti (yolo track) se integrato, utile per tracciare le classi richieste nei video.

Per iniziare

Per configurare rapidamente YOLOE con Ultralytics , procedere come segue:

1. Installazione: Installare o aggiornare il pacchetto Ultralytics :

   pip install -U ultralytics
   

2. Scarica i pesi YOLOE: I modelli YOLOE pre-addestrati (ad esempio, le varianti YOLOE-v8-S/L e YOLOE-11) sono disponibili nelle release di YOLOE GitHub. È sufficiente scaricare il modello desiderato .pt da caricare nella classe Ultralytics YOLO .

3. Requisiti hardware:

   • Inferenza: GPU consigliataNVIDIA con ≥4-8 GB di VRAM). I modelli di piccole dimensioni vengono eseguiti in modo efficiente su GPU di fascia bassa (ad esempio, Jetson) o CPU a risoluzioni inferiori.
   • Formazione: La messa a punto di YOLOE su dati personalizzati richiede in genere una sola GPU. Il pre-training estensivo del vocabolario aperto (LVIS/Objects365) utilizzato dagli autori ha richiesto una notevole quantità di calcoli (8× GPU RTX 4090).

4. Configurazione: Le configurazioni di YOLOE utilizzano i file YAML standard di Ultralytics . Le configurazioni predefinite (ad esempio, yoloe-s.yaml) sono in genere sufficienti, ma è possibile modificare la spina dorsale, le classi o le dimensioni dell'immagine secondo le necessità.

5. Esecuzione di YOLOE:

   • Inferenza rapida (senza fretta):

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

   • Rilevamento su richiesta (esempio di richiesta di testo):

     yolo predict model=yoloe-s.pt source="kitchen.jpg" classes="bowl,apple"
     

     In Python:

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

6. Suggerimenti per l'integrazione:

   • Nomi delle classi: Le uscite predefinite di YOLOE utilizzano le categorie LVIS; utilizzare set_classes() per specificare le proprie etichette.
   • Velocità: YOLOE non ha spese generali, a meno che non si utilizzino i prompt. I suggerimenti testuali hanno un impatto minimo, quelli visivi un po' di più.
   • Inferenza in batch: Supportato direttamente (model.predict([img1, img2])). Per le richieste specifiche delle immagini, eseguire le immagini singolarmente.

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

Citazioni e ringraziamenti

Se YOLOE ha contribuito alla vostra ricerca o al vostro progetto, vi preghiamo di citare 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, il documento originale di YOLOE è disponibile su arXiv. Il codice sorgente del progetto e le risorse aggiuntive sono accessibili tramite il loro repository GitHub.

FAQ

In cosa si differenzia YOLOE da YOLO?

Sebbene sia YOLOE che YOLO consentano il rilevamento del 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. YOLOE supporta anche tre modalità di prompt (testuale, visivo e vocabolario interno), mentre YOLO si concentra principalmente sui prompt testuali. Inoltre, YOLOE include funzionalità integrate di segmentazione delle istanze, fornendo maschere precise al pixel per gli oggetti rilevati senza costi aggiuntivi.

Posso utilizzare YOLOE come un normale modello YOLO ?

Sì, YOLOE può funzionare esattamente come un modello YOLO standard senza alcuna penalizzazione delle prestazioni. Quando viene utilizzato in modalità closed-set (senza prompt), i moduli a vocabolario aperto di YOLOE vengono ri-parametrizzati nella testina di rilevamento standard, ottenendo velocità e precisione identiche a quelle dei modelli YOLO11 equivalenti. Ciò rende YOLOE estremamente versatile: è possibile utilizzarlo come rilevatore tradizionale per ottenere la massima velocità e passare alla modalità a vocabolario aperto solo quando necessario.

Quali tipi di suggerimenti si possono utilizzare con YOLOE?

YOLOE supporta tre tipi di richieste:

1. Richiami di testo: Specificare le classi di oggetti utilizzando il linguaggio naturale (ad esempio, "persona", "semaforo", "scooter per uccelli").
2. Suggerimenti visivi: Fornire immagini di riferimento degli oggetti che si desidera rilevare.
3. Vocabolario interno: Utilizzate il vocabolario integrato di YOLOE, composto da oltre 1200 categorie, senza bisogno di suggerimenti esterni.

Questa flessibilità consente di adattare YOLOE a vari scenari senza dover riqualificare il modello, rendendolo particolarmente utile per gli 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 la testa di rilevamento con un ramo di predizione della maschera. Questo approccio è simile a YOLOv8, ma funziona per qualsiasi classe di oggetti richiesta. Le maschere di segmentazione sono automaticamente incluse 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 di oggetti precisi al pixel.

Come gestisce YOLOE l'inferenza con i prompt personalizzati?

Come YOLO, YOLOE supporta una strategia di "prompt-then-detect" che utilizza un vocabolario offline per migliorare l'efficienza. I suggerimenti personalizzati, come le didascalie o le categorie specifiche di oggetti, sono pre-codificati e memorizzati come embedding di vocabolario offline. Questo approccio semplifica il processo di rilevamento senza richiedere una nuova formazione. È possibile impostare dinamicamente questi suggerimenti all'interno del modello per adattarlo a compiti di rilevamento specifici:

from ultralytics import YOLO

# Initialize a YOLOE model
model = YOLO("yoloe-s.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()

📅C reato 1 mese fa ✏️ Aggiornato 2 giorni fa

Commenti