Link to this sectionYOLOE: Alles in Echtzeit sehen#

Link to this sectionEinführung#

YOLOE (Real-Time Seeing Anything) ist ein neuer Fortschritt bei Zero-Shot, 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 Objektklasse ermöglicht. Basierend auf YOLOv10 und inspiriert durch YOLO-World, erreicht YOLOE eine erstklassige Zero-Shot-Leistung bei minimalen Auswirkungen auf Geschwindigkeit und Genauigkeit.

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 es nur ein Drittel der Trainingsressourcen verbraucht und eine 1,4-fach schnellere Inferenzgeschwindigkeit erreicht. Auf COCO feinabgestimmt, übertrifft YOLOE-v8-large YOLOv8-L um 0,1 mAP bei nahezu 4-mal kürzerer Trainingszeit. Dies zeigt 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.

Link to this sectionArchitektur-Übersicht#

YOLOE behält die Standard-YOLO-Struktur bei – ein konvolutionales Backbone (z. B. CSP-Darknet) zur Merkmalsextraktion, ein Neck (z. B. PAN-FPN) für die Multi-Scale-Fusion und einen ankerfreien, entkoppelten Erkennungs-Head (wie in YOLOv8/YOLO11), der Objektpräsenz, Klassen und Bounding Boxes 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 text-promptbasierte 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 null Overhead gewährleistet. YOLOE erkennt somit beliebige textbeschriftete Objekte (z. B. unsichtbare "Ampeln") ohne Laufzeitnachteile.

• Semantic-Activated Visual Prompt Encoder (SAVPE): Ermöglicht visuell-promptbasierte Erkennung über einen leichtgewichtigen Embedding-Zweig. Bei gegebenem Referenzbild 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 Prompt-freien Modus führt YOLOE eine Open-Set-Erkennung mittels interner Embeddings durch, die auf großen Vokabularen trainiert wurden (1200+ Kategorien aus LVIS und Objects365). Ohne externe Prompts oder Encoder identifiziert YOLOE Objekte durch Ähnlichkeitsabgleich von Embeddings und verarbeitet große Label-Bereiche effizient bei der Inferenz.

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

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

Link to this sectionVerfü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.

Link to this sectionText-/Visual-Prompt-Modelle#

Link to this sectionPrompt-freie Modelle#

Link to this sectionAnwendungsbeispiele#

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

Link to this sectionTraining Nutzung#

Link to this sectionFeinabstimmung 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
)

Link to this sectionPredict-Nutzung#

YOLOE unterstützt sowohl textbasierte als auch visuelle Prompts. Die Verwendung von Prompts ist unkompliziert – übergebe 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()

Link to this sectionVal-Nutzung#

Die Modellvalidierung auf einem Datensatz ist 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")

Link to this sectionExport-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()

Link to this sectionOffizielle Modelle trainieren#

Link to this sectionDatensätze vorbereiten#

• Trainingsdaten

• Val-Daten

Link to this sectionTraining 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",
)

Link to this sectionYOLOE Leistungsvergleich#

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

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

YOLOE26-L erreicht 36,8% LVIS mAP mit 32,3M Parametern und 88,3B FLOPs bei der Verarbeitung von 640×640 Bildern mit 6,2 ms (161 FPS) auf einer T4 GPU. Dies ist eine Verbesserung gegenüber den 35,2% LVIS mAP von YOLOE-L bei gleicher Inferenzgeschwindigkeit. Entscheidend ist, dass die Open-Vocabulary-Module von YOLOE keine zusätzlichen Inferenzkosten verursachen, was ein "no free lunch trade-off"-Design unterstreicht.

Für Zero-Shot-Aufgaben übertrifft YOLOE26 frühere Open-Vocabulary-Detektoren deutlich: Auf LVIS erreicht YOLOE26-S 29,9% mAP, was YOLO-World-S um +11,4 AP schlägt, während YOLOE26-L 36,8% mAP erreicht und damit 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 Echtzeit-Open-Vocabulary-Anwendungen.

Link to this sectionVergleich 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 eine gute Balance zwischen Geschwindigkeit und Genauigkeit, erforderte aber ein Retraining für neue Klassen und nutzte Anchor-basierte Heads. Im Gegensatz dazu ist YOLOE Anchor-frei und erkennt neue Klassen dynamisch. Basierend auf den Verbesserungen von YOLOv8 erreicht YOLOE eine höhere Genauigkeit (52,6% vs. ca. 50% mAP von YOLOv5 auf COCO) und integriert im Gegensatz zu YOLOv5 die Instanzsegmentierung.

• YOLOE vs. YOLOv8: YOLOE erweitert die überarbeitete Architektur von YOLOv8 und erreicht eine ähnliche oder bessere Genauigkeit (52,6% mAP bei ca. 26M Parametern gegenüber 52,9% bei ca. 44M Parametern von YOLOv8-L). Aufgrund des stärkeren Vortrainings verkürzt sich die Trainingszeit erheblich. Der entscheidende Fortschritt ist die Open-World-Fähigkeit von YOLOE, die unsichtbare Objekte (z. B. "bird scooter" oder "peace symbol") per Prompt erkennt, anders als das Closed-Set-Design von YOLOv8.

• YOLOE vs. YOLO11: YOLO11 verbessert YOLOv8 durch höhere Effizienz und weniger Parameter (ca. 22% Reduzierung). YOLOE übernimmt diese Gewinne direkt, entspricht der Inferenzgeschwindigkeit und Parameteranzahl von YOLO11 (ca. 26M Parameter) und fügt gleichzeitig Open-Vocabulary-Detektion und -Segmentierung hinzu. In Closed-Set-Szenarien ist YOLOE äquivalent zu YOLO11, bietet aber entscheidend die Anpassungsfähigkeit zur Erkennung unsichtbarer Klassen, was YOLO11 + Open-World-Fähigkeit ohne Geschwindigkeitsverlust bedeutet.

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

• YOLOE26 vs. frühere Open-Vocabulary-Detektoren: Frühere Open-Vocab-Modelle (GLIP, OWL-ViT, YOLO-World) verließen sich stark auf Vision-Language-Transformer, was zu langsamer Inferenz führte. Auf LVIS erreicht 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), während eine Echtzeit-Inferenz von 161 FPS auf einer T4 GPU beibehalten wird. Verglichen mit Transformer-basierten Ansätzen (z. B. GLIP) bietet YOLOE26 eine um Größenordnungen schnellere Inferenz und überbrückt effektiv die Lücke zwischen Genauigkeit und Effizienz bei der Open-Set-Detektion.

Zusammenfassend behalten YOLOE und YOLOE26 die bekannte Geschwindigkeit und Effizienz von YOLO bei, übertreffen Vorgänger in der Genauigkeit, integrieren Segmentierung und führen leistungsstarke Open-World-Detektion ein. YOLOE26 verbessert die Architektur weiter durch NMS-freie End-to-End-Inferenz von YOLO26, was es ideal für Echtzeit-Open-Vocabulary-Anwendungen macht.

Link to this sectionAnwendungsfälle und Einsatzgebiete#

Die Open-Vocabulary-Detektion und -Segmentierung von YOLOE ermöglichen vielfältige Anwendungen, die über traditionelle Fixed-Class-Modelle hinausgehen:

• Open-World-Objektdetektion: 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 ein Retraining zu erfordern.

• Few-Shot- und One-Shot-Detektion: Mit visuellen Prompts (SAVPE) lernt YOLOE schnell neue Objekte aus einzelnen Referenzbildern—perfekt für die industrielle Inspektion (sofortiges Identifizieren von Teilen oder Fehlern) oder kundenspezifische Überwachung, was visuelle Suchen mit minimalem Setup ermöglicht.

• Großes 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, Einzelhandelsinventur oder E-Commerce aus, wobei viele Klassen ohne umfangreiches klassenspezifisches Training zuverlässig identifiziert werden.

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

• Automatisierte Datenbeschriftung und Bootstrapping: YOLOE erleichtert die schnelle Erstellung von Datensätzen durch die Bereitstellung anfänglicher Bounding-Box- und Segmentierungsannotationen, was den manuellen Beschriftungsaufwand erheblich reduziert. Besonders wertvoll bei der Analyse großer Mediensammlungen, wo es Objekte automatisch identifizieren kann und somit beim schnelleren Aufbau spezialisierter Modelle hilft.

• Segmentierung für jedes Objekt: Erweitert die Segmentierungsfähigkeiten auf beliebige Objekte mittels Prompts—besonders vorteilhaft für medizinische Bildgebung, Mikroskopie oder Satellitenbildanalyse, wobei Strukturen ohne spezialisierte vortrainierte Modelle automatisch identifiziert und präzise segmentiert werden. Anders als Modelle wie SAM erkennt und segmentiert YOLOE Objekte gleichzeitig automatisch, was bei Aufgaben wie Content-Erstellung oder Szenenverständnis hilft.

Über all diese Anwendungsfälle hinweg ist der Kernvorteil von YOLOE die Vielseitigkeit, da es ein einheitliches Modell für Detektion, Erkennung und Segmentierung in dynamischen Szenarien bietet. Die Effizienz stellt eine Echtzeitleistung auf ressourcenbeschränkten Geräten sicher, ideal für Robotik, autonomes Fahren, Verteidigung und mehr.

Link to this sectionTraining und Inferenz#

YOLOE lässt sich nahtlos in die Ultralytics Python API und CLI integrieren, ähnlich wie andere YOLO-Modelle (YOLOv8, YOLO-World). So startest du schnell:

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

Link to this sectionWeitere unterstützte Aufgaben#

• Validierung: Evaluiere die Genauigkeit einfach mit model.val() oder yolo val.
• Export: Exportiere YOLOE-Modelle (model.export()) nach ONNX, TensorRT usw., um die Bereitstellung zu erleichtern.
• Tracking: YOLOE unterstützt Objekt-Tracking (yolo track), wenn integriert, nützlich für das Verfolgen von ge-prompteten Klassen in Videos.

Link to this sectionErste Schritte#

Richte YOLOE schnell mit Ultralytics ein, indem du diese Schritte befolgst:

1. Installation: Installiere oder aktualisiere 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 verfügbar. Lade einfach die gewünschte .pt-Datei herunter, um sie in die Ultralytics YOLO-Klasse zu laden.

3. Hardware-Anforderungen:

   • 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 Hochleistungsinferenz auf kompakten Workstations siehe unseren NVIDIA DGX Spark-Leitfaden.
   • Training: Das Fine-Tuning von YOLOE auf benutzerdefinierten Daten erfordert typischerweise nur eine GPU. Umfassendes Open-Vocabulary-Vortraining (LVIS/Objects365), das 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, du kannst jedoch Backbone, Klassen oder Bildgröße nach Bedarf ändern.

5. YOLOE ausführen:

   • Schnelle Inferenz (prompt-frei):

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

   • Prompt-basierte Detektion (Text-Prompt-Beispiel):

     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-Outputs verwenden LVIS-Kategorien; verwende set_classes(), um deine eigenen Labels anzugeben.
   • Geschwindigkeit: YOLOE hat keinen Overhead, es sei denn, Prompts werden verwendet. Text-Prompts haben minimalen Einfluss; 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 Detektionen, wenn dasselbe Objekt mehreren Kategorien im großen Vokabular von YOLOE (1200+ LVIS-Klassen) entspricht. Du kannst dies überschreiben, indem du explizit agnostic_nms=False übergibst.
   • Batch-Inferenz: Direkt unterstützt (model.predict([img1, img2])). Für bildspezifische Prompts verarbeite Bilder einzeln.

Die Ultralytics-Dokumentation bietet weitere Ressourcen. YOLOE ermöglicht dir den einfachen Einstieg in leistungsstarke Open-World-Fähigkeiten innerhalb des vertrauten YOLO-Ökosystems.

Link to this sectionZitate und Danksagungen#

Falls YOLOE zu deiner Forschung oder deinem Projekt beigetragen hat, zitiere bitte das Originalpaper von Ao Wang, Lihao Liu, Hui Chen, Zijia Lin, Jungong Han und Guiguang Ding 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 Lektüre ist das originale YOLOE-Paper auf arXiv verfügbar. Der Quellcode und zusätzliche Ressourcen des Projekts können über das zugehörige GitHub-Repository abgerufen werden.

Link to this sectionFAQ#

Link to this sectionWie unterscheidet sich YOLOE von YOLO-World?#

Obwohl sowohl YOLOE als auch YOLO-World Open-Vocabulary-Detektion ermöglichen, bietet YOLOE mehrere Vorteile. YOLOE erzielt eine um +3,5 AP höhere Genauigkeit auf LVIS bei gleichzeitig dreifach geringerem Ressourcenverbrauch für das Training und einer 1,4-mal schnelleren Ausführung als YOLO-Worldv2. YOLOE unterstützt außerdem drei Prompting-Modi (Text, visuell und internes Vokabular), während sich YOLO-World primär auf Text-Prompts konzentriert. Zusätzlich beinhaltet YOLOE integrierte Instanzsegmentierungs-Funktionen, die pixelgenaue Masken für erkannte Objekte ohne zusätzlichen Overhead liefern.

Link to this sectionKann ich YOLOE als reguläres YOLO-Modell verwenden?#

Ja, YOLOE kann exakt wie ein Standard-YOLO-Modell ohne Leistungseinbußen funktionieren. Wenn es im Closed-Set-Modus verwendet wird (ohne Prompts), werden die Open-Vocabulary-Module von YOLOE in den Standard-Detektions-Head re-parametrisiert, was zu identischer Geschwindigkeit und Genauigkeit wie bei vergleichbaren YOLO11-Modellen führt. Das macht YOLOE extrem vielseitig—du kannst es als traditionellen Detektor für maximale Geschwindigkeit verwenden und nur bei Bedarf in den Open-Vocabulary-Modus wechseln.

Link to this sectionWelche Arten von Prompts kann ich mit YOLOE verwenden?#

YOLOE unterstützt drei Arten von Prompts:

1. Text-Prompts: Gib Objektklassen in natürlicher Sprache an (z. B. "person", "traffic light", "bird scooter")
2. Visuelle Prompts: Stelle Referenzbilder von Objekten bereit, die du erkennen möchtest
3. Internes Vokabular: Nutze das eingebaute Vokabular von über 1200 Kategorien von YOLOE ohne externe Prompts

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

Link to this sectionWie geht YOLOE mit Instanzsegmentierung um?#

YOLOE integriert die Instanzsegmentierung direkt in seine Architektur, indem der Detektionskopf um einen Zweig zur Maskenvorhersage erweitert wird. Dieser Ansatz ähnelt YOLOv8-Seg, funktioniert jedoch für jede beliebig per Prompt vorgegebene 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 optimiert Arbeitsabläufe für Anwendungen, die pixelgenaue Objektbegrenzungen erfordern.

Link to this sectionWie geht YOLOE mit der Inferenz bei benutzerdefinierten Prompts um?#

Ähnlich wie bei YOLO-World unterstützt YOLOE eine „Prompt-then-detect“-Strategie, die ein Offline-Vokabular nutzt, um die Effizienz zu steigern. Benutzerdefinierte Prompts, wie Beschriftungen oder spezifische Objektkategorien, werden vorab kodiert und als Offline-Vokabular-Embeddings gespeichert. Dieser Ansatz optimiert den Detektionsprozess, ohne ein erneutes Training zu erfordern. Du kannst diese Prompts dynamisch im Modell festlegen, um es an spezifische Detektionsaufgaben anzupassen:

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