Model Export with Ultralytics YOLO#

Exporting a YOLO26 model to ONNX format is straightforward with Ultralytics. It provides both Python and CLI methods for exporting models.

from ultralytics import YOLO

# Load a model
model = YOLO("yolo26n.pt")  # load an official model
model = YOLO("path/to/best.pt")  # load a custom-trained model

# Export the model
model.export(format="onnx")

For more details on the process, including advanced options like handling different input sizes, refer to the ONNX integration guide.

Using TensorRT for model export offers significant performance improvements. YOLO26 models exported to TensorRT can achieve up to a 5x GPU speedup, making it ideal for real-time inference applications.

• Versatility: Optimize models for a specific hardware setup.
• Speed: Achieve faster inference through advanced optimizations.
• Compatibility: Integrate smoothly with NVIDIA hardware.

To learn more about integrating TensorRT, see the TensorRT integration guide.

INT8 quantization is an excellent way to compress the model and speed up inference, especially on edge devices. Here's how you can enable INT8 quantization:

from ultralytics import YOLO

model = YOLO("yolo26n.pt")  # Load a model
model.export(format="onnx", quantize=8, data="coco8.yaml")

INT8 quantization can be applied to formats such as ONNX, TensorRT, OpenVINO, CoreML, and Rockchip RKNN. For optimal quantization results, provide a representative dataset using the data parameter. See Quantization Options for accepted quantize values and supported formats.

Dynamic input size allows the exported model to handle varying image dimensions, providing flexibility and optimizing processing efficiency for different use cases. When exporting to formats like ONNX or TensorRT, enabling dynamic input size ensures that the model can adapt to different input shapes seamlessly.

To enable this feature, use the dynamic=True flag during export:

from ultralytics import YOLO

model = YOLO("yolo26n.pt")
model.export(format="onnx", dynamic=True)

Dynamic input sizing is particularly useful for applications where input dimensions may vary, such as video processing or when handling images from different sources.

Understanding and configuring export arguments is crucial for optimizing model performance:

• format: The target format for the exported model (e.g., onnx, torchscript, tensorflow).
• imgsz: Desired image size for the model input (e.g., 640 or (height, width)).
• quantize: Quantization precision, such as 8/"int8", 16/"fp16", 32/"fp32", or the mixed weight/activation schemes "w8a16" and "w8a32" (LiteRT dynamic INT8) on supported formats. See Quantization Options.
• optimize: Enables higher compiler optimization for DEEPX exports.

For deployment on specific hardware platforms, consider using specialized export formats like TensorRT for NVIDIA GPUs, CoreML for Apple devices, or Edge TPU for Google Coral devices.

When you export a YOLO model to formats like ONNX or TensorRT, the output tensor structure depends on the model task. Understanding these outputs is important for custom inference implementations.

For YOLO26 detection models (e.g., yolo26n.pt), end-to-end export is enabled by default in formats that support it, so the output is shaped like (batch_size, max_detections, 6) with [x1, y1, x2, y2, confidence, class_id] values. With the default max_det=300, this is commonly (batch_size, 300, 6). Some constrained formats automatically fall back to the traditional output layout when end-to-end operators are unsupported.

For non-end-to-end detection models, or YOLO26 models exported with end2end=False, the output is typically a single tensor shaped like (batch_size, 4 + num_classes, num_predictions) where the channels represent box coordinates plus per-class scores, and num_predictions depends on the export input resolution (and can be dynamic).

For segmentation models (e.g., yolo26n-seg.pt), you'll typically get two outputs: the first tensor shaped like (batch_size, 4 + num_classes + mask_dim, num_predictions) (boxes, class scores, and mask coefficients), and the second tensor shaped like (batch_size, mask_dim, proto_h, proto_w) containing mask prototypes used with the coefficients to generate instance masks. Sizes depend on the export input resolution (and can be dynamic).

For pose models (e.g., yolo26n-pose.pt), the output tensor is typically shaped like (batch_size, 4 + num_classes + keypoint_dims, num_predictions), where keypoint_dims depends on the pose specification (e.g., number of keypoints and whether confidence is included), and num_predictions depends on the export input resolution (and can be dynamic).

The examples in the ONNX inference examples demonstrate how to process these outputs for each model type.

Ultralytics does not currently provide a dedicated C++ inference API for YOLO models. For C++ deployments, export the model to a runtime format such as ONNX, TensorRT, TorchScript, or MNN, then load the exported artifact with that runtime's native C++ API.

For example, export a detection model with yolo export model=yolo26n.pt format=onnx and run the .onnx file with ONNX Runtime C++, or export with format=engine and run the TensorRT engine from a TensorRT C++ application. When you use custom C++ post-processing, match the output tensor layout for your task and export settings; YOLO26 end-to-end detection exports usually return (batch, max_det, 6), while non-end-to-end exports return raw prediction tensors that require external post-processing.

When exporting with quantize=16 (FP16) or quantize=8 (INT8), most tensors are converted to lower precision to reduce model size and improve performance. However, when end2end=True is enabled, post-processing (including class indices) is embedded directly in the exported graph.

The output0 tensor contains class indices, which are internally represented as floating-point values. FP16 cannot reliably represent integer values above 2048 due to its limited mantissa precision. To avoid potential precision loss or incorrect class IDs, output0 is intentionally kept in FP32.

This behavior is expected and also applies to lower-precision or quantized exports where class index fidelity must be preserved.

If full FP16 outputs are required, export with end2end=False and perform post-processing externally.