YOLOE: Alles in Echtzeit sehen

Einführung

YOLOE (Real-Time Seeing Anything) ist ein neuer Fortschritt bei Zero-Shot, promptable YOLO , die für die Erkennung und Segmentierung mit offenem Vokabular entwickelt wurden. Im Gegensatz zu früheren YOLO , die auf feste Kategorien beschränkt sind, verwendet YOLOE Text-, Bild- oder interne Vokabular-Prompts und ermöglicht so die Erkennung beliebiger Objektklassen in Echtzeit. Aufbauend auf YOLOv10 und inspiriert von YOLO, erreicht YOLOE eine hochmoderne Zero-Shot-Leistung mit minimalen Auswirkungen auf Geschwindigkeit und Genauigkeit.

Beobachten: Verwendung von YOLOE mit dem Ultralytics Python : Offenes Vokabular & Alles in Echtzeit sehen 🚀

Im Vergleich zu früheren YOLO steigert YOLOE die Effizienz und Genauigkeit erheblich. Es verbessert sich um +3,5 AP gegenüber YOLO auf LVIS, während es nur ein Drittel der Trainingsressourcen benötigt und eine 1,4-fach höhere Inferenzgeschwindigkeit erreicht. In der Feinabstimmung auf COCO übertrifft YOLOE-v8-large YOLOv8 um 0,1 mAP und benötigt dabei fast 4× weniger Trainingszeit. Dies beweist die außergewöhnliche Ausgewogenheit von YOLOE in Bezug auf Genauigkeit, Effizienz und Vielseitigkeit. In den folgenden Abschnitten werden die Architektur von YOLOE, Benchmark-Vergleiche und die Integration mit dem Ultralytics Rahmenwerk.

Überblick über die Architektur

YOLOE behält die standardmäßige YOLO bei - ein Faltungsrückgrat (z.B. CSP-Darknet) für die Merkmalsextraktion, einen Hals (z.B. PAN-FPN) für die Fusion auf mehreren Ebenen und einen ankerlosen, entkoppelten Erkennungskopf (wie in YOLO11), der Objektivität, Klassen und Boxen unabhängig voneinander vorhersagt. YOLOE führt drei neue Module ein, die die Erkennung von offenem Vokabular ermöglichen:

• Re-parametrisierbarer Region-Text-Abgleich (RepRTA): Unterstützt die textgestützte Erkennung durch Verfeinerung der Texteinbettungen (z. B. aus CLIP) über ein kleines Hilfsnetz. Bei der Inferenz wird dieses Netz in das Hauptmodell eingefügt, so dass kein Overhead entsteht. YOLOE erkennt somit beliebige textbeschriftete Objekte (z.B. eine ungesehene "Ampel") ohne Laufzeiteinbußen.

• Semantisch aktivierter visueller Prompt-Encoder (SAVPE): Ermöglicht die visuelle Erkennung über einen leichtgewichtigen Einbettungszweig. Bei einem Referenzbild kodiert SAVPE semantische und Aktivierungsmerkmale und konditioniert das Modell, um visuell ähnliche Objekte zu erkennen - eine einmalige Erkennungsfunktion, die für Logos oder bestimmte Teile nützlich ist.

• Lazy Region-Prompt Contrast (LRPC): Im Prompt-freien Modus führt YOLOE eine Open-Set-Erkennung mit internen Einbettungen durch, die auf großen Vokabularen (mehr als 1200 Kategorien aus LVIS und Objects365) trainiert wurden. Ohne externe Eingabeaufforderungen oder Kodierer identifiziert YOLOE Objekte über eine Ähnlichkeitssuche der Einbettung und kann so große Label-Spaces bei der Inferenz effizient verarbeiten.

Darüber hinaus integriert YOLOE die Echtzeit-Segmentierung von Instanzen, indem es den Erkennungskopf um einen Maskenvorhersagezweig erweitert (ähnlich wie YOLACT oder YOLOv8), was nur minimalen Overhead bedeutet.

Entscheidend ist, dass die Open-World-Module von YOLOE keine Inferenzkosten verursachen, wenn sie wie ein reguläres YOLO mit geschlossenem Satz verwendet werden. Nach dem Training können die YOLOE-Parameter in einen YOLO umparametrisiert werden, wobei die FLOPs und die Geschwindigkeit identisch bleiben (z.B. bei YOLO11 genau).

Verfügbare Modelle, unterstützte Aufgaben und Betriebsmodi

In diesem Abschnitt werden 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 beschrieben, gekennzeichnet durch ✅ für unterstützte Modi und ❌ für nicht unterstützte Modi.

Text/Visuelle Aufforderungsmodelle

Prompt Freie Modelle

Beispiele für die Verwendung

Die YOLOE-Modelle sind leicht in Ihre Python zu integrieren. Ultralytics bietet eine benutzerfreundliche Python und CLI zur Rationalisierung der Entwicklung.

Zugbenutzung

Feinabstimmung auf benutzerdefinierten Datensatz

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

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

model.train(
    data="coco128-seg.yaml",
    epochs=80,
    close_mosaic=10,
    batch=128,
    optimizer="AdamW",
    lr0=1e-3,
    warmup_bias_lr=0.0,
    weight_decay=0.025,
    momentum=0.9,
    workers=4,
    device="0",
    trainer=YOLOEPESegTrainer,
)

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

model = YOLOE("yoloe-11s-seg.pt")
head_index = len(model.model.model) - 1
freeze = [str(f) for f in range(0, head_index)]
for name, child in model.model.model[-1].named_children():
    if "cv3" not in name:
        freeze.append(f"{head_index}.{name}")

freeze.extend(
    [
        f"{head_index}.cv3.0.0",
        f"{head_index}.cv3.0.1",
        f"{head_index}.cv3.1.0",
        f"{head_index}.cv3.1.1",
        f"{head_index}.cv3.2.0",
        f"{head_index}.cv3.2.1",
    ]
)

model.train(
    data="coco128-seg.yaml",
    epochs=2,
    close_mosaic=0,
    batch=16,
    optimizer="AdamW",
    lr0=1e-3,
    warmup_bias_lr=0.0,
    weight_decay=0.025,
    momentum=0.9,
    workers=4,
    device="0",
    trainer=YOLOEPESegTrainer,
    freeze=freeze,
)

Nutzung vorhersagen

YOLOE supports both text-based and visual prompting. Using prompts is straightforward—just pass them through the predict Methode wie unten gezeigt:

from ultralytics import YOLOE

# Initialize a YOLOE model
model = YOLOE("yoloe-11l-seg.pt")  # or select yoloe-11s/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.
names = ["person", "bus"]
model.set_classes(names, model.get_text_pe(names))

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

# Show results
results[0].show()

import numpy as np

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

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

# Define visual prompts using bounding boxes and their corresponding class IDs.
# Each box highlights an example of the object you want the model to detect.
visual_prompts = dict(
    bboxes=np.array(
        [
            [221.52, 405.8, 344.98, 857.54],  # Box enclosing person
            [120, 425, 160, 445],  # Box enclosing glasses
        ],
    ),
    cls=np.array(
        [
            0,  # ID to be assigned for person
            1,  # ID to be assigned for glassses
        ]
    ),
)

# Run inference on an image, using the provided visual prompts as guidance
results = model.predict(
    "ultralytics/assets/bus.jpg",
    visual_prompts=visual_prompts,
    predictor=YOLOEVPSegPredictor,
)

# Show results
results[0].show()

import numpy as np

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

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

# Define visual prompts based on a separate reference image
visual_prompts = dict(
    bboxes=np.array([[221.52, 405.8, 344.98, 857.54]]),  # Box enclosing person
    cls=np.array([0]),  # ID to be assigned for person
)

# Run prediction on a different image, using reference image to guide what to look for
results = model.predict(
    "ultralytics/assets/zidane.jpg",  # Target image for detection
    refer_image="ultralytics/assets/bus.jpg",  # Reference image used to get visual prompts
    visual_prompts=visual_prompts,
    predictor=YOLOEVPSegPredictor,
)

# Show results
results[0].show()

import numpy as np

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

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

# Define visual prompts using bounding boxes and their corresponding class IDs.
# Each box highlights an example of the object you want the model to detect.
visual_prompts = dict(
    bboxes=[
        np.array(
            [
                [221.52, 405.8, 344.98, 857.54],  # Box enclosing person
                [120, 425, 160, 445],  # Box enclosing glasses
            ],
        ),
        np.array([[150, 200, 1150, 700]]),
    ],
    cls=[
        np.array(
            [
                0,  # ID to be assigned for person
                1,  # ID to be assigned for glasses
            ]
        ),
        np.array([0]),
    ],
)

# Run inference on multiple image, using the provided visual prompts as guidance
results = model.predict(
    ["ultralytics/assets/bus.jpg", "ultralytics/assets/zidane.jpg"],
    visual_prompts=visual_prompts,
    predictor=YOLOEVPSegPredictor,
)

# Show results
results[0].show()

from ultralytics import YOLOE

# Initialize a YOLOE model
model = YOLOE("yoloe-11l-seg-pf.pt")

# Run prediction. No prompts required.
results = model.predict("path/to/image.jpg")

# Show results
results[0].show()

Val-Verwendung

from ultralytics import YOLOE

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

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

from ultralytics import YOLOE

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

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

from ultralytics import YOLOE

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

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

from ultralytics import YOLOE

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

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

Die Modellvalidierung für einen Datensatz wird wie folgt vereinfacht:

Zug Offizielle Modelle

Datensätze vorbereiten

• Zugdaten

• Val-Daten

Ausbildung von Grund auf neu beginnen

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

data = dict(
    train=dict(
        yolo_data=["Objects365.yaml"],
        grounding_data=[
            dict(
                img_path="../datasets/flickr/full_images/",
                json_file="../datasets/flickr/annotations/final_flickr_separateGT_train_segm.json",
            ),
            dict(
                img_path="../datasets/mixed_grounding/gqa/images",
                json_file="../datasets/mixed_grounding/annotations/final_mixed_train_no_coco_segm.json",
            ),
        ],
    ),
    val=dict(yolo_data=["lvis.yaml"]),
)

model = YOLOE("yoloe-11l-seg.yaml")
model.train(
    data=data,
    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",
)

import torch

from ultralytics import YOLOE

det_model = YOLOE("yoloe-11l.yaml")
state = torch.load("yoloe-11l-seg.pt")
det_model.load(state["model"])
det_model.save("yoloe-11l-seg-det.pt")

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

data = dict(
    train=dict(
        yolo_data=["Objects365.yaml"],
        grounding_data=[
            dict(
                img_path="../datasets/flickr/full_images/",
                json_file="../datasets/flickr/annotations/final_flickr_separateGT_train_segm.json",
            ),
            dict(
                img_path="../datasets/mixed_grounding/gqa/images",
                json_file="../datasets/mixed_grounding/annotations/final_mixed_train_no_coco_segm.json",
            ),
        ],
    ),
    val=dict(yolo_data=["lvis.yaml"]),
)

model = YOLOE("yoloe-11l-seg.pt")
# replace to yoloe-11l-seg-det.pt if converted to detection model
# model = YOLOE("yoloe-11l-seg-det.pt")

# freeze every layer except of the savpe module.
head_index = len(model.model.model) - 1
freeze = list(range(0, head_index))
for name, child in model.model.model[-1].named_children():
    if "savpe" not in name:
        freeze.append(f"{head_index}.{name}")

model.train(
    data=data,
    batch=128,
    epochs=2,
    close_mosaic=2,
    optimizer="AdamW",
    lr0=16e-3,
    warmup_bias_lr=0.0,
    weight_decay=0.025,
    momentum=0.9,
    workers=4,
    trainer=YOLOEVPTrainer,
    device="0,1,2,3,4,5,6,7",
    freeze=freeze,
)

from copy import deepcopy

from ultralytics import YOLOE

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

vp_model = YOLOE("yoloe-11l-vp.pt")
model.model.model[-1].savpe = deepcopy(vp_model.model.model[-1].savpe)
model.eval()
model.save("yoloe-11l-seg.pt")

import torch

from ultralytics import YOLOE

det_model = YOLOE("yoloe-11l.yaml")
state = torch.load("yoloe-11l-seg.pt")
det_model.load(state["model"])
det_model.save("yoloe-11l-seg-det.pt")

from ultralytics import YOLOE

data = dict(
    train=dict(
        yolo_data=["Objects365.yaml"],
        grounding_data=[
            dict(
                img_path="../datasets/flickr/full_images/",
                json_file="../datasets/flickr/annotations/final_flickr_separateGT_train_segm.json",
            ),
            dict(
                img_path="../datasets/mixed_grounding/gqa/images",
                json_file="../datasets/mixed_grounding/annotations/final_mixed_train_no_coco_segm.json",
            ),
        ],
    ),
    val=dict(yolo_data=["lvis.yaml"]),
)

model = YOLOE("yoloe-11l-seg.pt")
# replace to yoloe-11l-seg-det.pt if converted to detection model
# model = YOLOE("yoloe-11l-seg-det.pt")

# freeze layers.
head_index = len(model.model.model) - 1
freeze = [str(f) for f in range(0, head_index)]
for name, child in model.model.model[-1].named_children():
    if "cv3" not in name:
        freeze.append(f"{head_index}.{name}")

freeze.extend(
    [
        f"{head_index}.cv3.0.0",
        f"{head_index}.cv3.0.1",
        f"{head_index}.cv3.1.0",
        f"{head_index}.cv3.1.1",
        f"{head_index}.cv3.2.0",
        f"{head_index}.cv3.2.1",
    ]
)

model.train(
    data=data,
    batch=128,
    epochs=1,
    close_mosaic=1,
    optimizer="AdamW",
    lr0=2e-3,
    warmup_bias_lr=0.0,
    weight_decay=0.025,
    momentum=0.9,
    workers=4,
    trainer=YOLOEPEFreeTrainer,
    device="0,1,2,3,4,5,6,7",
    freeze=freeze,
    single_cls=True,  # this is needed
)

from copy import deepcopy

from ultralytics import YOLOE

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

pf_model = YOLOE("yoloe-11l-seg-pf.pt")
names = ["object"]
tpe = model.get_text_pe(names)
model.set_classes(names, tpe)
model.model.model[-1].fuse(model.model.pe)

model.model.model[-1].cv3[0][2] = deepcopy(pf_model.model.model[-1].cv3[0][2]).requires_grad_(True)
model.model.model[-1].cv3[1][2] = deepcopy(pf_model.model.model[-1].cv3[1][2]).requires_grad_(True)
model.model.model[-1].cv3[2][2] = deepcopy(pf_model.model.model[-1].cv3[2][2]).requires_grad_(True)
del model.model.pe
model.save("yoloe-11l-seg-pf.pt")

YOLOE Leistungsvergleich

YOLOE erreicht oder übertrifft die Genauigkeit geschlossener YOLO bei Standard-Benchmarks wie COCO, ohne Kompromisse bei Geschwindigkeit oder Modellgröße einzugehen. Die folgende Tabelle vergleicht YOLOE-L (basierend auf YOLO11) mit den entsprechenden YOLOv8 und YOLO11 :

^† YOLO11 und YOLOE-L haben identische Architekturen (Prompt-Module in YOLO11 deaktiviert), was zu identischer Inferenzgeschwindigkeit und ähnlichen GFLOPs-Schätzungen führt.

YOLOE-L erreicht 52,6 % mAP und übertrifft damit YOLOv8(52,9 %) mit etwa 40 % weniger Parametern (26M vs. 43,7M). Es verarbeitet 640×640 Bilder in 6,2 ms (161 FPS) im Vergleich zu YOLOv8's 9,06 ms (110 FPS), was die Effizienz von YOLO11 unterstreicht. Entscheidend ist, dass die YOLOE-Module mit offenem Vokabular keine Kosten für die Inferenz verursachen, was zeigt, dass sie nicht zum Nulltarif zu haben sind.

Bei Zero-Shot- und Transfer-Aufgaben schneidet YOLOE hervorragend ab: Auf LVIS verbessert sich YOLOE-small gegenüber YOLO um +3,5 AP und benötigt dabei 3× weniger Trainingsressourcen. Die Feinabstimmung von YOLOE-L von LVIS auf COCO erforderte ebenfalls 4× weniger Trainingszeit als YOLOv8, was seine Effizienz und Anpassungsfähigkeit unterstreicht. YOLOE behält außerdem die für YOLO charakteristische Geschwindigkeit bei und erreicht 300+ FPS auf einem GPU und ~64 FPS auf dem iPhone 12 über CoreML, was ideal für Edge- und mobile Implementierungen ist.

Vergleich mit früheren Modellen

YOLOE bietet bemerkenswerte Fortschritte gegenüber früheren YOLO und Detektoren mit offenem Vokabular:

• YOLOE gegen YOLOv5:
  YOLOv5 bot ein gutes Gleichgewicht zwischen Geschwindigkeit und Genauigkeit, erforderte jedoch ein erneutes Training für neue Klassen und verwendete ankerbasierte Köpfe. Im Gegensatz dazu ist YOLOE ankerfrei und erkennt neue Klassen dynamisch. YOLOE, das auf den Verbesserungen von YOLOv8 aufbaut, erreicht eine höhere Genauigkeit (52,6% im Vergleich zu YOLOv5~50% mAP auf COCO) und integriert im Gegensatz zu YOLOv5 eine Instanzsegmentierung.

• YOLOE gegen YOLOv8:
  YOLOE erweitert YOLOv8die neu gestaltete Architektur von YOLOv8 und erreicht eine ähnliche oder bessere Genauigkeit(52,6% mAP mit ~26M Parametern gegenüber 52,9% bei YOLOv8 mit ~44M Parametern). Die Trainingszeit wird durch ein stärkeres Pre-Training deutlich reduziert. Der wichtigste Fortschritt ist die Fähigkeit von YOLOE, eine offene Welt zu erkennen, indem es ungesehene Objekte (z. B."Vogel-Roller" oder"Friedenssymbol") über Eingabeaufforderungen erkennt, im Gegensatz zu YOLOv8 geschlossenem Design.

• YOLOE gegen YOLO11:
  YOLO11 verbessert YOLOv8 mit verbesserter Effizienz und weniger Parametern (~22% Reduzierung). YOLOE übernimmt diese Verbesserungen direkt und erreicht die gleiche Inferenzgeschwindigkeit und Parameteranzahl wie YOLO11(~26 Mio. Parameter), wobei die Erkennung und Segmentierung von offenem Vokabular hinzugefügt wird. In Szenarien mit geschlossenem Vokabular ist YOLOE äquivalent zu YOLO11, bietet aber zusätzlich die Möglichkeit, ungesehene Klassen zu erkennen, wodurch YOLO11 + Open-World-Fähigkeit ohne Geschwindigkeitseinbußen erreicht wird.

• YOLOE im Vergleich zu früheren Detektoren für offenes Vokabular:
  Frühere offene Vokabularmodelle (GLIP, OWL-ViT, YOLO) stützten sich stark auf Bild-Sprache-Transformatoren, was zu einer langsamen Inferenz führte. YOLOE übertrifft diese in der Zero-Shot-Genauigkeit (z.B. +3.5 AP vs. YOLO) und läuft dabei 1.4× schneller mit deutlich weniger Trainingsressourcen. Im Vergleich zu transformatorbasierten Ansätzen (z.B. GLIP) bietet YOLOE eine um Größenordnungen schnellere Inferenz und überbrückt damit effektiv die Genauigkeits-Effizienz-Lücke bei der Erkennung offener Sätze.

Zusammenfassend lässt sich sagen, dass YOLOE die bekannte Geschwindigkeit und Effizienz von YOLO beibehält, seine Vorgänger in puncto Genauigkeit übertrifft, eine Segmentierung integriert und eine leistungsstarke Open-World-Erkennung einführt, was es einzigartig vielseitig und praktisch macht.

Anwendungsfälle und Anwendungen

YOLOEs Erkennung und Segmentierung von offenem Vokabular ermöglicht vielfältige Anwendungen jenseits traditioneller Modelle mit festen Klassen:

• Open-World-Objekterkennung:
  Ideal für dynamische Szenarien wie die Robotik, bei der Roboter zuvor ungesehene Objekte anhand von Aufforderungen erkennen, oder für Sicherheitssysteme, die sich schnell an neue Bedrohungen (z. B. gefährliche Gegenstände) anpassen, ohne dass ein erneutes Training erforderlich ist.

• Few-Shot- und One-Shot-Detektion:
  Mithilfe visueller Eingabeaufforderungen (SAVPE) lernt YOLOE schnell neue Objekte aus einzelnen Referenzbildern - perfekt für die industrielle Inspektion (um Teile oder Defekte sofort zu identifizieren) oder die benutzerdefinierte Überwachung, die visuelle Suchen mit minimaler Einrichtung ermöglicht.

• Großes Vokabular und Long-Tail-Erkennung:
  Ausgestattet mit einem Vokabular von mehr als 1000 Klassen eignet sich YOLOE hervorragend für Aufgaben wie die Überwachung der biologischen Vielfalt (Erkennung seltener Arten), Museumssammlungen, Einzelhandelsinventar oder E-Commerce, da es viele Klassen ohne umfangreiches Training pro Klasse zuverlässig erkennt.

• Interaktive Erkennung und Segmentierung:
  YOLOE unterstützt interaktive Echtzeitanwendungen wie die Suche nach Videos/Bildern, Augmented Reality (AR) und intuitive Bildbearbeitung, die durch natürliche Eingaben (Text oder visuelle Eingabeaufforderungen) gesteuert werden. Benutzer können Objekte mithilfe von Segmentierungsmasken dynamisch isolieren, identifizieren oder präzise bearbeiten.

• Automatisierte Datenbeschriftung und Bootstrapping:
  YOLOE erleichtert die schnelle Erstellung von Datensätzen, indem es anfängliche Bounding-Box- und Segmentierungskommentare bereitstellt und so den Aufwand für die menschliche Beschriftung erheblich reduziert. Besonders wertvoll ist dies bei der Analyse großer Mediensammlungen, wo es die vorhandenen Objekte automatisch identifizieren kann und so die Erstellung spezialisierter Modelle beschleunigt.

• Segmentierung für beliebige Objekte:
  Erweitert die Segmentierungsfunktionen durch Eingabeaufforderungen auf beliebige Objekte - besonders vorteilhaft für die medizinische Bildgebung, Mikroskopie oder die Analyse von Satellitenbildern-, indem Strukturen automatisch identifiziert und präzise segmentiert werden, ohne dass spezielle, vorab trainierte Modelle erforderlich sind. Im Gegensatz zu Modellen wie SAMerkennt und segmentiert YOLOE Objekte gleichzeitig automatisch und hilft so bei Aufgaben wie der Erstellung von Inhalten oder dem Verstehen von Szenen.

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

Ausbildung und Schlussfolgerungen

YOLOE lässt sich nahtlos in die Ultralytics Python API und CLIähnlich wie die anderen YOLO YOLOv8, YOLO). Hier erfahren Sie, wie Sie schnell loslegen können:

from ultralytics import YOLO

# Load pre-trained YOLOE model and train on custom data
model = YOLO("yoloe-11s-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

# Training YOLOE on custom dataset
yolo train model=yoloe-11s-seg.pt data=path/to/data.yaml epochs=50 imgsz=640

# Inference with text prompts
yolo predict model=yoloe-11s-seg.pt source="test_images/street.jpg" classes="person,bus"

Andere unterstützte Aufgaben

• Validierung: Bewerten Sie die Genauigkeit einfach mit model.val() oder yolo val.
• Ausfuhr: YOLOE-Modelle exportieren (model.export()) zu ONNX, TensorRT usw., was den Einsatz erleichtert.
• Verfolgung: YOLOE unterstützt Objektverfolgung (yolo track), wenn sie integriert ist, nützlich für die Verfolgung von aufgeforderten Klassen in Videos.

Erste Schritte

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

1. Installation: Installieren oder aktualisieren Sie das Ultralytics :

   pip install -U ultralytics
   

2. YOLOE Gewichte herunterladen: Vorgefertigte YOLOE-Modelle (z.B. YOLOE-v8-S/L, YOLOE-11-Varianten) sind in den YOLOE-GitHub-Versionen verfügbar. Laden Sie einfach Ihr gewünschtes .pt Datei zum Laden in die Ultralytics YOLO .

3. Hardware-Anforderungen:

   • Schlussfolgerung: Empfohlener GPU NVIDIA mit ≥4-8GB VRAM). Kleine Modelle laufen effizient auf Edge-GPUs (z. B. Jetson) oder CPUs mit niedrigeren Auflösungen.
   • Ausbildung: Die Feinabstimmung von YOLOE auf benutzerdefinierten Daten erfordert in der Regel nur eine GPU. Das von den Autoren verwendete umfangreiche Pre-Training mit offenem Vokabular (LVIS/Objects365) erforderte erhebliche Rechenleistung (8× RTX 4090 GPUs).

4. Konfiguration: YOLOE-Konfigurationen verwenden standardmäßige Ultralytics YAML-Dateien. Standardkonfigurationen (z.B., yoloe-11s-seg.yaml) reichen in der Regel aus, aber Sie können Backbone, Klassen oder Bildgröße nach Bedarf ändern.

5. YOLOE läuft:

   • Schnelle Schlussfolgerung (Souffleur):

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

   • Aufgeforderte Erkennung (Beispiel einer Texteingabeaufforderung):

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

6. Tipps zur Integration:

   • Namen der Klassen: Standard YOLOE-Ausgaben verwenden LVIS-Kategorien; verwenden set_classes() um Ihre eigenen Bezeichnungen anzugeben.
   • Geschwindigkeit: YOLOE hat keinen Overhead, es sei denn, Sie verwenden Prompts. Textaufforderungen haben minimale Auswirkungen, visuelle Aufforderungen etwas mehr.
   • Batch-Inferenz: Wird direkt unterstützt (model.predict([img1, img2])). Für bildspezifische Eingabeaufforderungen führen Sie die Bilder einzeln aus.

Die Ultralytics enthält weitere Ressourcen. Mit YOLOE können Sie auf einfache Weise leistungsstarke Open-World-Funktionen innerhalb des vertrauten YOLO erkunden.

Zitate und Danksagungen

Wenn YOLOE zu Ihrer Forschung oder Ihrem Projekt beigetragen hat, zitieren Sie bitte die Originalarbeit von Ao Wang, Lihao Liu, Hui Chen, Zijia Lin, Jungong Han und Guiguang Ding von der Tsinghua 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},
}

Für weitere Lektüre ist die ursprüngliche YOLOE-Veröffentlichung auf arXiv verfügbar. Der Quellcode des Projekts und weitere Ressourcen können über das GitHub-Repository abgerufen werden.

FAQ

Wie unterscheidet sich YOLOE von YOLO?

Während sowohl YOLOE als auch YOLO die Erkennung von offenem Vokabular ermöglichen, bietet YOLOE mehrere Vorteile. YOLOE erreicht eine um +3,5 AP höhere Genauigkeit bei LVIS und benötigt dabei 3× weniger Trainingsressourcen und läuft 1,4× schneller als YOLO. YOLOE unterstützt außerdem drei Prompting-Modi (Text, visuelles und internes Vokabular), während YOLO sich hauptsächlich auf Text-Prompts konzentriert. Darüber hinaus verfügt YOLOE über integrierte Instanzsegmentierungsfunktionen, die pixelgenaue Masken für erkannte Objekte ohne zusätzlichen Overhead bereitstellen.

Kann ich YOLOE als reguläres YOLO verwenden?

Ja, YOLOE kann genau wie ein YOLO funktionieren, ohne Leistungseinbußen. Wenn YOLOE im geschlossenen Modus (ohne Eingabeaufforderungen) verwendet wird, werden die Module des offenen Vokabulars in den Standard-Detektionskopf umparametriert, was zu einer identischen Geschwindigkeit und Genauigkeit wie bei entsprechenden YOLO11 führt. Dies macht YOLOE extrem vielseitig - Sie können es als herkömmlichen Detektor für maximale Geschwindigkeit verwenden und nur bei Bedarf in den Modus mit offenem Vokabular wechseln.

Welche Arten von Prompts kann ich mit YOLOE verwenden?

YOLOE unterstützt drei Arten von Prompts:

1. Text-Eingabeaufforderungen: Angabe von Objektklassen in natürlicher Sprache (z. B. "Person", "Ampel", "Vogel-Roller")
2. Visuelle Eingabeaufforderungen: Geben Sie Referenzbilder von Objekten an, die Sie erkennen möchten
3. Internes Vokabular: Verwenden Sie YOLOEs eingebautes Vokabular von mehr als 1200 Kategorien ohne externe Aufforderungen

Dank dieser Flexibilität können Sie YOLOE an verschiedene Szenarien anpassen, ohne das Modell neu trainieren zu müssen. Dies ist besonders nützlich für dynamische Umgebungen, in denen sich die Erkennungsanforderungen häufig ändern.

Wie geht YOLOE mit der Segmentierung von Instanzen um?

YOLOE integriert die Instanzsegmentierung direkt in seine Architektur, indem es den Erkennungskopf um einen Maskenvorhersagezweig erweitert. Dieser Ansatz ähnelt dem YOLOv8, funktioniert aber für jede angeforderte Objektklasse. Die Segmentierungsmasken werden automatisch in die Inferenzergebnisse aufgenommen und können über results[0].masks. Dieser einheitliche Ansatz macht separate Erkennungs- und Segmentierungsmodelle überflüssig und rationalisiert die Arbeitsabläufe für Anwendungen, die pixelgenaue Objektgrenzen erfordern.

Wie behandelt YOLOE Inferenzen mit benutzerdefinierten Prompts?

Ähnlich wie YOLO unterstützt YOLOE eine "Prompt-then-detect"-Strategie, die ein Offline-Vokabular zur Steigerung der Effizienz nutzt. Benutzerdefinierte Prompts wie Beschriftungen oder bestimmte Objektkategorien werden vorcodiert und als Offline-Vokabular-Einbettungen gespeichert. Dieser Ansatz rationalisiert den Erkennungsprozess, ohne dass ein erneutes Training erforderlich ist. Sie können diese Aufforderungen innerhalb des Modells dynamisch einstellen, um es an bestimmte Erkennungsaufgaben anzupassen:

from ultralytics import YOLO

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

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

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

# Show results
results[0].show()

📅 Erstellt vor 1 Monat ✏️ Aktualisiert vor 1 Tag

Kommentare