YOLOE: Erkennung und Segmentierung mit offenem Vokabular in Echtzeit#

Ultralytics YOLOE (Real-Time Seeing Anything) ist ein Modell zur Erkennung mit offenem Vokabular und zur Instanzsegmentierung: Statt einer beim Training festgelegten Klassenliste verwendet es beim Inferenzzeitpunkt die von dir gewünschten Kategorien als Textaufforderung, visuelles Beispiel oder integriertes Vokabular mit 4.585 Bezeichnungen. YOLOE basiert auf den Ultralytics-YOLO-Architekturen – YOLOv8, YOLO11 und YOLO26 – und ist von YOLO-World inspiriert. Das Modell erzielt Zero-Shot-Genauigkeit auf dem neuesten Stand der Technik bei einer Geschwindigkeit, die nahezu der von YOLO-Modellen mit geschlossenem Klassensatz entspricht.

Schnellstart#

Gib die gewünschten Klassen an und starte den Vorgang. YOLOE-26 gibt Boxen und Masken zur Instanzsegmentierung für Kategorien aus, mit denen das Modell nie trainiert wurde.

from ultralytics import YOLOE

model = YOLOE("yoloe-26s-seg.pt")

# "double-decker bus" ist keine COCO-Klasse; YOLOE erkennt sie allein anhand der Wörter
model.set_classes(["double-decker bus", "person"])

results = model.predict("https://ultralytics.com/images/bus.jpg")
results[0].show()

Beim ersten Aufruf von set_classes() wird ein Textencoder heruntergeladen. Lies vor dem Einsatz auf einem Rechner ohne Netzwerkzugriff die Installations- und Systemanforderungen.

Auswahl eines Aufforderungsmodus#

YOLOE unterstützt drei Aufforderungsmodi. Deine Auswahl bestimmt, welchen Checkpoint du lädst und wie deine Klassenbezeichnungen aussehen. Wähle die Zeile, die dem entspricht, was du zum Inferenzzeitpunkt bereitstellen kannst.

Installation und Systemanforderungen#

YOLOE ist im Ultralytics-Hauptpaket enthalten:

pip install -U ultralytics

Für Textaufforderungen wird zusätzlich ein Textencoder benötigt, der bei der ersten Verwendung und nicht während der Installation abgerufen wird:

• Beim ersten Aufruf von set_classes() wird ultralytics/CLIP von GitHub mit pip installiert (dieses Paket stellt den Tokenizer bereit) und ein TorchScript-Textencoder in das aktuelle Arbeitsverzeichnis heruntergeladen. YOLOE-26 lädt mobileclip2_b.ts herunter, etwa 254 MB; YOLOE-11 und YOLOE-v8 laden mobileclip_blt.ts herunter. Führe den Download einmal aus dem Verzeichnis aus, von dem aus du arbeiten wirst, oder kopiere die Datei dorthin. Andernfalls wird sie erneut heruntergeladen.
• Für beide Schritte ist Netzwerkzugriff erforderlich. Führe daher vor der Bereitstellung auf einem Rechner ohne Netzwerkzugriff oder in einer abgeschotteten Umgebung eine Vorhersage mit Aufforderung aus.
• Für visuelle Aufforderungen und aufforderungsfreie Checkpoints ist kein Textencoder erforderlich.

Für die YOLOE-26-Checkpoints ist ultralytics 8.4.0 oder neuer erforderlich. Die YOLOE-11- und YOLOE-v8-Familien sind in älteren Versionen verfügbar. Eine Vorhersage mit Textaufforderung führt den gesamten Ablauf aus – Checkpoint-Download, CLIP-Installation, Textencoder und Inferenz:

yolo predict model=yoloe-26s-seg.pt source="https://ultralytics.com/images/bus.jpg" classes="person"

Wenn du den Download des Textencoders zur Inferenzzeit vollständig vermeiden möchtest, hinterlege die Aufforderungen einmalig in den Gewichten und verwende sie wieder – siehe Eingabeaufforderungs-Embeddings wiederverwenden.

Architekturüberblick#

YOLOE behält die Standardstruktur von YOLO bei – einen Faltungs-Backbone zur Merkmalsextraktion, einen Neck zur Fusion auf mehreren Skalen und einen ankerlfreien, entkoppelten Kopf, der Klassen und Boxen vorhersagt – und ergänzt drei Module, eines pro Aufforderungsmodus:

• Re-parameterizable Region-Text Alignment (RepRTA) verfeinert Text-Embeddings von CLIP mithilfe eines kleinen zusätzlichen Netzwerks. Dieses Netzwerk läuft einmal pro Aufruf von set_classes() und wird beim Export entfernt, sodass pro Frame kein zusätzlicher Aufwand entsteht. Bei jedem Forward-Pass werden jedoch die gespeicherten Prompt-Embeddings mit den Regionenmerkmalen verglichen. Welche Kosten bei großen Mengen von Aufforderungen entstehen, erfährst du unter Einschränkungen.
• Semantic-Activated Visual Prompt Encoder (SAVPE) codiert semantische Merkmale und Aktivierungsmerkmale aus einer Beispielbox und konditioniert das Modell auf Objekte, die diesem Beispiel ähneln. Dies ist der One-Shot-Pfad für Ziele, die sich nur schwer benennen lassen, etwa ein Logo oder ein bestimmtes Teil.
• Lazy Region-Prompt Contrast (LRPC) gleicht Regions-Embeddings mit einem integrierten Vokabular mit 4.585 Bezeichnungen ab. Dadurch erkennen aufforderungsfreie Checkpoints Objekte ohne externe Aufforderung und ohne Textencoder.

Die Instanzsegmentierung erfolgt wie bei YOLOv8-Seg über einen Maskenzweig im Erkennungskopf. Jede Vorhersage enthält auf results[0].masks eine Maske. Nach dem Export werden die Open-World-Module in einen standardmäßigen YOLO-Kopf umparametrisiert, sodass die exportierte Datei den gewöhnlichen Erkennungs- und Segmentierungspfad nutzt.

Verfügbare Modelle#

Alle folgenden Checkpoints sind Modelle zur Instanzsegmentierung und unterstützen val, predict, export und track. Lade eine *-seg.pt-Datei für Text- oder visuelle Aufforderungen und eine *-seg-pf.pt-Datei für die Inferenz ohne Aufforderungen. Die Dateien sind nicht austauschbar. Siehe Auswahl eines Aufforderungsmodus. Nur die *-seg.pt-Dateien unterstützen train. Ein aufforderungsfreier Checkpoint wird aus einem trainierten Modell mit Textaufforderungen erstellt. Siehe Offizielle Modelle von Grund auf trainieren.

YOLOE-Leistung auf LVIS#

Zero-Shot-Ergebnisse auf LVIS minival bei 640 Pixeln aus dem Ultralytics-YOLO26-Paper.

Textuelle und visuelle Aufforderungen#

Jede Zelle mit Genauigkeit und Parameterzahl zeigt Textaufforderung / visuelle Aufforderung; FLOPs werden nur einmal angegeben. Parameterzahl und FLOPs beziehen sich auf die Erkennungskonfiguration, die im Paper ausgewertet wird. Die Genauigkeit ist der Non-E2E-Wert des Papers, das einzige Protokoll, für das Ergebnisse zu jedem Modell im Vergleich angegeben werden. Der End-to-End-Kopf von YOLOE-26 liegt bei Textaufforderungen höchstens 1,1 AP und bei visuellen Aufforderungen höchstens 2,6 AP darunter.

Aufforderungsfrei#

Die aufforderungsfreien Checkpoints liefern Ergebnisse anhand ihres integrierten Vokabulars, ohne dass eine Aufforderung eingegeben werden muss. Jede Zelle mit Genauigkeit zeigt End-to-End / Non-E2E, die beiden Protokolle, nach denen das Paper YOLOE-26 bewertet. Auf der YOLO26-Seite wird die Spalte Non-E2E zitiert.

Bei Text- und visuellen Prompts liegen die YOLOE-26-Modelle bei mAP_50-95 in jedem Größenvergleich vor ihren YOLOE-11- und YOLOE-v8-Pendants, bleiben bei Parameterzahl und FLOPs aber unter der v8-Reihe. Für denselben Split nennt die Studie für YOLO-Worldv2 Werte von 24.4 (S), 32.4 (M) und 35.5 (L) sowie für die Transformer-basierten Detektoren GLIP-T 26.0, GDINO-T 27.4 und DetCLIP-T 34.4; jedes dieser Modelle hat 155 bis 232 M Parameter. Die ursprüngliche YOLOE-Studie ergänzt zwei Ergebnisse für die von ihr eingeführten Modelle auf v8-Größenniveau. Auf LVIS übertrifft YOLOE-v8s YOLO-Worldv2-S um 3.5 AP – bei einem Drittel der Trainingskosten und 1,4-facher Inferenzgeschwindigkeit. Auf COCO übertragen erzielt YOLOE-v8l gegenüber YOLOv8-L mit geschlossenem Klassenumfang 0.6 box AP und 0.4 mask AP mehr, bei fast 4× kürzerer Trainingszeit.

Anwendungsbeispiele#

Jedes YOLOE-Beispiel unten lässt sich über die Python-API ausführen. Vorhersagen mit Text-Prompts, Validierung, Export, Tracking und einfaches Training funktionieren auch über die CLI. Für die Fine-Tuning-Rezepte und visuelle Prompts muss eine Trainer- oder Prädiktorklasse als Argument übergeben werden; das ist nur über die Python-API möglich.

Training verwenden#

Du kannst jeden verfügbaren *-seg.pt-Checkpoint mit deinem eigenen YOLO-Datensatz feinabstimmen. Das folgt weitgehend dem Standardverfahren für das YOLO-Training; der Unterschied besteht darin, welchen Trainer du übergibst. YOLOEPESegTrainer integriert deine Klassennamen in den Kopf und stimmt das Modell anschließend fein ab. Das ist die richtige Wahl für deine eigenen Labels; der Standardtrainer trainiert nicht anhand deiner Klassennamen.

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

model = YOLOE("yoloe-26s-seg.pt")

results = model.train(
    data="coco128-seg.yaml",
    epochs=80,
    patience=10,
    trainer=YOLOEPESegTrainer,  # <- Wichtig: der Trainer für die Feinabstimmung, nicht der Standardtrainer
)

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

model = YOLOE("yoloe-26s.yaml").load("yoloe-26s-seg.pt")

results = model.train(data="coco128.yaml", epochs=80, patience=10, trainer=YOLOEPETrainer)

Verwendung für Vorhersagen#

Der Aufruf mit Text-Prompt ist unter Schnellstart zu sehen. Für die beiden anderen Modi ist jeweils ein zusätzliches Argument erforderlich:

import numpy as np

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

model = YOLOE("yoloe-26l-seg.pt")

# Eine Beispiel-Bounding-Box pro Zielobjekt, jeweils mit eigener Klassen-ID
visual_prompts = {
    "bboxes": np.array([[221.52, 405.8, 344.98, 857.54], [120, 425, 160, 445]]),  # Person, Brille
    "cls": np.array([0, 1]),
}

results = model.predict(
    "ultralytics/assets/bus.jpg",
    visual_prompts=visual_prompts,
    predictor=YOLOEVPSegPredictor,
)
results[0].show()

import numpy as np

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

model = YOLOE("yoloe-26l-seg.pt")

visual_prompts = {"bboxes": np.array([[221.52, 405.8, 344.98, 857.54]]), "cls": np.array([0])}  # person

results = model.predict(
    "ultralytics/assets/zidane.jpg",  # Zielbild
    refer_image="ultralytics/assets/bus.jpg",  # Hier befinden sich die Beispiel-Bounding-Boxen
    visual_prompts=visual_prompts,
    predictor=YOLOEVPSegPredictor,
)
results[0].show()

# refer_image legt außerdem die Klassen dauerhaft fest, sodass spätere Aufrufe keine Prompts mehr benötigen
results = model("ultralytics/assets/bus.jpg")
model.export(format="onnx")  # Auch beim Export bleiben sie erhalten

import numpy as np
import torch

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

model = YOLOE("yoloe-11l-seg.pt")

img_tensor = torch.rand(1, 3, 480, 480)  # (1, 3, H, W) float-Tensor im Bereich [0, 1]
visual_prompts = {"bboxes": np.array([[10, 10, 50, 50]]), "cls": np.array([0])}

results = model.predict(
    img_tensor,
    refer_image=img_tensor,
    visual_prompts=visual_prompts,
    predictor=YOLOEVPSegPredictor,
    imgsz=640,
)

import numpy as np

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

model = YOLOE("yoloe-26l-seg.pt")

visual_prompts = {
    "bboxes": [
        np.array([[221.52, 405.8, 344.98, 857.54], [120, 425, 160, 445]]),  # bus.jpg: Person, Brille
        np.array([[150, 200, 1150, 700]]),  # zidane.jpg: Person
    ],
    "cls": [np.array([0, 1]), np.array([0])],
}

results = model.predict(
    ["ultralytics/assets/bus.jpg", "ultralytics/assets/zidane.jpg"],
    visual_prompts=visual_prompts,
    predictor=YOLOEVPSegPredictor,
)
results[0].show()

Verwendung zur Validierung#

Die Validierung erfolgt wie bei jedem anderen Modell anhand eines Segmentierungsdatensatzes:

from ultralytics import YOLOE

model = YOLOE("yoloe-26l-seg.pt")  # oder yoloe-26s/m-seg.pt für andere Größen

metrics = model.val(data="coco128-seg.yaml")

Zwei Varianten desselben Aufrufs decken die anderen Prompt-Modi ab:

• Visuelle Prompts — model.val(data="coco128-seg.yaml", load_vp=True) extrahiert für jede Kategorie ein visuelles Embedding direkt aus dem Datensatz. Ergänze refer_data="coco.yaml", um die Embeddings aus einem anderen Datensatz zu übernehmen. Dieser muss genau dieselben Kategorien enthalten.
• Ohne Prompts — lade einen *-seg-pf.pt-Checkpoint und übergib single_cls=True.

Export verwenden#

Prompt-Embeddings lassen sich einmal speichern und für statische Exporte wie ONNX, OpenVINO, TensorRT, CoreML, LiteRT und RKNN wiederverwenden. Das NPZ-Profil wird vor dem Export in das ursprüngliche PyTorch-Modell geladen. Es ist keine zusätzliche Laufzeiteingabe erforderlich, und das exportierte Modell benötigt die NPZ-Datei nicht.

from ultralytics import YOLOE

model = YOLOE("yoloe-26n-seg.pt")
model.set_classes(["person", "bus"])
model.save_prompt_embeddings("person-bus.npz")

# Das Profil ist an den Quell-Checkpoint gebunden und kann für spätere Exporte wiederverwendet werden.
model = YOLOE("yoloe-26n-seg.pt")
model.load_prompt_embeddings("person-bus.npz")
model.export(format="onnx")

Dasselbe Prompt-Profil kann auch ein reines Detektionsmodell konfigurieren, das auf der passenden YOLOE-Architektur basiert. Dadurch wird der Maskenzweig entfernt, während die mit Prompts ausgewählten Klassen erhalten bleiben:

from ultralytics import YOLOE

model = YOLOE("yoloe-26n.yaml").load("yoloe-26n-seg.pt")
model.load_prompt_embeddings("person-bus.npz")
model.export(format="rknn", name="rk3588", quantize=16)

Tracking-Nutzung#

Die mit Prompts ausgewählten Klassen lassen sich direkt zum Tracking übernehmen. So kannst du Objekte verfolgen, mit denen der Tracker nie trainiert wurde:

from ultralytics import YOLOE

model = YOLOE("yoloe-26s-seg.pt")
model.set_classes(["forklift", "pallet"])

# persist=True sorgt dafür, dass die Track-IDs über mehrere Bilder hinweg stabil bleiben
for result in model.track("path/to/video.mp4", stream=True, persist=True):
    print(result.boxes.id)

YOLOE im Vergleich#

YOLOE liegt zwischen einem Detektor mit geschlossenem Klassenumfang und einem umfangreichen Modell mit offenem Vokabular. Drei Vergleiche zeigen, ob YOLOE die richtige Wahl ist:

• Im Vergleich zu einem YOLO-Modell mit geschlossenem Klassenumfang. Sobald die Prompts festgelegt sind, erstellt YOLOE Vorhersagen über den üblichen Detektions- und Segmentierungspfad und lässt sich wie jedes andere Modell exportieren. Der Vorteil: Die Klassenliste lässt sich zur Inferenzzeit ändern, ohne neu zu trainieren. Der Nachteil: Die Zero-Shot-Genauigkeit liegt deutlich unter der eines Modells, das auf deinen eigenen Klassen trainiert wurde.
• Im Vergleich zu früheren YOLOE-Modellfamilien. YOLOE-26 übernimmt den NMS-freien End-to-End-Kopf von YOLO26, deckt fünf Größenklassen ab (n/s/m/l/x) statt der drei früheren (s/m/l) und liegt in jeder vergleichbaren Größenklasse in der Leistung vorn.
• Im Vergleich zu Transformer-basierten Detektoren mit offenem Vokabular. GLIP und OWL-ViT führen bei der Inferenz einen Vision-Language-Transformer aus. YOLOE kodiert die Prompts einmal und vergleicht sie anschließend in einem Faltungskopf mit den Merkmalen der Regionen.

Die nächstliegenden Alternativen akzeptieren alle einen Text-Prompt, aber nur YOLOE und SAM 3 geben Masken zurück. Die drei Modelle beantworten unterschiedliche Fragen:

Du kommst von YOLO-World? Die API hat denselben Aufbau: Ersetze YOLOWorld durch YOLOE, lade einen *-seg.pt-Checkpoint und lass deinen Aufruf von set_classes() unverändert. Du erhältst Masken und visuelle Prompts; der Hinweis zum Export bezüglich eingefrorener Klassen gilt für beide Modelle.

Anwendungsfälle und Einsatzbereiche#

Bei der Detektion mit offenem Vokabular entfällt das erneute Training für jede Klasse. Das ist besonders wichtig, wenn die Zielliste im Voraus nicht bekannt ist:

• Detektion in offenen Umgebungen — Robotik und Sicherheitssysteme, in denen Objekte auftauchen, die zum Trainingszeitpunkt niemand aufgelistet hat.
• One-Shot-Detektion anhand eines Beispiels — Mit visuellen Prompts lässt sich ein bestimmtes Bauteil, Logo oder ein Defekt anhand einer einzelnen Referenzbox erkennen. Das ist nützlich für die industrielle Inspektion.
• Erfassung einer großen Bandbreite von Objekten — Das integrierte Vokabular mit 4,585 Namen ist breit genug für Biodiversitätsmonitoring oder die Bestandsaufnahme im Einzelhandel.
• Datensatzaufbau — Bilder vor der menschlichen Prüfung mit Boxen und Masken vorbeschriften und anschließend mit den Ergebnissen ein schnelles Modell mit geschlossenem Klassenumfang trainieren.
• Segmentierung beliebiger Zielobjekte — Die verfügbaren *-seg.pt-Checkpoints geben für jede Vorhersage eine Maske zurück. So erhältst du in der medizinischen Bildgebung und bei der Satellitenbildanalyse pixelgenaue Ergebnisse ohne ein zweites Modell.

Ein gängiges Vorgehen kombiniert zwei Modi: Zuerst wird einmal der Modus ohne Prompts ausgeführt, um die vorhandenen Objekte zu entdecken. Anschließend wechselst du für die relevanten Kategorien zu Text-Prompts.

Einschränkungen#

YOLOE tauscht Genauigkeit gegen die Möglichkeit ein, Klassen zur Inferenzzeit zu ändern. Das solltest du vor deiner Entscheidung wissen:

• Die Zero-Shot-Genauigkeit liegt deutlich unter der eines Modells, das auf deinen Klassen trainiert wurde. Die Checkpoints mit Prompts erreichen auf LVIS minival ungefähr 22–40 mAP. Ein YOLO-Modell mit geschlossenem Klassenumfang, das auf deinen eigenen Daten trainiert wurde, erzielt bei diesen Klassen bessere Ergebnisse. Nutze YOLOE für Klassen, für die du nicht trainieren kannst, und nicht als Ersatz für das Training.
• Seltene Kategorien sind die Schwachstelle. Die Spalte mAP_r unter Leistung gibt die Genauigkeit speziell für seltene Klassen in LVIS an. Bei Text-Prompts liegt sie in jeder Zeile unter den Werten für häufige und sehr häufige Klassen. Wenn deine Zielobjekte ungewöhnlich sind, prüfe diesen Wert statt der Gesamt-mAP.
• Ein Prompt beschreibt das Erscheinungsbild, nicht Beziehungen. Die Detektion vergleicht Regionsmerkmale mit dem Prompt-Embedding. Für Prompts, die von Zustand, Kontext oder Vergleichen abhängen — etwa „beschädigt“, „ganz links“ oder „die Person, die getragen wird“ — gibt es daher keine zuverlässige Grundlage für einen Treffer. Verwende möglichst Formulierungen, die gebräuchlichen Kategorienamen entsprechen.
• Große Prompt-Sets erhöhen die Latenz. Die Prompt-Embeddings werden einmal berechnet, aber bei jedem Vorwärtslauf mit den Regionsmerkmalen verglichen. Bei Messungen auf einer CPU mit yoloe-26s-seg.pt verlängert sich ein Vorwärtslauf beim Wechsel von 80 auf 1,203 Klassen um etwa 19 % und beim vollständigen Vokabular mit 4,585 Namen um etwa 89 %. Die ausgewiesenen FLOPs ändern sich überhaupt nicht, da die Ähnlichkeit zwischen Regionen und Text nicht mitgezählt wird. Das Profil weist dich daher nicht auf den Mehraufwand hin.
• Klassennamen sind Platzhalter, bis du Prompts übergibst. Ein frisch geladener *-seg.pt-Checkpoint gibt nc=80 mit numerischen Namen zurück ("0", "1", …). Rufe daher set_classes() auf, bevor du die Labels ausliest. Bei Checkpoints ohne Prompts ist das vollständige Vokabular bereits enthalten.

Hinweise zur Bereitstellung#

• Hardware. Für die Inferenz benötigst du eine NVIDIA-GPU mit 4–8 GB VRAM. Die Größenklassen n und s laufen mit geringerer Auflösung auf Edge-GPUs wie Jetson oder auf einer CPU. Für das Fine-Tuning ist eine einzelne GPU erforderlich.
• NMS ist standardmäßig klassenunabhängig. YOLOE erstellt Vorhersagen mit agnostic_nms=True. Standardmäßig werden dabei überlappende Boxen mit niedrigeren Konfidenzwerten auch dann unterdrückt, wenn sie zu anderen Klassen gehören, statt nur Boxen derselben Klasse. So werden Duplikate vermieden, wenn ein Objekt zu mehreren Kategorien passt. Mit nms=False wendet YOLOE-26 keine IoU-Unterdrückung an. Im klassenunabhängigen Modus bleibt nur die beste Klasse pro Anker erhalten, statt dass ein Anker mehrere Klassenlabels ausgibt. Übergib agnostic_nms=False, um dieses Verhalten zu überschreiben.
• Batch-Verarbeitung. Batch-Inferenz wird direkt unterstützt. Visuelle Prompts können sich außerdem innerhalb desselben Aufrufs von Bild zu Bild unterscheiden.

Die offiziellen Modelle von Grund auf trainieren#

Die meisten Leserinnen und Leser benötigen das nicht. Damit lassen sich die veröffentlichten Checkpoints mit offenem Vokabular anhand von Objects365, GQA und Flickr30k reproduzieren — ungefähr 1,4 Mio. Trainingsbeispiele auf 8× RTX 4090. Das hat nichts mit dem Fine-Tuning auf deinen eigenen Daten zu tun, das oben unter Training verwenden beschrieben wird.

Für das Training werden Segmentierungsannotationen benötigt. Lade entweder die unten aufbereiteten Dateien herunter oder erstelle eigene mithilfe des vom offiziellen Team bereitgestellten Skripts, das auf SAM 2.1 basiert. Für die Validierung wird LVIS minival verwendet.

Zuerst wird das Modell mit Text-Prompts trainiert. Die beiden anderen Prompt-Modi bauen darauf auf:

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

data = {
    "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,  # oder der Pfad zu einer YAML-Datei mit derselben Struktur
    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",
)

Die Checkpoints für visuelle Prompts und promptfreie Inferenz gehen vom trainierten Text-Prompt-Modell aus und aktualisieren jeweils ein Modul. YOLOESegVPTrainer ist das Rezept für visuelle Prompts und YOLOEPEFreeTrainer das promptfreie Rezept. Keine der beiden Klassen friert jedoch selbst etwas ein: Das selektive Training wird durch die Liste freeze gesteuert, die du zusammen mit der Klasse übergibst. Sie führt alle untergeordneten Elemente des Heads außer savpe auf (beziehungsweise alle Klassifizierungstürme). Für den promptfreien Lauf wird zusätzlich single_cls=True benötigt. Das YOLOE-Repository des Upstream-Projekts enthält die vollständigen Rezepte für die Modelle im v8-Maßstab.

Ein abgeschlossener promptfreier Lauf wird in einen reparametrisierten Checkpoint umgewandelt, der bei der Inferenz seine Klassennamen ohne Prompt ausgibt. Dafür werden get_vocab und set_vocab verwendet:

from ultralytics import YOLOE

# Gewichte, die vom promptfreien Lauf und vom Text-Prompt-Lauf geschrieben wurden, mit dem er gestartet wurde. Jeder
# erneute Lauf erstellt ein neues Verzeichnis (train-2, train-3, ...); verwende daher die von den Läufen ausgegebenen Pfade.
model = YOLOE("runs/segment/train-2/weights/best.pt")  # promptfreier Lauf, sein Head ist bereits fusioniert
text_model = YOLOE("runs/segment/train/weights/best.pt")  # Text-Prompt-Lauf, sein Head ist noch nicht fusioniert

names = list(YOLOE("yoloe-26l-seg-pf.pt").model.names.values())  # das Vokabular mit 4.585 Namen oder deine eigene Liste
vocab = text_model.get_vocab(names)

model.set_vocab(vocab, names)
model.save("yoloe-26l-seg-pf-custom.pt")  # überschreibe niemals den veröffentlichten Checkpoint

get_vocab gibt den Zweig zurück, den das Flag end2end des Modells auswählt, und set_vocab reparametrisiert diesen Zweig. Die veröffentlichten YOLOE-26-Dateien enthalten stattdessen ein Vokabular pro Zweig. Dadurch kann nms zwischen den Zweigen auswählen. Um das nachzubilden, nimm das zweite Vokabular aus einer weiteren Kopie des Text-Prompt-Modells. YOLOE-11 und YOLOE-v8 haben nur einen Zweig; dort kannst du den obigen Aufruf unverändert verwenden.

one2one_model = YOLOE("runs/segment/train/weights/best.pt")  # get_vocab fusioniert den eingelesenen Head; lade daher eine zweite Kopie
one2one_model.model.end2end = True  # den NMS-freien Zweig einlesen

model.set_vocab(vocab, names, one2one_vocab=one2one_model.get_vocab(names))

Zitate und Danksagungen#

Wenn YOLOE zu deiner Forschung oder deinem Projekt beigetragen hat, zitiere bitte die Originalarbeit von Ao Wang, Lihao Liu, Hui Chen, Zijia Lin, Jungong Han und Guiguang Ding von der Tsinghua-Universität:

@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},
}

Weitere Informationen findest du in der Originalarbeit zu YOLOE auf arXiv. Den Quellcode des Projekts und weitere Ressourcen findest du im GitHub-Repository.

Häufig gestellte Fragen#