Link to this sectionExportieren von Nicht-YOLO PyTorch-Modellen mit Ultralytics#

Die Bereitstellung von PyTorch-Modellen für die Produktion bedeutet normalerweise, für jedes Ziel einen anderen Exporter zu jonglieren: torch.onnx.export für ONNX, coremltools für Apple-Geräte, onnx2tf für TensorFlow, pnnx für NCNN und so weiter. Jedes Tool hat seine eigene API, Abhängigkeitsbesonderheiten und Ausgabekonventionen.

Ultralytics bietet eigenständige Export-Dienstprogramme, die mehrere Backends hinter einer konsistenten Schnittstelle vereinen. Du kannst jedes torch.nn.Module, einschließlich timm Bildmodellen, torchvision Klassifikatoren und Detektoren oder deine eigenen benutzerdefinierten Architekturen nach ONNX, TorchScript, OpenVINO, CoreML, NCNN, PaddlePaddle, MNN, ExecuTorch und TensorFlow SavedModel exportieren, ohne jedes Backend einzeln lernen zu müssen.

Link to this sectionWarum Ultralytics für den Export von Nicht-YOLO-Modellen verwenden?#

• Eine API für 10 Formate: Lerne eine einzige Aufrufkonvention anstelle von einem Dutzend.
• Gemeinsame Utility-Oberfläche: Die Export-Helfer befinden sich unter ultralytics.utils.export, sodass du nach der Installation der Backend-Pakete dasselbe Aufrufmuster über alle Formate hinweg beibehalten kannst.
• Gleicher Codepfad wie bei YOLO-Exporten: Dieselben Helfer unterstützen jeden Ultralytics YOLO-Export.
• Integrierte FP16- und INT8-Quantisierung für Formate, die dies unterstützen (OpenVINO, CoreML, MNN, NCNN).
• Funktioniert auf der CPU: Kein GPU-Bedarf für den Export-Schritt selbst, sodass du ihn lokal auf jedem Laptop ausführen kannst.

Link to this sectionSchnellstart#

Der schnellste Weg ist ein Export in zwei Zeilen zu ONNX ohne YOLO-Code und ohne Einrichtung außer pip install ultralytics onnx timm:

import timm
import torch

from ultralytics.utils.export import torch2onnx

model = timm.create_model("resnet18", pretrained=True).eval()
torch2onnx(model, torch.randn(1, 3, 224, 224), output_file="resnet18.onnx")

Link to this sectionUnterstützte Exportformate#

Die torch2*-Funktionen verwenden ein Standard-torch.nn.Module und einen Beispiel-Eingabe-Tensor. MNN, TF SavedModel und TF Frozen Graph durchlaufen ein intermediäres ONNX- oder Keras-Artefakt. In keinem Fall sind YOLO-spezifische Attribute erforderlich.

Link to this sectionSchritt-für-Schritt-Beispiele#

Jedes Beispiel unten verwendet dieselbe Einrichtung, ein vortrainiertes ResNet-18 von timm im Evaluationsmodus:

import timm
import torch

model = timm.create_model("resnet18", pretrained=True).eval()
im = torch.randn(1, 3, 224, 224)

Link to this sectionExport nach ONNX#

from ultralytics.utils.export import torch2onnx

torch2onnx(model, im, output_file="resnet18.onnx")

Für eine dynamische Batch-Größe übergebe ein dynamic-Wörterbuch:

torch2onnx(model, im, output_file="resnet18_dyn.onnx", dynamic={"images": {0: "batch_size"}})

Das Standard-Opset ist 14 und der Standard-Eingabename ist "images". Überschreibe dies mit den Argumenten opset, input_names oder output_names.

Link to this sectionExport zu TorchScript#

Keine zusätzlichen Abhängigkeiten erforderlich. Verwendet torch.jit.trace im Hintergrund.

from ultralytics.utils.export import torch2torchscript

torch2torchscript(model, im, output_file="resnet18.torchscript")

Link to this sectionExport zu OpenVINO#

from ultralytics.utils.export import torch2openvino

ov_model = torch2openvino(model, im, output_dir="resnet18_openvino_model")

Das Verzeichnis enthält ein Paar aus model.xml und model.bin mit festem Namen:

resnet18_openvino_model/
├── model.xml
└── model.bin

Übergebe dynamic=True für dynamische Eingabeformen, half=True für FP16 oder int8=True für INT8-Quantisierung. INT8 erfordert zusätzlich ein calibration_dataset-Argument.

Erfordert openvino>=2024.0.0 (oder >=2025.2.0 auf macOS 15.4+) und torch>=2.1.

Link to this sectionExport zu CoreML#

import coremltools as ct

from ultralytics.utils.export import torch2coreml

inputs = [ct.TensorType("input", shape=(1, 3, 224, 224))]
ct_model = torch2coreml(model, inputs, im, output_file="resnet18.mlpackage")

Für Klassifizierungsmodelle übergebe eine Liste von Klassennamen an classifier_names, um dem CoreML-Modell einen Klassifizierungskopf hinzuzufügen.

Erfordert coremltools>=9.0, torch>=1.11 und numpy<=2.3.5. Wird unter Windows nicht unterstützt.

Link to this sectionExport zu TensorFlow SavedModel#

Der TF SavedModel-Export durchläuft ONNX als intermediären Schritt:

from ultralytics.utils.export import onnx2saved_model, torch2onnx

torch2onnx(model, im, output_file="resnet18.onnx")
keras_model = onnx2saved_model("resnet18.onnx", output_dir="resnet18_saved_model")

Die Funktion gibt ein Keras-Modell zurück und generiert auch TFLite-Dateien (.tflite) im Ausgabeverzeichnis:

resnet18_saved_model/
├── saved_model.pb
├── variables/
├── resnet18_float32.tflite
├── resnet18_float16.tflite
└── resnet18_int8.tflite

Anforderungen:

• tensorflow>=2.0.0,<=2.19.0
• onnx2tf>=1.26.3,<1.29.0
• tf_keras<=2.19.0
• sng4onnx>=1.0.1
• onnx_graphsurgeon>=0.3.26 (installiere mit --extra-index-url https://pypi.ngc.nvidia.com)
• ai-edge-litert>=1.2.0,<1.4.0 auf macOS (ai-edge-litert>=1.2.0 auf anderen Plattformen)
• onnxslim>=0.1.71
• onnx>=1.12.0,<2.0.0
• protobuf>=5

Link to this sectionExport zu TensorFlow Frozen Graph#

Ausgehend vom SavedModel-Export oben konvertiere das zurückgegebene Keras-Modell in einen gefrorenen .pb-Graph:

from pathlib import Path

from ultralytics.utils.export import keras2pb

keras2pb(keras_model, output_file=Path("resnet18_saved_model/resnet18.pb"))

Link to this sectionExport zu NCNN#

from ultralytics.utils.export import torch2ncnn

torch2ncnn(model, im, output_dir="resnet18_ncnn_model")

Das Verzeichnis enthält Param- und Bin-Dateien mit festem Namen sowie einen Python-Wrapper:

resnet18_ncnn_model/
├── model.ncnn.param
├── model.ncnn.bin
└── model_ncnn.py

torch2ncnn() prüft bei der ersten Verwendung auf ncnn und pnnx.

Link to this sectionExport zu MNN#

Der MNN-Export erfordert eine ONNX-Datei als Eingabe. Exportiere zuerst nach ONNX und konvertiere dann:

from ultralytics.utils.export import onnx2mnn, torch2onnx

torch2onnx(model, im, output_file="resnet18.onnx")
onnx2mnn("resnet18.onnx", output_file="resnet18.mnn")

Unterstützt half=True für FP16 und int8=True für INT8-Quantisierung. Erfordert MNN>=2.9.6 und torch>=1.10.

Link to this sectionExport zu PaddlePaddle#

from ultralytics.utils.export import torch2paddle

torch2paddle(model, im, output_dir="resnet18_paddle_model")

Das Verzeichnis enthält das PaddlePaddle-Modell und die Parameterdateien:

resnet18_paddle_model/
├── model.pdmodel
└── model.pdiparams

Erfordert x2paddle und die korrekte PaddlePaddle-Distribution für deine Plattform:

• paddlepaddle-gpu>=3.0.0,<3.3.0 auf CUDA
• paddlepaddle==3.0.0 auf ARM64 CPU
• paddlepaddle>=3.0.0,<3.3.0 auf anderen CPUs

Wird auf NVIDIA Jetson nicht unterstützt.

Link to this sectionExport in ExecuTorch#

from ultralytics.utils.export import torch2executorch

torch2executorch(model, im, output_dir="resnet18_executorch_model")

Die exportierte .pte-Datei wird im Ausgabeverzeichnis gespeichert:

resnet18_executorch_model/
└── model.pte

Erfordert torch>=2.9.0 und eine passende ExecuTorch-Laufzeitumgebung (pip install executorch). Zur Laufzeitnutzung siehe die ExecuTorch-Integration.

Link to this sectionÜberprüfe dein exportiertes Modell#

Überprüfe nach dem Export die numerische Parität mit dem ursprünglichen PyTorch-Modell, bevor du es bereitstellst. Ein schneller Rauchtest mit ONNXBackend aus ultralytics.nn.backends vergleicht die Ausgaben und markiert frühzeitig Fehler bei der Tracing- oder Quantisierung:

import numpy as np
import timm
import torch

from ultralytics.nn.backends import ONNXBackend

model = timm.create_model("resnet18", pretrained=True).eval()
im = torch.randn(1, 3, 224, 224)
with torch.no_grad():
    pytorch_output = model(im).numpy()

onnx_model = ONNXBackend("resnet18.onnx", device=torch.device("cpu"))
onnx_output = onnx_model(im)[0]

diff = np.abs(pytorch_output - onnx_output).max()
print(f"Max difference: {diff:.6f}")  # should be < 1e-5

Bei anderen Laufzeitumgebungen kann der Name des Eingabetensors abweichen. OpenVINO verwendet beispielsweise den Namen des Forward-Arguments des Modells (typischerweise x für generische Modelle), während torch2onnx standardmäßig "images" verwendet.

Link to this sectionBekannte Einschränkungen#

• Unterstützung für mehrere Eingaben ist uneinheitlich: torch2onnx und torch2openvino akzeptieren ein Tupel oder eine Liste von Beispiel-Tensoren für Modelle mit mehreren Eingaben. torch2torchscript, torch2coreml, torch2ncnn, torch2paddle und torch2executorch setzen einen einzelnen Eingabetensor voraus.
• ExecuTorch benötigt flatc: Die ExecuTorch-Laufzeitumgebung erfordert den FlatBuffers-Compiler. Installiere ihn mit brew install flatbuffers auf macOS oder apt install flatbuffers-compiler unter Ubuntu.
• Keine Inferenz über Ultralytics: Exportierte Nicht-YOLO-Modelle können nicht über YOLO() für die Inferenz geladen werden. Verwende die native Laufzeitumgebung für jedes Format (ONNX Runtime, OpenVINO Runtime, etc.).
• Nur-YOLO-Formate: Axelera und Sony IMX500 Exporte erfordern YOLO-spezifische Modellattribute und sind für generische Modelle nicht verfügbar.
• Plattformspezifische Formate: TensorRT erfordert eine NVIDIA GPU. RKNN erfordert das rknn-toolkit2 SDK (nur Linux). Edge TPU erfordert die edgetpu_compiler-Binärdatei (nur Linux).

Link to this sectionFAQ#

Link to this sectionWelche Modelle kann ich mit Ultralytics exportieren?#

Jedes torch.nn.Module. Dies umfasst Modelle von timm, torchvision oder jedes benutzerdefinierte PyTorch-Modell. Das Modell muss sich vor dem Export im Evaluierungsmodus (model.eval()) befinden. ONNX und OpenVINO akzeptieren zusätzlich ein Tupel von Beispiel-Tensoren für Modelle mit mehreren Eingaben.

Link to this sectionWelche Exportformate funktionieren ohne GPU?#

Alle unterstützten Formate (TorchScript, ONNX, OpenVINO, CoreML, TF SavedModel, TF Frozen Graph, NCNN, PaddlePaddle, MNN, ExecuTorch) können auf der CPU exportiert werden. Für den Exportprozess selbst ist keine GPU erforderlich. TensorRT ist das einzige Format, das eine NVIDIA GPU erfordert.

Link to this sectionWelche Ultralytics-Version benötige ich?#

Verwende Ultralytics >=8.4.38, das das ultralytics.utils.export-Modul und die standardisierten output_file/output_dir-Argumente enthält.

Link to this sectionKann ich ein torchvision-Modell für das iOS-Deployment nach CoreML exportieren?#

Ja. torchvision-Klassifizierer, Detektoren und Segmentierungsmodelle exportieren nach .mlpackage via torch2coreml. Übergebe für Bildklassifizierungsmodelle eine Liste von Klassennamen an classifier_names, um einen Klassifizierungs-Head einzubinden. Führe den Export auf macOS oder Linux durch. CoreML wird unter Windows nicht unterstützt. Siehe die CoreML-Integration für Details zum iOS-Deployment.

Link to this sectionKann ich mein exportiertes Modell nach INT8 oder FP16 quantisieren?#

Ja, für mehrere Formate. Übergebe half=True für FP16 oder int8=True für INT8 beim Export nach OpenVINO, CoreML, MNN oder NCNN. INT8 in OpenVINO erfordert zusätzlich ein calibration_dataset-Argument für Post-Training-Quantisierung. Siehe die Integrationsseite des jeweiligen Formats für Kompromisse bei der Quantisierung.