Export for Deployment

Worked Example: Export to ONNX#

yolo export model=runs/detect/pills_v1/weights/best.pt format=onnx

PyTorch: starting from 'runs/detect/pills_v1/weights/best.pt' with input shape (1, 3, 320, 320) BCHW and output shape(s) (1, 5, 2100) (5.2 MB)
ONNX: export success ✅ 0.9s, saved as 'runs/detect/pills_v1/weights/best.onnx' (9.3 MB)
Predict:         yolo predict task=detect model=runs/detect/pills_v1/weights/best.onnx imgsz=320
Validate:        yolo val task=detect model=runs/detect/pills_v1/weights/best.onnx imgsz=320 data=my_dataset/data.yaml

Line by line:

• input shape (1, 3, 320, 320): one image, 3 color channels, a fixed 320×320 square — the training imgsz, baked into the file.
• output shape(s) (1, 5, 2100): 4 box values plus 1 class score for 2,100 candidate boxes; NMS runs outside the graph by default.
• 9.3 MB: the ONNX file stores FP32 weights, so it's larger than the FP16 .pt.
• Predict: / Validate:: ready-made commands for the exported file, already at the right imgsz.

A few arguments cover most needs; the ONNX integration guide lists the rest.

Worked Example: Prove the Export Matches#

The YOLO class loads exported files too, so the predict code from earlier works unchanged. Compare both files on the same validation image:

from ultralytics import YOLO

image = "my_dataset/images/val/Frame_144.jpg"
pt = YOLO("runs/detect/pills_v1/weights/best.pt")(image, rect=False, verbose=False)[0]  # square input, like ONNX
onnx = YOLO("runs/detect/pills_v1/weights/best.onnx")(image, verbose=False)[0]

print(f"pt:   {len(pt.boxes)} pills, mean conf {pt.boxes.conf.mean():.3f}")
print(f"onnx: {len(onnx.boxes)} pills, mean conf {onnx.boxes.conf.mean():.3f}")
print(f"max box difference: {(pt.boxes.xyxy - onnx.boxes.xyxy).abs().max():.4f} px")

pt:   25 pills, mean conf 0.870
onnx: 25 pills, mean conf 0.870
max box difference: 0.0002 px

Same count, same confidence, boxes identical to a fraction of a pixel. Now the stronger check, validation over the whole split:

from ultralytics import YOLO

pt = YOLO("runs/detect/pills_v1/weights/best.pt").val(data="my_dataset/data.yaml", rect=False, verbose=False)
onnx = YOLO("runs/detect/pills_v1/weights/best.onnx").val(data="my_dataset/data.yaml", verbose=False)
print(f".pt   mAP50-95 {pt.box.map:.4f}")
print(f".onnx mAP50-95 {onnx.box.map:.4f}")

.pt   mAP50-95 0.6570
.onnx mAP50-95 0.6570

Identical. (The .pt file's default rectangular validation scored 0.659: a small difference from input padding, not from the export.)

Once it matches, time it with yolo benchmark on the target device so you know its real speed before you ship.

Pick a Format for Your Target#

from ultralytics import YOLO

model = YOLO("runs/detect/pills_v1/weights/best.pt")

model.export(format="onnx")  # cross-platform: ONNX Runtime
model.export(format="openvino")  # Intel CPU / iGPU
model.export(format="engine", quantize=16)  # NVIDIA TensorRT, FP16 (run on the target GPU)
model.export(format="coreml")  # Apple iOS / macOS
model.export(format="litert", quantize=8, data="my_dataset/data.yaml")  # Android / edge, INT8
model.export(format="qnn", name="73", data="my_dataset/data.yaml")  # Qualcomm Snapdragon NPU (HTP v73); calibrate on your own data

Each export writes next to the weights: best.onnx, best_openvino_model/, best.engine, and so on. Start with ONNX even if you'll end up elsewhere: it's the quickest to verify and the input to several other toolchains. The deployment options guide compares every format, and Choose a Deployment Target walks through the decision.

Model quantization trades precision for size and speed. FP16 (quantize=16) halves the file with accuracy almost unchanged. INT8 (quantize=8) is smaller and faster again but needs calibration images — representative frames the export runs through to choose value ranges; Ultralytics recommends at least 300. Always validate an INT8 model before shipping: the loss can be negligible or large depending on the model and calibration set.

Avoid These Mistakes#

You've Shipped#

You now have a trained best.pt, validation evidence next to a baseline, an exported file for your runtime, and proof that the export matches the original. That's the full loop — data, train, validate, export, deploy — and production teams run it on a schedule. Ultralytics YOLO in Production picks up from your verified export and covers optimized runtimes, tracking pipelines, multi-stream serving, and monitoring.