YOLOE: Alles in Echtzeit sehen

Einführung

YOLOE (Real-Time Seeing Anything) ist ein neuer Fortschritt bei Zero-Shot-fähigen, promptbaren YOLO-Modellen, die für 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, was die Echtzeiterkennung jeder beliebigen Objektklasse ermöglicht. YOLOE basiert auf YOLOv10 und wurde von YOLO-World inspiriert. Es erzielt modernste Zero-Shot-Leistung mit minimalen Auswirkungen auf Geschwindigkeit und Genauigkeit.

Im Vergleich zu früheren YOLO-Modellen steigert YOLOE die Effizienz und Genauigkeit erheblich. Es verbessert die Leistung auf LVIS um +3,5 AP gegenüber YOLO-Worldv2, während es nur ein Drittel der Trainingsressourcen benötigt und 1,4-mal schnellere Inferenzgeschwindigkeiten erreicht. Auf COCO feinabgestimmt, übertrifft YOLOE-v8-large YOLOv8-L um 0,1 mAP, wobei es fast 4-mal weniger Trainingszeit benötigt. 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 in das Ultralytics Framework.

Architektur-Übersicht

YOLOE behält die Standard-YOLO-Struktur bei – ein konvolutionelles Backbone (z. B. CSP-Darknet) zur Merkmalsextraktion, einen Neck (z. B. PAN-FPN) zur mehrskaligen Fusion und einen ankerfreien, entkoppelten Erkennungs-Head (wie in YOLOv8/YOLO11), der Objektpräsenz, Klassen und Boxen unabhängig voneinander vorhersagt. YOLOE führt drei neuartige Module ein, die eine Open-Vocabulary-Erkennung ermöglichen:

• Re-parameterizable Region-Text Alignment (RepRTA): Unterstützt textbasierte Erkennung durch Verfeinerung von Text-Embeddings (z. B. von CLIP) mittels eines kleinen Hilfsnetzwerks. Bei der Inferenz wird dieses Netzwerk in das Hauptmodell gefaltet, was sicherstellt, dass kein Mehraufwand entsteht. YOLOE erkennt so beliebige textbeschriftete Objekte (z. B. eine ungesehene „Ampel“) ohne Laufzeit-Einbußen.

• Semantic-Activated Visual Prompt Encoder (SAVPE): Ermöglicht visuell gesteuerte Erkennung über einen leichtgewichtigen Embedding-Zweig. Angesichts eines Referenzbildes kodiert SAVPE semantische und Aktivierungsmerkmale und konditioniert das Modell darauf, visuell ähnliche Objekte zu erkennen – eine One-Shot-Erkennungsfähigkeit, die für Logos oder spezifische Teile nützlich ist.

• Lazy Region-Prompt Contrast (LRPC): Im promptfreien Modus führt YOLOE eine Open-Set-Erkennung mittels interner Embeddings durch, die auf großen Vokabularen trainiert wurden (über 1200 Kategorien aus LVIS und Objects365). Ohne externe Prompts oder Encoder identifiziert YOLOE Objekte durch einen Abgleich der Embedding-Ähnlichkeit, wodurch große Label-Bereiche bei der Inferenz effizient verarbeitet werden.

Zusätzlich integriert YOLOE Echtzeit-Instanzsegmentierung, indem der Erkennungs-Head um einen Maskenvorhersage-Zweig erweitert wird (ähnlich wie bei YOLACT oder YOLOv8-Seg), was nur minimalen Mehraufwand bedeutet.

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 re-parameterisiert werden, wobei identische FLOPs und Geschwindigkeiten erhalten bleiben (z. B. exakt passend zu YOLO11).

Verfügbare Modelle, unterstützte Aufgaben und Betriebsmodi

Dieser Abschnitt beschreibt die verfügbaren Modelle mit ihren spezifischen vortrainierten Gewichten, die von ihnen unterstützten Aufgaben und ihre Kompatibilität mit verschiedenen Betriebsmodi wie Inferenz, 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 deine Python-Anwendungen integrieren. Ultralytics bietet eine benutzerfreundliche Python API und CLI-Befehle, um die Entwicklung zu beschleunigen.

Trainingsnutzung

Feinabstimmung auf einem benutzerdefinierten Datensatz

Du kannst jedes vorab trainierte YOLOE-Modell auf deinem 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-26s-seg.pt")

# Fine-tune on your segmentation dataset
results = model.train(
    data="coco128-seg.yaml",  # Segmentation dataset
    epochs=80,
    patience=10,
    trainer=YOLOEPESegTrainer,  # <- Important: use segmentation trainer
)

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

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

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

# Fine-tune on your detection dataset
results = model.train(
    data="coco128.yaml",  # Detection dataset
    epochs=80,
    patience=10,
    trainer=YOLOEPETrainer,  # <- Important: use detection trainer
)

Vorhersage-Nutzung

YOLOE unterstützt sowohl textbasierte als auch visuelle Prompts. Die Verwendung von Prompts ist unkompliziert – übergib sie einfach über die predict-Methode, wie unten gezeigt:

from ultralytics import YOLOE

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

# Set text prompt to detect person and bus. You only need to do this once after you load the model.
model.set_classes(["person", "bus"])

# Run detection on the given image
results = model.predict("path/to/image.jpg")

# Show results
results[0].show()

Validierungs-Nutzung

Die Modellvalidierung auf einem Datensatz wird wie folgt optimiert:

from ultralytics import YOLOE

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

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

Export-Nutzung

Der Exportprozess ähnelt anderen YOLO-Modellen, mit der zusätzlichen Flexibilität, Text- und visuelle Prompts zu handhaben:

from ultralytics import YOLOE

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

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

export_model = model.export(format="onnx")
model = YOLOE(export_model)

# Run detection on the given image
results = model.predict("path/to/image.jpg")

# Show results
results[0].show()

Offizielle Modelle trainieren

Datensätze vorbereiten

• Trainingsdaten

• Validierungsdaten

Training von Grund auf starten

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

# Option 1: Use Python dictionary
data = dict(
    train=dict(
        yolo_data=["Objects365.yaml"],
        grounding_data=[
            dict(
                img_path="flickr/full_images/",
                json_file="flickr/annotations/final_flickr_separateGT_train_segm.json",
            ),
            dict(
                img_path="mixed_grounding/gqa/images",
                json_file="mixed_grounding/annotations/final_mixed_train_no_coco_segm.json",
            ),
        ],
    ),
    val=dict(yolo_data=["lvis.yaml"]),
)

# Option 2: Use YAML file (yoloe_data.yaml)
# train:
#   yolo_data:
#     - Objects365.yaml
#   grounding_data:
#     - img_path: flickr/full_images/
#       json_file: flickr/annotations/final_flickr_separateGT_train_segm.json
#     - img_path: mixed_grounding/gqa/images
#       json_file: mixed_grounding/annotations/final_mixed_train_no_coco_segm.json
# val:
#   yolo_data:
#     - lvis.yaml

model = YOLOE("yoloe-26l-seg.yaml")
model.train(
    data=data,  # or data="yoloe_data.yaml" if using YAML file
    batch=128,
    epochs=30,
    close_mosaic=2,
    optimizer="AdamW",
    lr0=2e-3,
    warmup_bias_lr=0.0,
    weight_decay=0.025,
    momentum=0.9,
    workers=4,
    trainer=YOLOESegTrainerFromScratch,
    device="0,1,2,3,4,5,6,7",
)

YOLOE Leistungsvergleich

YOLOE erreicht oder übertrifft die Genauigkeit von Closed-Set YOLO-Modellen auf Standard-Benchmarks wie COCO und LVIS, ohne dabei Geschwindigkeit oder Modellgröße zu beeinträchtigen. Die folgende Tabelle vergleicht YOLOE-L (basierend auf YOLO11) und YOLOE26-L (basierend auf YOLO26) mit den entsprechenden Closed-Set-Modellen:

^† YOLOE-L teilt sich die Architektur von YOLO11-L und YOLOE26-L die von YOLO26-L, was zu ähnlicher Inferenzgeschwindigkeit und GFLOPs führt.

YOLOE26-L erzielt 36,8 % LVIS mAP mit 32,3 Mio. Parametern und 88,3 Mrd. FLOPs und verarbeitet 640×640 Bilder mit 6,2 ms (161 FPS) auf einer T4 GPU. Dies ist eine Verbesserung gegenüber dem 35,2 % LVIS mAP von YOLOE-L bei gleichbleibender Inferenzgeschwindigkeit. Entscheidend ist, dass die Open-Vocabulary-Module von YOLOE keine Inferenzkosten verursachen, was ein Design nach dem Prinzip "no free lunch trade-off" demonstriert.

Bei Zero-Shot-Aufgaben übertrifft YOLOE26 bisherige Open-Vocabulary-Detektoren deutlich: Auf LVIS erreicht YOLOE26-S 29,9 % mAP und übertrifft YOLO-World-S um +11,4 AP, während YOLOE26-L 36,8 % mAP erreicht und YOLO-World-L um +10,0 AP übertrifft. YOLOE26 behält eine effiziente Inferenz von 161 FPS auf einer T4 GPU bei, ideal für Open-Vocabulary-Anwendungen in Echtzeit.

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 jedoch ein erneutes Training für neue Klassen und verwendete Anchor-basierte Heads. Im Gegensatz dazu ist YOLOE Anchor-frei und erkennt neue Klassen dynamisch. Basierend auf den Verbesserungen von YOLOv8 erzielt YOLOE eine höhere Genauigkeit (52,6 % gegenüber ~50 % mAP bei YOLOv5 auf COCO) und integriert, im Gegensatz zu YOLOv5, Instanzsegmentierung.

• YOLOE vs. YOLOv8: YOLOE erweitert die neugestaltete Architektur von YOLOv8 und erzielt eine ähnliche oder bessere Genauigkeit (52,6 % mAP mit ~26 Mio. Parametern gegenüber 52,9 % mit ~44 Mio. Parametern bei YOLOv8-L). Aufgrund eines stärkeren Vortrainings wird die Trainingszeit erheblich verkürzt. Der entscheidende Fortschritt ist die Open-World-Fähigkeit von YOLOE, die unbekannte Objekte (z. B. "bird scooter" oder "peace symbol") per Prompt erkennt, im Gegensatz zum Closed-Set-Design von YOLOv8.

• YOLOE vs. YOLO11: YOLO11 verbessert YOLOv8 durch höhere Effizienz und weniger Parameter (Reduzierung um ~22 %). YOLOE übernimmt diese Gewinne direkt, entspricht der Inferenzgeschwindigkeit und Parameteranzahl von YOLO11 (~26 Mio. Parameter) und fügt gleichzeitig Open-Vocabulary-Erkennung und -Segmentierung hinzu. In Closed-Set-Szenarien ist YOLOE äquivalent zu YOLO11, erweitert dies jedoch um die Anpassungsfähigkeit, unbekannte Klassen zu erkennen, und erzielt so YOLO11 + Open-World-Fähigkeit, ohne die Geschwindigkeit zu beeinträchtigen.

• YOLOE26 vs. YOLOE (YOLO11-basiert): YOLOE26 baut auf der Architektur von YOLO26 auf und übernimmt dessen NMS-freies End-to-End-Design für schnellere Inferenz. Auf LVIS erreicht YOLOE26-L 36,8 % mAP und verbessert damit den Wert von 35,2 % mAP bei YOLOE-L. YOLOE26 bietet alle fünf Modellgrößen (N/S/M/L/X) im Vergleich zu den drei von YOLOE (S/M/L) und bietet somit mehr Flexibilität für verschiedene Bereitstellungsszenarien.

• YOLOE26 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 langsamer Inferenz führte. Auf LVIS erzielt YOLOE26-S 29,9 % mAP (+11,4 AP gegenüber YOLO-World-S) und YOLOE26-L 36,8 % mAP (+10,0 AP gegenüber YOLO-World-L), bei gleichbleibender Echtzeit-Inferenz von 161 FPS auf einer T4 GPU. Im Vergleich zu Transformer-basierten Ansätzen (z. B. GLIP) bietet YOLOE26 eine um Größenordnungen schnellere Inferenz und überbrückt so effektiv die Lücke zwischen Genauigkeit und Effizienz bei der Open-Set-Erkennung.

Zusammenfassend lässt sich sagen, dass YOLOE und YOLOE26 die bekannte Geschwindigkeit und Effizienz von YOLO beibehalten, Vorgänger in der Genauigkeit übertreffen, Segmentierung integrieren und eine leistungsstarke Open-World-Erkennung einführen. YOLOE26 verbessert die Architektur weiter durch die NMS-freie End-to-End-Inferenz von YOLO26, was es ideal für Open-Vocabulary-Anwendungen in Echtzeit macht.

Anwendungsfälle und Einsatzgebiete

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

• Open-World-Objekterkennung: Ideal für dynamische Szenarien wie Robotik, bei denen Roboter zuvor unbekannte Objekte mittels Prompts erkennen, oder 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-Erkennung: Mit visuellen Prompts (SAVPE) lernt YOLOE neue Objekte schnell aus einzelnen Referenzbildern—perfekt für die industrielle Inspektion (sofortige Identifizierung von Teilen oder Fehlern) oder kundenspezifische Überwachung, was visuelle Suchen mit minimalem Einrichtungsaufwand ermöglicht.

• Erkennung großer Vokabulare & Long-Tail-Kategorien: Ausgestattet mit einem Vokabular von über 1000 Klassen zeichnet sich YOLOE bei 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-/Bildabfrage, erweiterte Realität (AR) und intuitive Bildbearbeitung, gesteuert durch natürliche Eingaben (Text- oder visuelle Prompts). Benutzer können Objekte präzise mittels Segmentierungsmasken dynamisch isolieren, identifizieren oder bearbeiten.

• Automatisierte Datenkennzeichnung und Bootstrapping: YOLOE erleichtert die schnelle Erstellung von Datensätzen durch die Bereitstellung anfänglicher Bounding-Box- und Segmentierungsanmerkungen, wodurch der manuelle Kennzeichnungsaufwand erheblich reduziert wird. Besonders wertvoll bei der Analyse großer Mediensammlungen, wo vorhandene Objekte automatisch identifiziert werden können, was beim schnelleren Aufbau spezialisierter Modelle hilft.

• Segmentierung für beliebige Objekte: Erweitert die Segmentierungsfähigkeiten auf beliebige Objekte mittels Prompts—besonders vorteilhaft für medizinische Bildgebung, Mikroskopie oder Satellitenbildanalyse, indem Strukturen automatisch identifiziert und präzise segmentiert werden, ohne dass spezialisierte vortrainierte Modelle erforderlich sind. Im Gegensatz zu Modellen wie SAM erkennt und segmentiert YOLOE Objekte gleichzeitig automatisch, was bei Aufgaben wie der Inhaltserstellung oder dem Szenenverständnis hilft.

Bei all diesen Anwendungsfällen ist der Hauptvorteil von YOLOE seine Vielseitigkeit, die ein einheitliches Modell für Erkennung, Identifizierung und Segmentierung in dynamischen Szenarien bietet. Seine Effizienz gewährleistet Echtzeitleistung auf ressourcenbeschränkten Geräten, ideal für Robotik, autonomes Fahren, Verteidigung und mehr.

Training und Inferenz

YOLOE lässt sich nahtlos in die Ultralytics Python API und das CLI integrieren, ähnlich wie andere YOLO-Modelle (YOLOv8, YOLO-World). So gelingt der schnelle Einstieg:

from ultralytics import YOLO

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

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

Weitere unterstützte Aufgaben

• Validierung: Evaluieren Sie die Genauigkeit einfach mit model.val() oder yolo val.
• Export: Exportieren Sie YOLOE-Modelle (model.export()) in ONNX, TensorRT usw., um die Bereitstellung zu erleichtern.
• Tracking: YOLOE unterstützt Objektverfolgung (yolo track), wenn es integriert ist, nützlich für die Verfolgung von Prompt-Klassen in Videos.

Erste Schritte

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

1. Installation: Installieren oder aktualisieren Sie das Ultralytics-Paket:

   pip install -U ultralytics

2. YOLOE-Gewichte herunterladen: Vortrainierte YOLOE-Modelle (z. B. YOLOE-v8-S/L, YOLOE-11 Varianten) sind über die YOLOE GitHub-Releases erhältlich. Laden Sie einfach Ihre gewünschte .pt-Datei herunter, um sie in die Ultralytics YOLO-Klasse zu laden.

3. Hardwareanforderungen:

   • Inferenz: Empfohlene GPU (NVIDIA mit ≥4-8GB VRAM). Kleine Modelle laufen effizient auf Edge-GPUs (z. B. Jetson) oder CPUs bei niedrigeren Auflösungen. Für leistungsstarke Inferenz auf kompakten Workstations lesen Sie unseren NVIDIA DGX Spark Leitfaden.
   • Training: Das Feintuning von YOLOE auf benutzerdefinierten Daten erfordert typischerweise nur eine GPU. Umfangreiches Open-Vocabulary-Vortraining (LVIS/Objects365), wie es von den Autoren verwendet wurde, erforderte erhebliche Rechenleistung (8× RTX 4090 GPUs).

4. Konfiguration: YOLOE-Konfigurationen verwenden Standard-Ultralytics YAML-Dateien. Standard-Configs (z. B. yoloe-26s-seg.yaml) reichen in der Regel aus, aber Sie können Backbone, Klassen oder Bildgröße bei Bedarf anpassen.

5. Ausführen von YOLOE:

   • Schnelle Inferenz (prompt-frei):

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

   • Prompt-basierte Erkennung (Beispiel für Text-Prompt):

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

6. Integrations-Tipps:

   • Klassennamen: Standard-YOLOE-Ausgaben verwenden LVIS-Kategorien; verwenden Sie set_classes(), um eigene Labels anzugeben.
   • Geschwindigkeit: YOLOE hat keinen Overhead, es sei denn, Sie verwenden Prompts. Text-Prompts haben minimale Auswirkungen; visuelle Prompts etwas mehr.
   • NMS-Verhalten: YOLOE verwendet automatisch agnostic_nms=True während der Vorhersage und führt überlappende Boxen über Klassen hinweg zusammen. Dies verhindert doppelte Erkennungen, wenn dasselbe Objekt mehreren Kategorien im großen Vokabular von YOLOE (über 1200 LVIS-Klassen) entspricht. Sie können dies überschreiben, indem Sie explizit agnostic_nms=False übergeben.
   • Batch-Inferenz: Direkt unterstützt (model.predict([img1, img2])). Für bildspezifische Prompts verarbeiten Sie Bilder einzeln.

Die Ultralytics Dokumentation bietet weitere Ressourcen. YOLOE ermöglicht es Ihnen, leistungsstarke Open-World-Fähigkeiten innerhalb des bekannten YOLO-Ökosystems zu erkunden.

Zitate und Danksagungen

Wenn YOLOE zu Ihrer Forschung oder Ihrem Projekt beigetragen hat, zitieren Sie bitte die Originalarbeit 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 weiterführende Literatur ist das YOLOE-Originalpapier auf arXiv verfügbar. Der Quellcode des Projekts und weitere Ressourcen sind über deren GitHub-Repository zugänglich.

FAQ

Wie unterscheidet sich YOLOE von YOLO-World?

Obwohl sowohl YOLOE als auch YOLO-World eine Open-Vocabulary-Erkennung ermöglichen, bietet YOLOE mehrere Vorteile. YOLOE erreicht 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 zudem drei Prompt-Modi (Text, visuell und internes Vokabular), während sich YOLO-World primär auf Text-Prompts konzentriert. Zusätzlich umfasst YOLOE integrierte Instanzsegmentierungs-Funktionen, die pixelgenaue Masken für erkannte Objekte ohne zusätzlichen Overhead liefern.

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

Ja, YOLOE kann exakt wie ein Standard-YOLO-Modell ohne Leistungseinbußen funktionieren. Bei Verwendung im Closed-Set-Modus (ohne Prompts) werden die Open-Vocabulary-Module von YOLOE in den Standard-Detektions-Head reparametrisiert, was zu identischer Geschwindigkeit und Genauigkeit wie bei entsprechenden YOLO11-Modellen führt. Dies macht YOLOE extrem vielseitig—Sie können es als traditionellen Detektor für maximale Geschwindigkeit verwenden und nur bei Bedarf in den Open-Vocabulary-Modus umschalten.

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", "traffic light", "bird scooter")
2. Visuelle Prompts: Stellen Sie Referenzbilder von Objekten bereit, die Sie erkennen möchten
3. Internes Vokabular: Nutzen Sie das integrierte Vokabular von YOLOE mit über 1200 Kategorien ohne externe Prompts

Diese Flexibilität erlaubt es Ihnen, YOLOE an verschiedene Szenarien anzupassen, ohne das Modell neu zu trainieren, was es besonders nützlich für dynamische Umgebungen macht, in denen sich Erkennungsanforderungen häufig ändern.

Wie geht YOLOE mit Instanzsegmentierung um?

YOLOE integriert Instanzsegmentierung direkt in seine Architektur, indem es den Detektions-Head um einen Maskenvorhersage-Zweig erweitert. Dieser Ansatz ähnelt YOLOv8-Seg, funktioniert jedoch für jede Prompt-basierte Objektklasse. Segmentierungsmasken sind automatisch in den Inferenz-Ergebnissen enthalten und können über results[0].masks abgerufen werden. Dieser einheitliche Ansatz macht separate Detektions- und Segmentierungsmodelle überflüssig und strafft Workflows für Anwendungen, die pixelgenaue Objektgrenzen erfordern.

Wie geht YOLOE mit Inferenz bei benutzerdefinierten Prompts um?

Ähnlich wie YOLO-World unterstützt YOLOE eine "Prompt-then-Detect"-Strategie, die ein Offline-Vokabular nutzt, um die Effizienz zu steigern. Benutzerdefinierte Prompts wie Bildunterschriften oder spezifische Objektkategorien werden vorab kodiert und als Offline-Vokabular-Embeddings gespeichert. Dieser Ansatz optimiert den Detektionsprozess, ohne dass ein erneutes Training erforderlich ist. Sie können diese Prompts innerhalb des Modells dynamisch festlegen, um es auf spezifische Detektionsaufgaben zuzuschneiden:

from ultralytics import YOLO

# Initialize a YOLOE model
model = YOLO("yoloe-26s-seg.pt")

# Define custom classes
model.set_classes(["person", "bus"])

# Execute prediction on an image
results = model.predict("path/to/image.jpg")

# Show results
results[0].show()