Ultralytics YOLO27: Trag dich in die Warteliste ein.
Get Started
Trainiere dein erstes YOLO-Modell·Vorhersagen·Lektion 3/10
LektionAnfänger

Größe eines Ultralytics YOLO-Modells auswählen

Vergleiche YOLO26 n, s, m, l und x, miss ihre Leistung auf deiner Zielhardware und wähle die kleinste Größe, die dein Latenzbudget einhält.

Wählst du ein zu großes Modell, läuft eine Kamera-App mit 30 FPS nur mit 12 FPS. Wählst du ein zu kleines Modell, verschenkst du Genauigkeit, die ein größeres Modell auf einer GPU ohne zusätzliche Kosten liefern würde. Da die trainierte Größe auch die ausgelieferte Größe ist, musst du diese Entscheidung vor dem langen Trainingslauf treffen.

YOLO26 gibt es in fünf Größen – n, s, m, l und x – für alle sieben Aufgaben: Detektion, Segmentierung, semantische Segmentierung, Klassifizierung, Pose, OBB und Tiefe. In dieser Lektion rechnest du eine Bildrate in ein Millisekundenbudget um, misst zwei Größen auf deinem eigenen Rechner mit dem Benchmark-Modus und triffst eine Auswahl.

Lernergebnis

Du kannst ein Bildratenziel in ein Millisekundenbudget umrechnen, YOLO26-Größen auf deiner Hardware vergleichen und deine erste Wahl sowie eine Ausweichoption in einer Zeile begründen.

Schnellkurs
Wenn du dich bereits auskennst, findest du hier die Kurzfassung.
  1. Budget = 1000 ÷ Ziel-FPS: Bei 30 FPS stehen für alles 33 ms pro Bild zur Verfügung.

  2. Vergleiche yolo26n und yolo26s mit yolo benchmark ... format=onnx auf dem Zielrechner.

  3. Wähle die kleinste Größe, die mit ausreichend Spielraum ins Budget passt; ignoriere die Benchmark-mAP auf coco8.

  4. Trainiere das Modell und wechsle nur dann eine Größe nach oben, wenn die Genauigkeit auf deinem eigenen Validierungssatz nicht ausreicht.

Praxisnah

Modellpalette kennenlernen#

Registerkarte „Übersicht“ auf der Modellseite der Ultralytics Platform mit Zusammenfassungsmetriken und Details zu einem trainierten Modell

Das sind die offiziellen COCO-Detektionswerte aus der YOLO26-Dokumentation, jeweils bei 640 Pixeln:

ModellParameter (M)FLOPs (B)mAP50-95CPU ONNX (ms)T4 TensorRT10 (ms)
yolo26n2.45.540.938.91.7
yolo26s9.520.948.687.22.5
yolo26m20.468.453.1220.04.7
yolo26l24.886.855.0286.26.2
yolo26x55.7194.457.5525.811.8

Jede Größe gibt es für jede Aufgabe – tausche einfach das Suffix aus, etwa bei yolo26s-seg.pt, yolo26s-sem.pt, yolo26s-depth.pt, yolo26s-cls.pt, yolo26s-pose.pt oder yolo26s-obb.pt. Du migrierst ein älteres Projekt? Der Vergleich von YOLO11 und YOLO26 zeigt, was sich ändert.

Lies die Tabelle als Antwort auf die Frage: „Was kostet die nächste Größe?“:

SchrittZugewonnene mAPZusätzliche FLOPsCPU-Latenz-Multiplikator
n → s+7.7×3.8×2.2
s → m+4.5×3.3×2.5
m → l+1.9×1.3×1.3
l → x+2.5×2.2×1.8

Der erste Schritt bietet das beste Verhältnis; ab m wird jeder zusätzliche Punkt COCO-Genauigkeit teuer. Und COCO mit seinen 80 vielfältigen Klassen ist schwieriger als die meisten realen Projekte: Bei einer eng umrissenen Aufgabe, etwa einem einzelnen Produkt auf einem Förderband, liegen n und s oft höchstens einen Punkt von m entfernt.

Vom Budget ausgehen#

Dein Budget für die Inferenzlatenz beträgt 1000 ms ÷ Ziel-FPS. Das Modell muss sich dieses Budget mit dem Dekodieren, Zeichnen und deiner eigenen Logik teilen. Typische Ausgangspunkte:

ZielwertBeginne mit
Smartphone, Raspberry Pi, Browser oder ein anderes kleines Edge-AI-Gerätn
Laptop- oder Desktop-CPU, 10–30 FPSn, dann s, falls noch Spielraum vorhanden ist
Einzelne GPU, Echtzeitvideos oder m
Offline-Stapelverarbeitung, Genauigkeit zuerstl oder x

Beispiel: Zwei Größen messen#

Der Benchmark-Modus exportiert das Modell, validiert es mit coco8 und misst die Inferenzzeit auf deinem Rechner. Mit format=onnx wird der Lauf auf ein Format beschränkt und ist in wenigen Sekunden fertig. Lasse die Option weg, um alle Exportformate zu vergleichen.

yolo benchmark model=yolo26n.pt imgsz=640 format=onnx
yolo benchmark model=yolo26s.pt imgsz=640 format=onnx

Echte Ergebnisse auf der CPU eines Apple M5 Pro-Laptops:

|     Format   Status❔   Size (MB)   metrics/mAP50-95(B)   Inference time (ms/im)   FPS   |
| 1   ONNX     ✅         9.5         0.6693                13.87                    72.08 |   <- yolo26n
| 1   ONNX     ✅         36.5        0.6654                30.87                    32.39 |   <- yolo26s

Verglichen mit einem Budget von 30 FPS (33 ms):

  • yolo26n, 13.87 ms: passt und lässt 19 ms für das Dekodieren und Zeichnen übrig.
  • yolo26s, 30.87 ms: passt gerade noch, lässt aber keinen Spielraum für irgendetwas anderes. Derselbe Benchmark dauerte 60 ms, während auf dem Rechner andere Prozesse liefen.
  • Size (MB): die Größe der ONNX-Datei, wichtig für App-Downloads und den Speicherbedarf auf Mobilgeräten.
  • metrics/mAP50-95(B): hier kannst du sie ignorieren. coco8 hat vier Validierungsbilder: genug, um zu bestätigen, dass der Export funktioniert, aber viel zu wenige, um die Genauigkeit zu bewerten.

Entscheidung: Trainiere zuerst yolo26n und verwende yolo26s mit einem niedrigeren imgsz als Rückfalloption.

Diese Fehler vermeiden#

Benchmark auf dem falschen Gerät

Symptom: Ein Modell, das auf deinem Laptop mit 70 FPS lief, erreicht auf dem Edge-Gerät nur 8 FPS. Lösung: Führe den Benchmark auf dem Gerät aus, auf dem das Modell später laufen soll, und zwar unter realistischen Bedingungen – mit anderen Prozessen, Kameradekodierung und dem tatsächlich verwendeten Laufzeitformat.

Größen bei unterschiedlichen Einstellungen vergleichen

Symptom: In deinen Notizen steht „s war schneller als n“. Ursache: Bei einem Lauf wurde imgsz=480 oder ein anderes Format verwendet. Lösung: Vergleiche die Modellgrößen mit demselben imgsz, Format und Batch und ändere jeweils nur eine Variable.

Mit der Größe trainieren, die du bereitstellen willst

Trainiere nicht mit x, wenn du das Modell später mit Modellbeschneidung oder Quantisierung auf n verkleinern willst: Eine kleinere Architektur erfordert erneutes Training. Wähle zuerst die Größe; betrachte Quantisierung als zusätzliche Beschleunigung der passenden Größe, nicht als Ersatz dafür.

Die ausführlichere Latenzoptimierung – Batching, Quantisierung und die Wahl der Laufzeitumgebung – wird im Produktionskurs unter Kosten- und Latenzoptimierung behandelt. Der Leitfaden zu Leistungsmetriken erklärt die einzelnen Genauigkeitswerte.

Ausprobieren

Lege das Zielgerät und die Bildrate für dein Projekt fest. Führe auf diesem Gerät (oder dem ähnlichsten verfügbaren Rechner) Benchmarks für yolo26n und yolo26s mit format=onnx aus. Halte anschließend deine Entscheidung zur Größe in drei Zeilen fest: dein Zeitbudget in ms, die beiden gemessenen Latenzen sowie die Größe, mit der du zuerst trainierst, und deine Rückfalloption.

Abgeschlossen, wenn
Du hast die Lektion abgeschlossen, wenn alle folgenden Punkte zutreffen.
  • Du hast die Zeit in ms pro Bild für zwei YOLO26-Größen bei identischem imgsz und Format gemessen.

  • Du hast dein Budget pro Einzelbild in Millisekunden notiert und festgehalten, wie viel Spielraum jede Größe lässt.

  • Du hast eine Größe für das erste Training und eine Rückfalloption ausgewählt und die Entscheidung in einem Satz begründet.

Lösung anzeigen
Budget:   30 FPS on a laptop CPU -> 33 ms per frame, shared with decode and drawing
Measured: ONNX at 640 -> yolo26n 13.9 ms (19 ms headroom), yolo26s 30.9 ms (none; 60 ms under load)
Decision: train yolo26n first. If accuracy on our val set falls short,
          try yolo26s at imgsz=480 and re-benchmark before committing.
Wie es weitergeht

Du weißt, welches Modell du trainieren willst. Als Nächstes bringst du deine Daten in die Ordner- und Beschriftungsstruktur, die Ultralytics YOLO erwartet.