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 vs. YOLOv5:
  YOLOv5 bot ein gutes Gleichgewicht zwischen Geschwindigkeit und Genauigkeit, erforderte aber ein erneutes Training für neue Klassen und verwendete ankerbasierte Heads. Im Gegensatz dazu ist YOLOE ankerfrei und erkennt dynamisch neue Klassen. YOLOE, das auf den Verbesserungen von YOLOv8 aufbaut, erzielt eine höhere Genauigkeit (52,6 % vs. ~50 % mAP auf COCO) und integriert die Instanzsegmentierung, anders als YOLOv5.

• YOLOE vs. YOLOv8:
  YOLOE erweitert die neu gestaltete Architektur von YOLOv8 und erzielt eine ähnliche oder höhere Genauigkeit (52,6 % mAP mit ~26 Millionen Parametern vs. 52,9 % mit ~44 Millionen Parametern bei YOLOv8-L). Es reduziert die Trainingszeit aufgrund eines stärkeren Vortrainings erheblich. Der wichtigste Fortschritt ist die Open-World-Fähigkeit von YOLOE, unbekannte Objekte (z. B. "bird scooter" oder "peace symbol") über Prompts zu erkennen, im Gegensatz zum Closed-Set-Design von YOLOv8.

• YOLOE vs. YOLO11:
  YOLO11 verbessert YOLOv8 durch erhöhte Effizienz und weniger Parameter (~22 % Reduktion). YOLOE erbt diese Vorteile direkt, erreicht die gleiche Inferenzgeschwindigkeit und Parameteranzahl wie YOLO11 (~26 Millionen Parameter) und fügt gleichzeitig Open-Vocabulary-Erkennung und -Segmentierung hinzu. In Closed-Set-Szenarien ist YOLOE äquivalent zu YOLO11, bietet aber entscheidend die Anpassungsfähigkeit, um unbekannte Klassen zu erkennen, und erreicht YOLO11 + Open-World-Fähigkeit, ohne die Geschwindigkeit zu beeinträchtigen.

• YOLOE vs. frühere Open-Vocabulary-Detektoren:
  Frühere Open-Vocab-Modelle (GLIP, OWL-ViT, YOLO-World) stützten sich stark auf Vision-Language-Transformer, was zu einer langsamen Inferenz führte. YOLOE übertrifft diese in der Zero-Shot-Genauigkeit (z. B. +3,5 AP vs. YOLO-Worldv2) und läuft dabei 1,4-mal schneller mit deutlich geringeren Trainingsressourcen. Im Vergleich zu Transformer-basierten Ansätzen (z. B. GLIP) bietet YOLOE eine um Größenordnungen schnellere Inferenz und schließt effektiv die Genauigkeits-Effizienz-Lücke in der Open-Set-Erkennung.

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 Robotik, wo Roboter zuvor ungesehene Objekte mithilfe von Prompts erkennen, oder Sicherheitssysteme, die sich schnell an neue Bedrohungen (z. B. gefährliche Gegenstände) anpassen, ohne ein erneutes Training.

• Few-Shot- und One-Shot-Detection:
  Mithilfe visueller Prompts (SAVPE) lernt YOLOE schnell neue Objekte aus einzelnen Referenzbildern – perfekt für die industrielle Inspektion (sofortige Identifizierung von Teilen oder Defekten) oder benutzerdefinierte Überwachung, die visuelle Suchen mit minimalem Setup ermöglicht.

• Erkennung mit großem Vokabular & Long-Tail-Erkennung:
  Ausgestattet mit einem Vokabular von über 1000 Klassen, zeichnet sich YOLOE in Aufgaben wie Biodiversitätsüberwachung (Erkennung seltener Arten), Museumssammlungen, Einzelhandelsinventar oder E-Commerce aus und identifiziert zuverlässig viele Klassen ohne umfangreiches Training pro Klasse.

• Interaktive Erkennung und Segmentierung:
  YOLOE unterstützt interaktive Echtzeitanwendungen wie durchsuchbare Video- / Bildabrufe, Augmented Reality (AR) und intuitive Bildbearbeitung, die durch natürliche Eingaben (Text- oder visuelle Prompts) gesteuert werden. Benutzer können Objekte dynamisch isolieren, identifizieren oder präzise bearbeiten, indem sie Segmentierungsmasken verwenden.

• Automatisierte Datenbeschriftung und Bootstrapping:
  YOLOE ermöglicht eine schnelle Erstellung von Datensätzen durch die Bereitstellung erster Begrenzungsrahmen- und Segmentierungsanmerkungen, wodurch der Aufwand für die manuelle Beschriftung erheblich reduziert wird. Besonders wertvoll bei der Analyse großer Mediensammlungen, wo es automatisch vorhandene Objekte identifizieren und so den Aufbau spezialisierter Modelle beschleunigen kann.

• Segmentierung für beliebige Objekte:
  Erweitert die Segmentierungsfunktionen auf beliebige Objekte durch Prompts – besonders vorteilhaft für medizinische Bildgebung, Mikroskopie oder Satellitenbildanalyse, wobei Strukturen automatisch identifiziert und präzise segmentiert werden, ohne dass spezielle vortrainierte Modelle erforderlich sind. Im Gegensatz zu Modellen wie SAM erkennt und segmentiert YOLOE Objekte gleichzeitig automatisch und unterstützt so Aufgaben wie Content-Erstellung oder Szenenverständnis.

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 5 Monaten ✏️ Aktualisiert vor 11 Tagen

Kommentare