YOLOE: Echtzeit-Erkennung und -Segmentierung mit offenem Vokabular#

Ultralytics YOLOE (Real-Time Seeing Anything) ist ein Erkennungs- und Instanzsegmentierungsmodell mit offenem Vokabular: Anstatt einer zum Trainingszeitpunkt festgelegten Klassenliste übernimmt es die gewünschten Kategorien zur Inferenzzeit als Text-Prompt, visuelles Beispiel oder integriertes Vokabular mit 4.585 Namen. Basierend auf den Ultralytics YOLO-Architekturen — YOLOv8, YOLO11 und YOLO26 — und inspiriert von YOLO-World, erreicht YOLOE modernste Zero-Shot-Genauigkeit bei nahezu geschlossener YOLO-Geschwindigkeit.

Kurzanleitung#

Benenne die gewünschten Klassen und starte den Prozess. YOLOE-26 liefert Bounding-Boxen und Instanzsegmentierungsmasken für Kategorien, auf die es nie trainiert wurde.

from ultralytics import YOLOE

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

# "double-decker bus" is not a COCO class; YOLOE resolves it from the words alone
model.set_classes(["double-decker bus", "person"])

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

Der erste set_classes()-Aufruf lädt einen Text-Encoder herunter; siehe Installation und Anforderungen vor der Bereitstellung auf einer Maschine ohne Netzwerkzugriff.

Auswahl eines Prompt-Modus#

YOLOE unterstützt drei Prompt-Modi, und die Auswahl bestimmt, welchen Checkpoint du lädst und wie deine Klassenlabels aussehen. Wähle die Zeile, die zu dem passt, was du zur Inferenzzeit bereitstellen kannst.

Installation und Anforderungen#

YOLOE ist im Hauptpaket von Ultralytics enthalten:

pip install -U ultralytics

Das Text-Prompting erfordert zusätzlich einen Text-Encoder, der bei der ersten Verwendung statt bei der Installation abgerufen wird:

• Der erste set_classes()-Aufruf installiert ultralytics/CLIP von GitHub mit pip (es stellt den Tokenizer bereit) und lädt einen TorchScript-Text-Encoder in das aktuelle Arbeitsverzeichnis herunter. YOLOE-26 lädt mobileclip2_b.ts (ca. 254 MB) herunter; YOLOE-11 und YOLOE-v8 laden mobileclip_blt.ts herunter. Führe den Download einmal aus dem Verzeichnis aus, von dem aus du den Betrieb startest, oder kopiere die Datei dorthin, da sie andernfalls erneut abgerufen wird.
• Beide Schritte erfordern einen Netzwerkzugriff. Führe daher eine geprompte Vorhersage aus, bevor du das System auf einer Offline- oder Air-Gapped-Maschine bereitstellst.
• Visuelle Prompts und prompt-freie Checkpoints benötigen überhaupt keinen Text-Encoder.

Die YOLOE-26-Checkpoints erfordern ultralytics 8.4.0 oder neuer; die YOLOE-11- und YOLOE-v8-Familien sind in früheren Versionen verfügbar. Eine durch Text geprompte Vorhersage durchläuft den gesamten Pfad — Checkpoint-Download, CLIP-Installation, Text-Encoder, Inferenz:

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

Um den Download des Text-Encoders zur Inferenzzeit komplett zu überspringen, kannst du die Prompts einmalig in die Gewichtungen einbetten und wiederverwenden — siehe Prompt-Einbettungen wiederverwenden.

Architektur-Übersicht#

YOLOE behält die Standard-YOLO-Struktur bei — ein konvolutionales Backbone zur Merkmalsxtraktion, ein Neck für die multiskalige Fusion und einen ankerfreien, entkoppelten Head zur Vorhersage von Klassen und Boxen — und fügt drei Module hinzu, eines pro Prompt-Modus:

• Re-parameterizable Region-Text Alignment (RepRTA) verfeinert Text-Einbettungen von CLIP über ein kleines Hilfsnetzwerk. Dieses Netzwerk läuft einmal pro set_classes()-Aufruf und wird beim Export herausgefiltert, sodass es pro Frame keine Rechenleistung kostet. Was bei jedem Forward-Pass tatsächlich ausgeführt wird, ist der Vergleich der gespeicherten Prompt-Einbettungen mit Regionsmerkmalen; siehe Einschränkungen bezüglich der Kosten bei einem großen Prompt-Set.
• Semantic-Activated Visual Prompt Encoder (SAVPE) kodiert semantische und Aktivierungsmerkmale aus einer Beispiel-Box und konditioniert das Modell auf Objekte, die ähnlich aussehen. Dies ist der One-Shot-Pfad für Ziele, die schwer zu benennen sind, wie etwa ein Logo oder ein spezifisches Bauteil.
• Lazy Region-Prompt Contrast (LRPC) gleicht Regions-Einbettungen mit einem integrierten Vokabular aus 4.585 Namen ab, sodass prompt-freie Checkpoints Objekte ohne externen Prompt und ohne Text-Encoder erkennen.

Die Instanzsegmentierung stammt von einem Masken-Zweig am Erkennungskopf wie bei YOLOv8-Seg, und jede Vorhersage liefert eine Maske auf results[0].masks. Sobald das Modell exportiert ist, werden die Open-World-Module in einen Standard-YOLO-Kopf reparameterisiert, sodass die exportierte Datei den gewöhnlichen Erkennungs-/Segmentierungspfad ausführt.

Verfügbare Modelle#

Jeder Checkpoint unten ist ein Instanzsegmentierungsmodell und unterstützt val, predict, export und track. Lade eine *-seg.pt-Datei für Text- oder visuelle Prompts und eine *-seg-pf.pt-Datei für die prompt-freie Inferenz; sie sind nicht austauschbar, siehe Auswahl eines Prompt-Modus. Nur die *-seg.pt-Dateien unterstützen train; ein prompt-freier Checkpoint wird aus einem trainierten Text-Prompt-Modell generiert, siehe Training der offiziellen Modelle von Grund auf.

YOLOE-Leistung auf LVIS#

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

Text- und visuelle Prompts#

Jede Genauigkeits- und Parameterzelle zeigt Text-Prompt / visueller Prompt; FLOPs werden einmal angegeben. Parameter und FLOPs gelten für die im Paper evaluierte Erkennungskonfiguration. Die Genauigkeit entspricht dem Non-E2E-Wert aus dem Paper, dem einzigen Protokoll, das für jedes Modell im Vergleich angegeben wird; der End-to-End-Kopf von YOLOE-26 bleibt bei Text-Prompts um maximal 1,1 AP und bei visuellen Prompts um maximal 2,6 AP dahinter zurück.

Ohne Prompt#

Die prompt-freien Checkpoints antworten aus ihrem integrierten Vokabular heraus ohne bereitgestellten Prompt. Jede Genauigkeitszelle zeigt End-to-End / Non-E2E, die beiden Protokolle, unter denen YOLOE-26 im Paper bewertet wird; die YOLO26-Seite zitiert die Non-E2E-Spalte.

Unter Text- und visuellen Prompts übertreffen die YOLOE-26-Modelle ihre Pendants YOLOE-11 und YOLOE-v8 bei jeder passenden Skalierung bezüglich mAP_50-95, während sie bei Parametern und FLOPs unter der v8-Linie bleiben. Auf demselben Split berichtet das Paper YOLO-Worldv2 mit 24,4 (S), 32,4 (M) und 35,5 (L) sowie die Transformer-basierten Detektoren GLIP-T mit 26,0, GDINO-T mit 27,4 und DetCLIP-T mit 34,4, jeweils mit 155 bis 232 Mio. Parametern. Das ursprüngliche YOLOE-Paper fügt zwei Ergebnisse für die von ihm eingeführten Modelle im v8-Maßstab hinzu. Auf LVIS schlägt YOLOE-v8s YOLO-Worldv2-S um 3,5 AP bei einem Drittel der Trainingskosten und der 1,4-fachen Inferenzgeschwindigkeit. Auf COCO übertragen erzielt YOLOE-v8l einen Gewinn von 0,6 Box-AP und 0,4 Masken-AP gegenüber dem geschlossenen YOLOv8-L bei fast 4-fach kürzerer Trainingszeit.

Anwendungsbeispiele#

Jedes YOLOE-Beispiel unten läuft über die Python-API. Text-Prompt-Vorhersage, Validierung, Export, Tracking und einfaches Training funktionieren auch über die CLI; die Fine-Tuning-Rezepte und visuellen Prompts übergeben eine Trainer- oder Predictor-Klasse als Argument, was nur die Python-API akzeptiert.

Training Nutzung#

Führe Fine-Tuning für jeden veröffentlichten *-seg.pt-Checkpoint auf deinem eigenen YOLO-Dataset durch. Dies folgt größtenteils dem standardmäßigen YOLO-Trainingsverfahren; der Unterschied liegt darin, welchen Trainer du übergibst. YOLOEPESegTrainer integriert deine Klassennamen in den Kopf und führt von dort aus ein Fine-Tuning durch, was bei deinen eigenen Labels erwünscht ist; der Standard-Trainer trainiert nicht gegen deine 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,  # <- Important: the fine-tuning trainer, not the default
)

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)

Predict-Nutzung#

Der Text-Prompt-Aufruf entspricht dem in Schnellstart gezeigten. Die verbleibenden beiden Modi erfordern jeweils ein zusätzliches Argument:

import numpy as np

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

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

# One example box per target, each with its own class ID
visual_prompts = {
    "bboxes": np.array([[221.52, 405.8, 344.98, 857.54], [120, 425, 160, 445]]),  # person, glasses
    "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",  # Target image
    refer_image="ultralytics/assets/bus.jpg",  # Where the example boxes live
    visual_prompts=visual_prompts,
    predictor=YOLOEVPSegPredictor,
)
results[0].show()

# refer_image also sets the classes permanently, so later calls need no prompts at all
results = model("ultralytics/assets/bus.jpg")
model.export(format="onnx")  # And the export keeps them

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 in [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, glasses
        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()

Val-Nutzung#

Die Validierung läuft wie bei jedem anderen Modell auf einem Segmentierungsdataset ab:

from ultralytics import YOLOE

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

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 eine visuelle Einbettung pro Kategorie aus dem Dataset selbst. Füge refer_data="coco.yaml" hinzu, um die Einbettungen aus einem anderen Dataset zu beziehen, das exakt dieselben Kategorien enthalten muss.
• Prompt-frei — lade einen *-seg-pf.pt-Checkpoint und übergebe single_cls=True.

Export-Nutzung#

Prompt-Embeddings können einmal gespeichert und bei der Erstellung statischer Exporte wie ONNX, OpenVINO, TensorRT, CoreML, LiteRT und RKNN wiederverwendet werden. Das NPZ-Profil wird vor dem Export vom originalen PyTorch-Modell geladen; es ist kein zusätzlicher Laufzeiteingang, 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")

# The profile is bound to the source checkpoint and can be reused for later exports.
model = YOLOE("yoloe-26n-seg.pt")
model.load_prompt_embeddings("person-bus.npz")
model.export(format="onnx")

Dasselbe Prompt-Profil kann auch ein reines Erfassungsmodell konfigurieren, das auf der passenden YOLOE-Architektur basiert. Dadurch wird der Masken-Zweig entfernt, während die vorgegebenen 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)

Track-Nutzung#

Geprompte Klassen werden direkt in das Tracking übernommen, sodass du Objekte verfolgen kannst, auf die der Tracker nie trainiert wurde:

from ultralytics import YOLOE

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

# persist=True keeps track IDs stable across frames
for result in model.track("path/to/video.mp4", stream=True, persist=True):
    print(result.boxes.id)

Wie sich YOLOE im Vergleich schlägt#

YOLOE positioniert sich zwischen einem Detektor mit geschlossenem Vokabular und einem schwergewichtigen Open-Vocabulary-Modell. Drei Vergleiche entscheiden, ob es die richtige Wahl ist:

• Gegenüber einem YOLO mit geschlossenem Vokabular. Sobald die Prompts festgelegt sind, sagt YOLOE über den gewöhnlichen Erkennungs-/Segmentierungspfad voraus und exportiert wie jedes andere Modell. Der Vorteil ist die Möglichkeit, die Klassenliste zur Inferenzzeit zu ändern anstatt ein Retraining durchzuführen; der Nachteil ist eine Zero-Shot-Genauigkeit, die deutlich unter der eines Modells liegt, das auf deine eigenen Klassen trainiert wurde.
• Gegenüber den früheren YOLOE-Familien. YOLOE-26 übernimmt den NMS-freien End-to-End-Kopf von YOLO26, deckt fünf Skalierungen (n/s/m/l/x) im Vergleich zu den früheren drei (s/m/l) ab und führt bei jeder passenden Skalierung in der Leistung.
• Gegenüber Transformer-basierten Open-Vocabulary-Detektoren. GLIP und OWL-ViT führen zur Inferenzzeit einen Vision-Language-Transformer aus. YOLOE kodiert die Prompts einmalig und gleicht sie dann innerhalb eines konvolutionalen Kopfes mit Regionsmerkmalen ab.

Die nächstliegenden Alternativen verwenden alle einen Text-Prompt, aber nur YOLOE und SAM 3 liefern Masken, und die drei beantworten unterschiedliche Fragen:

Kommst du von YOLO-World? Die API hat dieselbe Form: Ersetze YOLOWorld durch YOLOE, lade einen *-seg.pt-Checkpoint und behalte deinen set_classes()-Aufruf bei. Du erhältst Masken und visuelle Prompts; der Export-Hinweis zu eingefrorenen Klassen gilt für beide.

Anwendungsfälle und Einsatzgebiete#

Open-Vocabulary-Detektion macht den Schritt des Neutrainierens pro Klasse überflüssig, was besonders dort wichtig ist, wo die Zielliste nicht im Voraus bekannt ist:

• Open-World-Detektion — Robotik und Sicherheitssysteme, die auf Objekte treffen, die zum Zeitpunkt des Trainings niemand aufgelistet hat.
• One-Shot-Detektion aus einem Beispiel — visuelle Prompts erkennen ein spezifisches Teil, Logo oder einen Defekt anhand einer einzelnen Referenzbox, nützlich in der industriellen Inspektion.
• Long-Tail-Katalogisierung — das integrierte Vokabular mit 4.585 Namen ist breit genug für das Überwachen der Biodiversität oder Einzelhandelsbestandsaufnahmen.
• Dataset Bootstrapping — Bilder vor dem menschlichen Review mit Boxen und Masken vorlabeln, um dann ein schnelles Modell für feste Klassen auf dem Ergebnis zu trainieren.
• Segmentierung beliebiger Ziele — die veröffentlichten *-seg.pt-Checkpoints liefern bei jeder Vorhersage eine Maske zurück, sodass medizinische Bildgebung und Satellitenanalyse pixelgenaue Ergebnisse ohne ein zweites Modell erhalten.

Ein gängiges Muster kombiniert zwei Modi: Führe den prompt-freien Modus einmal aus, um zu entdecken, was vorhanden ist, und schalte dann für die relevanten Kategorien auf Text-Prompts um.

Einschränkungen#

YOLOE tauscht Genauigkeit gegen die Fähigkeit ein, Klassen zur Inferenzzeit zu ändern. Die Konsequenzen, die du kennen solltest, bevor du dich festlegst:

• Die Zero-Shot-Genauigkeit liegt deutlich unter der eines Modells, das auf deinen Klassen trainiert wurde. Die mit Prompts versehenen Checkpoints landen grob im Bereich von 22-40 mAP auf LVIS minival; ein auf deine eigenen Daten trainiertes YOLO mit festen Klassen wird das bei diesen Klassen übertreffen. Greife zu YOLOE, um Klassen abzudecken, für die du nicht trainieren kannst, nicht um das Training zu ersetzen.
• Seltene Kategorien sind der Schwachpunkt. Die mAP_r-Spalte in Performance berichtet speziell über die Genauigkeit bei den seltenen Klassen von LVIS, und bei Text-Prompts liegt sie in jeder Zeile unter den Spalten für häufige und sehr häufige Klassen. Überprüfe diese anstelle des allgemeinen mAP, wenn deine Ziele ungewöhnlich sind.
• Ein Prompt beschreibt das Aussehen, keine Beziehungen. Die Detektion funktioniert, indem Regionsmerkmale mit dem Prompt-Embedding verglichen werden. Prompts, die von Zustand, Kontext oder Vergleich abhängen – „beschädigt“, „ganz links“, „das getragene Objekt“ – haben keinen verlässlichen Anhaltspunkt für den Abgleich. Bevorzuge Formulierungen, die alltäglichen Klassennamen nahekommen.
• Große Prompt-Mengen kosten Latenz. Die Prompt-Embeddings werden einmal berechnet, aber bei jedem Forward-Pass mit Regionsmerkmalen verglichen. Gemessen auf der CPU mit yoloe-26s-seg.pt wächst ein Forward-Pass beim Übergang von 80 auf 1.203 Klassen um etwa 19 % und beim vollständigen Vokabular mit 4.585 Namen um etwa 89 %. Die gemeldeten FLOPs verändern sich überhaupt nicht, da die Region-Text-Ähnlichkeit nicht mitgezählt wird, sodass das Profil dich nicht davor warnen wird.
• Klassennamen sind Platzhalter, bis du einen Prompt eingibst. Ein frisch geladener *-seg.pt-Checkpoint meldet nc=80 mit numerischen Namen ("0", "1", …), rufe also set_classes() auf, bevor du Labels liest. Prompt-freie Checkpoints liefern das vollständige Vokabular bereits ausgefüllt mit.

Bereitstellungshinweise#

• Hardware. Die Inferenz benötigt eine NVIDIA-GPU mit 4-8 GB VRAM; die Skalierungen n und s laufen auf Edge-GPUs wie Jetson oder auf der CPU bei reduzierter Auflösung. Das Fine-Tuning erfordert eine einzelne GPU.
• NMS ist standardmäßig klassenagnostisch. YOLOE prognostiziert mit agnostic_nms=True. Bei YOLOE-11 und YOLOE-v8 werden überlappende Boxen mit niedrigerem Score über verschiedene Klassen hinweg unterdrückt, anstatt nur innerhalb derselben Klasse, was Duplikate verhindert, wenn ein Objekt mehreren Kategorien entspricht. End-to-End YOLOE-26-Modelle wenden überhaupt keine IoU-Unterdrückung an; dort behält der agnostische Modus nur die jeweils beste Klasse pro Anker bei, anstatt zuzulassen, dass ein Anker mehrere Klassennamen ausgibt. Übergib agnostic_nms=False, um dies zu überschreiben.
• Batching. Batch-Inferenz funktioniert direkt, und visuelle Prompts können pro Bild im selben Aufruf variieren.

Training der offiziellen Modelle von Grund auf#

Die meisten Leser benötigen dies nie. Es reproduziert die veröffentlichten Open-Vocabulary-Checkpoints von Objects365, GQA und Flickr30k – etwa 1,4 Millionen Trainingsdaten auf 8× RTX 4090 – und steht in keinem Zusammenhang mit dem Fine-Tuning auf deinen eigenen Daten, das oben unter Train Usage behandelt wird.

Das Training erfordert Segment-Annotationen. Entweder lädst du die verarbeiteten Dateien unten herunter oder generierst deine eigenen mit dem vom offiziellen Team bereitgestellten Skript, das von SAM 2.1 unterstützt wird. Für die Validierung wird LVIS minival verwendet.

Das Text-Prompt-Modell wird zuerst trainiert, und die beiden anderen Prompting-Modi sind Verfeinerungen davon:

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,  # or the path to a YAML file holding the same structure
    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 den prompt-freien Modus basieren auf diesem trainierten Text-Prompt-Modell und aktualisieren jeweils ein Modul. YOLOESegVPTrainer ist das Rezept für visuelle Prompts und YOLOEPEFreeTrainer das für den prompt-freien Modus, aber keine Klasse friert von sich aus etwas ein: Das selektive Training erfolgt über die Liste freeze, die du zusammen damit übergibst und die jedes Head-Kind außer savpe (bzw. jeden Klassifikationsturm) benennt, und der prompt-freie Lauf benötigt zusätzlich single_cls=True. Das upstream YOLOE repository enthält die vollständigen Rezepte für die Modelle im v8-Maßstab.

Ein abgeschlossener prompt-freier Lauf wird in einen Checkpoint reparameterisiert, der seine Namen bei der Inferenz ohne Prompt ausgibt, unter Verwendung von get_vocab und set_vocab:

from ultralytics import YOLOE

# Weights written by the prompt-free run and by the text-prompt run it started from. Each
# rerun creates a new directory (train-2, train-3, ...), so take the paths the runs printed.
model = YOLOE("runs/segment/train-2/weights/best.pt")  # prompt-free run, its head is already fused
text_model = YOLOE("runs/segment/train/weights/best.pt")  # text-prompt run, its head is still unfused

names = list(YOLOE("yoloe-26l-seg-pf.pt").model.names.values())  # the 4,585-name vocabulary, or your own list
vocab = text_model.get_vocab(names)

model.set_vocab(vocab, names)
model.save("yoloe-26l-seg-pf-custom.pt")  # never overwrite the released checkpoint

Zitate 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 weitere Lektüre ist das originale YOLOE-Papier auf arXiv verfügbar. Auf den Quellcode des Projekts und zusätzliche Ressourcen kann über das GitHub-Repository zugegriffen werden.

FAQ#