So exportieren SiePyTorch , dieYOLO , mit Ultralytics
Die Bereitstellung von PyTorch in der Produktion bedeutet in der Regel, dass man für jedes Ziel einen anderen Exporter verwenden muss: 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, seine eigenen Besonderheiten bei den Abhängigkeiten und seine eigenen Konventionen für die Ausgabe.
Ultralytics eigenständige Export-Dienstprogramme Ultralytics , die mehrere Backends hinter einer einheitlichen Benutzeroberfläche vereinen. Sie können beliebige torch.nn.Module, einschließlich timm Bildvorlagen, Torchvision Klassifikatoren und Detektoren oder Ihre eigenen benutzerdefinierten Architekturen, um ONNX, TorchScript, OpenVINO, CoreML, NCNN, PaddlePaddle, MNN, ExecuTorchund TensorFlow SavedModel ohne jedes Backend einzeln erlernen zu müssen.
Warum sollte man Ultralytics YOLO verwenden?
- Eine API für 10 Formate: Lernen Sie nur eine einzige Aufrufkonvention statt einem Dutzend.
- Gemeinsam genutzte Versorgungsfläche: Die Export-Hilfsprogramme befinden sich unter
ultralytics.utils.exportSobald die Backend-Pakete installiert sind, kannst du also das gleiche Aufrufmuster für alle Formate beibehalten. - Derselbe Codepfad wie bei YOLO : Alle Ultralytics YOLO basieren auf denselben Hilfsfunktionen.
- FP16- und INT8-Quantisierung ist für Formate integriert, die dies unterstützen (OpenVINO, CoreML, MNN, NCNN).
- Läuft auf CPU: Für den Exportvorgang selbst GPU keine GPU , sodass Sie ihn lokal auf jedem Laptop ausführen können.
Schnellstart
Der schnellste Weg ist ein zweizeiliger Export nach ONNX ohne YOLO und ohne weitere Einrichtung 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")
Unterstützte Exportformate
Die torch2* Funktionen nehmen einen Standardwert entgegen torch.nn.Module sowie einen tensor. MNN, TF SavedModel und TF Graph durchlaufen ein Zwischenformat in Form eines ONNX Keras-Artefakts. In beiden Fällen sind keine YOLO Attribute erforderlich.
| Format | Funktion | Installieren | Ausgabe |
|---|---|---|---|
| ONNX | torch2onnx() | pip install onnx | .onnx Datei definiert |
| TorchScript | torch2torchscript() | in PyTorch enthalten | .torchscript Datei definiert |
| OpenVINO | torch2openvino() | pip install openvino | _openvino_model/ Verzeichnis |
| CoreML | torch2coreml() | pip install coremltools | .mlpackage |
| TF SavedModel | onnx2saved_model() | siehe untenstehende detaillierte Anforderungen | _saved_model/ Verzeichnis |
| TF -Graph | keras2pb() | siehe untenstehende detaillierte Anforderungen | .pb Datei definiert |
| NCNN | torch2ncnn() | pip install ncnn pnnx | _ncnn_model/ Verzeichnis |
| MNN | onnx2mnn() | pip install MNN | .mnn Datei definiert |
| PaddlePaddle | torch2paddle() | pip install paddlepaddle x2paddle | _paddle_model/ Verzeichnis |
| ExecuTorch | torch2executorch() | pip install executorch | _executorch_model/ Verzeichnis |
ONNX Zwischenformat
MNN, TF SavedModelund TF Graph-Exporte durchlaufen ONNX Zwischenschritt. Exportieren Sie ONNX nach ONNX und konvertieren Sie dann.
Einbetten von Metadaten
Einige Exportfunktionen akzeptieren ein optionales metadata Wörterbuch (z. B. torch2torchscript(..., metadata={"author": "me"})), das benutzerdefinierte Schlüssel-Wert-Paare in das exportierte Artefakt einbettet, sofern das Format dies unterstützt.
Schritt-für-Schritt-Beispiele
In jedem der folgenden Beispiele wird dieselbe Konfiguration verwendet, nämlich ein vortrainiertes ResNet-18 aus dem Paket „timm“ im Auswertungsmodus:
import timm
import torch
model = timm.create_model("resnet18", pretrained=True).eval()
im = torch.randn(1, 3, 224, 224)
Rufen Sie immer an model.eval() vor dem Export
Schulabbruch, Batch-Normalisierung, und andere ausschließlich für das Training bestimmte Schichten verhalten sich während der Inferenz anders. Überspringen .eval() erzeugt Exportdateien mit fehlerhaften Ausgaben.
Export nach ONNX
from ultralytics.utils.export import torch2onnx
torch2onnx(model, im, output_file="resnet18.onnx")
Für eine dynamische Losgröße übergeben Sie eine dynamic Wörterbuch:
torch2onnx(model, im, output_file="resnet18_dyn.onnx", dynamic={"images": {0: "batch_size"}})
Der Standard-Opset lautet 14 und der Standardname für die Eingabe lautet "images". Überschreiben mit dem opset, input_names, oder output_names Argumente.
In TorchScript exportieren
Keine zusätzlichen Abhängigkeiten erforderlich. Verwendet torch.jit.trace hinter den Kulissen.
from ultralytics.utils.export import torch2torchscript
torch2torchscript(model, im, output_file="resnet18.torchscript")
In OpenVINO exportieren
from ultralytics.utils.export import torch2openvino
ov_model = torch2openvino(model, im, output_dir="resnet18_openvino_model")
Das Verzeichnis enthält einen festen Namen model.xml und model.bin Paar:
resnet18_openvino_model/
├── model.xml
└── model.bin
Überspringen dynamic=True für dynamische Eingabeformen, half=True für FP16 oder int8=True für die INT8-Quantisierung. INT8 erfordert zusätzlich eine calibration_dataset Argument.
Erfordert openvino>=2024.0.0 (oder >=2025.2.0 unter macOS 15.4+) und torch>=2.1.
In CoreML exportieren
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 Klassifizierung Modelle, übergeben Sie eine Liste mit Klassennamen an classifier_names um dem CoreML eine Klassifizierungsüberschrift hinzuzufügen.
Erfordert coremltools>=9.0, torch>=1.11und numpy<=2.3.5. Unter Windows nicht unterstützt.
BlobWriter not loaded Fehler
coremltools>=9.0 Liefert „wheels“ für Python .10–3.13 unter macOS und Linux. Bei neueren Python kann die native C-Erweiterung nicht geladen werden. Verwenden Sie Python .10–3.13 für CoreML .
In TensorFlow SavedModel exportieren
SavedModel TF SavedModel erfolgt über ONNX 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 außerdem TFLite (.tflite) im Ausgabeverzeichnis:
resnet18_saved_model/
├── saved_model.pb
├── variables/
├── resnet18_float32.tflite
├── resnet18_float16.tflite
└── resnet18_int8.tflite
Voraussetzungen:
tensorflow>=2.0.0,<=2.19.0onnx2tf>=1.26.3,<1.29.0tf_keras<=2.19.0sng4onnx>=1.0.1onnx_graphsurgeon>=0.3.26(Installieren mit--extra-index-url https://pypi.ngc.nvidia.com)ai-edge-litert>=1.2.0,<1.4.0unter macOS (ai-edge-litert>=1.2.0(auf anderen Plattformen)onnxslim>=0.1.71onnx>=1.12.0,<2.0.0protobuf>=5
In TensorFlow -Graph exportieren
Anknüpfend an den oben beschriebenen SavedModel konvertieren Sie das zurückgegebene Keras-Modell in ein „frozen“-Modell .pb Grafik:
from pathlib import Path
from ultralytics.utils.export import keras2pb
keras2pb(keras_model, output_file=Path("resnet18_saved_model/resnet18.pb"))
In NCNN exportieren
from ultralytics.utils.export import torch2ncnn
torch2ncnn(model, im, output_dir="resnet18_ncnn_model")
Das Verzeichnis enthält Param- und Bin-Dateien mit festen Namen sowie einen Python :
resnet18_ncnn_model/
├── model.ncnn.param
├── model.ncnn.bin
└── model_ncnn.py
torch2ncnn() prüft auf ncnn und pnnx bei der ersten Verwendung.
In MNN exportieren
Für den MNN-Export ist eine ONNX als Eingabe erforderlich. Exportieren Sie ONNX in ONNX und konvertieren Sie die Datei anschließend:
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 die INT8-Quantisierung. Erfordert MNN>=2.9.6 und torch>=1.10.
In PaddlePaddle exportieren
from ultralytics.utils.export import torch2paddle
torch2paddle(model, im, output_dir="resnet18_paddle_model")
Das Verzeichnis enthält die PaddlePaddle und Parameterdateien:
resnet18_paddle_model/
├── model.pdmodel
└── model.pdiparams
Erfordert x2paddle sowie die richtige PaddlePaddle für Ihre Plattform:
paddlepaddle-gpu>=3.0.0,<3.3.0auf CUDApaddlepaddle==3.0.0auf CPU ARM64 CPUpaddlepaddle>=3.0.0,<3.3.0auf anderen CPUs
Wird auf NVIDIA nicht unterstützt.
In ExecuTorch exportieren
from ultralytics.utils.export import torch2executorch
torch2executorch(model, im, output_dir="resnet18_executorch_model")
Die exportierten .pte Die 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 Verwendung zur Laufzeit finden Sie in der ExecuTorch-Integration.
Überprüfen Sie Ihr exportiertes Modell
Überprüfen Sie nach dem Export vor der Auslieferung die numerische Übereinstimmung mit dem ursprünglichen PyTorch . Ein kurzer Funktionstest mit ONNXBackend von ultralytics.nn.backends vergleicht die Ausgabewerte und meldet 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.forward(im)[0]
diff = np.abs(pytorch_output - onnx_output).max()
print(f"Max difference: {diff:.6f}") # should be < 1e-5
Erwartete Differenz
Bei FP32-Exporten sollte die maximale absolute Abweichung unter 1e-5. Größere Abweichungen deuten auf nicht unterstützte Operationen, eine falsche Eingabeform oder ein Modell hin, das sich nicht im Evaluierungsmodus befindet. Bei FP16- und INT8-Exporten gelten großzügigere Toleranzen. Führen Sie die Validierung anhand realer Daten statt anhand von Zufallstensor durch.
Bei anderen Laufzeiten kann tensor abweichen. OpenVINO verwendet beispielsweise den Namen des Forward-Arguments des Modells (in der Regel x (für generische Modelle), während torch2onnx Standardmäßig "images".
Bekannte Einschränkungen
- Die Unterstützung für mehrere Eingänge ist uneinheitlich:
torch2onnxundtorch2openvinoein Tupel oder eine Liste von Beispiel-Tensoren für Modelle mit mehreren Eingängen akzeptieren.torch2torchscript,torch2coreml,torch2ncnn,torch2paddleundtorch2executorchGehen wir von einem einzelnen tensor aus. - ExecuTorch benötigt
flatc: Für die ExecuTorch-Laufzeitumgebung ist der FlatBuffers-Compiler erforderlich. Installieren Sie ihn mitbrew install flatbuffersunter macOS oderapt install flatbuffers-compilerunter Ubuntu. - Keine Schlussfolgerung über Ultralytics: ExportierteYOLO können nicht wieder über
YOLO()zur Inferenz. Verwenden Sie für jedes Format die native Laufzeitumgebung (ONNX, OpenVINO, usw.). - YOLO Formate: Exporte für Axelera und Sony IMX500 erfordern YOLO Modellattribute und sind für generische Modelle nicht verfügbar.
- Plattformspezifische Formate: TensorRT erfordert eine NVIDIA GPU. RKNN erfordert die
rknn-toolkit2SDK (nur Linux). Edge TPU erfordert dieedgetpu_compilerBinärdatei (nur Linux).
FAQ
Welche Modelle kann ich mit Ultralytics exportieren?
Beliebig torch.nn.Module. Dazu gehören Modelle von timm, torchvision oder beliebige benutzerdefinierte PyTorch . Das Modell muss sich im Auswertungsmodus befinden (model.eval()) vor dem Export. ONNX OpenVINO akzeptieren OpenVINO ein Tupel mit Beispiel-Tensoren für Modelle mit mehreren Eingängen.
Welche Exportformate funktionieren ohne GPU?
Alle unterstützten Formate (TorchScript, ONNX, OpenVINO, CoreML, TF SavedModel, TF Graph, NCNN, PaddlePaddle, MNN, ExecuTorch) können auf CPU exportiert werden. Für den Exportvorgang selbst GPU keine GPU erforderlich. TensorRT das einzige Format, für das eineGPU benötigt wird.
Welche Ultralytics benötige ich?
Ultralytics verwenden >=8.4.38, zu dem auch die ultralytics.utils.export Modul und die standardisierte output_file/output_dir Argumente.
Kann ich ein Torchvision-Modell CoreML iOS in CoreML exportieren?
Ja. Klassifikatoren, Detektoren und Segmentierungsmodelle von Torchvision lassen sich exportieren in .mlpackage über torch2coreml. Bei Bildklassifizierungsmodellen übergeben Sie eine Liste mit Klassennamen an classifier_names zum Trainieren in einem Klassifikationsmodell. Führen Sie den Export unter macOS oder Linux aus. CoreML unter Windows nicht unterstützt. Siehe die CoreML für Details iOS .
Kann ich mein exportiertes Modell auf INT8 oder FP16 quantisieren?
Ja, für mehrere Formate. Weiter half=True für FP16 oder int8=True für INT8 beim Export in OpenVINO, CoreML, MNN oder NCNN. Für INT8 in OpenVINO ist OpenVINO eine calibration_dataset Argument für Quantisierung nach dem Training. Informationen zu den Kompromissen bei der Quantisierung finden Sie auf der Integrationsseite des jeweiligen Formats.
