YOLO Deployment: Model Export and Multi-Platform Deployment

Wed, 20 May 2026 00:00:00 +0000

Model Export (17 Format Support)

Ultralytics Unified Export API

python


 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25


from ultralytics import YOLO

model = YOLO("yolo26n.pt")

# ========== Export Various Formats ==========
# 1. ONNX (Cross-platform Universal)
model.export(format="onnx", simplify=True, dynamic=True)

# 2. TensorRT (Best for NVIDIA GPU)
model.export(format="engine", half=True, workspace=4)

# 3. OpenVINO (Best for Intel CPU)
model.export(format="openvino", half=True)

# 4. CoreML (Apple Devices)
model.export(format="coreml", int8=True)

# 5. TFLite (Android/iOS Mobile)
model.export(format="tflite", int8=True)

# 6. NCNN (Mobile)
model.export(format="ncnn")

# 7. PaddlePaddle
model.export(format="paddle")

Version Export Compatibility

Format	YOLOv8	YOLO11	YOLO26
ONNX	✅	✅	✅ Best
TensorRT	✅	✅	✅ No NMS, Simpler
OpenVINO	✅	✅	✅
TFLite	✅	✅	✅
NCNN	✅	✅	✅

Python Deployment Practice

ONNX Runtime Deployment

python


 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23


import onnxruntime as ort
import cv2
import numpy as np

# Load ONNX model
session = ort.InferenceSession(
 "yolo26n.onnx",
 providers=["CUDAExecutionProvider", "CPUExecutionProvider"]
)

def preprocess(image, imgsz=640):
 """Image preprocessing"""
 img = cv2.resize(image, (imgsz, imgsz))
 img = img.transpose(2, 0, 1) / 255.0
 return img[np.newaxis].astype(np.float32)

# Inference
image = cv2.imread("test.jpg")
input_data = preprocess(image)
outputs = session.run(None, {"images": input_data})

# YOLO26 Special Note: No NMS post-processing needed!
# Output is already the final detection results

TensorRT Python Deployment

python


 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66


import tensorrt as trt
import pycuda.driver as cuda
import pycuda.autoinit
import numpy as np
import time

# ========== 1. Engine Loading & Context Creation ==========
TRT_LOGGER = trt.Logger(trt.Logger.WARNING)
runtime = trt.Runtime(TRT_LOGGER)

with open("yolo26n.engine", "rb") as f:
 engine = runtime.deserialize_cuda_engine(f.read())

context = engine.create_execution_context()

# ========== 2. CUDA Memory Allocation ==========
stream = cuda.Stream()
bindings = []

for i in range(engine.num_io_tensors):
 name = engine.get_tensor_name(i)
 shape = engine.get_tensor_shape(name)
 dtype = trt.nptype(engine.get_tensor_dtype(name))
 size = trt.volume(shape)
 
 host_mem = cuda.pagelocked_empty(size, dtype) # Host pinned memory
 device_mem = cuda.mem_alloc(host_mem.nbytes) # Device VRAM
 bindings.append({"name": name, "host": host_mem, "device": device_mem,
 "shape": shape, "size": size, "dtype": dtype})

# ========== 3. Async Inference Loop ==========
def async_infer(input_blob):
 # H2D copy
 np.copyto(bindings[0]["host"], input_blob.ravel())
 cuda.memcpy_htod_async(bindings[0]["device"], bindings[0]["host"], stream)
 
 # Set tensor addresses and execute
 context.set_tensor_address(bindings[0]["name"], int(bindings[0]["device"]))
 context.set_tensor_address(bindings[1]["name"], int(bindings[1]["device"]))
 context.execute_async_v3(stream.handle)
 
 # D2H copy
 cuda.memcpy_dtoh_async(bindings[1]["host"], bindings[1]["device"], stream)
 stream.synchronize()
 
 return bindings[1]["host"].copy()

# ========== 4. Performance Benchmark ==========
def benchmark(warmup=10, runs=100):
 dummy = np.random.randn(1, 3, 640, 640).astype(np.float32)
 for _ in range(warmup):
 async_infer(dummy)
 
 latencies = []
 for _ in range(runs):
 t0 = time.perf_counter()
 async_infer(dummy)
 latencies.append((time.perf_counter() - t0) * 1000)
 
 latencies.sort()
 print(f"TensorRT FP16 | Mean: {np.mean(latencies):.1f}ms | "
 f"P50: {latencies[runs//2]:.1f}ms | "
 f"P99: {latencies[int(runs*0.99)]:.1f}ms | "
 f"Throughput: {1000/np.mean(latencies):.0f} FPS")

benchmark()

OpenVINO Deployment with Benchmarking

python


 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70


import openvino as ov
import cv2
import numpy as np
import time

# ========== 1. ONNX → OpenVINO Conversion ==========
# Ultralytics unified export:
# model.export(format="openvino", half=True)

core = ov.Core()
model = core.read_model("yolo26n_openvino/yolo26n.xml")

# ========== 2. CPU Inference ==========
compiled_cpu = core.compile_model(model, device_name="CPU")
infer_request = compiled_cpu.create_infer_request()

def openvino_infer(image):
 img = cv2.resize(image, (640, 640))
 blob = img.transpose(2, 0, 1)[np.newaxis].astype(np.float32) / 255.0
 outputs = infer_request.infer({"images": blob})
 return outputs[next(iter(outputs))]

# ========== 3. Async Pipeline (Throughput Optimized) ==========
def async_pipeline(images, num_requests=4):
 """Multi-request async inference pipeline"""
 requests = [core.compile_model(model, "CPU").create_infer_request()
 for _ in range(num_requests)]
 results = [None] * len(images)
 
 def completion_callback(request, userdata):
 idx = userdata
 results[idx] = request.get_output_tensor().data.copy()
 
 for req in requests:
 req.set_callback(completion_callback)
 
 for i, img in enumerate(images):
 req = requests[i % num_requests]
 req.start_async({"images": preprocess(img)}, userdata=i)
 
 for req in requests:
 req.wait()
 
 return results

# ========== 4. CPU vs NPU Benchmark Comparison ==========
def benchmark_openvino():
 dummy = np.random.randn(1, 3, 640, 640).astype(np.float32)
 
 for device in ["CPU", "AUTO"]:
 compiled = core.compile_model(model, device)
 req = compiled.create_infer_request()
 
 # Warmup (avoid first-inference kernel compilation overhead)
 for _ in range(20):
 req.infer({"images": dummy})
 
 times = []
 for _ in range(200):
 t0 = time.perf_counter()
 req.infer({"images": dummy})
 times.append((time.perf_counter() - t0) * 1000)
 
 times.sort()
 print(f"OpenVINO {device}: "
 f"Mean {np.mean(times):.1f}ms | "
 f"P99 {times[int(199*0.99)]:.1f}ms | "
 f"{1000/np.mean(times):.0f} FPS")

benchmark_openvino()

NCNN Mobile Deployment

NCNN is Tencent’s open-source mobile inference framework supporting ARM NEON and Vulkan GPU acceleration.

YOLO Go Deployment Guide

Tue, 26 May 2026 00:00:00 +0000

Chapter 8: Complete YOLO Tutorial with Golang

Go language, with its high performance, low memory footprint, and native concurrency features, has become one of the preferred languages for industrial YOLO deployment. This chapter provides a comprehensive implementation guide for YOLO in the Go ecosystem.

Library	Stars	Maintenance Status	Use Case	Recommendation
onnxruntime-go	⭐ 1.2k	Active	ONNX model inference, CPU/GPU acceleration	⭐⭐⭐⭐⭐
gocv	⭐ 5.8k	Active	OpenCV bindings, image processing + DNN inference	⭐⭐⭐⭐⭐
yolo-go	⭐ 800+	Active	Pre-packaged YOLO detection library, out-of-the-box	⭐⭐⭐⭐
go-yolo	⭐ 300+	Maintained	Darknet CGO bindings	⭐⭐⭐
gorgonia	⭐ 4.9k	Active	Pure Go computational graph, custom networks	⭐⭐⭐

Core Feature Comparison:

YOLO Rust Deployment Guide

Fri, 29 May 2026 00:00:00 +0000

Chapter 9: Complete YOLO Tutorial with Rust

With its three core characteristics of memory safety, zero-cost abstractions, and extreme performance, Rust has become the ultimate choice for production-grade YOLO deployment. In edge computing and high-concurrency scenarios, Rust’s performance advantages are particularly significant.

Library Name	Crates.io	Maintenance Status	Use Cases	Recommendation Index
ort (onnxruntime-rs)	v2.0.0	Super Active	Official ONNX binding, full platform support	⭐⭐⭐⭐⭐
ultralytics-inference	v0.0.11	Official Maintenance	Official Ultralytics Rust library	⭐⭐⭐⭐⭐
tract	v0.21.0	Active	Pure Rust inference engine, no external dependencies	⭐⭐⭐⭐
opencv-rust	v0.94.0	Active	OpenCV binding, DNN + image processing	⭐⭐⭐⭐
tch-rs	v0.15.0	Active	LibTorch binding, PyTorch models	⭐⭐⭐
candle	v0.6.0	Super Active	HuggingFace pure Rust ML framework	⭐⭐⭐⭐

Core Features Comparison:

Model Deployment on Mi&Bee Blog