Bắt đầu

Xuất model bằng Ultralytics YOLO

Ultralytics YOLO ecosystem and integrations

Giới thiệu#

Mục tiêu của việc huấn luyện model thường là triển khai model trong các ứng dụng thực tế. Chế độ Export trong Ultralytics YOLO26 chuyển đổi model đã huấn luyện sang nhiều định dạng để model có thể chạy trên các nền tảng và thiết bị khác nhau. Hướng dẫn này trình bày cách sử dụng chế độ Export, các đối số, định dạng được hỗ trợ và tùy chọn lượng tử hóa.

Xem bản xem trước YOLO27 chưa phát hành để biết các định dạng xuất dự kiến được hỗ trợ.



Xem: Cách xuất Ultralytics YOLO26 sang nhiều định dạng để triển khai | ONNX, TensorRT, CoreML 🚀

Vì sao nên chọn Export Mode của YOLO26?#

  • Tính linh hoạt: Xuất sang nhiều định dạng, bao gồm ONNX, TensorRT, CoreML và nhiều định dạng khác.
  • Hiệu suất: Tăng tốc GPU lên đến 5 lần với TensorRT và tăng tốc CPU lên đến 3 lần với ONNX hoặc OpenVINO.
  • Tương thích: Triển khai model trên nhiều môi trường phần cứng và phần mềm.
  • Dễ sử dụng: Export chỉ bằng một lệnh CLI hoặc lời gọi Python.

Ví dụ sử dụng#

Export model YOLO26n sang định dạng khác như ONNX hoặc TensorRT.

Ví dụ
from ultralytics import YOLO

# Tải model
model = YOLO("yolo26n.pt")  # tải model chính thức
model = YOLO("path/to/best.pt")  # # Tải model được huấn luyện tùy chỉnh

# # Xuất model
model.export(format="onnx")

Đối số#

Bảng này liệt kê các đối số có thể dùng để export model YOLO sang nhiều định dạng khác nhau. Các đối số này kiểm soát hiệu năng, kích thước của model được export và khả năng tương thích với nền tảng cũng như môi trường đích.

Đối sốKiểuMặc địnhMô tả
formatstr'torchscript'Định dạng đích cho model được export, chẳng hạn 'onnx', 'torchscript', 'engine' (TensorRT) hoặc định dạng khác. Mỗi định dạng cho phép tương thích với các môi trường triển khai khác nhau.
namestrNoneTên mục tiêu phần cứng cho các format yêu cầu tên mục tiêu: kiến trúc Hailo ('hailo8', 'hailo8l', 'hailo10h', 'hailo15h', 'hailo15l'; mặc định là 'hailo8l'), chip Rockchip RKNN (mặc định là 'rk3588'), SoC Huawei Ascend (một --soc_version CANN; mặc định là 'Ascend310B4'), mục tiêu Qualcomm QNN HTP (mặc định là '73'), hoặc thiết bị AMD Xilinx Versal AI Edge Series Gen 2 (mặc định là 've2-xc2ve3858', bộ kit đánh giá VEK385). Khác với cặp đặt tên lần chạy project/name được các mode khác sử dụng.
imgszint hoặc tuple640Kích thước ảnh đầu vào của model. Có thể là số nguyên đối với ảnh vuông (ví dụ: 640 cho 640×640) hoặc tuple (height, width) để chỉ định kích thước cụ thể. Nếu không truyền giá trị, quá trình export sẽ dùng lại kích thước huấn luyện được ghi trong checkpoint đã tải: các checkpoint YOLO26 chính thức ghi 1024 cho model semantic được pretrained trên Cityscapes (yolo26n-sem.pt), 768 cho depth, 224 cho classify, 1024 cho OBB và 640 cho các tác vụ khác, bao gồm model semantic được pretrained trên ADE20K (yolo26n-sem-ade20k.pt), trong khi một model fine-tune ghi bất kỳ imgsz nào mà model được huấn luyện với. Model được tạo từ YAML không có kích thước huấn luyện được ghi lại và sử dụng 640.
optimizeboolFalseBật tối ưu hóa trình biên dịch nâng cao cho DEEPX, giảm độ trễ suy luận nhưng tăng thời gian biên dịch.
quantizeint hoặc strNoneĐộ chính xác lượng tử hóa: 16 (FP16, giảm kích thước model và có thể tăng tốc suy luận trên phần cứng được hỗ trợ) hoặc 8 (INT8/PTQ, nén model thêm với mức mất độ chính xác tối thiểu, chủ yếu dành cho thiết bị biên; cần data/fraction để hiệu chuẩn); 32 chọn FP32 nếu được hỗ trợ; nếu không đặt, sẽ dùng FP32 trừ khi thiết bị đích yêu cầu lượng tử hóa, chẳng hạn INT8 cho NXP. Checkpoint được huấn luyện với quantize=8 luôn xuất ra INT8: onnx và engine xuất từ các dải giá trị có sẵn mà không cần hiệu chuẩn, còn các định dạng hoặc độ chính xác khác sẽ bị từ chối. 'w8a8' và 'w16a16' là bí danh của 8 và 16; các độ chính xác hỗn hợp 'w8a16' (trọng số INT8 với activation 16-bit: CoreML, LiteRT, QNN) và 'w8a32' (INT8 động: LiteRT) chỉ được các định dạng tương ứng chấp nhận. Thay thế các cờ half/int8 đã lỗi thời (half=True → 16, int8=True → 8, vẫn được chấp nhận kèm cảnh báo lỗi thời). Chỉ cho phép các độ chính xác được định dạng đích hỗ trợ (xem bên dưới).
dynamicboolFalseCho phép kích thước đầu vào động khi export TorchScript, ONNX, OpenVINO, TensorRT, CoreML và MNN, tăng tính linh hoạt khi xử lý ảnh có kích thước khác nhau.
simplifyboolTrueĐơn giản hóa đồ thị ONNX trung gian bằng onnxslim cho các định dạng export có tạo đồ thị này (xem Các định dạng Export), có thể cải thiện hiệu năng và khả năng tương thích với các engine suy luận.
opsetintNoneChỉ định phiên bản ONNX opset cho các định dạng export tạo đồ thị ONNX (xem Các định dạng Export), nhằm đảm bảo tương thích với nhiều parser và runtime ONNX. Nếu không được thiết lập, phiên bản opset 18 sẽ được sử dụng (thấp hơn trên PyTorch < 2.4), tối đa bằng phiên bản onnx đã cài đặt. Các định dạng export RKNN, Ascend, AMD Xilinx, Hailo và RT-DETR TensorFlow tự thiết lập opset riêng.
workspacefloat hoặc NoneNoneĐặt kích thước workspace tối đa tính bằng GiB cho các tối ưu hóa TensorRT, cân bằng mức sử dụng bộ nhớ và hiệu năng. Dùng None để TensorRT tự động cấp phát tối đa theo giới hạn của thiết bị.
nmsbool, không bắt buộcNoneNone xuất các dự đoán one-to-many thô để thực hiện NMS bên ngoài (YOLO26 vẫn giữ head không cần NMS trên Axelera); True tích hợp NMS ở những nơi được hỗ trợ; False chọn head không cần NMS khi có. NMS tích hợp của CoreML hỗ trợ detect, segment và pose với shape tĩnh. Xem hướng dẫn Phát hiện End-to-End.
conffloatNoneNgưỡng confidence được dùng ở mọi nơi tạo NMS trong quá trình export: các định dạng export nms=True; định dạng export detect không đầu-cuối của Hailo; và định dạng export detect, pose, segment của IMX, vốn buộc dùng nms=True nội bộ. Mặc định là 0.25 nếu không đặt.
ioufloat0.5Ngưỡng IoU được dùng ở mọi nơi tạo NMS trong quá trình export: các định dạng export nms=True; định dạng export detect không đầu-cuối của Hailo; và định dạng export detect, pose, segment của IMX, vốn buộc dùng nms=True nội bộ.
max_detint300Số lượng detection tối đa được giữ lại trong đầu ra của model đã export. Áp dụng cho các định dạng export nms=True trên mọi định dạng, ngoại trừ detection CoreML có pipeline NMS gốc không giới hạn số detection, cùng với các định dạng export detection đầu-cuối không dùng NMS (YOLO26, YOLOv10, giới hạn theo số anchor hiện có) và các định dạng export detect, pose, segment của IMX.
agnostic_nmsboolFalseBật NMS không phụ thuộc class ở mọi nơi tạo NMS trong quá trình export thông qua pipeline nms=True tiêu chuẩn, bao gồm cả giai đoạn NMS riêng của CoreML; tùy chọn này loại bỏ các box chồng lấp có điểm thấp hơn giữa các class khác nhau thay vì chỉ trong cùng một class. Không áp dụng với cấu hình NMS được tạo riêng của Hailo hoặc IMX; các cấu hình này không có tùy chọn không phụ thuộc class và vẫn xét class bất kể flag này. Tùy chọn này cũng được tích hợp sẵn trong các định dạng export đầu-cuối không dùng NMS (YOLO26, YOLOv10), tại đó nó chỉ ngăn cùng một detection xuất hiện dưới nhiều nhãn class (các bản trùng IoU=1.0), chứ không loại bỏ các box riêng biệt dựa trên ngưỡng IoU.
batchint1Chỉ định kích thước batch suy luận của model đã export hoặc số lượng ảnh tối đa mà model đã export xử lý đồng thời ở chế độ predict. Các định dạng không có batch trong các tham số export sẽ export với batch 1 và từ chối các giá trị khác.
devicestrNoneChỉ định thiết bị dùng để export: GPU (device=0), CPU (device=cpu), MPS cho Apple silicon (device=mps), Huawei Ascend NPU (device=npu hoặc device=npu:0), hoặc DLA cho NVIDIA Jetson (device=dla:0 hoặc device=dla:1). Export TensorRT tự động sử dụng GPU, nhưng TensorRT 11 không hỗ trợ DLA. Export OpenVINO INT8 với device=npu được tối ưu cho NPU Intel.
verboseboolFalseTăng mức độ nhật ký của TensorRT builder lên VERBOSE trong quá trình export format='engine'. Các định dạng export khác bỏ qua tùy chọn này.
datastrNoneHiệu chuẩn dataset: đường dẫn YAML (không phải phân loại), đường dẫn hoặc URL NDJSON, URI dataset của Platform (ul://owner/datasets/name) hoặc URL web. Dataset của Platform yêu cầu API key và Python 3.11+. Với tác vụ phân loại, bạn cũng có thể dùng thư mục dataset hoặc tên dataset tích hợp sẵn. Nếu không được chỉ định khi bật INT8, Ultralytics sẽ chọn dataset hiệu chuẩn phù hợp với tác vụ khi cần, hoặc dùng dataset mặc định cho tác vụ của model. Checkpoint được huấn luyện bằng quantize=8 có sẵn các dải INT8 riêng và không cần dữ liệu hiệu chuẩn.
splitstr'val'Phần chia dataset ('train', 'val' hoặc 'test') dùng để tạo dataloader calibration lượng tử hóa INT8 từ data.
fractionfloat, int hoặc list1.0Tập con dataset dùng cho calibration INT8: tỷ lệ, số lượng ảnh hoặc các giá trị [train, val, test]. 1 có nghĩa là toàn bộ phần chia; số nguyên lớn hơn 1 là số lượng ảnh; chỉ mục test không bắt buộc mới chấp nhận 0/0.0 với nghĩa là không dùng mục nào. Danh sách hai mục sẽ giữ nguyên toàn bộ test.

Chọn định dạng và thiết lập phù hợp với môi trường triển khai, giới hạn phần cứng và mục tiêu hiệu năng để đạt được sự cân bằng tốt nhất giữa kích thước, tốc độ và độ chính xác của model.

Các định dạng xuất#

Các định dạng xuất YOLO26 hiện có được liệt kê trong bảng bên dưới. Bạn có thể xuất sang bất kỳ định dạng nào bằng đối số format, ví dụ: format='onnx' hoặc format='engine'. Bạn có thể chạy dự đoán hoặc xác thực trực tiếp trên model đã xuất, ví dụ: yolo predict model=yolo26n.onnx. Sau khi quá trình xuất hoàn tất, các ví dụ sử dụng sẽ được hiển thị cho model của bạn. Bạn cũng có thể xuất model trực tiếp từ trình duyệt trên Ultralytics Platform mà không cần thiết lập cục bộ.

Định dạngĐối số formatModelMetadataĐối số
PyTorch-yolo26n.pt✅-
TorchScripttorchscriptyolo26n.torchscript✅imgsz, quantize, dynamic, nms, batch, device
ONNXonnxyolo26n.onnx✅imgsz, quantize, dynamic, simplify, opset, nms, batch, data, fraction, device
OpenVINOopenvinoyolo26n_openvino_model/✅imgsz, quantize, dynamic, nms, batch, data, fraction, device
TensorRTengineyolo26n.engine✅imgsz, quantize, dynamic, simplify, opset, workspace, nms, batch, data, fraction, device
CoreMLcoremlyolo26n.mlpackage✅imgsz, dynamic, quantize, nms, batch, device
Apple Core AIcoreaiyolo26n.aimodel✅imgsz, batch, quantize
TF SavedModelsaved_modelyolo26n_saved_model/✅imgsz, quantize, opset, nms, batch, data, fraction, device
TF GraphDefpbyolo26n.pb❌imgsz, opset, batch, device
TF Edge TPUedgetpuyolo26n_edgetpu.tflite✅imgsz, quantize, opset, data, fraction, device
LiteRTlitertyolo26n.tflite✅imgsz, quantize, batch, data, fraction, device
PaddlePaddlepaddleyolo26n_paddle_model/✅imgsz, batch, device
MNNmnnyolo26n.mnn✅imgsz, batch, dynamic, quantize, simplify, opset, nms, device
NCNNncnnyolo26n_ncnn_model/✅imgsz, quantize, device
IMX500imxyolo11n_imx_model/✅imgsz, quantize, data, fraction, nms, device
RKNNrknnyolo26n_rknn_model/✅imgsz, batch, name, quantize, simplify, opset, data, fraction, device
ExecuTorchexecutorchyolo26n_executorch_model/✅imgsz, quantize, batch, data, fraction, device
Axeleraaxelerayolo26n_axelera_model/✅imgsz, batch, quantize, data, fraction, device
DEEPXdeepxyolo26n_deepx_model/✅imgsz, quantize, simplify, opset, data, optimize, device
Qualcomm QNNqnnyolo26n_qnn.onnx✅imgsz, batch, name, quantize, simplify, opset, data, fraction, device
Hailohailoyolo26n_hailo_model/✅imgsz, name, quantize, data, fraction, simplify, conf, iou, device
Huawei Ascendascendyolo26n_ascend_model/✅imgsz, batch, name, quantize, opset, simplify, nms, device
AMD Xilinxxilinxyolo26n_xilinx_model/✅imgsz, name, quantize, data, fraction, opset, simplify, device
NXPnxpyolo26n_nxp.tflite✅imgsz, quantize, data, fraction, device
ST Edge AIstedgeaiyolo26n_stedgeai.onnx✅imgsz, quantize, data, fraction, opset, simplify, device

nms=None mặc định xuất dữ liệu thô để thực hiện NMS bên ngoài (YOLO26 vẫn giữ head không cần NMS trên Axelera). Đặt nms=False để chọn head không cần NMS hiện có; các định dạng không được hỗ trợ sẽ chuyển về đường dẫn xuất dữ liệu gốc của định dạng đó. Các mục nms ở trên xác định những định dạng có thể tích hợp NMS bằng nms=True.

Tự động cài đặt các dependency cần thiết để xuất

Hầu hết định dạng cần các package không được cài đặt cùng với ultralytics. Khi thiếu package, quá trình xuất sẽ cài đặt package đó khi chạy bằng uv hoặc pip, và trên Linux sẽ dùng apt để cài các package hệ thống như Java cho IMX. Trình biên dịch Edge TPU được tải xuống mà không cần apt hoặc sudo. Để giữ nguyên môi trường, chẳng hạn như trong image container, CI job hoặc dịch vụ production, hãy đặt YOLO_AUTOINSTALL=False. Quá trình xuất vẫn kiểm tra và báo cáo các package còn thiếu, nhưng không thay đổi môi trường và sẽ thất bại cho đến khi các package đó được cài đặt.

export YOLO_AUTOINSTALL=False

Tùy chọn lượng tử hóa#

Dùng đối số quantize để yêu cầu độ chính xác khi xuất. Giá trị chuỗi không phân biệt chữ hoa, chữ thường; Ultralytics chuẩn hóa các alias được chấp nhận trước khi xuất:

Giá trị yêu cầuGiá trị chuẩnÝ nghĩa
8, "8", "int8", "w8a8"8Trọng số và activation INT8
16, "16", "fp16", "w16a16"16Trọng số và activation FP16
32, "32", "fp32", "w32a32"32Xuất FP32; giống như khi không thiết lập, ngoại trừ CoreML NMS ML Programs mặc định dùng FP16
"w8a16""w8a16"Trọng số INT8 với activation 16-bit (FP16; INT16 trên LiteRT)
"w8a32""w8a32"Trọng số INT8 với activation FP32 (INT8 động của LiteRT, không cần hiệu chuẩn)

Các flag cũ half=True và int8=True vẫn được chấp nhận kèm cảnh báo ngừng hỗ trợ và chuyển tiếp sang quantize=16 và quantize=8.

Không phải định dạng xuất nào cũng hỗ trợ mọi độ chính xác. Các yêu cầu rõ ràng về quantize sẽ tạo ra độ chính xác đó hoặc thất bại trước khi xuất:

Định dạngFP32 (32/không thiết lập)FP16 (16)INT8 (8)W8A16 ("w8a16")Ghi chú
PyTorch✅Không áp dụngKhông áp dụngKhông áp dụngĐịnh dạng huấn luyện/checkpoint gốc.
TorchScript✅✅ Chỉ GPU❌❌Xuất TorchScript FP16 yêu cầu device=0; xuất trên CPU sẽ dùng FP32.
ONNX✅✅✅❌INT8 sử dụng lượng tử hóa tĩnh của ONNX Runtime và dữ liệu hiệu chuẩn.
OpenVINO✅✅✅❌INT8 sử dụng lượng tử hóa sau huấn luyện của NNCF.
TensorRT✅✅✅❌INT8 cần dữ liệu hiệu chuẩn đại diện.
CoreML✅¹✅✅✅INT8 của CoreML là lượng tử hóa trọng số; W8A16 sử dụng trọng số INT8 với activation FP16. ¹ NMS ML Programs khi không thiết lập mặc định dùng FP16, và các model segment/pose được xuất bằng nms=True luôn dùng FP16.
Core AI✅✅❌❌Mặc định dùng FP32 hoặc dùng tài sản FP16 .aimodel với quantize=16; không có quy trình INT8.
TF SavedModel✅❌✅❌Các file INT8 được lưu trong .tflite bên cạnh SavedModel FP32.
TF GraphDef✅❌❌❌Không chuyển đổi độ chính xác trong quá trình xuất.
Edge TPU❌❌✅ tự động❌Edge TPU yêu cầu INT8; tính năng này được bật tự động khi không thiết lập.
LiteRT✅❌✅✅INT8 tĩnh (8) và "w8a16" (trọng số int8 + activation int16) sử dụng dữ liệu hiệu chuẩn; đồng thời hỗ trợ INT8 động "w8a32" (không cần hiệu chuẩn). quantize=16 không phải là một định dạng xuất riêng; model FP32 chạy ở FP16 trong thời gian thực thi thông qua GPU delegate.
PaddlePaddle✅❌❌❌Không chuyển đổi độ chính xác trong quá trình xuất.
MNN✅✅✅❌INT8 là lượng tử hóa trọng số thông qua quá trình chuyển đổi MNN.
NCNN✅✅❌❌Định dạng runtime cho thiết bị di động/nhúng.
IMX500❌❌✅ tự động❌IMX500 yêu cầu lượng tử hóa; INT8 được bật tự động khi không thiết lập.
RKNN❌✅ tùy thuộc vào chip✅❌RK3588/RK3576/RK3566/RK3568/RK3562/RK2118/RV1126B hỗ trợ FP16 hoặc INT8; các biến thể RV1103/RV1106 chỉ hỗ trợ INT8.
ExecuTorch✅❌✅❌INT8 tĩnh (8) sử dụng dữ liệu hiệu chuẩn và giữ head detect, segment, pose và OBB ở FP32.
Axelera❌❌✅ tự động❌Xuất Axelera yêu cầu INT8; tính năng này được bật tự động khi không thiết lập.
DEEPX❌❌✅ tự động❌Xuất DEEPX yêu cầu INT8; tính năng này được bật tự động khi không thiết lập.
Qualcomm QNN❌❌❌✅ tự độngXuất QNN HTP cố định ở trọng số INT8 với activation 16-bit.
Hailo❌❌✅ tự động❌Xuất Hailo yêu cầu INT8; tính năng này được bật tự động khi không thiết lập.
Huawei Ascend❌✅ tự động❌❌Các phép tích chập của Ascend AI Core chỉ nhận đầu vào FP16/INT8, vì vậy ATC biên dịch sang FP16; tính năng này được bật tự động khi không thiết lập.
AMD Xilinx❌❌✅ tự động❌AMD Xilinx yêu cầu Vitis AI INT8 khi export (VINT8); tùy chọn này sẽ tự động được bật nếu chưa được thiết lập.
NXP❌❌✅ tự động❌Xuất NXP i.MX95 yêu cầu INT8 với Neutron SDK 3.3.0; tùy chọn này tự động được bật nếu không được đặt.
ST Edge AI✅❌✅❌INT8 lượng tử hóa toàn bộ graph theo định dạng ONNX Runtime QDQ; đầu ra box và keypoint được chuẩn hóa về [0, 1] để head cũng được lượng tử hóa.

Đối với xuất INT8 và W8A16, hãy cung cấp dữ liệu hiệu chuẩn đại diện bằng data, chẳng hạn như data="coco8.yaml", trừ khi tài liệu về tích hợp mục tiêu nêu rõ hành vi mặc định hoặc tự động bật. Phương pháp "w8a32" (INT8 động) của LiteRT không cần dữ liệu hiệu chuẩn.

Huấn luyện nhận biết lượng tử hóa#

Các bản export INT8 ở trên sử dụng lượng tử hóa sau huấn luyện (PTQ): các khoảng giá trị được quan sát trong một lượt hiệu chỉnh duy nhất trên data. Ngược lại, huấn luyện nhận biết lượng tử hóa (QAT) học các trọng số có khả năng chịu được INT8 bằng cách tinh chỉnh với lượng tử hóa giả trong vòng lặp, qua đó khôi phục phần độ chính xác mà quá trình hiệu chỉnh đơn thuần làm mất. Truyền quantize=8 cho train để tinh chỉnh checkpoint đã huấn luyện trước, sau đó export như thông thường:

Ví dụ
from ultralytics import YOLO

model = YOLO("yolo26n.pt")
model.train(
    data="coco.yaml",
    quantize=8,
    epochs=5,
    batch=64,
    optimizer="AdamW",
    lr0=0.00001,
    lrf=0.1,
    warmup_epochs=0.5,
    cos_lr=True,
    mosaic=0.0,
)
model.export(format="engine", quantize=8)  # các khoảng giá trị được lưu cùng checkpoint, không cần dữ liệu hiệu chuẩn

Hãy dùng learning rate nhỏ khi fine-tune checkpoint đã huấn luyện trước. QAT ban đầu có thể làm giảm độ chính xác, và lợi ích so với lượng tử hóa sau huấn luyện phụ thuộc vào model, dataset và ngân sách huấn luyện. Xác thực model đã xuất bằng cách so sánh với cả checkpoint gốc lẫn bản xuất đã lượng tử hóa sau huấn luyện; điểm số lượng tử hóa giả trong quá trình huấn luyện không chứng minh được độ chính xác khi triển khai.

Mức lợi ích của QAT phụ thuộc vào hiệu quả hiệu chuẩn tích hợp của backend xuất đối với model. Các giá trị dưới đây là mAP50-95 trên COCO val2017, được đo bằng các engine TensorRT 10.16 tại imgsz=640 và batch 1, trong đó mỗi checkpoint QAT được huấn luyện với epochs=20 patience=3:

ModelEngine FP32Engine PTQ INT8Engine QAT INT8
yolo26n0.40320.39340.3935
yolo26s0.47940.44120.4711
yolo26m0.52690.46960.5137
yolo26l0.54400.48890.5307
yolo26x0.57010.51380.5527

QAT làm giảm 0.008 đến 0.017 mAP50-95 so với FP32 trên toàn dải, trong khi lượng tử hóa sau huấn luyện làm giảm 0.010 trên yolo26n và 0.038 đến 0.057 trên các model lớn hơn. Vì vậy, QAT hầu như không mang lại lợi ích cho model nhỏ nhất, nơi hiệu chuẩn vốn đã hoạt động tốt, nhưng giúp tăng 0.030 đến 0.044 ở các model còn lại. Các con số có thể khác trên tập dữ liệu, định dạng xuất hoặc phiên bản TensorRT khác; hãy tự đo lường.

Model QAT yêu cầu compile=False; các module đã lượng tử hóa của ModelOpt không hỗ trợ torch.compile.

Các lớp đầu ra của head, tức các convolution và linear thuần nằm ngoài các khối Conv, được cố ý giữ ở định dạng float để hạn chế suy giảm độ chính xác INT8; TensorRT bật độ chính xác hỗn hợp FP16 cho các lớp chưa được lượng tử hóa. QAT được thực hiện thông qua NVIDIA TensorRT Model Optimizer, được cài đặt tự động trong lần sử dụng đầu tiên, và cần cài đặt công cụ này để tải checkpoint được tạo ra. Các dải giá trị đó đi kèm checkpoint, còn các bản xuất onnx và engine tạo chúng dưới dạng các node Q/DQ; các định dạng khác đọc dữ liệu hiệu chuẩn thay thế và từ chối checkpoint QAT.

Tiếp theo là gì#

Tìm hướng dẫn tích hợp cho mục tiêu triển khai của bạn — có ONNX, TensorRT, CoreML và nhiều định dạng khác trong danh sách tích hợp đầy đủ — để biết cách chạy model đã xuất.

Câu hỏi thường gặp#

  • Export model YOLO26 sang ONNX bằng Python API hoặc CLI:

    Ví dụ
    from ultralytics import YOLO
    
    # Tải model
    model = YOLO("yolo26n.pt")  # tải model chính thức
    model = YOLO("path/to/best.pt")  # # Tải model được huấn luyện tùy chỉnh
    
    # # Xuất model
    model.export(format="onnx")

    Để biết thêm chi tiết về quy trình, bao gồm các tùy chọn nâng cao như xử lý nhiều kích thước đầu vào khác nhau, hãy tham khảo hướng dẫn tích hợp ONNX.

  • Sử dụng TensorRT để export model giúp cải thiện đáng kể hiệu năng trên GPU NVIDIA. Model YOLO26 được export sang TensorRT có thể đạt tốc độ GPU nhanh hơn tới 5 lần, khiến TensorRT phù hợp với các ứng dụng inference thời gian thực.

    • Tính linh hoạt: Tối ưu hóa model cho cấu hình phần cứng cụ thể.
    • Tốc độ: Tăng tốc suy luận nhờ các phương pháp tối ưu hóa tiên tiến.
    • Khả năng tương thích: Tích hợp liền mạch với phần cứng NVIDIA.

    Để tìm hiểu thêm về tích hợp TensorRT, hãy xem hướng dẫn tích hợp TensorRT.

  • Lượng tử hóa INT8 giúp nén model và tăng tốc inference, đặc biệt trên thiết bị biên. Bật tính năng này bằng quantize=8:

    Ví dụ
    from ultralytics import YOLO
    
    model = YOLO("yolo26n.pt")  # Tải model
    model.export(format="onnx", quantize=8, data="coco8.yaml")

    Có thể áp dụng lượng tử hóa INT8 cho các format như ONNX, TensorRT, OpenVINO, CoreML, Rockchip RKNN và AMD Xilinx. Để đạt kết quả lượng tử hóa tối ưu, hãy cung cấp một dataset đại diện bằng tham số data. Xem Tùy chọn lượng tử hóa để biết các giá trị quantize được chấp nhận và các format được hỗ trợ.

  • Kích thước đầu vào động cho phép model được export xử lý các kích thước ảnh khác nhau, tạo sự linh hoạt và tối ưu hiệu quả xử lý cho nhiều trường hợp sử dụng. Khi export sang các định dạng như ONNX hoặc TensorRT, bật kích thước đầu vào động cho phép model chấp nhận các shape đầu vào khác nhau.

    Để bật tính năng này, hãy sử dụng flag dynamic=True trong quá trình xuất:

    Ví dụ
    from ultralytics import YOLO
    
    model = YOLO("yolo26n.pt")
    model.export(format="onnx", dynamic=True)

    Đặt kích thước đầu vào động đặc biệt hữu ích cho các ứng dụng có thể nhận đầu vào với kích thước thay đổi, chẳng hạn như xử lý video hoặc xử lý ảnh từ các nguồn khác nhau.

    Bản export động được tải bằng YOLO() sẽ dự đoán và xác thực ở kích thước export imgsz (cạnh dài hơn của bản export không vuông), trong khi model PyTorch sử dụng imgsz khi huấn luyện. Truyền imgsz để chạy model ở kích thước khác.

  • Model PyTorch và các bản xuất động mặc định sử dụng padding hình chữ nhật tối thiểu, trong khi các bản xuất tĩnh đệm đến hết imgsz, vì vậy các detection gần ngưỡng confidence có thể khác nhau. Dùng rect=False để suy luận gốc nhằm khớp với bản xuất tĩnh, hoặc xuất bằng dynamic=True nếu được hỗ trợ.

  • Các đối số export sau có tác động lớn nhất đến hiệu năng model:

    • format: Định dạng đích của model đã xuất (ví dụ: onnx, torchscript, saved_model).
    • imgsz: Kích thước ảnh mong muốn cho đầu vào của model (ví dụ: 640 hoặc (height, width)).
    • quantize: Độ chính xác lượng tử hóa, chẳng hạn như 8/"int8", 16/"fp16", 32/"fp32", hoặc các phương pháp kết hợp trọng số/activation "w8a16" và "w8a32" (INT8 động của LiteRT) trên các định dạng được hỗ trợ. Xem Tùy chọn lượng tử hóa.
    • dynamic: Chấp nhận kích thước đầu vào thay đổi trên các định dạng hỗ trợ dynamic shape, chẳng hạn như ONNX, OpenVINO và TensorRT.
    • nms: Chọn dữ liệu thô để thực hiện NMS bên ngoài (None; YOLO26 vẫn giữ head không cần NMS trên Axelera), NMS tích hợp (True) hoặc head không cần NMS (False).
    • device: Thiết bị dùng để trace model trong quá trình xuất, chẳng hạn như cpu hoặc 0 cho GPU CUDA đầu tiên; TorchScript FP16 yêu cầu GPU.

    Để triển khai trên các nền tảng phần cứng cụ thể, hãy cân nhắc sử dụng các định dạng xuất chuyên biệt như TensorRT cho GPU NVIDIA, CoreML cho thiết bị Apple hoặc Edge TPU cho thiết bị Google Coral.

  • Khi xuất model YOLO sang các định dạng như ONNX hoặc TensorRT, cấu trúc tensor đầu ra phụ thuộc vào tác vụ của model. Việc hiểu rõ các đầu ra này rất quan trọng khi triển khai suy luận tùy chỉnh.

    Đối với model phát hiện YOLO26 (ví dụ: yolo26n.pt) được xuất bằng nms=False, các định dạng được hỗ trợ tạo ra đầu ra không dùng NMS có hình dạng như (batch_size, max_detections, 6) với các giá trị [x1, y1, x2, y2, confidence, class_id]. Với max_det=300 mặc định, đầu ra thường là (batch_size, 300, 6). Một số định dạng bị giới hạn sẽ tự động chuyển về bố cục đầu ra truyền thống khi không hỗ trợ các toán tử end-to-end.

    Theo mặc định (nms=None), các model phát hiện, bao gồm YOLO26, xuất các dự đoán one-to-many thô (YOLO26 vẫn giữ head không cần NMS trên Axelera). Đầu ra thường là một tensor duy nhất có shape như (batch_size, 4 + num_classes, num_predictions), trong đó các kênh biểu thị tọa độ hộp cùng điểm số theo từng lớp, còn num_predictions phụ thuộc vào độ phân giải đầu vào khi export (và có thể là dynamic). Hướng dẫn Phát hiện End-to-End trình bày những định dạng giữ nguyên đầu ra end-to-end.

    Đối với model phân đoạn (ví dụ: yolo26n-seg.pt), thông thường sẽ có hai đầu ra: tensor đầu tiên có hình dạng như (batch_size, 4 + num_classes + mask_dim, num_predictions) (hộp, điểm số lớp và hệ số mask), còn tensor thứ hai có hình dạng như (batch_size, mask_dim, proto_h, proto_w), chứa các prototype mask được dùng cùng với các hệ số để tạo mask cho từng instance. Kích thước phụ thuộc vào độ phân giải đầu vào khi xuất (và có thể động).

    Đối với model pose (ví dụ: yolo26n-pose.pt), tensor đầu ra thường có hình dạng như (batch_size, 4 + num_classes + keypoint_dims, num_predictions), trong đó keypoint_dims phụ thuộc vào đặc tả pose (ví dụ: số lượng keypoint và việc có bao gồm độ tin cậy hay không), còn num_predictions phụ thuộc vào độ phân giải đầu vào khi xuất (và có thể động).

    Các ví dụ trong ví dụ suy luận ONNX minh họa cách xử lý những đầu ra này cho từng loại model.

  • Hiện Ultralytics chưa cung cấp API suy luận C++ chuyên biệt cho các model YOLO. Để triển khai bằng C++, hãy xuất model sang định dạng runtime như ONNX, TensorRT, TorchScript hoặc MNN, sau đó nạp artifact đã xuất bằng API C++ gốc của runtime đó.

    Ví dụ: xuất model phát hiện bằng yolo export model=yolo26n.pt format=onnx rồi chạy tệp .onnx bằng ONNX Runtime C++, hoặc xuất bằng format=engine rồi chạy engine TensorRT từ ứng dụng TensorRT C++. Khi sử dụng hậu xử lý C++ tùy chỉnh, hãy khớp bố cục tensor đầu ra với tác vụ và cài đặt xuất; các bản xuất phát hiện YOLO26 mặc định trả về tensor dự đoán thô cần NMS bên ngoài. Xuất bằng nms=False để có đầu ra phát hiện không dùng NMS với hình dạng (batch, max_det, 6), hoặc dùng nms=True để tích hợp NMS vào các định dạng được hỗ trợ.

  • Khi xuất bằng quantize=16 (FP16) hoặc quantize=8 (INT8), phần lớn tensor được chuyển sang độ chính xác thấp hơn để giảm kích thước model và cải thiện hiệu năng. Tuy nhiên, khi bật nms=False, bước hậu xử lý (bao gồm chỉ số lớp) được tích hợp trực tiếp vào graph đã xuất.

    Tensor output0 chứa chỉ số lớp, vốn được biểu diễn nội bộ dưới dạng giá trị dấu phẩy động. Do độ chính xác phần định trị hạn chế, FP16 không thể biểu diễn đáng tin cậy các giá trị số nguyên lớn hơn 2048. Để tránh nguy cơ mất độ chính xác hoặc sai ID lớp, output0 được giữ ở định dạng FP32.

    Nếu cần đầu ra hoàn toàn ở FP16, hãy xuất bằng nms=None trên GPU và thực hiện hậu xử lý bên ngoài. Các bản xuất ONNX FP16 trên CPU vẫn giữ đầu vào và đầu ra FP32, chỉ chuyển đổi graph nội bộ.

Bình luận447

Đặt câu hỏi, chia sẻ kết quả hoặc giúp đỡ người khác.

  1. yubaobao-GPUGitHub

    你好,请问为什么我转onnx的时候会显示end2end参数非法 (ywh_26) root@ai-avcon:/data/ywh_folder/yolo/yolo26# python to_onnx.py WARNING ⚠️ Ultralytics settings reset to default values. This may be due to a possible problem with your settings or a recent ultralytics package update. View Ultralytics Settings with 'yolo settings' or at '/root/.config/Ultralytics/settings.json' Update Settings with 'yolo settings key=value', i.e. 'yolo settings runs_dir=path/to/dir'. For help see https://docs.ultralytics.com/quickstart/#ultralytics-settings. Traceback (most recent call last): File "/data/ywh_folder/yolo/yolo26/to_onnx.py", line 12, in model.export( File "/data/ywh_folder/yolo/yolo26/ultralytics/engine/model.py", line 710, in export return Exporter(overrides=args, _callbacks=self.callbacks)(model=self.model) File "/data/ywh_folder/yolo/yolo26/ultralytics/engine/exporter.py", line 312, in init self.args = get_cfg(cfg, overrides) File "/data/ywh_folder/yolo/yolo26/ultralytics/cfg/init.py", line 308, in get_cfg check_dict_alignment(cfg, overrides) File "/data/ywh_folder/yolo/yolo26/ultralytics/cfg/init.py", line 505, in check_dict_alignment raise SyntaxError(string + CLI_HELP_MSG) from e SyntaxError: 'end2end' is not a valid YOLO argument.

    我是用的8.4.6版本的ultralytics

    1
    1. Glenn JocherUltralytics

      ultralytics==8.4.6 还不支持 end2end 这个导出参数(它是给支持 NMS-free 的新模型/新版本用的),所以你这边要么把 model.export() 里的 end2end=... 去掉,要么升级到最新 Ultralytics;另外你的报错路径显示实际导入的是本地仓库 .../yolo26/ultralytics,建议先跑一次 yolo checks 并把文本输出贴上来确认是否存在多套安装/路径冲突(参数列表可参考 Model.export() 参考文档)。

      pip install -U ultralytics
      yolo checks
  2. qcnameGitHub

    您好,使用.pt和导出为.onnx进行yolov8模型的图片中目标检测时,参数设置一致,但是最终检测框数量,位置不完全一致。比如.onnx比.pt多画一个或者检测到.pt检测不出来的类别,请问是什么问题导致的呢?

    1
    1. Paula DerrengerUltralytics

      @nacenace 您好,

      感谢您提出这个问题!在导出模型时遇到检测结果不一致的情况确实令人困惑。以下是一些可能的原因和解决方法:

      1. 版本一致性:请确保您使用的是最新版本的 torch 和 ultralytics。您可以通过以下命令进行升级:

        pip install --upgrade torch ultralytics
      2. 模型导出参数:导出为 ONNX 时,某些参数可能会影响模型的行为。请确保在导出时使用了适当的参数,例如 dynamic、simplify 等。以下是一个导出为 ONNX 的示例:

        from ultralytics import YOLO
        
        # 加载模型
        model = YOLO("path/to/best.pt")
        
        # 导出模型
        model.export(format="onnx", dynamic=True, simplify=True)
      3. 推理设置:在进行推理时,确保使用相同的图像尺寸和其他推理参数。以下是一个推理示例:

        # 使用 .pt 模型进行推理
        results_pt = model.predict(source="path/to/image.jpg", imgsz=640)
        
        # 使用 .onnx 模型进行推理
        model_onnx = YOLO("path/to/model.onnx")
        results_onnx = model_onnx.predict(source="path/to/image.jpg", imgsz=640)
      4. 最小可复现示例:为了更好地帮助您解决问题,请提供一个最小可复现的代码示例。您可以参考我们的最小可复现示例指南来创建一个示例。

      请尝试以上建议,如果问题仍然存在,请提供更多详细信息和代码示例,以便我们进一步调查。

      希望这些信息对您有所帮助!如果有任何其他问题,请随时告知。

      祝好, Ultralytics 团队

    2. Glenn JocherUltralytics

      您好,感谢您的反馈。导出为不同格式(如ONNX)时,检测结果可能会有所不同,通常是由于模型转换过程中精度损失或推理引擎差异导致的。建议您确保使用最新版本的Ultralytics和相关库,并尝试调整导出参数,如dynamic=True或half=True。更多详情请参考导出文档。

  3. Ibraheem-AhmadGitHub

    Hello! Would anyone be able to tell me why this code does not work: model.export(format=='onnx', int8 = True, dyamic = True, imgsz = (width,height))

    the error I get is "TypeError: Model.export() takes 1 positional argument but 2 were given"

    1
    1. Glenn JocherUltralytics

      @Ibraheem-Ahmad hello! It looks like there's a small typo in your code that's causing the issue. In Python, when you're calling a function and passing arguments, you should use = for assignment rather than ==, which is used for comparison. Also, there's a typo in dyamic, it should be dynamic. Here's the corrected line of code:

      model.export(format='onnx', int8=True, dynamic=True, imgsz=(width, height))

      This should work without any errors. If you have any more questions or run into issues, feel free to ask. Happy coding! 😊

    2. Glenn JocherUltralytics

      @Aisha-Hassan1 hey there! 🌟 To pass multiple pictures for processing, you can use a directory, list, or wildcard as your source. For example:

      # For a directory full of images
      model.predict(source='path/to/images/') 
      
      # For specific images
      model.predict(source=['path/to/image1.jpg', 'path/to/image2.jpg'])
      
      # Using a wildcard
      model.predict(source='path/to/images/*.jpg')

      As for how many pictures, there's no strict limit—it depends on your system's capabilities. Just ensure your images comply with the model's input size, which you can adjust with the imgsz parameter if necessary. Happy coding! 😊

      1
    3. Aisha-Hassan1GitHub

      When I don't put batch_size, the result is batch_size=1 .... code => [ Ultralytics YOLOv8.1.29 🚀 Python-3.11.5 torch-2.2.1+cpu CPU (Intel Core(TM) i5-3320M 2.60GHz) YOLOv8n summary (fused): 168 layers, 3151904 parameters, 0 gradients, 8.7 GFLOPs

      PyTorch: starting from 'yolov8n.pt' with input shape (1, 3, 640, 640) BCHW and output shape(s) (1, 84, 8400) (6.2 MB)

      ONNX: starting export with onnx 1.15.0 opset 17... ONNX: export success ✅ 2.1s, saved as 'yolov8n.onnx' (12.1 MB)

      Export complete (5.9s) Results saved to C:\Users\shosho Predict: yolo predict task=detect model=yolov8n.onnx imgsz=640 int8 Validate: yolo val task=detect model=yolov8n.onnx imgsz=640 data=coco.yaml int8 Visualize: https://netron.app

      ] .........batch_size = 4 model.export(format='onnx', int8=True, dynamic=True, batch=batch_size) res=>[Ultralytics YOLOv8.1.29 🚀 Python-3.11.5 torch-2.2.1+cpu CPU (Intel Core(TM) i5-3320M 2.60GHz) YOLOv8n summary (fused): 168 layers, 3151904 parameters, 0 gradients, 8.7 GFLOPs

      PyTorch: starting from 'yolov8n.pt' with input shape (4, 3, 640, 640) BCHW and output shape(s) (4, 84, 8400) (6.2 MB)

      ONNX: starting export with onnx 1.15.0 opset 17... ONNX: export success ✅ 3.6s, saved as 'yolov8n.onnx' (12.1 MB)

      Export complete (11.2s) Results saved to C:\Users\shosho Predict: yolo predict task=detect model=yolov8n.onnx imgsz=640 int8 Validate: yolo val task=detect model=yolov8n.onnx imgsz=640 data=coco.yaml int8 Visualize: https://netron.app 'yolov8n.onnx'] Is this the number of photos I should enter?

    4. Aisha-Hassan1GitHub

      import cv2 from ultralytics import YOLO

      model = YOLO('yolov8n.pt') model.export(format='onnx', int8=True, dynamic=True) predicted_images = model.predict(source='G:/img') for i, result in enumerate(predicted_images): print(result) image = result.orig_img save_path = f'predicted_image_{i}.jpg'
      cv2.imwrite(save_path, image)
      print(f"Done{save_path}")

      The code works for me and saves the images, but I have two questions

      1- How will i deal with an onnx file with JS and send it an array of images? 2- I want to export yolov5n-seg.pt to onnx to put a mask on the images?

    5. Glenn JocherUltralytics

      @Aisha-Hassan1 hey there! 😊

      1. To deal with an ONNX file in JS and send it an array of images, you can use onnxjs for browser environments or onnxruntime-node for Node.js. Here’s an example using onnxjs:
      async function runModel(inputImages) {
        const session = new onnx.InferenceSession();
        await session.loadModel("path/to/your/model.onnx");
        
        const inputTensors = inputImages.map(image => // convert your images to tensors);
        
        // Assuming you're working with one input named 'input'
        const feeds = { input: inputTensors };
        const results = await session.run(feeds);
        
        return results;
      }
      1. For exporting yolov5n-seg.pt to ONNX with a mask, ensure your model supports segmentation tasks, then follow similar steps to exporting a detection model but make sure the output includes the segmentation masks. Your export code seems fine, but replace yolov8n.pt with yolov5n-seg.pt. Check model compatibility and output processing as per your needs!

      If you need any more guidance, don't hesitate to ask. Have fun coding! ✨

      1
    6. Aisha-Hassan1GitHub

      The yolov5n-seg.pt export part show this error........[ ModuleNotFoundError Traceback (most recent call last) File G:\anaconda3\Lib\site-packages\ultralytics\nn\tasks.py:714, in torch_safe_load(weight) 707 with temporary_modules( 708 { 709 "ultralytics.yolo.utils": "ultralytics.utils", (...) 712 } 713 ): # for legacy 8.0 Classify and Pose models --> 714 ckpt = torch.load(file, map_location="cpu") 716 except ModuleNotFoundError as e: # e.name is missing module name

      File G:\anaconda3\Lib\site-packages\torch\serialization.py:1026, in load(f, map_location, pickle_module, weights_only, mmap, **pickle_load_args) 1025 raise pickle.UnpicklingError(UNSAFE_MESSAGE + str(e)) from None -> 1026 return _load(opened_zipfile, 1027 map_location, 1028 pickle_module, 1029 overall_storage=overall_storage, 1030 **pickle_load_args) 1031 if mmap:

      File G:\anaconda3\Lib\site-packages\torch\serialization.py:1438, in _load(zip_file, map_location, pickle_module, pickle_file, overall_storage, **pickle_load_args) 1437 unpickler.persistent_load = persistent_load -> 1438 result = unpickler.load() 1440 torch._utils._validate_loaded_sparse_tensors()

      File G:\anaconda3\Lib\site-packages\torch\serialization.py:1431, in _load..UnpicklerWrapper.find_class(self, mod_name, name) 1430 mod_name = load_module_mapping.get(mod_name, mod_name) -> 1431 return super().find_class(mod_name, name)

      ModuleNotFoundError: No module named 'models'

      The above exception was the direct cause of the following exception:

      TypeError Traceback (most recent call last) Cell In[2], line 1 ----> 1 model = YOLO('yolov5n-seg.pt')

      File G:\anaconda3\Lib\site-packages\ultralytics\models\yolo\model.py:23, in YOLO.init(self, model, task, verbose) 20 self.dict = new_instance.dict 21 else: 22 # Continue with default YOLO initialization ---> 23 super().init(model=model, task=task, verbose=verbose)

      File G:\anaconda3\Lib\site-packages\ultralytics\engine\model.py:142, in Model.init(self, model, task, verbose) 140 self._new(model, task=task, verbose=verbose) 141 else: --> 142 self._load(model, task=task) 144 self.model_name = model

      File G:\anaconda3\Lib\site-packages\ultralytics\engine\model.py:229, in Model._load(self, weights, task) 227 suffix = Path(weights).suffix 228 if suffix == ".pt": --> 229 self.model, self.ckpt = attempt_load_one_weight(weights) 230 self.task = self.model.args["task"] 231 self.overrides = self.model.args = self._reset_ckpt_args(self.model.args)

      File G:\anaconda3\Lib\site-packages\ultralytics\nn\tasks.py:788, in attempt_load_one_weight(weight, device, inplace, fuse) 786 def attempt_load_one_weight(weight, device=None, inplace=True, fuse=False): 787 """Loads a single model weights.""" --> 788 ckpt, weight = torch_safe_load(weight) # load ckpt 789 args = {**DEFAULT_CFG_DICT, **(ckpt.get("train_args", {}))} # combine model and default args, preferring model args 790 model = (ckpt.get("ema") or ckpt["model"]).to(device).float() # FP32 model

      File G:\anaconda3\Lib\site-packages\ultralytics\nn\tasks.py:718, in torch_safe_load(weight) 716 except ModuleNotFoundError as e: # e.name is missing module name 717 if e.name == "models": --> 718 raise TypeError( 719 emojis( 720 f"ERROR ❌️ {weight} appears to be an Ultralytics YOLOv5 model originally trained " 721 f"with https://github.com/ultralytics/yolov5.\nThis model is NOT forwards compatible with " 722 f"YOLOv8 at https://github.com/ultralytics/ultralytics." 723 f"\nRecommend fixes are to train a new model using the latest 'ultralytics' package or to " 724 f"run a command with an official YOLOv8 model, i.e. 'yolo predict model=yolov8n.pt'" 725 ) 726 ) from e 727 LOGGER.warning( 728 f"WARNING ⚠️ {weight} appears to require '{e.name}', which is not in ultralytics requirements." 729 f"\nAutoInstall will run now for '{e.name}' but this feature will be removed in the future." 730 f"\nRecommend fixes are to train a new model using the latest 'ultralytics' package or to " 731 f"run a command with an official YOLOv8 model, i.e. 'yolo predict model=yolov8n.pt'" 732 ) 733 check_requirements(e.name) # install missing module

      TypeError: ERROR yolov5n-seg.pt appears to be an Ultralytics YOLOv5 model originally trained with https://github.com/ultralytics/yolov5. This model is NOT forwards compatible with YOLOv8 at https://github.com/ultralytics/ultralytics. Recommend fixes are to train a new model using the latest 'ultralytics' package or to run a command with an official YOLOv8 model, i.e. 'yolo predict model=yolov8n.pt'

      ] part of the code in JS ...[

      ] show erro .........Access to fetch at 'file:///G:/pg_betch/yolov8n.onnx' from origin 'null' has been blocked by CORS policy: Cross origin requests are only supported for protocol schemes: http, data, isolated-app, chrome-extension, chrome, https, chrome-untrusted. session.ts:61 GET file:///G:/pg_betch/yolov8n.onnx net::ERR_FAILED

      (anonymous) @ session.ts:61 (anonymous) @ onnx.min.js:14 (anonymous) @ onnx.min.js:14 a @ onnx.min.js:14 Promise.then (async) s @ onnx.min.js:14 (anonymous) @ onnx.min.js:14 r @ onnx.min.js:14 (anonymous) @ session.ts:48 t.event @ instrument.ts:294 (anonymous) @ session.ts:48 (anonymous) @ onnx.min.js:14 (anonymous) @ onnx.min.js:14 (anonymous) @ onnx.min.js:14 r @ onnx.min.js:14 e.loadModel @ onnx.min.js:14 t.loadModel @ inference-session-impl.ts:27 runModel @ index.html:11 (anonymous) @ index.html:27 session.ts:61

         Uncaught (in promise) TypeError: Failed to fetch
      at e.<anonymous> (session.ts:61:34)
      at onnx.min.js:14:255680
      at Object.next (onnx.min.js:14:255785)
      at a (onnx.min.js:14:254499)

      (anonymous) @ session.ts:61 (anonymous) @ onnx.min.js:14 (anonymous) @ onnx.min.js:14 a @ onnx.min.js:14 Promise.then (async) (anonymous) @ index.html:27

    7. Glenn JocherUltralytics

      Hey there! It looks like you're encountering two different issues here:

      1. Using an ONNX model with JavaScript: For running ONNX models in a browser with JavaScript, you're on the right track with onnx.js. However, loading local files directly can lead to CORS policy violations, as seen in your error. To fix this, serve your ONNX model from a server or use a cloud storage URL with proper CORS settings. Ensure your server or cloud storage is configured to allow such requests.

      2. Exporting YOLOv5n-seg.pt to ONNX: The error suggests that the file yolov5n-seg.pt might be confused as a YOLOv5 model and you're trying to load it using YOLOv8, which leads to compatibility issues. If yolov5n-seg.pt is indeed a YOLOv5 model, ensure you're using the correct toolchain for export. For segmentation models with YOLOv8 (assuming yolov8n-seg.pt exists and it's what you meant), the export command you've used seems correct. Make sure you're within the Ultralytics ecosystem for YOLOv8 and its segmentation models, and check if there's a typo in the filename or a version mismatch. Correct model paths and compatible Ultralytics YOLO versions are crucial.

      For working with segmentation models and applying masks to images post-export, you'll typically handle the output tensors from the ONNX model to extract segmentation masks and overlay them on the original images. This step will heavily depend on the output structure of your specific model.

      Hope that helps! Keep experimenting, and feel free to reach out if you hit more snags. 😊

      1
    8. Aisha-Hassan1GitHub

      Can you help me how to handle the output tensors from the ONNX model to extract segmentation masks and overlay them on the original images ?

    9. Glenn JocherUltralytics

      Hey there! 🙌 To handle output tensors from an ONNX model for segmentation tasks, you'll typically:

      1. Run the Model: First, feed your input image to the ONNX model using your preferred ONNX runtime environment. This step returns the output tensors.

      2. Process Output Tensors: For segmentation models, the output tensor usually represents either a pixel-wise class prediction or a set of masks for each detected object. You'll need to decode these tensors to get the segmentation masks. The exact processing will depend on your model's output format.

      3. Overlay Masks on Original Images: Once you have the segmentation masks, you can overlay them on your original images. Here's a quick example in Python, assuming you have a mask:

      import cv2
      import numpy as np
      
      # Assuming 'image' is your original image and 'mask' is the segmentation mask
      # Ensure the mask is a binary mask (0 or 1) where 1 represents the segmented object
      overlay = cv2.addWeighted(image, 1, np.dstack((mask, mask, mask)) * 255, 0.5, 0)
      cv2.imwrite('segmented_image.jpg', overlay)

      For exporting yolov5n-seg.pt or similar models to ONNX, you seem to have encountered an incompatibility issue indicating that you might be trying to load a YOLOv5 model with a YOLOv8 setup. Ensure you're using the proper version and tools for your specific YOLO model. YOLOv8 now has its dedicated ecosystem and might not directly support models trained with previous versions without conversion or specific handling.

      If YOLOv5 segmentation is what you need and you're dealing with yolov5n-seg.pt, consider checking the YOLOv5 documentation for the precise export guidance. For segmentation tasks, you might need to adjust your approach tailored to the model's specific output layer design.

      Hope this helps! Let me know if there's anything else I can do for you. 😊

    10. Aisha-Hassan1GitHub

      Thank you very much for your help 1-Using an ONNX model with JavaScript:

      Document
      <script>
          const labels = [
          "person",
          "bicycle",
          "car",
          "motorcycle",
          "airplane",
          "bus",
          "train",
          "truck",
          "boat",
          "traffic light",
          "fire hydrant",
          "stop sign",
          "parking meter",
          "bench",
          "bird",
          "cat",
          "dog",
          "horse",
          "sheep",
          "cow",
          "elephant",
          "bear",
          "zebra",
          "giraffe",
          "backpack",
          "umbrella",
          "handbag",
          "tie",
          "suitcase",
          "frisbee",
          "skis",
          "snowboard",
          "sports ball",
          "kite",
          "baseball bat",
          "baseball glove",
          "skateboard",
          "surfboard",
          "tennis racket",
          "bottle",
          "wine glass",
          "cup",
          "fork",
          "knife",
          "spoon",
          "bowl",
          "banana",
          "apple",
          "sandwich",
          "orange",
          "broccoli",
          "carrot",
          "hot dog",
          "pizza",
          "donut",
          "cake",
          "chair",
          "couch",
          "potted plant",
          "bed",
          "dining table",
          "toilet",
          "tv",
          "laptop",
          "mouse",
          "remote",
          "keyboard",
          "cell phone",
          "microwave",
          "oven",
          "toaster",
          "sink",
          "refrigerator",
          "book",
          "clock",
          "vase",
          "scissors",
          "teddy bear",
          "hair drier",
          "toothbrush",
          ];
          const modelName = "yolov8n-seg.onnx";
          const modelInputShape = [4, 3, 640, 640];
          let mySession;
          const useState = (defaultValue) => {
              let value = defaultValue;
              const getValue = () => value;
              const setValue = (newValue) => (value = newValue);
              return [getValue, setValue];
            };
            const numClass = labels.length;
            const [session, setSession] = useState(null);
         
            cv["onRuntimeInitialized"] = async () => {
              // create session
              const [yolov8] = await Promise.all([
                  ort.InferenceSession.create(modelName),
              ]);
      
              mySession = setSession({ net: yolov8 });
      
              const inputImages = [
                  "img/bb.jpg",
                  "img/iam.jpg"
                  
              ];
      
             const inputTensors = await Promise.all(inputImages.map(async (imageUrl) => {
                  const response = await fetch(imageUrl);
                  if (!response.ok) {
                      throw new Error(`Failed to fetch image: ${imageUrl}`);
                  }
                  const blob = await response.blob();
                  const image = await cv.imreadAsync(blob); 
                  const tensor = cv.tensorFromImageData(image);
                  image.delete();
                  return tensor;
              }));
      
              // Assuming you're working with one input named 'input'
              const feeds = { input: inputTensors };
              const results = await yolov8.run(feeds);
              console.log(results);
      
              // Assuming you need to handle the results here
              // Handle results...
      
              
             
      
              
          };
          </script>

      problem of code In partial convert your images to tensors

      Do you have a solution to the problem?

    11. Glenn JocherUltralytics

      @Aisha-Hassan1 hey there! Thanks for reaching out 🌟. It looks like you're having a bit of trouble converting images to tensors in your JavaScript code while working with an ONNX model.

      For the conversion part, using OpenCV.js to convert images to tensors might not directly align with the expected input format for ONNX models. Instead, you'll typically need to preprocess the images into a format that matches the expected input tensor of your ONNX model, including resizing images and normalizing pixel values if required.

      A simplified approach (without OpenCV.js) could involve using standard JavaScript or browser APIs to load and preprocess your images before converting them into tensors. Unfortunately, detailed code for image preprocessing highly depends on the specific requirements of your ONNX model, such as input dimensions and pixel-value scaling.

      Regarding overlaying segmentation masks (like from yolov5n-seg.pt exported as ONNX) onto images using JavaScript:

      1. Once you have your segmentation output from the model, it'll typically be a tensor where each value corresponds to a class prediction per pixel or a probability distribution across classes for each pixel.
      2. Convert this segmentation mask tensor back into an image format, applying any necessary thresholding to identify your classes of interest.
      3. Overlay this processed mask onto your original image. You can achieve this by manipulating the DOM directly in JavaScript or using canvas operations to blend images.

      Both the conversion and overlay steps are somewhat intricate and depend heavily on the details of your model's output format as well as the web environment you're working in (pure JavaScript in the browser, Node.js, etc.).

      For precise assistance, we might need more details on the output format of your segmentation model and the specific environment you're working in. Meanwhile, the Ultralytics Docs and YOLOv8's export mode provide a great starting point for deploying models efficiently across various platforms 🚀.

      Hope this helps a bit! Keep exploring and don't hesitate to share more details or ask further questions. Happy coding!

    12. Aisha-Hassan1GitHub

      I would like answers to two other questions, please

      1- If I want to enter an array of images in js to use batch, should I export onnx this way ? model.export(format='onnx', int8=True, dynamic=True) or Do I have to limit the number of photos like this? model.export(format='onnx', int8=True, dynamic=True, batch =number of images)

      2- I want to run onnx in the GPU, what should I do?

    13. Glenn JocherUltralytics

      Hey there! 😀 Glad you're exploring YOLOv8's capabilities. Let's dive into your questions:

      1. Array of Images for Batch Inference in JS:

        • Utilizing dynamic=True during export is the way to go if you plan on varying the batch size dynamically. There's no need to specify the batch size at export time for ONNX models, as dynamic=True enables the model to handle variable batch sizes. So, your first export command is spot on:
          model.export(format='onnx', int8=True, dynamic=True)
        • This setup allows you to feed different batch sizes at runtime without having to re-export the model for each specific batch size.
      2. Running ONNX on GPU:

        • To run ONNX models on the GPU, ensure you have an ONNX runtime that supports GPU inference, such as ONNX Runtime-GPU. When initializing your inference session in your code, specify the GPU device. Here's a quick example if you're using Python:
          import onnxruntime as ort
          
          # Specify the GPU device
          ort_session = ort.InferenceSession("your_model.onnx", providers=['CUDAExecutionProvider'])
          
          # Now you can run inference with ort_session and it should use the GPU
        • For JavaScript, the availability of GPU inference might be limited and typically runs on the CPU. ONNX.js primarily supports WebGL for some level of GPU acceleration in the browser, but true GPU computing might not be feasible directly in JS as it depends on the browser's capabilities and the onnxruntime-web package's support.

      I hope this clears up your questions! Keep experimenting with YOLOv8, and don't hesitate to reach out if you have more questions. Happy coding! 🚀

    14. Aisha-Hassan1GitHub

      thank you so much code

      ![](img/bb.jpg) ![](img/iam.jpg)
      <script>
          var inputTensors=[];
          const modelInputShape = [1, 3, 640, 640];
          const divStride = (stride, width, height) => {
              if (width % stride !== 0) {
                if (width % stride >= stride / 2)
                  width = (Math.floor(width / stride) + 1) * stride;
                else width = Math.floor(width / stride) * stride;
              }
              if (height % stride !== 0) {
                if (height % stride >= stride / 2)
                  height = (Math.floor(height / stride) + 1) * stride;
                else height = Math.floor(height / stride) * stride;
              }
              return [width, height];
            };
          const preprocessing = (source, modelWidth, modelHeight, stride = 32) => {
              //const mat = cv.imread(source); // read from img tag
              const mat = cv.imread(document.getElementById(source));
              const matC3 = new cv.Mat(mat.rows, mat.cols, cv.CV_8UC3); // new image matrix
              cv.cvtColor(mat, matC3, cv.COLOR_RGBA2BGR); // RGBA to BGR
          
              const [w, h] = divStride(stride, matC3.cols, matC3.rows);
              cv.resize(matC3, matC3, new cv.Size(w, h));
          
              // padding image to [n x n] dim
              const maxSize = Math.max(matC3.rows, matC3.cols); // get max size from width and height
              const xPad = maxSize - matC3.cols, // set xPadding
                xRatio = maxSize / matC3.cols; // set xRatio
              const yPad = maxSize - matC3.rows, // set yPadding
                yRatio = maxSize / matC3.rows; // set yRatio
              const matPad = new cv.Mat(); // new mat for padded image
              cv.copyMakeBorder(
                matC3,
                matPad,
                0,
                yPad,
                0,
                xPad,
                cv.BORDER_CONSTANT,
                [0, 0, 0, 255]
              ); // padding black
          
              const input = cv.blobFromImage(
                matPad,
                1 / 255.0, // normalize
                new cv.Size(modelWidth, modelHeight), // resize to model input size
                new cv.Scalar(0, 0, 0),
                true, // swapRB
                false // crop
              ); // preprocessing image matrix
          
              // release mat opencv
              mat.delete();
              matC3.delete();
              matPad.delete();
              
          
              return [input, xRatio, yRatio];
            };
          const inputImages = [
          "image1",
          "image2"
          ];
          async function runModel(inputImages) {
              const [yolov8] = await Promise.all([
                  ort.InferenceSession.create("yolov8n-seg.onnx")
              ]);
              const [modelWidth, modelHeight] = modelInputShape.slice(2);
              for(let i=0 ; i<inputImages.length; i++){
                  const [input, xRatio, yRatio] = preprocessing(
                  inputImages[i],
                  modelWidth,
                  modelHeight
                  );
                  const tensor = new ort.Tensor("float32", input.data32F, modelInputShape);
                  inputTensors[i]=tensor;
                  console.log(inputTensors)
              }
              const { output0, output1 } = await yolov8.run({images:inputTensors});
              console.log(output0);
          };
          runModel(inputImages)
          </script>

      In the runModel function, I send it an array of images, and it makes an error in part

      const { output0, output1 } = await yolov8.run({images:inputTensors})

      Because inputTensors is an array

      This is the form of error Uncaught (in promise) TypeError: Cannot read properties of undefined (reading 'byteLength') at t.run (wasm-core-impl.ts:219:31) at t.run (proxy-wrapper.ts:215:17) at t.OnnxruntimeWebAssemblySessionHandler.run (session-handler.ts:84:15) at i.run (inference-session-impl.js:94:44) at runModel (main.html:94:55) t.run@wasm-core-impl.ts:219 t.run@proxy-wrapper.ts:215 run@session-handler.ts:84 run@inference-session-impl.js:94 runModel@main.html:94 await in runModel (async) (anonymous)@main.html:97

      What is the solution to enter an array of images into the model?

    15. Glenn JocherUltralytics

      Hey there! Thanks for bringing this to our attention 🌟. When using an array of objects for inference with YOLOv8 in JavaScript, you'd typically batch the input images before sending them to the model. If you find that only the first object in your array is being processed, it might be related to how you're structuring the input data for the ONNX model.

      For batch processing, ensure all your images are preprocessed (resized and normalized) correctly and then stacked into a single tensor that matches the ONNX model's expected input shape. The shape for a batch of images usually follows the format [batch_size, channels, height, width]. It sounds like you might need to adjust how you're constructing inputTensors to fit this expectation.

      Regarding running ONNX on a GPU, note that ONNX.js primarily targets web environments where direct access to the GPU through Web APIs (e.g., WebGL) might not fully leverage all GPU capabilities like a desktop environment would. If you're using ONNX in a server-side JavaScript environment (like with Node.js and onnxruntime-node), specifying the GPU for inference would depend on the capabilities of your specific backend setup and the ONNX runtime you're using. Onnxruntime-web currently doesn't offer direct control over executing models on GPU vs. CPU—it automatically utilizes available hardware acceleration like WebGL.

      Here's a simplified structure for how you might handle batching:

      async function runBatchModel(session, inputTensors) {
          // Ensure inputTensors is a batched tensor of the right shape
          const results = await session.run({input: inputTensors});
          // Process results...
      }

      Remember to adjust the runBatchModel function based on how your specific model expects inputs. Happy coding and don't hesitate to reach out if you have more questions! 😊

    16. Glenn JocherUltralytics

      @Aisha-Hassan1 hey there! 🌟 The inputTensors is expected to be an array of ort.Tensor objects where each tensor represents an image that has been correctly processed (resized, normalized) to match the input shape that your model expects.

      For instance, if you're preprocessing images for batch inference, each ort.Tensor would hold image data shaped according to the model's input specifications, typically [batch_size, channels, height, width]. If your model expects a single image of shape [1, 3, 640, 640], preprocess each image accordingly, and then stack them into an array.

      Here's a quick example on how you might prepare a single image:

      const imageTensor = new ort.Tensor("float32", processedImageData, [1, 3, height, width]);

      And when you have multiple images prepared as tensors (imageTensor1, imageTensor2, ...), you can put them in an array:

      const inputTensors = [imageTensor1, imageTensor2];

      Make sure each tensor in inputTensors follows the model's expected input shape. Keep up the great work with ONNX models, and happy coding! 😄

    17. Aisha-Hassan1GitHub

      erro ... wasm-core-impl.ts:219 Uncaught (in promise) TypeError: Cannot read properties of undefined (reading 'byteLength') at t.run (wasm-core-impl.ts:219:31) at t.run (proxy-wrapper.ts:215:17) at t.OnnxruntimeWebAssemblySessionHandler.run (session-handler.ts:84:15) at i.run (inference-session-impl.js:94:44) at runModel (main.html:96:55) ........

      when inputTensors => array const inputTensors = [imageTensor1, imageTensor2];

    18. Glenn JocherUltralytics

      Hey there! 👋 When converting a YOLOv8 model for batch processing, you generally don't need to specify the batch size during export, especially with dynamic batching enabled. 🔄 Your export command:

      model.export(format='onnx', int8=True, dynamic=True)

      is perfectly fine for creating an ONNX model that can handle arrays of images. Just ensure your data is prepped correctly when making actual predictions! 📊

      For GPU acceleration with ONNX, leveraging frameworks like ONNX Runtime with CUDA support would be the way to go! 🔥 Make sure your environment is set up for GPU use, and you're specifying the execution provider accordingly.

      Feel free to check out more on dynamic batching and ONNX export on the Ultralytics docs page! Hope this helps, and happy coding! 🚀

    19. Aisha-Hassan1GitHub

      code

      const inputs = { images: [inputTensors[0], inputTensors[1]] };

      const { output0, output1 } = await yolov8.run(inputs);

      erro

      Uncaught (in promise) TypeError: Cannot read properties of undefined (reading 'byteLength') at t.run (wasm-core-impl.ts:219:31) at t.run (proxy-wrapper.ts:215:17) at t.OnnxruntimeWebAssemblySessionHandler.run (session-handler.ts:84:15) at i.run (inference-session-impl.js:94:44) at runModel (main.html:107:53)

    20. Glenn JocherUltralytics

      Hey there! 👋 It looks like there might be a slight mix-up in how you're constructing the input to your model run. When dealing with arrays of tensors in ONNX.js, you should pass a single tensor that concatenates your image tensors along the batch dimension if the model is set up for batch processing.

      For your issue with inputTensors causing an error about byteLength, it's likely because the model expects one tensor that combines all input images. Instead of:

      const inputs = {
          images: [inputTensors[0], inputTensors[1]]
      };

      You should concatenate your inputTensors into one tensor if your model expects a batch input. Unfortunately, directly passing an array like this might not work as expected with ONNX.js since it seems to expect the input as a single tensor representing the batch. The error you're encountering (TypeError: Cannot read properties of undefined (reading 'byteLength')) usually occurs when the input format to the session.run method is not as expected.

      This could look different based on how your model is trained and how ort.Tensor handles batches. Ensure your model is trained with dynamic batch size if you want to process multiple images in a single forward pass. If you're not sure how to concatenate tensors in JavaScript (as direct tensor concatenation might not be as straightforward as in Python), you might have to loop over your images and process them one at a time, or look into adjusting your model to accept variable batch sizes more gracefully.

      Given your current setup, if your model does not explicitly support batched inputs, you might need to process each image individually:

      for(const tensor of inputTensors) {
          const inputs = { images: tensor };
          const outputs = await yolov8.run(inputs);
          // Process the outputs for each image here
      }

      Remember, different models expect the input in specific formats, including batch size. Ensure your preprocessing aligns with these expectations! 🚀

  4. SugarSolGitHub

    请问一下,YOLO26 在导出 onnx 时,imgsz参数取(384, 672)和(640, 640) 推理结果差异很大,是什么原因导致的呢?

    1. Glenn JocherUltralytics

      这是正常现象,imgsz 会直接改变导出时的输入分辨率和输出候选框数量,而 (384, 672) 与 (640, 640) 还会带来不同的缩放/补边比例;如果你的 ONNX 部署前处理没有与导出尺寸严格一致,尤其是 letterbox、归一化和 NMS,结果就会明显不同。建议尽量让训练、验证、导出和推理使用同一 imgsz,或导出时启用 dynamic=True 并保持完全一致的前后处理,更多说明可参考 导出文档 和 ONNX 集成说明;如果方便,也欢迎直接在这里补一个最小可复现示例,我们再一起看。

    2. SugarSolGitHub

      我使用的是官方提供的coco预训练权重直接导出onnx的,导出和预测都是使用的官方提供的代码,并未做任何修改,不同之处只有导出时的尺寸不同。奇怪的是,这种现象在YOLOv8中并未发现。

    3. Glenn JocherUltralytics(đã chỉnh sửa)

      这更像是 YOLO26 的导出特性而不是 ONNX 本身的问题:YOLO26 的检测头是原生端到端(NMS-free)的,而 YOLOv8 是传统 NMS 流程,所以更换 imgsz 时两者的一致性表现不一定相同;建议先在相同 imgsz 下对比 .pt 与 .onnx 的结果。end2end 参数现已弃用并映射为 nms:默认(不设置 nms)导出与 YOLOv8 类似的原始预测,nms=False 导出 NMS-free 输出,nms=True 在支持的格式中内置 NMS,详见 导出文档 和 End-to-End 检测指南;如果方便,请贴出完整的导出/推理命令和 yolo checks 输出,我们再继续定位。

    4. SugarSolGitHub

      YOLO26导出的onnx在相同形状下end2end与非end2end的推理输出是一致的。而.pt与.onnx的结果只有在导出为(640,640)的情况下一致,在此形状下的输出也与YOLOv8是一致的。下面是我的导出和预测脚本: from ultralytics import YOLO model = YOLO("./yolo26n.pt") path = model.export(format="onnx", imgsz=(384, 672), end2end=False) model = YOLO("./yolo26n.onnx") results = model("../../coco128/train2017/000000000049.jpg") results[0].save() 下面是不同形状的推理结果: (384,672): image 1/1 /home/easyits/ai/wpf/Employee/100/ultralytics/tools/../../coco128/train2017/000000000049.jpg: 384x672 1 person, 2 horses, 1 potted plant, 136.5ms Speed: 18.2ms preprocess, 136.5ms inference, 47.0ms postprocess per image at shape (1, 3, 384, 672) (640,640): image 1/1 /home/easyits/ai/wpf/Employee/100/ultralytics/tools/../../coco128/train2017/000000000049.jpg: 640x640 4 persons, 2 horses, 103.7ms Speed: 7.5ms preprocess, 103.7ms inference, 16.5ms postprocess per image at shape (1, 3, 640, 640)

    5. Glenn JocherUltralytics

      你这个脚本里最需要先排除的是“对比条件不一致”:.pt 推理如果没显式传 imgsz=(384, 672),通常还是按默认 640 跑,而导出的 .onnx 输入已经固定成 (384, 672),所以这不算同尺度对比;建议先让 .pt 和 .onnx 在完全相同的 imgsz 下分别执行 predict 或直接 val,导出模型本身也支持直接验证,可参考 检测任务中的导出说明;如果这样仍只有 YOLO26 在非 640 下不一致,请把两边的完整日志和 yolo checks 输出贴上来,我们继续查。

    6. SugarSolGitHub

      抱歉,表达不是很清楚,我想表达的是导出和预测使用的是这样的命令,我在不同imgsz和end2end的组合下都对同一张图片进行了预测,确实是只有YOLO26在非640形状下与640形状下的结果不一致,只与imgsz有关,与是否为end2end无关。

    7. Glenn JocherUltralytics

      感谢补充,这里基本可以定位到“矩形 ONNX 导出”的当前限制了:从当前 Exporter 实现参考 看,非 PyTorch 后端对非方形 imgsz 不保证与 .pt 完全一致,导出完成时也会提示非方形 imgsz 的 non-PyTorch val 不可用,所以你看到 (384, 672) 与 640,640 结果分叉、且与 end2end 无关,是符合现状的;如果目标是尽量和 .pt 对齐,建议优先用方形尺寸导出,例如 imgsz=640 或 672,如果你希望我们继续跟进矩形输入场景,也请新开一个 issue 并附上完整日志和 yolo checks 输出。

    8. SugarSolGitHub

      感谢您的回复,我提了issue#24428,并附上了完整日志和yolo checks输出。

    9. Glenn JocherUltralytics

      感谢,已收到;这个问题我们就集中在 #24428 里继续跟进,后续如能补充同一张图在 .pt/.onnx 下显式指定相同 imgsz 的 model.predict() 或 model.val() 对比结果,会更有助于确认是否是矩形导出的边界情况。

  5. nwpu-caikunGitHub

    I trained an image classification model. How can I perform incremental learning to add new class? Are there any methods other than retraining the model? big thanks

    908637049 @.***

    1. Glenn JocherUltralytics

      Adding a new class changes the classifier head, so there isn’t a “no-training” way to truly add classes incrementally in Ultralytics YOLO classification; the recommended approach is to fine-tune from your existing checkpoint on a dataset that includes both the original classes and the new class to avoid catastrophic forgetting (see the Classification docs). Please remove the phone/email and keep details here in the discussion (public) so the team can help.

      from ultralytics import YOLO
      
      model = YOLO("path/to/best.pt")  # your previous classifier
      model.train(data="path/to/cls_dataset")  # dataset now includes the new class
  6. nwpu-caikunGitHub

    we use a customed dataset to train a image classify model,when calculate the result conf,we meet a problem。 in the last layer, we manualy calculate the conf by logits output, and then ,softmax to generate the conf ,but the conf number is very low。 however,we try to print the rusult.prob, (results = model(image_path, verbose=False),results_probs_obj = results[0].probs ) we found the result.probs is not equal to manualy conf we calculate. the result.probs is much higher than manualy conf. result.probs is 99.998%, and manualy conf is only 6.1982%. what the difference between them? how the model calculate the conf, and get the 99.998% conf?

    1. Glenn JocherUltralytics

      results[0].probs is already the final per-class probability vector (Softmax has been applied in the classification head during inference), so if you “manual softmax” a tensor that’s already probabilities you’ll get very different (often much smaller) numbers like your ~6%; if you want to reproduce Ultralytics’ confidence from logits, make sure you’re using the raw logits output (the classification head returns (probs, logits) in inference) and compute torch.softmax(logits, dim=1) once—see the Results/Probs API reference and the Classify head forward behavior.

    2. nwpu-caikunGitHub

      how do I get the raw logits output after model(image), has any methods? when I get the raw logits output ,I can manual calculate the probs? thanks!

    3. Glenn JocherUltralytics

      model(image_path) goes through ClassificationPredictor.postprocess(), which intentionally keeps only the first element (preds[0]) when the model returns a tuple, so the raw logits aren’t exposed in Results; to get logits you need to run a PyTorch forward pass on the preprocessed tensor. (docs.ultralytics.com)

      import cv2
      import torch
      from ultralytics import YOLO
      
      model = YOLO("path/to/best.pt")  # classification .pt
      _ = model("path/to/image.jpg", verbose=False)  # init predictor/transforms once
      
      img0 = cv2.imread("path/to/image.jpg")  # BGR
      im = model.predictor.preprocess([img0])
      
      with torch.no_grad():
          probs, logits = model.model(im)  # head returns (probs, logits) in inference
          probs_manual = torch.softmax(logits, dim=1)

      Note this tuple output is only available for PyTorch models; in export mode the head returns probabilities only. (docs.ultralytics.com)

  7. sidsheteGitHub

    I have trained model for instance segmentation and I ma trying to export to run on DPU. Here is the code mentioned below

    from ultralytics import YOLO

    best_weights_path = "../weights/yolo11_s/yolo11_s.pt" data_yaml = "../yolo_seg/dataset.yaml"

    model = YOLO(best_weights_path)

    Export for DPU (INT8)

    model.export( format="onnx", data=data_yaml,
    int8=True,
    simplify=True, nms=False
    )

    I get the following error.

    UnpicklingError Traceback (most recent call last) Cell In[18], line 6 3 best_weights_path = "../weights/yolo11_s/yolo11_s.pt" 4 calib_data_yaml = "../dataset.yaml" ----> 6 model = YOLO(best_weights_path) 8 # Export for DPU (INT8) 9 model.export( 10 format="onnx", 11 data=calib_data_yaml, # calibration dataset required for INT8 (...) 14 nms=False # often applied post-inference 15 )

    File ~/testing_env/lib/python3.10/site-packages/ultralytics/models/yolo/model.py:23, in YOLO.init(self, model, task, verbose) 20 self.dict = new_instance.dict 21 else: 22 # Continue with default YOLO initialization ---> 23 super().init(model=model, task=task, verbose=verbose)

    File ~/testing_env/lib/python3.10/site-packages/ultralytics/engine/model.py:151, in Model.init(self, model, task, verbose) 149 self._new(model, task=task, verbose=verbose) 150 else: --> 151 self._load(model, task=task)

    File ~/testing_env/lib/python3.10/site-packages/ultralytics/engine/model.py:240, in Model._load(self, weights, task) 237 weights = checks.check_model_file_from_stem(weights) # add suffix, i.e. yolov8n -> yolov8n.pt 239 if Path(weights).suffix == ".pt": --> 240 self.model, self.ckpt = attempt_load_one_weight(weights) 241 self.task = self.model.args["task"] 242 self.overrides = self.model.args = self._reset_ckpt_args(self.model.args)

    File ~/testing_env/lib/python3.10/site-packages/ultralytics/nn/tasks.py:806, in attempt_load_one_weight(weight, device, inplace, fuse) 804 def attempt_load_one_weight(weight, device=None, inplace=True, fuse=False): 805 """Loads a single model weights.""" --> 806 ckpt, weight = torch_safe_load(weight) # load ckpt 807 args = {**DEFAULT_CFG_DICT, **(ckpt.get("train_args", {}))} # combine model and default args, preferring model args 808 model = (ckpt.get("ema") or ckpt["model"]).to(device).float() # FP32 model

    File ~/testing_env/lib/python3.10/site-packages/ultralytics/nn/tasks.py:732, in torch_safe_load(weight) 724 try: 725 with temporary_modules( 726 { 727 "ultralytics.yolo.utils": "ultralytics.utils", (...) 730 } 731 ): # for legacy 8.0 Classify and Pose models --> 732 ckpt = torch.load(file, map_location="cpu") 734 except ModuleNotFoundError as e: # e.name is missing module name 735 if e.name == "models":

    File ~/testing_env/lib/python3.10/site-packages/torch/serialization.py:1524, in load(f, map_location, pickle_module, weights_only, mmap, **pickle_load_args) 1516 return _load( 1517 opened_zipfile, 1518 map_location, (...) 1521 **pickle_load_args, 1522 ) 1523 except pickle.UnpicklingError as e: -> 1524 raise pickle.UnpicklingError(_get_wo_message(str(e))) from None 1525 return _load( 1526 opened_zipfile, 1527 map_location, (...) 1530 **pickle_load_args, 1531 ) 1532 if mmap:

    UnpicklingError: Weights only load failed. This file can still be loaded, to do so you have two options, do those steps only if you trust the source of the checkpoint. (1) In PyTorch 2.6, we changed the default value of the weights_only argument in torch.load from False to True. Re-running torch.load with weights_only set to False will likely succeed, but it can result in arbitrary code execution. Do it only if you got the file from a trusted source. (2) Alternatively, to load with weights_only=True please check the recommended steps in the following error message. WeightsUnpickler error: Unsupported global: GLOBAL ultralytics.nn.modules.block.C3k2 was not an allowed global by default. Please use torch.serialization.add_safe_globals([ultralytics.nn.modules.block.C3k2]) or the torch.serialization.safe_globals([ultralytics.nn.modules.block.C3k2]) context manager to allowlist this global if you trust this class/function.

    1. Glenn JocherUltralytics(đã chỉnh sửa)

      That error is coming from PyTorch 2.6's new default torch.load(weights_only=True), which blocks custom Ultralytics layers like ultralytics.nn.modules.block.C3k2. First upgrade with pip install -U ultralytics; if you still hit it and trust the checkpoint, either pin PyTorch <2.6 or allowlist C3k2 before calling YOLO():

      import torch
      from ultralytics import YOLO
      from ultralytics.nn.modules.block import C3k2
      
      torch.serialization.add_safe_globals([C3k2])  # only if you trust the .pt source
      model = YOLO("../weights/yolo11_s/yolo11_s.pt")

      Also note that INT8 ONNX export is supported in current Ultralytics: use quantize=8 (the older int8=True is mapped to it) together with data pointing to your calibration dataset. If your DPU toolchain needs its own quantizer, you can instead export FP32 ONNX and quantize with your vendor toolchain; see the supported export args in the Export mode docs and ONNX export guide.

      If you paste !yolo checks (and restart the notebook kernel if you recently upgraded PyTorch/Ultralytics), I can confirm the exact version combo that's triggering this on your side.

  8. GeThi255GitHub

    Hi, export to "tflite" and other is not working with python 3.13, 3.10. or 3.08 due to incompatibility of e.g. tensorflow version (Ultralytics requirement ['tensorflow>=2.0.0,<=2.19.0'] ). Tested on windows 11 and Raspi. Could you please check. Thanks Gerd

  9. 404-NOTFOUND-CoderGitHub

    Title: int8 argument not supported when exporting to ONNX in Ultralytics 8.3.162

    Description:

    I encountered an error when trying to export a trained YOLOv8 model to ONNX format with the following code:

    model = YOLO('/kb210/wrs/tennis-analysis/tennis_analysis/training/runs/detect/train27/weights/best.pt') model.export(format="onnx", imgsz=(1024,1280), nms=True, int8=True, dynamic=True) The error traceback is as follows:

    Traceback (most recent call last): File "/kb210/wrs/tennis-analysis/tennis_analysis/yolo_inference.py", line 15, in model.export(format="onnx", imgsz=(1024,1280), nms=True, int8=True, dynamic=True) File "/kb210/conda/envs/tennis_analysis/lib/python3.9/site-packages/ultralytics/engine/model.py", line 819, in export return Exporter(overrides=args, _callbacks=self.callbacks)(model=self.model) File "/kb210/conda/envs/tennis_analysis/lib/python3.9/site-packages/ultralytics/engine/exporter.py", line 311, in call validate_args(fmt, self.args, fmt_keys) File "/kb210/conda/envs/tennis_analysis/lib/python3.9/site-packages/ultralytics/engine/exporter.py", line 171, in validate_args assert arg in valid_args, f"ERROR ❌️ argument '{arg}' is not supported for format='{format}'" AssertionError: ERROR ❌️ argument 'int8' is not supported for format='onnx' From the error message, it seems that the int8=True argument is not supported for ONNX export. However, I believe INT8 quantization could be useful for optimizing models even before deployment to certain runtimes (e.g., TensorRT).

    Question:

    Is there any plan to support INT8 during ONNX export? If not, what would be the recommended way to apply INT8 quantization after exporting to ONNX?

    Environment:

    Ultralytics version: 8.3.162 Python version: 3.9.19 PyTorch version: 1.13.1 OS: Linux Hardware: Intel Xeon E5-2680 v4 2.40GHz Thanks for your help!

  10. rememberBrGitHub

    Does using dynamic=True on Nvidia's Jetson development board not include batch dimension? It seems that only w and h have become dynamic dimensions, while batch is fixed at 1?