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

Ultralytics YOLOE (Echtzeit-Erkennung beliebiger Objekte) 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 Text-Prompt, visuelles Beispiel oder aus einem integrierten Vokabular mit 4.585 Namen. YOLOE basiert auf den Ultralytics YOLO-Architekturen – YOLOv8, YOLO11 und YOLO26 – und ist von YOLO-World inspiriert. Das Modell erreicht beim Zero-Shot-Lernen eine Genauigkeit auf dem neuesten Stand der Technik und ist dabei nahezu so schnell wie YOLO-Modelle mit geschlossenem Klassenumfang.

Schnellstart#

Gib die gewünschten Klassen an und starte die Ausführung. YOLOE-26 gibt Boxen und Masken für die Instanzsegmentierung von Kategorien zurück, 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 Aufruf von set_classes() lädt einen Text-Encoder herunter. Lies vor der Bereitstellung auf einem Rechner ohne Netzwerkzugriff den Abschnitt Installation und Anforderungen.

Auswahl des Prompt-Modus#

YOLOE unterstützt drei Prompt-Modi. Deine Wahl bestimmt, welchen Checkpoint du lädst und wie die Klassenbezeichnungen aussehen. Wähle die Zeile, die zu dem passt, was du bei der Inferenz bereitstellen kannst.

Installation und Anforderungen#

YOLOE ist im Hauptpaket von Ultralytics enthalten:

pip install -U ultralytics

Für Text-Prompts wird zusätzlich ein Text-Encoder benötigt. Dieser wird bei der ersten Verwendung abgerufen und nicht während der Installation:

• Der erste Aufruf von set_classes() installiert ultralytics/CLIP von GitHub mit pip (stellt den Tokenizer bereit) und lädt einen TorchScript-Text-Encoder in das aktuelle Arbeitsverzeichnis herunter. YOLOE-26 lädt mobileclip2_b.ts mit etwa 254 MB; YOLOE-11 und YOLOE-v8 laden mobileclip_blt.ts. Führe den Download einmal aus dem Verzeichnis aus, aus dem du später startest, oder kopiere die Datei dorthin. Andernfalls wird sie erneut abgerufen.
• Für beide Schritte ist Netzwerkzugriff erforderlich. Führe daher vor der Bereitstellung auf einem Offline- oder vollständig vom Netzwerk getrennten Rechner eine Vorhersage mit Prompt aus.
• Visuelle Prompts und promptfreie Checkpoints benötigen überhaupt keinen Text-Encoder.

Die YOLOE-26-Checkpoints erfordern ultralytics 8.4.0 oder neuer. Die Familien YOLOE-11 und YOLOE-v8 sind bereits in früheren Versionen verfügbar. Eine Vorhersage mit Text-Prompt durchläuft den gesamten Ablauf – Download des Checkpoints, Installation von CLIP, Text-Encoder und Inferenz:

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

Um den Download des Text-Encoders zum Inferenzzeitpunkt vollständig zu überspringen, kannst du die Prompts einmalig in die Gewichte einbetten und anschließend wiederverwenden. Siehe Prompt-Einbettungen wiederverwenden.

Architekturübersicht#

YOLOE behält die standardmäßige YOLO-Struktur bei – ein konvolutionales Backbone zur Merkmalsextraktion, einen Neck zur Fusion auf mehreren Maßstabsebenen und einen ankerfreien, entkoppelten Kopf, der Klassen und Boxen vorhersagt – und ergänzt drei Module, eines pro Prompt-Modus:

• Re-parameterizable Region-Text Alignment (RepRTA) verfeinert Text-Einbettungen aus CLIP mithilfe eines kleinen zusätzlichen Netzwerks. Dieses Netzwerk wird einmal pro Aufruf von set_classes() ausgeführt und beim Export entfernt, sodass pro Frame keine zusätzlichen Kosten entstehen. Bei jedem Forward-Pass wird jedoch der Abgleich der gespeicherten Prompt-Einbettungen mit den Regionsmerkmalen ausgeführt. Welche Kosten bei einer großen Anzahl von Prompts entstehen, erfährst du unter Einschränkungen.
• Semantic-Activated Visual Prompt Encoder (SAVPE) kodiert semantische Merkmale und Aktivierungsmerkmale aus einer Beispielbox und konditioniert das Modell auf Objekte, die diesem Beispiel ähnlich sehen. 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) vergleicht Regionseinbettungen mit einem integrierten Vokabular aus 4.585 Namen. Dadurch erkennen promptfreie Checkpoints Objekte ohne externen Prompt und ohne Text-Encoder.

Die Instanzsegmentierung wird wie bei YOLOv8-Seg durch einen Maskenzweig im Erkennungskopf ermöglicht, und jede Vorhersage enthält eine Maske auf results[0].masks. Nach dem Export werden die Open-World-Module in einen standardmäßigen YOLO-Kopf umparametrisiert, sodass die exportierte Datei den gewöhnlichen Pfad für Erkennung und Segmentierung ausführt.

Verfügbare Modelle#

Jeder unten aufgeführte Checkpoint ist ein Modell zur Instanzsegmentierung und unterstützt val, predict, export und track. Lade für Text- oder visuelle Prompts eine *-seg.pt-Datei und für promptfreie Inferenz eine *-seg-pf.pt-Datei. Sie sind nicht austauschbar; siehe Auswahl des Prompt-Modus. Nur die *-seg.pt-Dateien unterstützen train. Ein promptfreier Checkpoint wird aus einem trainierten Modell für Text-Prompts erzeugt. 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.

Text- und visuelle Prompts#

Jede Zelle mit Genauigkeits- und Parameterangaben ist als Text-Prompt / visueller Prompt zu lesen; FLOPs werden nur einmal angegeben. Parameter und FLOPs beziehen sich auf die Erkennungskonfiguration, die im Paper evaluiert wird. Die Genauigkeit entspricht der Non-E2E-Angabe des Papers, dem einzigen Protokoll, das es für jedes Vergleichsmodell berichtet. Der End-to-End-Kopf von YOLOE-26 liegt bei Text-Prompts höchstens 1,1 AP und bei visuellen Prompts höchstens 2,6 AP dahinter.

Promptfrei#

Die promptfreien Checkpoints treffen ihre Entscheidung anhand des integrierten Vokabulars, ohne dass ein Prompt übergeben wird. Jede Zelle mit Genauigkeitsangaben ist als End-to-End / Non-E2E zu lesen – die beiden Protokolle, unter denen das Paper YOLOE-26 bewertet. Auf der YOLO26-Seite wird die Non-E2E-Spalte angegeben.

Bei Text- und visuellen Prompts liegen die YOLOE-26-Modelle bei mAP_50-95 auf jeder vergleichbaren Modellgröße vor ihren YOLOE-11- und YOLOE-v8-Pendants, während sie bei Parametern und FLOPs unter der v8-Reihe bleiben. Für dieselbe Aufteilung berichtet das Paper 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 verfügt über 155 bis 232 M Parameter. Das ursprüngliche YOLOE-Paper ergänzt zwei Ergebnisse für die von ihm eingeführten Modelle in der v8-Größenklasse. Auf LVIS übertrifft YOLOE-v8s YOLO-Worldv2-S um 3,5 AP – bei einem Drittel des Trainingsaufwands und 1,4-facher Inferenzgeschwindigkeit. Auf COCO erzielt YOLOE-v8l gegenüber YOLOv8-L mit geschlossenem Klassenumfang 0,6 Box-AP und 0,4 Masken-AP mehr – bei nahezu viermal kürzerer Trainingszeit.

Verwendungsbeispiele#

Jedes YOLOE-Beispiel unten wird über die Python API ausgeführt. Vorhersagen mit Text-Prompt, Validierung, Export, Tracking und gewöhnliches Training funktionieren auch über die CLI. Die Rezepte für Feinabstimmung und visuelles Prompting übergeben eine Trainer- oder Predictor-Klasse als Argument, was nur die Python API unterstützt.

Trainingsverwendung#

Stimme jeden veröffentlichten *-seg.pt-Checkpoint auf deinen eigenen YOLO-Datensatz ab. Dies folgt weitgehend dem standardmäßigen YOLO-Trainingsverfahren; der Unterschied besteht darin, welchen Trainer du übergibst. YOLOEPESegTrainer integriert deine Klassennamen in den Kopf und führt die Feinabstimmung von dort aus durch – genau das brauchst du für deine eigenen Bezeichnungen. Der Standard-Trainer 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,  # <- 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)

Verwendung für Vorhersagen#

Der Aufruf mit Text-Prompt ist der unter Quick Start gezeigte. Die beiden übrigen Modi benötigen 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()

Verwendung für die Validierung#

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

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 für jede Kategorie ein visuelles Embedding direkt aus dem Datensatz. Füge refer_data="coco.yaml" hinzu, um die Embeddings aus einem anderen Datensatz zu übernehmen. Dieser muss exakt dieselben Kategorien enthalten.
• Ohne Prompt – Lade einen *-seg-pf.pt-Prüfpunkt und übergebe single_cls=True.

Verwendung beim Export#

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 ursprünglichen 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 Erkennungsmodell konfigurieren, das aus der passenden YOLOE-Architektur erstellt wurde. Dadurch wird der Maskenzweig entfernt, während die per Prompt festgelegten 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)

Verwendung für die Verfolgung#

Die per Prompt festgelegten Klassen werden direkt in das Tracking übernommen. So kannst du Objekte verfolgen, auf denen 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)

YOLOE im Vergleich#

YOLOE liegt zwischen einem Erkennungsmodell mit geschlossenem Klassenbestand und einem umfangreichen Modell mit offenem Vokabular. Drei Vergleiche entscheiden, ob es die richtige Wahl ist:

• Im Vergleich zu einem YOLO mit geschlossenem Klassenbestand. Sobald die Prompts festgelegt sind, erstellt YOLOE Vorhersagen über den gewöhnlichen Pfad für Erkennung und Segmentierung und wird wie jedes andere Modell exportiert. Der Vorteil ist, dass du die Klassenliste zur Inferenzzeit ändern kannst, ohne neu zu trainieren. Der Nachteil ist eine deutlich geringere Zero-Shot-Genauigkeit gegenüber einem Modell, das auf deinen eigenen Klassen trainiert wurde.
• Im Vergleich zu den früheren YOLOE-Familien. YOLOE-26 übernimmt den YOLO26-Kopf für eine durchgängige Erkennung ohne NMS und deckt fünf Größen (n/s/m/l/x) gegenüber den früheren drei (s/m/l) ab. Außerdem führt es bei jeder vergleichbaren Größe in Performance.
• Im Vergleich zu Transformer-basierten Erkennungsmodellen mit offenem Vokabular. GLIP und OWL-ViT führen bei der Inferenz einen Transformer für Bild und Sprache aus. YOLOE kodiert die Prompts einmal und vergleicht sie anschließend innerhalb eines Faltungskopfs mit den Merkmalen der Regionen.

Die nächstgelegenen 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 dieselbe Struktur: Ersetze YOLOWorld durch YOLOE, lade einen *-seg.pt-Prüfpunkt und belasse deinen set_classes()-Aufruf unverändert. Du erhältst Masken und visuelle Prompts. Der Exporthinweis zu eingefrorenen Klassen gilt für beide Modelle.

Anwendungsfälle und Anwendungen#

Die Erkennung mit offenem Vokabular macht den Schritt „für jede Klasse neu trainieren“ überflüssig. Das ist besonders wichtig, wenn die Zielliste vorab nicht bekannt ist:

• Erkennung in einer offenen Welt – Robotik und Sicherheitssysteme, die auf Objekte treffen, die zum Trainingszeitpunkt niemand aufgelistet hat.
• One-Shot-Erkennung anhand eines Beispiels – Visuelle Prompts erkennen ein bestimmtes Bauteil, Logo oder einen Defekt anhand einer einzelnen Referenzbox. Das ist nützlich bei der industriellen Inspektion.
• Katalogisierung einer langen Verteilung – Das integrierte Vokabular mit 4.585 Namen ist breit genug für die Überwachung der Biodiversität oder die Bestandsaufnahme im Einzelhandel.
• Aufbau eines Datensatzes – Versehe Bilder vor der menschlichen Prüfung mit vorläufigen Boxen und Masken und trainiere anschließend ein schnelles Modell mit geschlossenem Klassenbestand auf dem Ergebnis.
• Segmentierung beliebiger Ziele – Die veröffentlichten *-seg.pt-Prüfpunkte geben mit jeder Vorhersage eine Maske zurück. Dadurch erhalten medizinische Bildgebung und Satellitenanalyse pixelgenaue Ergebnisse ohne ein zweites Modell.

Ein häufiges Muster kombiniert zwei Modi: Führe zunächst einmal den Modus ohne Prompt aus, um die vorhandenen Objekte zu erkennen, und wechsle anschließend für die wichtigen Kategorien zu Text-Prompts.

Einschränkungen#

YOLOE tauscht Genauigkeit gegen die Möglichkeit, Klassen zur Inferenzzeit zu ändern. Diese Folgen solltest du kennen, bevor du dich dafür entscheidest:

• Die Zero-Shot-Genauigkeit liegt deutlich unter der eines auf deinen Klassen trainierten Modells. Die Prompt-Prüfpunkte erreichen auf LVIS minival ungefähr 22–40 mAP. Ein Modell mit geschlossenem Klassenbestand, das auf deinen eigenen Daten trainiert wurde, wird diese Klassen besser erkennen. Verwende YOLOE, um Klassen abzudecken, für die du nicht trainieren kannst, und nicht als Ersatz für das Training.
• Seltene Kategorien sind die Schwachstelle. Die Spalte mAP_r in Performance gibt die Genauigkeit speziell für die seltenen Klassen von LVIS an. Bei Text-Prompts liegt sie in jeder Zeile unter den Spalten für häufige und sehr häufige Klassen. Prüfe diese Spalte statt der zentralen mAP, wenn deine Ziele ungewöhnlich sind.
• Ein Prompt beschreibt das Aussehen, nicht Beziehungen. Die Erkennung vergleicht Merkmale von Regionen mit dem Prompt-Embedding. Prompts, die von Zustand, Kontext oder Vergleichen abhängen – „beschädigt“, „ganz links“, „das getragene Objekt“ – bieten daher keinen zuverlässigen Anhaltspunkt für einen Abgleich. Verwende möglichst Formulierungen, die alltäglichen Kategorienamen entsprechen.
• Große Prompt-Mengen erhöhen die Latenz. Die Prompt-Embeddings werden einmal berechnet, aber bei jedem Vorwärtsdurchlauf mit den Merkmalen der Regionen verglichen. Messungen auf der CPU mit yoloe-26s-seg.pt zeigen, dass sich die Dauer eines Vorwärtsdurchlaufs beim Wechsel von 80 auf 1.203 Klassen um etwa 19 % und beim vollständigen Vokabular mit 4.585 Namen um etwa 89 % erhöht. Die angegebenen FLOPs verändern sich überhaupt nicht, weil die Ähnlichkeit zwischen Regionen und Text nicht mitgezählt wird. Das Profil warnt dich daher nicht davor.
• Klassennamen sind vor der Prompt-Übergabe nur Platzhalter. Ein frisch geladener *-seg.pt-Prüfpunkt gibt nc=80 mit numerischen Namen ("0", "1", …) zurück. Rufe daher set_classes() auf, bevor du die Bezeichnungen ausliest. Prüfpunkte ohne Prompt enthalten das vollständige Vokabular bereits.

Hinweise zur Bereitstellung#

• Hardware. Für die Inferenz benötigst du eine NVIDIA-GPU mit 4–8 GB VRAM. Die Größen n und s laufen auf Edge-GPUs wie Jetson oder bei verringerter Auflösung auf der CPU. Für die Feinabstimmung wird eine einzelne GPU benötigt.
• NMS ist standardmäßig klassenagnostisch. YOLOE prognostiziert mit agnostic_nms=True. Standardmäßig unterdrückt dies überlappende Boxen mit niedrigeren Bewertungen über verschiedene Klassen hinweg anstatt nur innerhalb derselben Klasse, wodurch Duplikate verhindert werden, wenn ein Objekt mehreren Kategorien entspricht. Mit nms=False wendet YOLOE-26 keine IoU-Unterdrückung an; der agnostische Modus behält nur die jeweils beste Klasse pro Anker bei, anstatt zuzulassen, dass ein Anker mehrere Klassenbezeichnungen ausgibt. Übergebe agnostic_nms=False, um dies zu überschreiben.
• Batch-Verarbeitung. Batch-Inferenz funktioniert direkt, und visuelle Prompts können sich im selben Aufruf für jedes Bild unterscheiden.

Die offiziellen Modelle von Grund auf trainieren#

Die meisten Leser benötigen diesen Abschnitt nicht. Er reproduziert die veröffentlichten Prüfpunkte mit offenem Vokabular aus Objects365, GQA und Flickr30k – etwa 1,4 Millionen Trainingsbeispiele auf 8× RTX 4090 – und steht in keinem Zusammenhang mit der Feinabstimmung auf deinen eigenen Daten, die oben unter Train Usage behandelt wird.

Für das Training werden Segmentannotationen benötigt. Lade entweder die verarbeiteten Dateien unten herunter oder erstelle eigene mit dem vom offiziellen Team bereitgestellten Skript, das auf SAM 2.1 basiert. Für die Validierung wird LVIS minival verwendet.

Das Modell mit Text-Prompts wird zuerst trainiert. Die beiden anderen Prompt-Modi sind darauf aufbauende Weiterentwicklungen:

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 Prüfpunkte für visuelle Prompts und ohne Prompt starten mit diesem trainierten Modell und aktualisieren jeweils ein Modul. YOLOESegVPTrainer ist das Rezept für visuelle Prompts und YOLOEPEFreeTrainer das Rezept ohne Prompt. Keiner der beiden Modi friert jedoch selbst Klassen ein: Das selektive Training wird durch die Liste freeze gesteuert, die du zusammen mit dem jeweiligen Modus übergibst. Sie nennt jedes untergeordnete Element des Kopfs außer savpe (beziehungsweise jeden Klassifikationsturm). Der Lauf ohne Prompt benötigt zusätzlich single_cls=True. Das YOLOE-Repository des Upstream-Projekts enthält die vollständigen Rezepte für die Modelle der v8-Größen.

Ein abgeschlossener Lauf ohne Prompt wird mit get_vocab und set_vocab in einen parametrisierten Prüfpunkt umgewandelt, der seine Namen bei der Inferenz ohne Prompt zurückgibt:

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#

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. Der Quellcode des Projekts und weitere Ressourcen sind über das GitHub-Repository verfügbar.

FAQ#