Link to this sectionUltralytics ile YOLO Olmayan PyTorch Modelleri Nasıl Dışa Aktarılır#

PyTorch modellerini üretime almak, genellikle her hedef için farklı bir dışa aktarıcı (exporter) kullanmayı gerektirir: ONNX için torch.onnx.export, Apple cihazları için coremltools, TensorFlow için onnx2tf, NCNN için pnnx gibi. Her aracın kendi API'si, bağımlılık tuhaflıkları ve çıktı kuralları vardır.

Ultralytics ships standalone export utilities that wrap multiple backends behind one consistent interface. You can export any torch.nn.Module, including timm image models, torchvision classifiers and detectors, or your own custom architectures, to ONNX, TorchScript, OpenVINO, CoreML, NCNN, PaddlePaddle, MNN, ExecuTorch, and TensorFlow SavedModel without learning each backend separately.

Link to this sectionNeden YOLO Dışı Dışa Aktarma İçin Ultralytics Kullanmalısın?#

• 10 formatta tek bir API: düzinelerce yöntem yerine tek bir çağırma kuralı öğren.
• Paylaşılan yardımcı yüzey: dışa aktarma yardımcıları ultralytics.utils.export altında yer alır, bu nedenle arka uç paketleri yüklendiğinde formatlar arasında aynı çağırma düzenini koruyabilirsin.
• YOLO dışa aktarmalarıyla aynı kod yolu: aynı yardımcılar tüm Ultralytics YOLO dışa aktarmalarını destekler.
• Bunu destekleyen formatlar (OpenVINO, CoreML, MNN, NCNN) için FP16 ve INT8 kuantizasyon dahili olarak mevcuttur.
• CPU üzerinde çalışır: dışa aktarma adımı için GPU gerekmez, böylece herhangi bir dizüstü bilgisayarda yerel olarak çalıştırabilirsin.

Link to this sectionHızlı Başlangıç#

The fastest path is a two-line export to ONNX with no YOLO code and no setup beyond 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 sectionDesteklenen Dışa Aktarma Formatları#

torch2* işlevleri standart bir torch.nn.Module ve bir örnek girdi tensörü alır. MNN, TF SavedModel ve TF Frozen Graph, ara bir ONNX veya Keras dosyası üzerinden geçer. Her iki durumda da YOLO'ya özgü öznitelikler gerekmez.

Link to this sectionAdım Adım Örnekler#

Aşağıdaki her örnek aynı kurulumu kullanır: değerlendirme modunda önceden eğitilmiş bir timm ResNet-18:

import timm
import torch

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

Link to this sectionONNX'e aktar#

from ultralytics.utils.export import torch2onnx

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

Dinamik batch boyutu için bir dynamic sözlüğü geçir:

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

Varsayılan opset 14 ve varsayılan girdi adı "images"'dir. Bunları opset, input_names veya output_names bağımsız değişkenleriyle geçersiz kılabilirsin.

Link to this sectionTorchScript formatına dışa aktar#

Ek bağımlılık gerekmez. Arka planda torch.jit.trace kullanır.

from ultralytics.utils.export import torch2torchscript

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

Link to this sectionOpenVINO formatına dışa aktar#

from ultralytics.utils.export import torch2openvino

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

Dizin, sabit isimli bir model.xml ve model.bin çifti içerir:

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

Dinamik girdi şekilleri için dynamic=True, FP16 için half=True veya INT8 kuantizasyonu için int8=True geç. INT8 ayrıca bir calibration_dataset argümanı gerektirir.

openvino>=2024.0.0 (veya macOS 15.4+ üzerinde >=2025.2.0) ve torch>=2.1 gerekir.

Link to this sectionCoreML formatına dışa aktar#

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")

sınıflandırma modelleri için, CoreML modeline bir sınıflandırma başlığı eklemek üzere sınıf isimlerini içeren bir listeyi classifier_names bağımsız değişkenine geçir.

coremltools>=9.0, torch>=1.11 ve numpy<=2.3.5 gerekir. Windows üzerinde desteklenmez.

Link to this sectionTensorFlow SavedModel formatına dışa aktar#

TF SavedModel dışa aktarımı, ara adım olarak ONNX üzerinden geçer:

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")

İşlev bir Keras modeli döndürür ve çıktı dizininde TFLite dosyaları (.tflite) da oluşturur:

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

Gereksinimler:

• 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 (--extra-index-url https://pypi.ngc.nvidia.com ile yükle)
• macOS'te ai-edge-litert>=1.2.0,<1.4.0 (diğer platformlarda ai-edge-litert>=1.2.0)
• onnxslim>=0.1.71
• onnx>=1.12.0,<2.0.0
• protobuf>=5

Link to this sectionTensorFlow Frozen Graph formatına dışa aktar#

Yukarıdaki SavedModel dışa aktarma işleminden devam ederek, döndürülen Keras modelini dondurulmuş bir .pb grafiğine dönüştür:

from pathlib import Path

from ultralytics.utils.export import keras2pb

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

Link to this sectionNCNN formatına dışa aktar#

from ultralytics.utils.export import torch2ncnn

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

Dizin, Python sarmalayıcı ile birlikte sabit isimli param ve bin dosyalarını içerir:

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

torch2ncnn() ilk kullanımda ncnn ve pnnx olup olmadığını kontrol eder.

Link to this sectionMNN formatına dışa aktar#

MNN dışa aktarma, girdi olarak bir ONNX dosyası gerektirir. Önce ONNX formatına aktar, sonra dönüştür:

from ultralytics.utils.export import onnx2mnn, torch2onnx

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

FP16 için half=True ve INT8 kuantizasyonu için int8=True destekler. MNN>=2.9.6 ve torch>=1.10 gerekir.

Link to this sectionPaddlePaddle formatına dışa aktar#

from ultralytics.utils.export import torch2paddle

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

Dizin, PaddlePaddle modelini ve parametre dosyalarını içerir:

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

x2paddle ve platformun için doğru PaddlePaddle dağıtımı gerekir:

• CUDA üzerinde paddlepaddle-gpu>=3.0.0,<3.3.0
• ARM64 CPU üzerinde paddlepaddle==3.0.0
• Diğer CPU'larda paddlepaddle>=3.0.0,<3.3.0

NVIDIA Jetson üzerinde desteklenmez.

Link to this sectionExecuTorch formatına aktar#

from ultralytics.utils.export import torch2executorch

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

Dışa aktarılan .pte dosyası çıktı dizininin içine kaydedilir:

resnet18_executorch_model/
└── model.pte

torch>=2.9.0 ve uyumlu bir ExecuTorch çalışma zamanı (pip install executorch) gerektirir. Çalışma zamanı kullanımı için ExecuTorch entegrasyonu kısmına göz at.

Link to this sectionDışa Aktardığın Modeli Doğrula#

After exporting, verify numerical parity with the original PyTorch model before shipping. A quick smoke test with ONNXBackend from ultralytics.nn.backends compares outputs and flags tracing or quantization errors early:

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

Diğer çalışma zamanları için giriş tensör adı farklı olabilir. Örneğin OpenVINO, modelin iletme argümanı adını (genel modeller için genellikle x) kullanırken, torch2onnx varsayılan olarak "images" adını kullanır.

Link to this sectionBilinen Kısıtlamalar#

• Çoklu giriş desteği düzensizdir: torch2onnx ve torch2openvino, çoklu girişe sahip modeller için örnek tensörlerden oluşan bir tuple veya liste kabul eder. torch2torchscript, torch2coreml, torch2ncnn, torch2paddle ve torch2executorch ise tek bir giriş tensörü varsayar.
• ExecuTorch flatc gerektirir: ExecuTorch çalışma zamanı, FlatBuffers derleyicisini gerektirir. macOS üzerinde brew install flatbuffers veya Ubuntu üzerinde apt install flatbuffers-compiler komutuyla yükleyebilirsin.
• Ultralytics üzerinden çıkarım yapılamaz: Dışa aktarılan YOLO olmayan modeller, çıkarım için YOLO() üzerinden geri yüklenemez. Her format için kendi yerel çalışma zamanını kullan (ONNX Runtime, OpenVINO Runtime vb.).
• Yalnızca YOLO formatları: Axelera ve Sony IMX500 dışa aktarımları, YOLO'ya özgü model nitelikleri gerektirir ve genel modeller için mevcut değildir.
• Platforma özgü formatlar: TensorRT bir NVIDIA GPU gerektirir. RKNN rknn-toolkit2 SDK gerektirir (yalnızca Linux). Edge TPU ise edgetpu_compiler ikili dosyasını gerektirir (yalnızca Linux).

Link to this sectionSSS#

Link to this sectionUltralytics ile hangi modelleri dışa aktarabilirim?#

Herhangi bir torch.nn.Module. Buna timm, torchvision veya özel herhangi bir PyTorch modeli dahildir. Model, dışa aktarmadan önce değerlendirme modunda (model.eval()) olmalıdır. ONNX ve OpenVINO ayrıca çoklu girişli modeller için örnek tensörlerden oluşan bir tuple da kabul eder.

Link to this sectionHangi dışa aktarma formatları GPU olmadan çalışır?#

Desteklenen tüm formatlar (TorchScript, ONNX, OpenVINO, CoreML, TF SavedModel, TF Frozen Graph, NCNN, PaddlePaddle, MNN, ExecuTorch) CPU üzerinde dışa aktarılabilir. Dışa aktarma sürecinin kendisi için GPU gerekmez. TensorRT, NVIDIA GPU gerektiren tek formattır.

Link to this sectionHangi Ultralytics sürümüne ihtiyacım var?#

Use Ultralytics >=8.4.38, which includes the ultralytics.utils.export module and the standardized output_file/output_dir arguments.

Link to this sectionBir torchvision modelini iOS dağıtımı için CoreML'e aktarabilir miyim?#

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 sectionDışa aktardığım modelimi INT8 veya FP16'ya niceleyebilir (quantize) miyim?#

Yes, for several formats. Pass half=True for FP16 or int8=True for INT8 when exporting to OpenVINO, CoreML, MNN, or NCNN. INT8 in OpenVINO additionally requires a calibration_dataset argument for post-training quantization. See each format's integration page for quantization trade-offs.