YOLOE: Echtzeit-Objekterkennung für alles

Einführung

YOLOE (Real-Time Seeing Anything) ist eine neue Weiterentwicklung im Bereich der Zero-Shot-, Promptable-YOLO-Modelle, die für die Open-Vocabulary-Erkennung und -Segmentierung entwickelt wurden. Im Gegensatz zu früheren YOLO-Modellen, die auf feste Kategorien beschränkt waren, verwendet YOLOE Text-, Bild- oder interne Vokabular-Prompts, wodurch die Echtzeiterkennung jeder Objektklasse ermöglicht wird. YOLOE basiert auf YOLOv10 und ist von YOLO-World inspiriert. Es erreicht modernste Zero-Shot-Performance mit minimalen Auswirkungen auf Geschwindigkeit und Genauigkeit.

Ansehen: Wie man YOLOE mit dem Ultralytics Python-Paket verwendet: Open Vocabulary & Real-Time Seeing Anything 🚀

Im Vergleich zu früheren YOLO-Modellen steigert YOLOE die Effizienz und Genauigkeit erheblich. Es verbessert sich um +3,5 AP gegenüber YOLO-Worldv2 auf LVIS, während nur ein Drittel der Trainingsressourcen verwendet wird und 1,4-fach schnellere Inferenzgeschwindigkeiten erreicht werden. Feinabgestimmt auf COCO übertrifft YOLOE-v8-large YOLOv8-L um 0,1 mAP, wobei fast 4× weniger Trainingszeit benötigt wird. Dies demonstriert das außergewöhnliche Gleichgewicht von YOLOE zwischen Genauigkeit, Effizienz und Vielseitigkeit. Die folgenden Abschnitte untersuchen die Architektur von YOLOE, Benchmark-Vergleiche und die Integration mit dem Ultralytics Framework.

Architektur-Überblick

YOLOE behält die Standard-YOLO-Struktur bei: ein konvolutionelles Backbone (z. B. CSP-Darknet) zur Merkmalsextraktion, ein Neck (z. B. PAN-FPN) zur multiskaligen Fusion und ein ankerfreier, entkoppelter Erkennungs-Head (wie in YOLOv8/YOLO11), der Objektivität, Klassen und Boxen unabhängig voneinander vorhersagt. YOLOE führt drei neuartige Module ein, die die Erkennung mit offenem Vokabular ermöglichen:

• Re-parameterizable Region-Text Alignment (RepRTA): Unterstützt die textgesteuerte Erkennung, indem Text-Einbettungen (z. B. von CLIP) über ein kleines Hilfsnetzwerk verfeinert werden. Bei der Inferenz wird dieses Netzwerk in das Hauptmodell eingefaltet, wodurch ein Overhead von Null gewährleistet wird. YOLOE erkennt somit beliebige textbeschriftete Objekte (z. B. ungesehenes "Verkehrslicht") ohne Laufzeitbeeinträchtigungen.

• Semantic-Activated Visual Prompt Encoder (SAVPE): Ermöglicht visuell-gestützte Detektion über einen schlanken Embedding-Zweig. Angesichts eines Referenzbildes kodiert SAVPE semantische und Aktivierungsmerkmale und konditioniert das Modell, um visuell ähnliche Objekte zu erkennen – eine One-Shot-Detektionsfähigkeit, die für Logos oder bestimmte Teile nützlich ist.

• Lazy Region-Prompt Contrast (LRPC): Im Prompt-freien Modus führt YOLOE eine Open-Set-Erkennung mithilfe interner Einbettungen durch, die auf großen Vokabularen trainiert wurden (1200+ Kategorien von LVIS und Objects365). Ohne externe Prompts oder Encoder identifiziert YOLOE Objekte über die Ähnlichkeit der Einbettungen und verarbeitet so effizient große Label-Räume bei der Inferenz.

Zusätzlich integriert YOLOE Echtzeit-Instanzsegmentierung, indem der Erkennungskopf um einen Masken-Vorhersagezweig erweitert wird (ähnlich wie bei YOLACT oder YOLOv8-Seg), wodurch nur minimaler Overhead entsteht.

Entscheidend ist, dass die Open-World-Module von YOLOE keine Inferenzkosten verursachen, wenn sie als reguläres Closed-Set-YOLO verwendet werden. Nach dem Training können YOLOE-Parameter in einen Standard-YOLO-Head reparametrisiert werden, wodurch identische FLOPs und Geschwindigkeit erhalten bleiben (z. B. genau übereinstimmend mit YOLO11).

Verfügbare Modelle, unterstützte Aufgaben und Betriebsmodi

Dieser Abschnitt beschreibt detailliert die verfügbaren Modelle mit ihren spezifischen vortrainierten Gewichten, die von ihnen unterstützten Aufgaben und ihre Kompatibilität mit verschiedenen Betriebsmodi wie Inference, Validierung, Training und Export, gekennzeichnet durch ✅ für unterstützte Modi und ❌ für nicht unterstützte Modi.

Text/Visual Prompt Modelle

Prompt-freie Modelle

Anwendungsbeispiele

Die YOLOE-Modelle lassen sich einfach in Ihre Python-Anwendungen integrieren. Ultralytics bietet benutzerfreundliche Python APIs und CLI-Befehle, um die Entwicklung zu optimieren.

Trainingsanwendung

Feinabstimmung auf einem benutzerdefinierten Datensatz

Sie können jedes vorab trainierte YOLOE-Modell auf Ihrem benutzerdefinierten YOLO-Datensatz sowohl für Erkennungs- als auch für Instanzsegmentierungsaufgaben feinabstimmen.

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
)

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
)

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

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

Vorhersageanwendung

YOLOE unterstützt sowohl textbasierte als auch visuelle Prompts. Die Verwendung von Prompts ist unkompliziert—einfach durch die predict Methode, wie unten gezeigt, verwenden:

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

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

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

Val-Anwendung

Die Modellvalidierung auf einem Datensatz wird wie folgt optimiert:

from ultralytics import YOLOE

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

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

from ultralytics import YOLOE

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

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

from ultralytics import YOLOE

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

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

from ultralytics import YOLOE

# Create a YOLOE model
model = YOLOE("yoloe-11l-seg-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)

Export-Nutzung

Der Exportprozess ähnelt dem anderer YOLO-Modelle, bietet aber zusätzlich die Flexibilität, Text- und visuelle Prompts zu verarbeiten:

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

Offizielle Modelle trainieren

Datensätze vorbereiten

• Trainingsdaten

• Val-Daten

Training von Grund auf starten

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

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

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

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

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

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
)

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

YOLOE Performancevergleich

YOLOE erreicht oder übertrifft die Genauigkeit von Closed-Set-YOLO-Modellen auf Standard-Benchmarks wie COCO, ohne Kompromisse bei Geschwindigkeit oder Modellgröße einzugehen. Die folgende Tabelle vergleicht YOLOE-L (basierend auf YOLO11) mit entsprechenden YOLOv8- und YOLO11-Modellen:

^† YOLO11-L und YOLOE-L haben identische Architekturen (Prompt-Module in YOLO11-L deaktiviert), was zu identischer Inferenzgeschwindigkeit und ähnlichen GFLOPs-Schätzungen führt.

YOLOE-L erreicht 52,6 % mAP und übertrifft damit YOLOv8-L (52,9 %) mit etwa 40 % weniger Parametern (26 Mio. vs. 43,7 Mio.). Es verarbeitet 640×640 Bilder in 6,2 ms (161 FPS) im Vergleich zu YOLOv8-L mit 9,06 ms (110 FPS), was die Effizienz von YOLO11 unterstreicht. Entscheidend ist, dass die Open-Vocabulary-Module von YOLOE keine Inferenzkosten verursachen, was ein "No Free Lunch Trade-off"-Design demonstriert.

Für Zero-Shot- und Transferaufgaben zeichnet sich YOLOE aus: Auf LVIS verbessert sich YOLOE-small gegenüber YOLO-Worldv2 um +3,5 AP bei 3-fach geringerem Trainingsaufwand. Das Feinjustieren von YOLOE-L von LVIS auf COCO erforderte ebenfalls 4-fach weniger Trainingszeit als YOLOv8-L, was seine Effizienz und Anpassungsfähigkeit unterstreicht. YOLOE behält weiterhin die typische YOLO-Geschwindigkeit bei und erreicht 300+ FPS auf einer T4 GPU und ~64 FPS auf dem iPhone 12 über CoreML, ideal für Edge- und Mobile-Bereitstellungen.

Vergleich mit früheren Modellen

YOLOE führt bemerkenswerte Fortschritte gegenüber früheren YOLO-Modellen und Open-Vocabulary-Detektoren ein:

• YOLOE gegen YOLOv5: YOLOv5 bot ein gutes Gleichgewicht zwischen Geschwindigkeit und Genauigkeit, erforderte jedoch ein erneutes Training für neue Klassen und verwendete ankerbasierte Köpfe. Im Gegensatz dazu ist YOLOE ankerfrei und erkennt neue Klassen dynamisch. YOLOE, das auf den Verbesserungen von YOLOv8 aufbaut, erreicht eine höhere Genauigkeit (52,6% im Vergleich zu YOLOv5~50% mAP auf COCO) und integriert im Gegensatz zu YOLOv5 eine Instanzsegmentierung.

• YOLOE gegen YOLOv8: YOLOE erweitert YOLOv8die neu gestaltete Architektur von YOLOv8 und erreicht eine ähnliche oder bessere Genauigkeit(52,6% mAP mit ~26M Parametern gegenüber 52,9% bei YOLOv8 mit ~44M Parametern). Die Trainingszeit wird durch ein stärkeres Pre-Training deutlich reduziert. Der wichtigste Fortschritt ist die Fähigkeit von YOLOE, eine offene Welt zu erkennen, indem es ungesehene Objekte (z. B."Vogel-Roller" oder"Friedenssymbol") über Eingabeaufforderungen erkennt, im Gegensatz zu YOLOv8 geschlossenem Design.

• YOLOE gegen YOLO11: YOLO11 verbessert YOLOv8 mit verbesserter Effizienz und weniger Parametern (~22% Reduzierung). YOLOE übernimmt diese Verbesserungen direkt und erreicht die gleiche Inferenzgeschwindigkeit und Parameteranzahl wie YOLO11(~26 Mio. Parameter), wobei die Erkennung und Segmentierung von offenem Vokabular hinzugefügt wird. In Szenarien mit geschlossenem Vokabular ist YOLOE äquivalent zu YOLO11, bietet aber zusätzlich die Möglichkeit, ungesehene Klassen zu erkennen, wodurch YOLO11 + Open-World-Fähigkeit ohne Geschwindigkeitseinbußen erreicht wird.

• YOLOE im Vergleich zu früheren Detektoren für offenes Vokabular: Frühere offene Vokabularmodelle (GLIP, OWL-ViT, YOLO) stützten sich stark auf Bild-Sprache-Transformatoren, was zu einer langsamen Inferenz führte. YOLOE übertrifft diese in der Zero-Shot-Genauigkeit (z.B. +3.5 AP vs. YOLO) und läuft dabei 1.4× schneller mit deutlich weniger Trainingsressourcen. Im Vergleich zu transformatorbasierten Ansätzen (z.B. GLIP) bietet YOLOE eine um Größenordnungen schnellere Inferenz und überbrückt damit effektiv die Genauigkeits-Effizienz-Lücke bei der Erkennung offener Sätze.

Zusammenfassend lässt sich sagen, dass YOLOE die bekannte Geschwindigkeit und Effizienz von YOLO beibehält, Vorgänger in der Genauigkeit übertrifft, die Segmentierung integriert und eine leistungsstarke Open-World-Erkennung einführt, was es einzigartig vielseitig und praktisch macht.

Anwendungsfälle und Anwendungen

Die Open-Vocabulary-Erkennung und -Segmentierung von YOLOE ermöglichen vielfältige Anwendungen, die über traditionelle Modelle mit festen Klassen hinausgehen:

• Open-World-Objekterkennung: Ideal für dynamische Szenarien wie die Robotik, bei der Roboter zuvor ungesehene Objekte anhand von Aufforderungen erkennen, oder für Sicherheitssysteme, die sich schnell an neue Bedrohungen (z. B. gefährliche Gegenstände) anpassen, ohne dass ein erneutes Training erforderlich ist.

• Few-Shot- und One-Shot-Detektion: Mithilfe visueller Eingabeaufforderungen (SAVPE) lernt YOLOE schnell neue Objekte aus einzelnen Referenzbildern - perfekt für die industrielle Inspektion (um Teile oder Defekte sofort zu identifizieren) oder die benutzerdefinierte Überwachung, die visuelle Suchen mit minimaler Einrichtung ermöglicht.

• Großes Vokabular und Long-Tail-Erkennung: Ausgestattet mit einem Vokabular von mehr als 1000 Klassen eignet sich YOLOE hervorragend für Aufgaben wie die Überwachung der biologischen Vielfalt (Erkennung seltener Arten), Museumssammlungen, Einzelhandelsinventar oder E-Commerce, da es viele Klassen ohne umfangreiches Training pro Klasse zuverlässig erkennt.

• Interaktive Erkennung und Segmentierung: YOLOE unterstützt interaktive Echtzeitanwendungen wie die Suche nach Videos/Bildern, Augmented Reality (AR) und intuitive Bildbearbeitung, die durch natürliche Eingaben (Text oder visuelle Eingabeaufforderungen) gesteuert werden. Benutzer können Objekte mithilfe von Segmentierungsmasken dynamisch isolieren, identifizieren oder präzise bearbeiten.

• Automatisierte Datenbeschriftung und Bootstrapping: YOLOE erleichtert die schnelle Erstellung von Datensätzen, indem es anfängliche Bounding-Box- und Segmentierungskommentare bereitstellt und so den Aufwand für die menschliche Beschriftung erheblich reduziert. Besonders wertvoll ist dies bei der Analyse großer Mediensammlungen, wo es die vorhandenen Objekte automatisch identifizieren kann und so die Erstellung spezialisierter Modelle beschleunigt.

• Segmentierung für beliebige Objekte: Erweitert die Segmentierungsfunktionen durch Eingabeaufforderungen auf beliebige Objekte - besonders vorteilhaft für die medizinische Bildgebung, Mikroskopie oder die Analyse von Satellitenbildern-, indem Strukturen automatisch identifiziert und präzise segmentiert werden, ohne dass spezielle, vorab trainierte Modelle erforderlich sind. Im Gegensatz zu Modellen wie SAMerkennt und segmentiert YOLOE Objekte gleichzeitig automatisch und hilft so bei Aufgaben wie der Erstellung von Inhalten oder dem Verstehen von Szenen.

Bei all diesen Anwendungsfällen liegt der Hauptvorteil von YOLOE in seiner Vielseitigkeit, da es ein einheitliches Modell für Erkennung, Wiedererkennung und Segmentierung in dynamischen Szenarien bietet. Seine Effizienz gewährleistet Echtzeitleistung auf ressourcenbeschränkten Geräten, ideal für Robotik, autonomes Fahren, Verteidigung und darüber hinaus.

Training und Inferenz

YOLOE lässt sich nahtlos in die Ultralytics Python API und die CLI integrieren, ähnlich wie andere YOLO-Modelle (YOLOv8, YOLO-World). Hier erfahren Sie, wie Sie schnell loslegen können:

from ultralytics import YOLO

# Load pre-trained YOLOE model and train on custom data
model = YOLO("yoloe-11s-seg.pt")
model.train(data="path/to/data.yaml", epochs=50, imgsz=640)

# Run inference using text prompts ("person", "bus")
model.set_classes(["person", "bus"])
results = model.predict(source="test_images/street.jpg")
results[0].save()  # save annotated output

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

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

Andere unterstützte Aufgaben

• Validierung: Bewerten Sie die Genauigkeit einfach mit model.val() oder yolo val.
• Exportieren: YOLOE-Modelle exportieren (model.export()) zu ONNX, TensorRT usw., was die Bereitstellung erleichtert.
• Tracking: YOLOE unterstützt Objektverfolgung (yolo track) bei der Integration nützlich, um abgefragte Klassen in Videos zu verfolgen.

Loslegen

Richten Sie YOLOE mit Ultralytics schnell ein, indem Sie diese Schritte befolgen:

1. Installation: Installiere oder aktualisiere das Ultralytics-Paket:

   pip install -U ultralytics
   

2. YOLOE-Gewichte herunterladen: Vorab trainierte YOLOE-Modelle (z. B. YOLOE-v8-S/L, YOLOE-11-Varianten) sind über die YOLOE GitHub-Releases verfügbar. Laden Sie einfach Ihr gewünschtes Modell herunter .pt Datei, die in die Ultralytics YOLO-Klasse geladen werden soll.

3. Hardwareanforderungen:

   • Inferenz: Empfohlene GPU (NVIDIA mit ≥4-8 GB VRAM). Kleine Modelle laufen effizient auf Edge-GPUs (z. B. Jetson) oder CPUs mit niedrigeren Auflösungen.
   • Training: Das Feinjustieren von YOLOE auf benutzerdefinierten Daten erfordert typischerweise nur eine GPU. Umfangreiches Open-Vocabulary-Pre-Training (LVIS/Objects365), das von den Autoren verwendet wurde, erforderte erhebliche Rechenleistung (8× RTX 4090 GPUs).

4. Konfiguration: YOLOE-Konfigurationen verwenden standardmäßige Ultralytics YAML-Dateien. Standardkonfigurationen (z. B. yoloe-11s-seg.yaml) in der Regel ausreichen, aber Sie können Backbone, Klassen oder die Bildgröße nach Bedarf anpassen.

5. YOLOE ausführen:

   • Schnelle Inferenz (Prompt-frei):

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

   • Prompted Detection (Text-Prompt-Beispiel):

     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. Integrationstipps:

   • Klassennamen: Standardmäßige YOLOE-Ausgaben verwenden LVIS-Kategorien; verwenden Sie set_classes() um Ihre eigenen Labels anzugeben.
   • Geschwindigkeit: YOLOE hat keinen Overhead, es sei denn, es werden Prompts verwendet. Text-Prompts haben minimale Auswirkungen; visuelle Prompts etwas mehr.
   • Batch-Inferenz: Direkt unterstützt (model.predict([img1, img2])). Für bildspezifische Prompts führen Sie die Bilder einzeln aus.

Die Ultralytics-Dokumentation bietet weitere Ressourcen. Mit YOLOE können Sie auf einfache Weise leistungsstarke Open-World-Funktionen innerhalb des vertrauten YOLO-Ökosystems erkunden.

Zitate und Danksagungen

Wenn YOLOE zu Ihrer Forschung oder Ihrem Projekt beigetragen hat, zitieren Sie bitte das Originalpapier von Ao Wang, Lihao Liu, Hui Chen, Zijia Lin, Jungong Han und Guiguang Ding von der 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},
}

Für weitere Informationen steht das Original YOLOE-Paper auf arXiv zur Verfügung. Der Quellcode des Projekts und zusätzliche Ressourcen sind über das GitHub-Repository zugänglich.

FAQ

Wie unterscheidet sich YOLOE von YOLO-World?

Während sowohl YOLOE als auch YOLO-World Open-Vocabulary-Detection ermöglichen, bietet YOLOE mehrere Vorteile. YOLOE erzielt eine um +3,5 AP höhere Genauigkeit auf LVIS, während es 3× weniger Trainingsressourcen verbraucht und 1,4× schneller läuft als YOLO-Worldv2. YOLOE unterstützt auch drei Prompting-Modi (Text, visuell und internes Vokabular), während sich YOLO-World hauptsächlich auf Text-Prompts konzentriert. Zusätzlich beinhaltet YOLOE integrierte Instanzsegmentierungs-Funktionen, die pixelgenaue Masken für erkannte Objekte ohne zusätzlichen Overhead bereitstellen.

Kann ich YOLOE als reguläres YOLO-Modell verwenden?

Ja, YOLOE kann genau wie ein Standard-YOLO-Modell ohne Leistungseinbußen funktionieren. Wenn YOLOE im Closed-Set-Modus (ohne Prompts) verwendet wird, werden die Open-Vocabulary-Module in den Standard-Detection-Head reparametrisiert, was zu identischer Geschwindigkeit und Genauigkeit wie bei äquivalenten YOLO11-Modellen führt. Dies macht YOLOE äußerst vielseitig – Sie können es als traditionellen Detektor für maximale Geschwindigkeit verwenden und nur bei Bedarf in den Open-Vocabulary-Modus wechseln.

Welche Arten von Prompts kann ich mit YOLOE verwenden?

YOLOE unterstützt drei Arten von Prompts:

1. Text-Prompts: Geben Sie Objektklassen in natürlicher Sprache an (z. B. "Person", "Ampel", "Vogelroller")
2. Visuelle Prompts: Stellen Sie Referenzbilder von Objekten bereit, die Sie erkennen möchten
3. Internes Vokabular: Verwenden Sie das integrierte Vokabular von YOLOE mit über 1200 Kategorien ohne externe Prompts.

Diese Flexibilität ermöglicht es Ihnen, YOLOE an verschiedene Szenarien anzupassen, ohne das Modell neu trainieren zu müssen. Dies ist besonders nützlich für dynamische Umgebungen, in denen sich die Erkennungsanforderungen häufig ändern.

Wie handhabt YOLOE die Instanzsegmentierung?

YOLOE integriert die Instanzsegmentierung direkt in seine Architektur, indem es den Erkennungskopf um einen Maskenprädiktionszweig erweitert. Dieser Ansatz ähnelt YOLOv8-Seg, funktioniert aber für jede abgefragte Objektklasse. Segmentierungsmasken sind automatisch in den Inferenz-Ergebnissen enthalten und können abgerufen werden über results[0].masks. Dieser einheitliche Ansatz macht separate Detektions- und Segmentierungsmodelle überflüssig und rationalisiert die Arbeitsabläufe für Anwendungen, die pixelgenaue Objektgrenzen erfordern.

Wie verarbeitet YOLOE die Inferenz mit benutzerdefinierten Prompts?

Ähnlich wie YOLO-World unterstützt YOLOE eine "Prompt-then-Detect"-Strategie, die ein Offline-Vokabular verwendet, um die Effizienz zu steigern. Benutzerdefinierte Prompts wie Bildunterschriften oder bestimmte Objektkategorien werden vorab codiert und als Offline-Vokabular-Einbettungen gespeichert. Dieser Ansatz rationalisiert den Erkennungsprozess, ohne dass ein erneutes Training erforderlich ist. Sie können diese Prompts dynamisch innerhalb des Modells festlegen, um es an spezifische Erkennungsaufgaben anzupassen:

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

📅 Erstellt vor 6 Monaten ✏️ Aktualisiert vor 19 Tagen

Kommentare