Link to this sectionSo exportierst du PyTorch-Modelle, die keine YOLO-Modelle sind, mit Ultralytics#

Das Bereitstellen von PyTorch-Modellen in der Produktion bedeutet meistens, 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ängigkeits-Eigenheiten und Ausgabekonventionen.

Ultralytics bietet eigenständige Export-Dienstprogramme, die mehrere Backends hinter einer einheitlichen Schnittstelle zusammenfassen. 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 separat erlernen zu müssen.

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

• Eine API für 10 Formate: Lerne eine einzige Aufrufkonvention statt eines Dutzends.
• Gemeinsame Hilfsoberfläche: Die Export-Helfer befinden sich unter ultralytics.utils.export. Sobald die Backend-Pakete installiert sind, kannst du dasselbe Aufrufmuster über alle Formate hinweg beibehalten.
• Derselbe Codepfad wie bei YOLO-Exporten: Dieselben Helfer steuern jeden Ultralytics YOLO-Export.
• FP16- und INT8-Quantisierung ist für unterstützte Formate (OpenVINO, CoreML, MNN, NCNN) integriert.
• Funktioniert auf der CPU: Für den Export-Schritt selbst ist keine GPU erforderlich, sodass du ihn lokal auf jedem Laptop ausführen kannst.

Link to this sectionKurzanleitung#

Der schnellste Weg ist ein Export in zwei Zeilen nach 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 nehmen ein Standard-torch.nn.Module und einen Beispiel-Eingabe-Tensor entgegen. MNN, TF SavedModel und TF Frozen Graph durchlaufen ein zwischengeschaltetes ONNX- oder Keras-Artefakt. In beiden Fällen sind keine YOLO-spezifischen Attribute erforderlich.

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

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

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 übergib 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 nach 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 nach 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

Übergib dynamic=True für dynamische Eingabe-Shapes, 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 unter macOS 15.4+) und torch>=2.1.

Link to this sectionExport nach 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, classifier_names=None, output_file="resnet18.mlpackage")

Für Klassifizierungsmodelle übergib 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. Unter Windows nicht unterstützt.

Link to this sectionExport nach TensorFlow SavedModel#

Der Export von TF SavedModel erfolgt über ONNX als Zwischenschritt:

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 zusätzlich 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 unter 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 nach TensorFlow Frozen Graph#

Fahre fort mit dem oben genannten SavedModel-Export und konvertiere das zurückgegebene Keras-Modell in einen eingefrorenen .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 nach 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 nach 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 nach PaddlePaddle#

from ultralytics.utils.export import torch2paddle

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

Das Verzeichnis enthält das PaddlePaddle-Modell und 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 nach 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). Informationen zur Nutzung der Laufzeitumgebung findest du in der 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 kennzeichnet Tracing- oder Quantisierungsfehler frühzeitig:

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 bei generischen Modellen), während torch2onnx standardmäßig "images" verwendet.

Link to this sectionBekannte Einschränkungen#

• Multi-Input-Unterstützung ist ungleichmäßig: torch2onnx und torch2openvino akzeptieren ein Tupel oder eine Liste von Beispiel-Tensoren für Modelle mit mehreren Eingängen. torch2torchscript, torch2coreml, torch2ncnn, torch2paddle und torch2executorch setzen einen einzelnen Eingabetensor voraus.
• ExecuTorch benötigt flatc: Die ExecuTorch-Laufzeit erfordert den FlatBuffers-Compiler. Installiere ihn mit brew install flatbuffers auf macOS oder apt install flatbuffers-compiler auf Ubuntu.
• Keine Inferenz über Ultralytics: Exportierte Nicht-YOLO-Modelle können nicht über YOLO() zur Inferenz geladen werden. Nutze die native Laufzeitumgebung für jedes Format (ONNX Runtime, OpenVINO Runtime usw.).
• 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-Binary (nur Linux).

Link to this sectionFAQ#

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

Jedes torch.nn.Module. Dazu gehören Modelle von timm, torchvision oder jedes beliebige 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 Multi-Input-Modelle.

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 benötigt.

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 die iOS-Bereitstellung nach CoreML exportieren?#

Yes. torchvision classifiers, detectors, and segmentation models export to .mlpackage via torch2coreml. For image classification models, pass a list of class names to classifier_names to bake in a classification head. Run the export on macOS or Linux. CoreML is not supported on Windows. See the CoreML integration for iOS deployment details.

Link to this sectionKann ich mein exportiertes Modell auf 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 die Post-Training-Quantisierung. Siehe die Integrationsseite des jeweiligen Formats für die Vor- und Nachteile der Quantisierung.