ONNX Export for YOLO26 Models#

Often, when deploying computer vision models, you'll need a model format that's both flexible and compatible with multiple platforms.

Exporting Ultralytics YOLO26 models to ONNX format simplifies deployment across many runtimes and hardware platforms. This guide shows how to convert your YOLO26 models to ONNX and run them in real-world applications.

Watch: Ultralytics YOLO26 vs Ultralytics YOLO11 ONNX Inference Test | ~43% Faster Inference with YOLO26 🚀

ONNX and ONNX Runtime#

ONNX, which stands for Open Neural Network Exchange, is a community project that Facebook and Microsoft initially developed. The ongoing development of ONNX is a collaborative effort supported by various organizations like IBM, Amazon (through AWS), and Google. The project aims to create an open file format designed to represent machine learning models in a way that allows them to be used across different AI frameworks and hardware.

ONNX models can be used to move between different frameworks. For instance, a deep learning model trained in PyTorch can be exported to ONNX format and then imported into TensorFlow.

Alternatively, ONNX models can be used with ONNX Runtime. ONNX Runtime is a versatile cross-platform accelerator for machine learning models that is compatible with frameworks like PyTorch, TensorFlow, scikit-learn, etc.

ONNX Runtime optimizes the execution of ONNX models by using hardware-specific capabilities. This optimization allows the models to run efficiently and with high performance on various hardware platforms, including CPUs, GPUs, and specialized accelerators.

Whether used independently or in tandem with ONNX Runtime, ONNX provides a flexible solution for machine learning model deployment and compatibility.

Key Features of ONNX Models#

The ability of ONNX to handle various formats can be attributed to the following key features:

• Common Model Representation: ONNX defines a common set of operators (like convolutions, layers, etc.) and a standard data format. When a model is converted to ONNX format, its architecture and weights are translated into this common representation. This uniformity ensures that the model can be understood by any framework that supports ONNX.

• Versioning and Backward Compatibility: ONNX maintains a versioning system for its operators. This ensures that even as the standard evolves, models created in older versions remain usable. Backward compatibility is a crucial feature that prevents models from becoming obsolete quickly.

• Graph-based Model Representation: ONNX represents models as computational graphs. This graph-based structure is a universal way of representing machine learning models, where nodes represent operations or computations, and edges represent the tensors flowing between them. This format is easily adaptable to various frameworks which also represent models as graphs.

• Tools and Ecosystem: There is a rich ecosystem of tools around ONNX that assist in model conversion, visualization, and optimization. These tools make it easier for developers to work with ONNX models and to convert models between different frameworks.

Common Usage of ONNX#

ONNX models are commonly used in the following scenarios.

CPU Deployment#

ONNX models are often deployed on CPUs due to their compatibility with ONNX Runtime. This runtime is optimized for CPU execution. It significantly improves inference speed and makes real-time CPU deployments feasible.

Supported Deployment Options#

While ONNX models are commonly used on CPUs, they can also be deployed on the following platforms:

• GPU Acceleration: ONNX fully supports GPU acceleration on NVIDIA GPUs through CUDA and on AMD GPUs through ROCm and MIGraphX.

• Edge and Mobile Devices: ONNX extends to edge and mobile devices, suited to on-device and real-time inference scenarios. It's lightweight and compatible with edge hardware, and serves as the basis for vendor NPU formats such as Huawei Ascend, Qualcomm QNN for Snapdragon devices, and RKNN for Rockchip NPUs.

• Web Browsers: ONNX can run directly in web browsers, powering interactive and dynamic web-based AI applications.

Supported Tasks#

ONNX export supports all seven Ultralytics tasks. Semantic segmentation and depth estimation are available only with YOLO26, the only family that ships those heads.

Exporting YOLO26 Models to ONNX#

You can expand model compatibility and deployment flexibility by converting YOLO26 models to ONNX format. Ultralytics YOLO26 provides a straightforward export process for running your model across different platforms.

Installation#

To install the required package, run:

# Install the required package for YOLO26
pip install ultralytics

For detailed instructions and best practices related to the installation process, check our YOLO26 Installation guide. While installing the required packages for YOLO26, if you encounter any difficulties, consult our Common Issues guide for solutions and tips.

Usage#

The ONNX format supports the Export, Predict, and Validate modes. Export your model, then load the exported model to run inference or validate its accuracy.

from ultralytics import YOLO

# Load a YOLO26 model
model = YOLO("yolo26n.pt")

# Export the model to ONNX format
model.export(format="onnx")  # creates 'yolo26n.onnx'

# Export an INT8-quantized ONNX model with calibration data
model.export(format="onnx", quantize=8, data="coco8.yaml")  # creates 'yolo26n_int8.onnx'

from ultralytics import YOLO

# Load the exported ONNX model
model = YOLO("yolo26n.onnx")

# Run inference
results = model("https://ultralytics.com/images/bus.jpg")

from ultralytics import YOLO

# Load the exported ONNX model
model = YOLO("yolo26n.onnx")

# Validate accuracy on the COCO8 dataset
metrics = model.val(data="coco8.yaml")

Export Arguments#

When exporting your YOLO26 model to ONNX format, you can customize the process using various arguments to optimize for your specific deployment needs:

For more details about the export process, visit the Ultralytics documentation page on exporting.

INT8 Quantization#

For checkpoints not trained with quantization-aware training, quantize=8 applies ONNX Runtime static quantization to Conv, Gemm, and MatMul nodes only. All other nodes stay in float, including the ops that assemble output0: box coordinates (pixels) and class scores (0 to 1) share that tensor, so a single INT8 scale for it would round every class score to zero. Exclude the same nodes if you run quantize_static on an exported FP32 model yourself:

import onnx
from onnxruntime.quantization import quantize_static

model = "yolo26n.onnx"
exclude = [n.name for n in onnx.load(model).graph.node if n.op_type not in {"Conv", "Gemm", "MatMul"}]
quantize_static(model, "yolo26n_int8.onnx", calibration_reader, nodes_to_exclude=exclude)

Here calibration_reader is an onnxruntime.quantization.CalibrationDataReader that yields {"images": array} for each calibration image, preprocessed as for inference: letterboxed to the export size, RGB, NCHW, float32 in 0-1.

Deploying Exported YOLO26 ONNX Models#

Once you've successfully exported your Ultralytics YOLO26 models to ONNX format, the next step is deploying these models in various environments. For detailed instructions on deploying your ONNX models, take a look at the following resources:

• ONNX Runtime Python API Documentation: This guide provides essential information for loading and running ONNX models using ONNX Runtime.

• Deploying on Edge Devices: Examples of deploying ONNX models on edge devices.

• ONNX Tutorials on GitHub: A collection of tutorials that cover various aspects of using and implementing ONNX models in different scenarios.

• Triton Inference Server: Learn how to deploy your ONNX models with NVIDIA's Triton Inference Server for high-performance, scalable deployments.

Windows ML Inference#

On Windows 11 24H2 (build 26100) or newer with Python 3.10+, you can install onnxruntime-windowsml in a separate environment to let Windows ML select execution providers for your hardware. Install it instead of other ONNX Runtime builds, then use the same exported .onnx model with YOLO("model.onnx"). The backend preserves the PyTorch thread count and supplied session options, including an explicit provider policy. Without a supplied policy, Windows ML selects hardware for maximum performance, even when the PyTorch device is cpu. Measure prediction latency on your device before choosing this runtime; it is optional and is not installed by default.

On integrated GPUs that share power with the CPU, idle PyTorch threads in preprocessing and postprocessing can slow Windows ML inference. Call torch.set_num_threads(1) before predicting to reduce this. It applies to the whole process, so other PyTorch models in that process also run on one thread.

import torch

from ultralytics import YOLO

torch.set_num_threads(1)  # optional, measure on your device
results = YOLO("yolo26n.onnx")("https://ultralytics.com/images/bus.jpg")

AMD GPU Inference with MIGraphX#

Ultralytics runs exported ONNX models on AMD GPUs through the ONNX Runtime MIGraphX execution provider. On a ROCm (HIP) system, the ONNX backend installs the onnxruntime-ep-migraphx plugin on first use and selects MIGraphXExecutionProvider automatically with no code changes, and all YOLO26 tasks are supported. See the AMD GPU inference guide for prerequisites, installation, usage, benchmarks, and the compiled-program cache.

Summary#

In this guide, you've learned how to export Ultralytics YOLO26 models to ONNX format to increase their interoperability and performance across various platforms. You were also introduced to the ONNX Runtime and ONNX deployment options.

ONNX export is just one of many export formats supported by Ultralytics YOLO26, allowing you to deploy your models in virtually any environment. Depending on your specific needs, you might also want to explore other export options like TensorRT for maximum GPU performance or CoreML for Apple devices.

For further details on usage, visit the ONNX official documentation.

FAQ#