Ultralytics YOLO27: Trag dich in die Warteliste ein.
Get Started
Ultralytics YOLO in der Produktion·Laufzeitumgebung auswählen·Lektion 1/9
LektionFortgeschrittene

Bereitstellungsziel auswählen

Leite aus dem Gerät, dem Latenzbudget und der Geräteflotte eine Laufzeitumgebung und ein Exportformat ab und überprüfe sie anschließend auf dem Gerät.

Verkehrskamera über einer Stadtautobahn bei Sonnenuntergang. Ultralytics YOLO verfolgt Autos, einen Kleintransporter und Lastwagen, jeweils mit Klassenbezeichnung und ID.

Dasselbe YOLO26n benötigt auf einer CPU mit ONNX Runtime 38,9 ms pro Bild und auf einer T4-GPU mit TensorRT 1,7 ms, wie die YOLO26-Benchmarks zeigen. Wählst du die falsche Laufzeitumgebung, zahlst du entweder für deutlich mehr Hardware als nötig oder setzt Kameras ein, die nicht mithalten können. In dieser Lektion triffst du die Entscheidung in zehn Minuten und kannst sie mit Zahlen begründen, die direkt auf dem Gerät gemessen wurden.

Lernergebnis

Wähle die Laufzeitumgebung und den Wert für format= für ein Gerät aus, rechne ein FPS-Ziel in ein Millisekundenbudget um und bestätige die Wahl mit wiederholten Benchmarks.

Schnellkurs
Wenn du dich bereits auskennst, findest du hier die Kurzfassung.
  1. NVIDIA-GPU oder Jetson → TensorRT (engine), auf dem Zielgerät erstellt. Intel-CPU, iGPU oder NPU → OpenVINO (openvino).

  2. Apple → CoreML (coreml). Android → LiteRT (litert). Snapdragon-NPU → QNN (qnn). Raspberry Pi → NCNN (ncnn).

  3. Alles andere → ONNX Runtime (onnx). Wenn du keine Server betreiben möchtest → ein verwalteter Ultralytics-Platform-Endpunkt.

  4. Budget = 1000 ÷ FPS, abzüglich Dekodierung und Nachverarbeitung. Miss die Kandidaten auf dem Gerät und richte dich nach dem p95-Wert, nicht nach dem Durchschnitt.

Praxisnah

Beim Gerät ansetzen#

Die Laufzeitumgebung richtet sich danach, wo die Inferenz ausgeführt wird, nicht nach Gewohnheit. Gehe den Entscheidungsbaum von oben durch und halte beim ersten Treffer an:

Jede Laufzeitumgebung ist in Exportmodus einem Wert für format= zugeordnet:

ZielwertLaufzeitumgebungformat=Achte auf
NVIDIA-GPU, JetsonTensorRTengineEine Engine läuft nur auf der GPU-Familie und mit der TensorRT-Version, mit denen sie erstellt wurde
Intel-CPU, iGPU, NPUOpenVINOopenvinoFür Intel optimiert; miss die Leistung, bevor du es anderswo einsetzt
Beliebige CPU oder GPUONNX RuntimeonnxWähle den Ausführungsanbieter ausdrücklich aus
iPhone, iPad, MacCoreMLcoremlDer Export läuft unter macOS oder Linux, nicht unter Windows
Android, eingebettetes GerätLiteRTlitertFür INT8 sind Kalibrierungsdaten für data erforderlich
Snapdragon-NPUQualcomm QNNqnnNur quantisierter Export; gib das Hexagon-Ziel als name an
Raspberry Pi, ARM-CPUNCNNncnnDas schnellste Format im Raspberry-Pi-Leitfaden
BrowserONNX Runtime WebonnxBeschränke dich auf Modelle mit n oder s

Auf aktuellen Apple-Plattformen kannst du auch in Apples neueres Format Core AI exportieren (format=coreai, exportiert unter macOS 26+ auf Apple Silicon oder unter x86-64 Linux). Du bist neu beim Exportieren? Die Lektion Export für die Bereitstellung behandelt die Grundlagen.

Wenn du Inferenzserver ganz vermeiden möchtest, stellt die Ultralytics Platform ein Modell als dedizierten Endpunkt in einer von 42 Regionen bereit. Auf dem Tab „Deployments“ deines Profils siehst du, wo die einzelnen Endpunkte ausgeführt werden:

Tab „Deployments“ im Profil der Ultralytics Platform mit einer Weltkarte der Bereitstellungsregionen und Übersichtskarten zu aktiven Bereitstellungen, HTTP-Anfragen, Fehlerrate und P95-Latenz

Dieser Weg wird unter Endpunkt bereitstellen und aufrufen behandelt. Der Rest dieses Kurses ist für den Fall gedacht, dass du das Modell selbst ausführst.

Das FPS-Ziel in ein Millisekundenbudget umrechnen#

„Echtzeit“ ist keine Anforderung; eine Zahl schon. Berechne sie, bevor du irgendetwas benchmarkst:

SchrittBeispiel: 20 FPS pro Kamera
Frame-Budget = 1000 ÷ FPS50 ms
Abzüglich Dekodierung (RTSP, 1080p)etwa 10 ms
Abzüglich Tracking, Zählung und Ausgabenetwa 5 ms
Abzüglich 20 % Reserve für Spitzenlasten10 ms
Für das Modell verbleibenetwa 25–30 ms

Wende anschließend diese Entscheidungsregeln an:

  • Wenn YOLO26n auf der Geräte-CPU mehr als dein Modellbudget benötigt, wechsle zu einem Beschleuniger (GPU, iGPU, NPU) oder verkleinere zuerst imgsz; die YOLO26-Benchmarks geben für YOLO26n 38.9 ms auf einer CPU mit ONNX und 1.7 ms auf einer T4 mit TensorRT an.
  • Wenn ein Gerät mehrere Kameras bedienen muss, teile das Modellbudget durch die Anzahl der Kameras.
  • Wenn der Gerätepark mehr als eine Handvoll Gerätetypen umfasst, bevorzuge Laufzeitumgebungen, die keine gerätespezifischen Builds erfordern, oder plane einen Build pro Geräteklasse ein.
  • Wenn der aufrufende Code in Swift, Kotlin oder C++ geschrieben ist, prüfe vor der Entscheidung das SDK der Laufzeitumgebung auf Unterstützung dieser Sprache.

Kandidaten auf dem Gerät benchmarken#

Technische Datenblätter und Benchmarks anderer sind ein Ausgangspunkt. Entscheidend ist die Hardware, auf der du das Modell bereitstellen willst, und zwar anhand der langsamen Frames, nicht des Durchschnitts: Eine Laufzeitumgebung, die im Median schnell ist, aber bei einem von zwanzig Frames stockt, wird weiterhin Frames verwerfen. Dieses Skript exportiert jeden Kandidaten, misst die Zeit für 100 Inferenzen mit einem echten Frame und bewertet jeden anhand seines 95. Perzentils (p95):

from ultralytics import YOLO
from ultralytics.utils.downloads import safe_download

BUDGET_MS = 30  # the model's share of a 20 FPS frame budget
CANDIDATES = ("onnx", "openvino")  # runtimes the decision tree allows on this machine

if __name__ == "__main__":  # exports and inference can start worker processes on macOS and Windows
    frame = str(safe_download("https://ultralytics.com/images/bus.jpg"))  # use a real frame from your camera
    for fmt in CANDIDATES:
        model = YOLO(YOLO("yolo26n.pt").export(format=fmt))
        for _ in range(5):  # warm up: the first calls include one-time setup
            model(frame, verbose=False)
        runs = sorted(model(frame, verbose=False)[0].speed["inference"] for _ in range(100))
        p50, p95 = runs[49], runs[94]
        verdict = "meets" if p95 <= BUDGET_MS else "misses"
        print(f"{fmt:9s} p50 {p50:5.1f} ms  p95 {p95:5.1f} ms  {verdict} the {BUDGET_MS} ms budget")

Auf dem Apple-Silicon-Laptop, mit dem dieser Kurs getestet wurde, während andere Aufträge die CPU mitbenutzten:

onnx      p50  30.0 ms  p95  46.4 ms  misses the 30 ms budget
openvino  p50  22.8 ms  p95 113.5 ms  misses the 30 ms budget

Gehe die Ergebnisse Zeile für Zeile durch:

  • speed["inference"] ist die reine Laufzeit des Modells für diesen Frame, ohne Dekodierung oder Zeichnen. So lassen sich Laufzeitumgebungen fair vergleichen.
  • OpenVINO liegt beim Median vorn, beim p95 aber um mehr als den Faktor zwei zurück. Nach Durchschnittswerten beurteilt, würdest du die Laufzeitumgebung bereitstellen, die bei hoher Auslastung stockt; nach p95 beurteilt, ist ONNX Runtime auf diesem Rechner die stabilere Wahl.
  • Beide überschreiten das Budget. Der nächste Schritt ist hier also ein kleineres imgsz, ein Beschleuniger oder weniger Kameras pro Gerät – nicht eine weitere CPU-Laufzeitumgebung.

Für einen schnellen Vergleich von Genauigkeit und Geschwindigkeit über verschiedene Formate exportiert, validiert und misst der Benchmarkmodus jedes Format:

yolo benchmark model=yolo26n.pt data=coco8.yaml imgsz=640 format=onnx

Entferne format=, um alle vom Rechner unterstützten Formate zu testen. COCO8 enthält nur vier Validierungsbilder; betrachte die mAP-Spalte daher als einfachen Funktionstest und verwende für Entscheidungen zur Genauigkeit deine eigene Dataset-YAML-Datei.

Stolperfallen#

Benchmark auf dem falschen Gerät

Symptom: Das Modell erreichte auf deiner Workstation 60 FPS, lässt auf dem Gerät aber Frames aus. Lösung: Miss die Leistung auf der Zielhardware oder auf dem ähnlichsten verfügbaren Gerät und führe das Modell unter der in der Produktion zu erwartenden Auslastung aus (andere Prozesse, andere Kameras).

TensorRT-Engines sind gerätespezifisch

Symptom: Ein .engine, das auf einer Rechenzentrums-GPU erstellt wurde, lässt sich auf einem Jetson Orin nicht laden. Lösung: Erstelle es zum Installationszeitpunkt auf dem Zielgerät (ein YOLO26n-FP16-Build dauert auf einem Jetson Orin etwa 5 Minuten, laut Platform-Exportdokumentation) oder verwalte einen Build pro Geräteklasse und TensorRT-Version und liefere das .pt oder .onnx mit, damit jedes Gerät neu bauen kann.

Mit der Größe messen, die du einsetzen wirst

yolo benchmark misst mit der imgsz, die du übergibst. Wenn die Produktion mit imgsz=1280 läuft, miss mit 1280: Der Rechenaufwand steigt mit der Pixelzahl, daher unterschätzen Messwerte bei 640 eine Bereitstellung mit 1280 um etwa das Vierfache.

Bei Edge-Geräten kommen vier Fragen hinzu#

Die Leitfäden zu Raspberry Pi, NVIDIA Jetson und DeepStream auf Jetson behandeln die gängigen Zielgeräte ausführlich. Bevor du dich für ein Edge-Gerät entscheidest, beantworte folgende Fragen:

  • Kaltstart: Wo wird die TensorRT-Engine erstellt, und wer muss darauf warten?
  • Stromversorgung und Wärme: Kann das Gehäuse das Modell den ganzen Tag bei voller FPS-Rate betreiben?
  • Speicher: Ist neben dem Modell genug Platz für Frame-Puffer und den Zustand des Trackers? INT8 halbiert den Speicheranteil des Modells.
  • Aktualisierungen: Wie kommt ein neues best.pt auf 1.000 Geräte? Ein Docker-Image sorgt für eine einheitliche Umgebung.
Ausprobieren

Erstelle für ein reales oder geplantes Projekt eine fünfzeilige Bereitstellungsskizze: Zielgerät, FPS pro Kamera, Kameras pro Gerät, aufrufende Sprache und Größe des Geräteparks. Leite daraus ein Modellbudget in Millisekunden ab, wähle Kandidaten anhand des Entscheidungsbaums aus und führe pick_runtime.py (mit deinem Modell und den Kandidaten) auf dem Zielgerät oder dem ähnlichsten verfügbaren Rechner aus.

Abgeschlossen, wenn
Du hast die Lektion abgeschlossen, wenn alle folgenden Punkte zutreffen.
  • In deiner Skizze sind das Gerät, die Laufzeitumgebung und der genaue Wert für format= angegeben.

  • Du hast das Millisekundenbudget des Modells aus dem FPS-Ziel abgeleitet und aufgeführt, was du abgezogen hast.

  • Für jeden Kandidaten liegen p50- und p95-Inferenzzeiten vor, die auf dem Gerät gemessen wurden, sowie eine Bewertung im Vergleich zum Budget.

Lösung anzeigen

Eine ausgearbeitete Skizze für die Einführung einer Einzelhandelsanalyse:

FrageAntwort
Gerät40 Mini-PCs in Geschäften mit Intel Core Ultra CPUs, ohne separate GPU
FPS und Kameras10 FPS pro Kamera, 2 Kameras pro Gerät
Aufrufender DienstPython-Dienst unter Linux
Gerätepark40 Geräte, aktualisiert über ein Docker-Image

Budget: 1000 ÷ 10 = 100 ms pro Frame; abzüglich etwa 15 ms für Dekodierung und Tracking sowie 20 % Reserve bleiben etwa 65 ms. Auf zwei Kameras verteilt sind das etwa 30 ms pro Inferenz. Der Entscheidungsbaum empfiehlt OpenVINO (Intel-CPU), mit ONNX Runtime als Ausweichlösung. Auf einem Gerät aus dem Geschäft:

python pick_runtime.py  # CANDIDATES = ("onnx", "openvino"), BUDGET_MS = 30

Der CPU-Benchmark für den Core Ultra 7 155H in der OpenVINO-Dokumentation gibt für YOLO26n mit OpenVINO FP32 13.4 ms an. yolo26n sollte also mit reichlich Spielraum passen. Liegt das p95 auf dem echten Gerät bei laufenden Pipelines beider Kameras unter 30 ms, solltest du OpenVINO bereitstellen. Falls nicht, teste die integrierte GPU des Geräts mit device="intel:gpu", bevor du Hardware kaufst.

Wie es weitergeht

Nachdem du ein Ziel ausgewählt hast, exportierst du in der nächsten Lektion nach ONNX und weist nach, dass der Export dieselben Ergebnisse wie PyTorch liefert.