Link to this sectionEnd-to-End-Erkennung in Ultralytics YOLO26 verstehen#

Link to this sectionEinführung#

If you're upgrading to YOLO26 from an earlier model like YOLOv8 or YOLO11, one of the biggest changes you'll notice is the removal of Non-Maximum Suppression (NMS). Traditional YOLO models produce thousands of overlapping predictions that need a separate NMS post-processing step to filter down to final detections. This adds latency, complicates export graphs, and can behave inconsistently across different hardware platforms.

YOLO26 verfolgt einen anderen Ansatz. Es gibt die endgültigen Erkennungen direkt vom Modell aus – es ist keine externe Filterung erforderlich. Dies wird als End-to-End Objekterkennung bezeichnet und ist in allen YOLO26-Modellen standardmäßig aktiviert. Das Ergebnis ist eine einfachere Bereitstellungspipeline, geringere Latenz und bis zu 43 % schnellere Inferenz auf CPUs.

Dieser Leitfaden führt dich durch die Änderungen, erklärt, ob du deinen Code aktualisieren musst, welche Exportformate die End-to-End-Inferenz unterstützen und wie du problemlos von älteren YOLO-Modellen migrierst.

Für einen tieferen Einblick in die Motivation hinter diesem architektonischen Wandel siehe den Ultralytics Blog-Beitrag darüber, warum YOLO26 NMS entfernt und wie das die Bereitstellung verändert.

Link to this sectionWie End-to-End-Erkennung funktioniert#

YOLO26 verwendet eine Dual-Head-Architektur während des Trainings. Beide Köpfe teilen sich dasselbe Backbone und denselben Neck, erzeugen die Ausgaben jedoch auf unterschiedliche Weise:

Die obigen Formen gelten für die Erkennung. Andere Aufgaben erweitern die One-to-One-Ausgabe um zusätzliche Daten pro Erkennung:

Während des Trainings laufen beide Köpfe gleichzeitig – der One-to-Many-Kopf liefert ein reichhaltigeres Lernsignal, während der One-to-One-Kopf lernt, saubere, nicht überlappende Vorhersagen zu erzeugen. Während der Inferenz und des Exports ist standardmäßig nur der One-to-One-Kopf aktiv, der bis zu 300 Erkennungen pro Bild im Format [x1, y1, x2, y2, confidence, class_id] erzeugt.

Wenn du model.fuse() aufrufst, werden Conv + BatchNorm Schichten für eine schnellere Inferenz zusammengefügt und bei End-to-End-Modellen wird zudem der One-to-Many-Kopf entfernt – was die Modellgröße und FLOPs reduziert. Weitere Details zur Dual-Head-Architektur findest du auf der YOLO26-Modellseite.

Link to this sectionMuss ich meinen Code ändern?#

Link to this sectionVerwendung der Ultralytics Python API oder CLI#

Keine Änderungen erforderlich. Wenn du die standardmäßige Ultralytics Python API oder CLI verwendest, funktioniert alles automatisch – Vorhersage, Validierung und Export verarbeiten End-to-End-Modelle direkt.

from ultralytics import YOLO

# Load a YOLO26 model
model = YOLO("yolo26n.pt")

# Predict — no NMS step, no code changes
results = model.predict("image.jpg")

Link to this sectionVerwendung von benutzerdefiniertem Inferenzcode#

Ja, das Ausgabeformat ist anders. Wenn du benutzerdefinierte Nachbearbeitungslogik für YOLOv8 oder YOLO11 geschrieben hast (z. B. bei der Inferenz mit ONNX Runtime oder TensorRT), musst du diese aktualisieren, um die neue Ausgabeform zu verarbeiten:

Für die Aufgaben Segmentierung, Pose und OBB fügt YOLO26 jeder Erkennung aufgabenspezifische Daten hinzu – siehe die Tabelle der Ausgabeformen oben.

Wobei N die Batch-Größe und nc die Anzahl der Klassen ist (z. B. 80 für COCO).

Mit End-to-End-Modellen wird die Nachbearbeitung wesentlich einfacher – zum Beispiel bei der Verwendung von ONNX Runtime:

import onnxruntime as ort

# Load and run the exported end-to-end model
session = ort.InferenceSession("yolo26n.onnx")
output = session.run(None, {session.get_inputs()[0].name: input_tensor})

# End-to-end output: (batch, 300, 6) → [x1, y1, x2, y2, confidence, class_id]
detections = output[0][0]  # first image in batch
detections = detections[detections[:, 4] > conf_threshold]  # confidence filter — that's it!

Link to this sectionUmschalten auf den One-to-Many-Kopf#

Wenn du das herkömmliche YOLO-Ausgabeformat benötigst (z. B. um vorhandenen NMS-basierten Nachbearbeitungscode wiederzuverwenden), kannst du jederzeit auf den One-to-Many-Kopf umschalten, indem du end2end=False setzt:

from ultralytics import YOLO

model = YOLO("yolo26n.pt")

# Prediction with NMS (traditional behavior)
results = model.predict("image.jpg", end2end=False)

# Validation with NMS
metrics = model.val(data="coco.yaml", end2end=False)

# Export without end-to-end
model.export(format="onnx", end2end=False)

Link to this sectionKompatibilität der Exportformate#

Die meisten Exportformate unterstützen die End-to-End-Inferenz direkt, einschließlich ONNX, TensorRT, CoreML, OpenVINO, TFLite, TF.js und MNN.

Die folgenden Formate unterstützen kein End-to-End und fallen automatisch auf den One-to-Many-Kopf zurück: NCNN, RKNN, PaddlePaddle, ExecuTorch, IMX, Edge TPU und Qualcomm QNN.

Für Hailo HEF findet der Kompilierungsschritt nach einem ONNX-Export außerhalb von model.export(format=...) statt. Verwende die Hailo DFC-Protokolle, das .alls Modellskript und das NMS-JSON, das genau zu deinem Erkennungsmodell passt; wenn ein End-to-End YOLO26-Graph von deiner Hailo-Toolchain nicht unterstützt wird, exportiere das ONNX-Modell mit end2end=False und kompiliere den herkömmlichen Erkennungskopf.

Link to this sectionKompromisse bei Genauigkeit und Geschwindigkeit#

End-to-End-Erkennung bietet erhebliche Vorteile bei der Bereitstellung mit minimalen Auswirkungen auf die Genauigkeit:

Für die meisten realen Anwendungen ist der ~0,5 mAP-Unterschied vernachlässigbar, insbesondere wenn man die Geschwindigkeits- und Einfachheitsgewinne betrachtet. Wenn maximale Genauigkeit deine oberste Priorität ist, kannst du jederzeit auf den One-to-Many-Kopf mit end2end=False zurückgreifen.

Siehe die YOLO26 Leistungsmetriken für detaillierte Benchmarks über alle Modellgrößen hinweg (n, s, m, l, x).

Link to this sectionMigration von YOLOv8 oder YOLO11#

Wenn du ein bestehendes Projekt auf YOLO26 aktualisierst, findest du hier eine kurze Checkliste für einen reibungslosen Übergang:

• Ultralytics API / CLI-Benutzer: Keine Änderungen erforderlich – aktualisiere einfach den Modellnamen auf yolo26n.pt (oder yolo26n-seg.pt, yolo26n-pose.pt, yolo26n-obb.pt)
• Benutzerdefinierter Nachbearbeitungscode: Aktualisiere ihn, um die neuen Ausgabeformen zu verarbeiten – (N, 300, 6) für Erkennung sowie aufgabenspezifische Daten für Segmentierung, Pose und OBB. Beachte auch den Wechsel des Box-Formats von xywh zu xyxy
• Export-Pipelines: Überprüfe den Abschnitt Kompatibilität der Exportformate oben für dein Zielformat
• TensorRT + INT8: Auf JetPack 6 deaktiviert TensorRT 10.3.0 automatisch End-to-End bei int8=True – verwende eine andere TensorRT-Version, um End-to-End beizubehalten
• FP16-Exporte: Wenn du alle Ausgaben in FP16 benötigst, exportiere mit end2end=False – siehe warum output0 FP32 bleibt
• iOS / CoreML: End-to-End wird vollständig unterstützt. Wenn du Unterstützung für die Xcode-Vorschau benötigst, verwende end2end=False mit nms=True
• Edge-Geräte (NCNN, RKNN): Diese Formate fallen automatisch auf One-to-Many zurück, also füge NMS in deine On-Device-Pipeline ein

Link to this sectionFAQ#

Link to this sectionKann ich end2end=True und nms=True zusammen verwenden?#

Nein. Diese Optionen schließen sich gegenseitig aus. Wenn du nms=True bei einem End-to-End-Modell während des Exports einstellst, wird es automatisch mit einer Warnung auf nms=False gezwungen. Der End-to-End-Kopf übernimmt die Duplikatfilterung bereits intern, daher ist ein externes NMS unnötig.

Jedoch ist end2end=False in Kombination mit nms=True eine gültige Konfiguration – sie integriert herkömmliches NMS direkt in den Exportgraphen. Dies kann nützlich für CoreML-Exporte sein, da du damit die Vorschau-Funktion in Xcode direkt mit dem Erkennungsmodell nutzen kannst.

Link to this sectionWas steuert der max_det-Parameter in End-to-End-Modellen?#

Der max_det-Parameter (Standard: 300) legt die maximale Anzahl an Detektionen fest, die der One-to-One-Head pro Bild ausgeben kann. Du kannst ihn bei der Inferenz oder beim Export anpassen:

model.predict("image.jpg", max_det=100)  # fewer detections, slightly faster
model.export(format="onnx", max_det=500)  # more detections for dense scenes

Beachte, dass die standardmäßigen YOLO26-Checkpoints mit max_det=300 trainiert wurden. Obwohl du diesen Wert erhöhen kannst, wurde der One-to-One-Head während des Trainings darauf optimiert, bis zu 300 saubere Detektionen zu erzeugen. Detektionen, die dieses Limit überschreiten, könnten daher von geringerer Qualität sein. Wenn du mehr als 300 Detektionen pro Bild benötigst, erwäge ein erneutes Training mit einem höheren max_det-Wert.

Link to this sectionMein exportiertes ONNX-Modell gibt (1, 300, 6) aus – ist das korrekt?#

Ja, das ist das erwartete End-to-End-Ausgabeformat für die Detektion: eine Batch Size von 1, bis zu 300 Detektionen, jede mit 6 Werten [x1, y1, x2, y2, confidence, class_id]. Filtere einfach nach dem Konfidenz-Schwellenwert und du bist fertig – kein NMS erforderlich.

Für andere Aufgaben unterscheidet sich die Ausgabeform:

Link to this sectionWie prüfe ich, ob mein exportiertes Modell End-to-End ist?#

Du kannst dies entweder über die Ultralytics Python API oder durch direktes Überprüfen der Metadaten des exportierten ONNX-Modells tun:

from ultralytics import YOLO

model = YOLO("yolo26n.onnx")
model.predict(verbose=False)  # run predict to setup predictor first
print(model.predictor.model.end2end)  # True if end-to-end is enabled

Alternativ kannst du die Ausgabeform prüfen – End-to-End-Detektionsmodelle geben (1, 300, 6) aus, während herkömmliche Modelle (1, nc + 4, 8400) ausgeben. Für Formen anderer Aufgaben siehe die FAQ zu Ausgabeformen.

Link to this sectionWird End-to-End für Instanzsegmentierung, Pose- und OBB-Aufgaben unterstützt?#

Ja. YOLO26-Aufgabenvarianten im Detektionsstil – Detektion, Instanzsegmentierung, Pose-Schätzung und Orientierte Objektdetektion (OBB) – unterstützen standardmäßig End-to-End-Inferenz. Der end2end=False-Fallback ist für diese Aufgaben ebenfalls verfügbar.

Jede Aufgabe erweitert die Basis-Detektionsausgabe um aufgabenspezifische Daten: