Başla

Rockchip RKNN Dışa Aktarımı

RKNN, RK3588 ve RK3566 gibi Rockchip işlemcilerindeki NPU'ların model biçimidir. Bir Ultralytics YOLO26 modelini format="rknn" ile dışa aktarmak, FP16 veya INT8 duyarlılığında, name bağımsız değişkeniyle seçtiğin bir Rockchip yongası için oluşturulmuş .rknn dosyasını içeren bir yolo26n_rknn_model/ dizini oluşturur.

Genel Bakış#

ÖzellikAyrıntılar
format bağımsız değişkenirknn
Çıktıyolo26n_rknn_model/; yolo26n-rk3588.rknn ve metadata.yaml içeren bir dizin; detect, segment, pose ve OBB modellerinin INT8 dışa aktarımlarına tail.onnx eklenir
Çalıştığı ortamlarHer dışa aktarım için tek bir Rockchip yongasının NPU'su: RK3588, RK3576, RK3566, RK3568, RK3562, RK2118, RV1126B, RV1103, RV1106, RV1103B veya RV1106B; Hedef Yongalar bölümüne bak
Çalışma zamanıRockchip cihazında RKNN Toolkit Lite2 (rknn-toolkit-lite2 Python paketi)
KesinlikFP16 (varsayılan) ve INT8; yalnızca RV1103, RV1106, RV1103B ve RV1106B'de INT8 kullanılabilir. FP32 dışa aktarımı yoktur. RK3588 için YOLO26n, FP16 biçiminde 7.4 MB, INT8 biçiminde 4.3 MB boyutundadır.
Dışa aktarma ana makinesiPython 3.12 veya daha eski sürümlerin kullanıldığı Linux x86-64. Dışa aktarımı bir bilgisayarda yap ve dışa aktarılan dizini Rockchip cihazına kopyala.
Bulutta dışa aktar

Ultralytics Platform, eğitilmiş bir modeli seçtiğin Rockchip yongası için RKNN biçimine aktarabilir; böylece yerel bir dışa aktarma ortamına ihtiyacın olmaz.

Hızlı Başlangıç#

Ultralytics paketini, RKNN araç takımının ihtiyaç duyduğu protobuf ve numpy sürümleriyle birlikte, x86-64 Linux makinesinde ayrı bir sanal ortama yükle:

pip install ultralytics "protobuf<7" "numpy<2.4"

İlk dışa aktarma, eksikse bağımlılıklarıyla birlikte onnx, onnxslim, onnxruntime ve rknn-toolkit2 paketlerini yükler. Normal bir pip install ultralytics ortamında ilk dışa aktarma, sürümleri aşağıdaki aralıkların dışındaysa numpy, protobuf ve setuptools paketlerini de değiştirir; bu nedenle ayrı bir ortam kullan. protobuf veya numpy paketini değiştirmesi gerektiğinde bu dışa aktarma başarısız olur; yeni bir süreçte yapılan sonraki dışa aktarma ise başarılı olur. Dışa aktarma için gereken sürümler şunlardır:

PaketGerekli sürüm
Python3.12 veya daha eski; rknn-toolkit2 2.3.2 sürümünün derlemeleri bulunan en yeni sürüm
rknn-toolkit22.3.2; gerekli aralıkta (2.3.2 veya üzeri ve 2.5'in altı) PyPI'da bulunan tek sürüm
onnx1.16.1 veya üzeri ve 1.19.0'ın altı
numpy2.4'ün altı
protobuf7'nin altı
setuptools82'nin altı

Diğer yükleme yöntemleri için yükleme kılavuzuna bak. Ardından modelini bilgisayarda dışa aktar, dışa aktarılan dizini Rockchip cihazına kopyala ve çıkarım çalıştırmak veya doğruluk ölçmek için cihazda yükle.

Dışa aktar
from ultralytics import YOLO

# YOLO26 modelini yükle
model = YOLO("yolo26n.pt")

# Modeli RK3588 için FP16 biçiminde RKNN formatına aktar
model.export(format="rknn", name="rk3588")  # creates 'yolo26n_rknn_model/'

# Ya da bunun yerine kalibrasyon verileriyle INT8 kuantizasyonlu bir RKNN modeli aktar
model.export(format="rknn", name="rk3588", quantize=8, data="coco8.yaml")  # creates 'yolo26n_rknn_model/'

Her iki dışa aktarma da aynı yolo26n_rknn_model/ dizinine yazar; dolayısıyla ikincisi birincisinin üzerine yazar. Predict ve Validate yalnızca bir Rockchip cihazında çalışır:

Tahmin
from ultralytics import YOLO

# Dışa aktarılan RKNN modelini Rockchip cihazına yükle
model = YOLO("yolo26n_rknn_model")

# Çıkarımı çalıştır
results = model("https://ultralytics.com/images/bus.jpg")
Doğrula
from ultralytics import YOLO

# Dışa aktarılan RKNN modelini Rockchip cihazına yükle
model = YOLO("yolo26n_rknn_model")

# COCO8 veri kümesinde doğruluğu doğrula
metrics = model.val(data="coco8.yaml")

Desteklenen Görevler#

RKNN dışa aktarımı, YOLOv8, YOLO11 ve YOLO26 modelleriyle yedi Ultralytics görevinin tümünü destekler: nesne algılama, segmentasyon, anlamsal segmentasyon, derinlik tahmini, sınıflandırma, poz tahmini ve OBB. Anlamsal segmentasyon ve derinlik tahmini yalnızca bu başlıklara sahip tek aile olan YOLO26 ile kullanılabilir.

Dışa Aktarma Bağımsız Değişkenleri#

Bağımsız değişkenTürVarsayılanAçıklama
formatstr'rknn'Dışa aktarılan modelin hedef biçimi; çeşitli dağıtım ortamlarıyla uyumluluğu tanımlar.
namestr'rk3588'Modelin oluşturulacağı Rockchip yongası; büyük veya küçük harfle yazılabilir. Hedef Yongalar bölümüne bak.
imgszint veya tuple640Model girişinin görüntü boyutu: kare görüntüler için bir tam sayı veya (height, width) biçiminde bir demet. Belirtilmediğinde dışa aktarma, kontrol noktasının eğitildiği boyutu kullanır. Resmî YOLO26 kontrol noktaları detect, segment ve pose modelleri ile ADE20K üzerinde önceden eğitilmiş anlamsal modeller için 640; OBB modelleri ve Cityscapes üzerinde önceden eğitilmiş anlamsal modeller için 1024; depth için 768 ve classify için 224 kullanır.
quantizeint veya strNoneDuyarlılık: 16 veya belirtilmemesi FP16 oluşturur; 8 ise data üzerinde kalibre edilmiş INT8 oluşturur. Yalnızca INT8 destekleyen yongalarda belirtilmemesi INT8 oluşturur ve 16 hata verir. 32 hata verir; quantize=8 ile eğitilmiş bir kontrol noktası RKNN'ye aktarılamaz. Sınırlamalar ve Sorun Giderme bölümüne bak. Kullanımdan kaldırılmış half/int8 bayraklarının yerini alır.
datastrNoneINT8 kalibrasyonu için kullanılan veri kümesi YAML dosyası; sınıflandırmada bunun yerine bir veri kümesi dizini veya yerleşik veri kümesi adı kullanılır. split ayarlanmadığı sürece kalibrasyonda val bölümü kullanılır. quantize=8 ile birlikte verilmezse Ultralytics, algılama için coco8.yaml gibi, modelin görevine uygun küçük varsayılan veri kümesini kullanır.
fractionfloat, int veya list1.0Kalibrasyon alt kümesi: bir oran, bir görüntü sayısı (1 üzerindeki tam sayılar) veya bir [train, val, test] listesi; bu listeden kalibrasyon bölmesinin girdisi kullanılır.
batchint1Dışa aktarılan modelin giriş şekline sabitlenen toplu iş boyutu.
simplifyboolTrueAra ONNX grafiğini onnxslim ile sadeleştirir.
opsetintNoneAra ONNX grafiğinin ONNX opset sürümü. Belirtilmediğinde 19 kullanılır ve daha yüksek değerler 19 değerine düşürülür.
nmsbool, isteğe bağlıNoneRKNN modelleri harici NMS için her zaman ham tahminler döndürür. NMS'siz başlık (False) ve gömülü NMS (True) kullanılamaz; Sınırlamalar ve Sorun Giderme bölümüne bak.
devicestrNoneAra ONNX grafiğini izleyen cihaz: cpu (varsayılan) veya CUDA GPU için 0.

Tüm biçimlerde ortak olan bağımsız değişkenler için Dışa aktarma modu belgelerine bak.

Hedef Yongalar#

Bir .rknn dosyası tek bir yonga için oluşturulur; yongayı name seçer. Boyutlar, quantize belirtilmeden imgsz=640 ile dışa aktarılan bir YOLO26n nesne algılama modeli içindir:

nameDuyarlılıklarquantize belirtilmediğinde oluşturulanlarYOLO26n dosyasıBoyut
rk3588FP16, INT8FP16yolo26n-rk3588.rknn7.4 MB
rk3576FP16, INT8FP16yolo26n-rk3576.rknn10.5 MB
rk3566FP16, INT8FP16yolo26n-rk3566.rknn6.8 MB
rk3568FP16, INT8FP16yolo26n-rk3568.rknn6.8 MB
rk3562FP16, INT8FP16yolo26n-rk3562.rknn6.8 MB
rk2118FP16, INT8FP16yolo26n-rk2118.rknn6.8 MB
rv1126bFP16, INT8FP16yolo26n-rv1126b.rknn7.1 MB
rv1103INT8INT8yolo26n-rv1103.rknn4.2 MB
rv1106INT8INT8yolo26n-rv1106.rknn4.2 MB
rv1103bINT8INT8yolo26n-rv1103b.rknn4.2 MB
rv1106bINT8INT8yolo26n-rv1106b.rknn4.2 MB

Yalnızca INT8 destekleyen dört yonga, bu tablodaki varsayılan coco8.yaml üzerinde kalibre edilir; bu yongalar için yapılan dışa aktarımlar tail.onnx dosyasını da oluşturur.

Kuantizasyon#

quantize, .rknn dosyasının duyarlılığını seçer. Boyutlar imgsz=640 ile dışa aktarma için ve batch=1 belirtilmediğinde geçerlidir:

quantizeKesinlikKalibrasyon verileriYOLO26n ve rk3588 dosyalarıBoyut
belirtilmemiş veya 16FP16Hayıryolo26n-rk3588.rknn7.4 MB
8INT8Evetyolo26n-rk3588.rknn ve tail.onnx4.3 MB ve 0.2 MB
  • FP16: Bunu destekleyen yedi yonga için varsayılan seçenektir. Kalibrasyon verisi gerekmez.
  • INT8: quantize=8, kalibrasyon görüntülerini modelden geçirir ve ağırlıkları ile aktivasyonları 8 bitlik tam sayılar olarak saklar. Dışa aktarma, data öğesinin val bölmesinde veya split ile belirttiğin bölmede kalibrasyon yapar ve 300'den az görüntü olduğunda uyarı verir. Görüntü sayısını sınırlamak için fraction kullan.
  • Karma duyarlılık: FP16'yı destekleyen yedi yongada, bir INT8 dışa aktarımı, kuantizasyon çıktısını çok fazla değiştirdiğinde RKNN Toolkit'in katmanları FP16'da tutmasına olanak verir (auto_hybrid). Yalnızca INT8 destekleyen dört yongada bu adım atlanır.
  • Algılama başlığı: detect, segment, pose ve OBB modellerinde INT8 .rknn dosyası, başlığın çıktı evrişim katmanlarında sona erer. Bu çıktıları kutulara dönüştüren işlemler tail.onnx olarak kaydedilir ve cihazın CPU'sunda kayan nokta biçiminde çalıştırılır; çünkü tensör başına INT8, kutu çözümlemesinin piksel aralığındaki değerlerini tutamaz.
  • Derinlik modelleri: INT8 derinlik dışa aktarımları, derinlik haritalarıyla eşleştirilmiş derinlik veri kümesi görüntüleri üzerinde kalibrasyon yapar. Dağıtım sahnesinin yakın ve uzak derinlik aralıklarını kapsayan kalibrasyon görüntüleri seç. Dört doğrulama görüntüsü içeren varsayılan depth8.yaml ile rknn-toolkit2 simülatöründe bir YOLO26n-depth INT8 modeli, FP16 modelinin 13.9'a kadar değer döndürdüğü bir sokak görüntüsü için 3.9'a kadar derinlik değerleri döndürdü.
  • Cihaz üzerindeki durum: Her görevin INT8 dışa aktarımları rknn-toolkit2 simülatöründe çalıştırıldı ve tek bir görüntüde ONNX modeliyle karşılaştırıldı. Doğrulukları bir veri kümesinde veya Rockchip donanımında ölçülmedi; bu nedenle bir INT8 modelini dağıtımdan önce kendi cihazında ve kendi verilerinle doğrula.
Örnek
from ultralytics import YOLO

model = YOLO("yolo26n.pt")

# COCO doğrulama görüntülerinin %10'u (500 görüntü) üzerinde kalibrasyon yap; coco.yaml dosyasını kendi veri kümenle değiştir
model.export(format="rknn", name="rk3588", quantize=8, data="coco.yaml", fraction=0.1)

Çıktı Biçimi#

Dışa aktarma tek bir dizin oluşturur:

Dosyaİçindekiler
yolo26n-rk3588.rknnModel; dosya adında name ile belirlenen yonga için
tail.onnxYalnızca INT8 detect, segment, pose ve OBB modelleri için: başlık çıktılarını ham tahminlere dönüştüren ve CPU'da çalıştırılacak işlemler
metadata.yamlUltralytics'in modeli yüklerken okuduğu sınıf adları, görev, görüntü boyutu, yığın boyutu, stride ve dışa aktarma bağımsız değişkenleri

Ara yolo26n.onnx dosyası dizinin yanında kalır. .rknn modeli, (batch, height, width, 3) şekilli tek bir girdi alır: RGB, kanallar sonda (NHWC), değerleri 0 ile 255 arasında olan uint8. 255'e bölme işlemi modelin bir parçasıdır; bu nedenle görüntüyü kendin ölçeklendirme. Bu, 0-1 aralığına ölçeklenmiş kanal-önce float32 görüntüleri alan ONNX dışa aktarımından farklıdır.

Çıktılar göreve ve duyarlılığa bağlıdır. Aşağıdaki şekiller, anlamsal segmentasyon için Cityscapes kontrol noktası yolo26n-sem.pt olmak üzere, varsayılan dışa aktarma boyutlarında resmî YOLO26n kontrol noktaları içindir:

GörevVarsayılan imgszFP16 çıktısı ve INT8 için tail.onnx çıktısıINT8 .rknn çıktısı
Detect640(1, 84, 8400)tail.onnx tarafından çözümlenen 6 başlık tensörü
Segment640(1, 116, 8400) ve (1, 32, 160, 160)9 başlık tensörü ve tail.onnx tarafından çözümlenen (1, 32, 160, 160)
Anlamsal1024(1, 19, 1024, 1024); her sınıf ve piksel için bir skorFP16 ile aynı
Derinlik768(1, 1, 768, 768), derinlik haritasıFP16 ile aynı
Sınıflandırma224(1, 1000), sınıf olasılıklarıFP16 ile aynı
Poz640(1, 56, 8400)tail.onnx tarafından çözümlenen 9 başlık tensörü
OBB1024(1, 20, 21504)tail.onnx tarafından çözümlenen 9 başlık tensörü
  • Ham tahminler: FP16 modeller ve INT8 modeller için tail.onnx, varsayılan ONNX dışa aktarımıyla aynı ham tahminleri döndürür: her bir anchor için girdi piksellerinde kutu merkezi x, merkez y, genişlik ve yükseklik; ardından sınıf skorları ve son olarak göreve özgü değerler (32 maske katsayısı, 17 x 3 anahtar nokta değeri veya radyan cinsinden OBB açısı). NMS'yi kendin uygula. Her görevin düzeni için ONNX çıktı biçimine bak.
  • INT8 başlık tensörleri: INT8 nesne algılama modeli, üç algılama ölçeğinin her biri için iki tensör döndürür; biri kutu değerlerini, diğeri sınıf skorlarını içerir. Segmentasyon, pose ve OBB modelleri ise ek değerleri içeren, her ölçek için bir tensör daha döndürür. Tensörleri modelin döndürdüğü sırayla tail.onnx öğesine ver; segmentasyon modeli ayrıca maske prototiplerini değiştirmeden tail.onnx üzerinden geçirir.
  • Anlamsal segmentasyon: çıktı, ONNX dışa aktarımındaki sınıf haritasını değil, her sınıf ve piksel için bir skor içerir. Bu nedenle kendi kodunda sınıf ekseni üzerinde argmax uygula.
  • NMS: NMS'siz veya gömülü NMS çıktısı yoktur; Sınırlamalar ve Sorun Giderme bölümüne bak.

YOLO("yolo26n_rknn_model"), düzeni metadata.yaml üzerinden okur, tail.onnx işlemini çalıştırır ve NMS uygular; bu nedenle modeli kendi kodunda çalıştırdığında bu ayrıntılara ihtiyaç duyarsın. metadata.yaml anahtarları arasında names, task, imgsz, stride, batch, end2end, args ve pose modelleri için kpt_shape bulunur.

RKNN Toolkit Lite2 ile çalıştırma#

Modeli Ultralytics paketi dışında cihazda çalıştırmak için rknn-toolkit-lite2 paketiyle yükle ve INT8 detect, segment, pose veya OBB modelinin çıktılarını ONNX Runtime ile tail.onnx öğesine aktar:

# Önce dışa aktar: yolo export model=yolo26n.pt format=rknn name=rk3588 quantize=8 data=coco8.yaml
import numpy as np
import onnxruntime as ort
from rknnlite.api import RKNNLite

rknn = RKNNLite()
assert rknn.load_rknn("yolo26n_rknn_model/yolo26n-rk3588.rknn") == 0
assert rknn.init_runtime() == 0

image = np.zeros((1, 640, 640, 3), dtype=np.uint8)  # harf kutusu uygulanmış görüntün: RGB, NHWC, 0-255
outputs = rknn.inference(inputs=[image])  # INT8 nesne algılama modeli için altı başlık tensörü

tail = ort.InferenceSession("yolo26n_rknn_model/tail.onnx", providers=["CPUExecutionProvider"])
feed = {t.name: x.astype(np.float32) for t, x in zip(tail.get_inputs(), outputs)}
predictions = tail.run(None, feed)[0]  # shape (1, 84, 8400), NMS gerektiren ham tahminler
assert predictions.shape == (1, 84, 8400), "export a detection model at imgsz=640 with quantize=8"

tail.onnx, dışa aktarma batch değeri ne olursa olsun 1 toplu iş boyutuna sahiptir; bu nedenle daha büyük bir toplu iş boyutuyla dışa aktarılan bir modelde her görüntü için bir kez çalıştır. FP16 modelinde tail.onnx bulunmaz ve outputs[0] ham tahminleri zaten içerir.

Dağıt#

Rockchip cihazında paketi pip install ultralytics ile yükle ve yolo26n_rknn_model/ dizinini cihaza kopyala; Quickstart'taki protobuf ve numpy sürümleri yalnızca dışa aktarma için gerekir. Ardından YOLO("yolo26n_rknn_model"), modeli rknn-toolkit-lite2 Python paketiyle NPU'da çalıştırır. Ultralytics bu paketi, dizinde bir tail.onnx bulunduğunda ilk kullanımda onnxruntime ile birlikte yükler. Cihazda Python 3.12 veya daha eski bir sürüm bulunmalıdır; rknn-toolkit-lite2 derlemelerinin bulunduğu en yeni sürüm budur.

  • Rockchip cihazı gerekir: Ultralytics bir RKNN modelini yalnızca, cihaz ağacı compatible dizgesi desteklenen yonga adlarından biriyle biten 64 bit ARM Linux sistemlerinde yükler. Diğer tüm ortamlarda yükleme başarısız olur; Sınırlamalar ve Sorun Giderme bölümüne bak. rknn-toolkit-lite2 de yalnızca 64 bit ARM Linux için derlemelere sahiptir; dolayısıyla bu koşulları karşılamayan bir hedefte .rknn dosyasını Rockchip'in C API'siyle çalıştır ve tail.onnx öğesini çalıştır ya da aynı çözümlemeyi kendi kodunda uygula.
  • Eşleşen yonga: kartındaki yonganın name değeriyle dışa aktar.
  • Sabit girdi şekli: model her zaman dışa aktarma sırasında belirlenen imgsz ve batch değerlerinde çalışır; Ultralytics bunları metadata.yaml üzerinden okur. predict veya val öğesine aktarılan imgsz yok sayılır. Daha büyük toplu işler, dışa aktarma toplu iş boyutundaki parçalara bölünür; daha küçük toplu işler ise doldurulur. Böylece herhangi bir sayıda görüntü kullanılabilir.
  • device: seçilecek bir cihaz yoktur. .rknn modeli RKNN çalışma zamanı üzerinden, tail.onnx ise CPU'da ONNX Runtime ile çalışır.

Bu iş akışının önceki bir sürümü Radxa Rock 5B (RK3588) ve Radxa Zero 3W (RK3566) üzerinde test edildi. Mevcut INT8 dışa aktarımı henüz donanımda çalıştırılmadı.

Dağıtım Kılavuzları#

Sınırlamalar ve Sorun Giderme#

  • Dışa aktarma ana makinesi: dışa aktarmayı x86-64 Linux makinesinde yap. macOS'te dışa aktarma rknn-toolkit2 paketini yükleyemez ve No module named 'rknn' hatası verir; paketin macOS veya Windows derlemeleri yoktur. Rockchip kartları dâhil ARM64 Linux'ta dışa aktarma test edilmemiştir ve desteklenmez: Ultralytics, RKNN dışa aktarımını yalnızca x86-64 Linux'ta test eder.

  • Python sürümü: rknn-toolkit2 2.3.2, Python 3.12 ve daha eski sürümler için derlemelere sahiptir. Daha yeni bir Python sürümünde ortamı Python 3.12 ile oluştur.

  • Yeni ortamda ilk dışa aktarma: Quickstart'taki protobuf ve numpy sürümlerinin bulunmadığı bir ortamda ilk dışa aktarma, çalışma sırasında bu paketleri değiştirir ve başarısız olur. pip'in onnx ile birlikte yüklediği protobuf 7'yi değiştirdiğinde hata AttributeError: 'google._upb._message.FieldDescriptor' object has no attribute 'label' olur; yalnızca numpy değiştiğinde hata TypeError: only 0-dimensional arrays can be converted to Python scalars olur. Dışa aktarmayı yeni bir süreçte yeniden çalıştır; not defterinde bu, çekirdeği yeniden başlatmak demektir. Alternatif olarak, Quickstart bölümündeki gibi ilk dışa aktarmadan önce "protobuf<7" "numpy<2.4" paketini yükle.

  • RKNN modelleri bilgisayarda çalışmaz: bilgisayarda veya /proc/device-tree/compatible dizgesi desteklenen yonga adlarından biriyle bitmeyen bir kartta YOLO("yolo26n_rknn_model") ile tahmin yapmak ya da doğrulama çalıştırmak RKNN inference is only supported on Rockchip devices. hatası verir. Dizgeyi cat /proc/device-tree/compatible ile yazdır.

  • FP32: quantize=32, quantize=32 (FP32) is not supported; format='rknn' supports quantize=16 (FP16), 8 (INT8). hatası verir.

  • Yalnızca INT8 destekleyen yongalar: rv1103, rv1106, rv1103b ve rv1106b için quantize olmadan yapılan bir dışa aktarma Rockchip target 'rv1106' requires INT8 quantization, enabling it. günlüğünü yazar ve INT8 modeli oluşturur; quantize=16 ise Rockchip target 'rv1106' only supports INT8, but got quantize=16. hatası verir.

  • Eksik veya yanlış name: name olmadan dışa aktarma Rockchip RKNN export requires a missing 'name' arg for processor type. Using default name='rk3588'. günlüğünü yazar. Bilinmeyen bir değer, geçerli adları listeleyen Invalid processor name 'rk9999' for Rockchip RKNN export. hatasıyla başarısız olur.

  • NMS'siz başlık: RKNN modelleri her zaman NMS gerektiren ham tahminler döndürür. nms=False ile YOLO26 veya YOLOv10 modelinin dışa aktarımı This export format does not support end2end models, disabling the end2end branch. günlüğünü yazar ve bire-çok başlığı kullanır; örneğin YOLO11 gibi diğer nesne algılama, segmentasyon, pose ve OBB modelleri için This model has no one-to-one head; using one-to-many outputs. günlüğünü yazar. Sınıflandırma, anlamsal segmentasyon ve derinlik modelleri nms=False seçeneğini yok sayar.

  • Gömülü NMS: nms=True, format=rknn does not support embedded NMS; exporting native outputs for external NMS. günlüğünü yazar ve ham çıktıyı kaydeder.

  • quantize=8 ile eğitilmiş kontrol noktaları: kuantizasyon farkındalıklı eğitim ile ince ayar yapılmış bir kontrol noktası format='rknn' cannot export a QAT model: its Q/DQ ranges are only read by the 'onnx' and 'engine' backends hatası verir. Bunun yerine, ince ayara başladığın kontrol noktasını quantize=8 ile dışa aktar.

  • RT-DETR: rknn-toolkit2 2.3.2 ile bir RT-DETR modelinin dışa aktarımı, FP16 ve INT8 biçimlerinde araç takımının içinde başarısız olur; rtdetr-l.pt için imgsz=640 noktasında ValueError: operands could not be broadcast together with shapes (256,256) (8400,1) hatası verir.

  • Sabit girdi şekli: dynamic=True, argument 'dynamic' is not supported for format='rknn' hatası verir. Görüntü boyutunu veya toplu iş boyutunu değiştirmek için yeniden dışa aktar.

  • data olmadan kalibrasyon: Bir nesne algılama modelinin quantize=8 dışa aktarımı INT8 export requires a missing 'data' arg for calibration. Using default 'data=coco8.yaml'. günlüğünü yazar ve bu küçük veri kümesinde kalibrasyon yapar; diğer görevler kendi varsayılan veri kümelerini belirtir. Dağıtım verilerini temsil eden görüntüler içeren data öğesini aktar.

  • Kalibrasyon boyutu: Kalibrasyon bölmesinde 300'den az görüntü olduğunda dışa aktarma >300 images recommended for INT8 calibration, found 4 images. günlüğünü yazar. coco8.yaml yalnızca 4 doğrulama görüntüsü içerir; bu sayı dışa aktarmayı test etmek için yeterlidir, ancak bir modeli dağıtım için kalibre etmeye yetmez.

  • Çıktı dizini: Bir kontrol noktasının her dışa aktarımı, name, quantize, imgsz veya batch ne olursa olsun aynı yolo26n_rknn_model/ dizinini oluşturur ve önceki içeriği siler. İkinci bir yonga veya duyarlılık için dışa aktarmadan önce dizini yeniden adlandır ve adına _rknn_model ekle; örneğin yolo26n_rk3566_rknn_model/, çünkü Ultralytics biçimi bu ifadeden tanır.

  • ONNX opset: 19'un üzerindeki bir opset, rknn-toolkit2 requires opset<=19, setting opset=19. kaydeder

  • Önceki sürümlerdeki INT8 modelleri: ultralytics 8.4.191 sürümünden önce (tail.onnx özelliğini ekleyen sürüm) dışa aktarılmış INT8 nesne algılama, segmentasyon, poz kestirimi ve OBB modellerini yeniden dışa aktar. Bu modeller, kutu ve anahtar nokta koordinatlarını girdi boyutuna göre döndürür; güncel sürümler bu koordinatları artık yeniden ölçeklendirmediğinden modeller hatasız yüklenir ancak yanlış kutular döndürür.

  • Çalışma zamanı sürümü uyuşmazlığı: cihazdaki günlükte RKNN çalışma zamanı sürümünün RKNN Toolkit sürümüyle eşleşmediği bildiriliyor ve çıkarım başarısız oluyorsa /usr/lib/librknnrt.so dosyasını resmi librknnrt.so dosyasıyla değiştir.

    Model araç takımı sürümünün librknnrt çalışma zamanı sürümüyle eşleşmediğini belirten RKNN günlük uyarısı

Diğer hatalar için Yaygın Sorunlar kılavuzuna bak.

Kıyaslamalar#

Aşağıdaki YOLO26 kıyaslamaları, hız ve doğruluk ölçümleri için Rockchip RK3588 tabanlı Radxa Rock 5B üzerinde rknn model biçimi kullanılarak Ultralytics ekibi tarafından gerçekleştirildi.

Performans
ModelBiçimKesinlikDurumBoyut (MB)mAP50-95(B)Çıkarım süresi (ms/im)
YOLO26nrknnFP16✅7.20.47758.5
YOLO26nrknnINT8✅4.10.46341.2
YOLO26srknnFP16✅21.00.56993.8
YOLO26srknnINT8✅12.00.55461.9
YOLO26mrknnFP16✅43.00.608226.3
YOLO26mrknnINT8✅22.00.603122.0
YOLO26lrknnFP16✅53.00.628264.7
YOLO26lrknnINT8✅28.00.617145.3
YOLO26xrknnFP16✅113.00.664655.4
YOLO26xrknnINT8✅58.00.649287.4

ultralytics 8.4.60 ile kıyaslandı

Not

Yukarıdaki kıyaslamalara yönelik doğrulama COCO128 veri kümesi kullanılarak yapıldı. Çıkarım süresine ön ve son işleme dahil değildir. Mevcut INT8 dışa aktarma yolu (ana bilgisayar tarafında çözümleme ve auto_hybrid) Rockchip donanımında doğrulandıktan sonra INT8 satırları güncellenecektir.

Tablodaki boyutlar önceki sürümle kaydedilmiştir; bu sayfanın başka yerlerindeki boyutlar, güncel bir dışa aktarımdaki .rknn dosyasının MB (10^6 bayt) cinsinden boyutudur. YOLO26 model sayfasında PyTorch kontrol noktalarının COCO tam doğrulama kümesindeki doğruluk değerleri listelenir.

RKNN hakkında#

Rockchip, Radxa, ASUS, Pine64, Orange Pi, Odroid, Khadas ve Banana Pi gibi şirketlerin tek kartlı bilgisayarlarında ve gömülü ürünlerinde kullanılan, yerleşik NPU'lara sahip ARM tabanlı yongada sistemler tasarlar. Rockchip Neural Network'ün kısaltması olan RKNN, bu NPU'ların model biçimidir; RKNN Toolkit ise modelleri bir bilgisayarda bu biçime dönüştürür ve cihazda çalıştırır.

Rockchip RKNN export for NPU deployment

Sık Sorulan Sorular#

  • Kartın adını değil, işlemcinin adını kullan: örneğin Radxa Rock 5B için rk3588, Radxa Zero 3W içinse rk3566. Kartta cat /proc/device-tree/compatible, Ultralytics'in yongayı tanımak için okuduğu dizgeyi yazdırır. Bir yonga için dışa aktarılan model başka bir yonga için oluşturulmamıştır; bu nedenle her yonga için ayrı dışa aktarım yap. Kabul edilen adlar için Hedef Yongalar bölümüne bak.

  • Varsayılan seçenek olan FP16 ile başla. Kalibrasyon verisi gerektirmez ve ham tahminlerini CPU'da ikinci bir model çalıştırmadan döndürür. Daha küçük ve hızlı bir model gerektiğinde veya yonga yalnızca INT8 desteklediğinde INT8'i (quantize=8) seç: RK3588 için YOLO26n, INT8'de 4.3 MB, FP16'da ise 7.4 MB'tır; önceki bir dışa aktarımla ölçülen karşılaştırma testlerinde INT8, YOLO26n'ı görüntü başına 41.2 ms'de, FP16 ise 58.5 ms'de çalıştırmıştır. INT8, temsili kalibrasyon verisi gerektirir ve algılama, segmentasyon, poz ve OBB modellerinde kutu çözümlemesini CPU'da tail.onnx ile gerçekleştirir. Seçimini yapmadan önce cihazındaki gecikme süresini ve doğruluğu ölç.

  • RKNN modellerini yalnızca Rockchip cihazlarında yükleyen YOLO() ile bunu yapamazsın. Modelin kendisini bilgisayarda kontrol etmek için PyTorch kontrol noktasını veya dışa aktarımın dizinin yanına bıraktığı ara yolo26n.onnx dosyasını ONNX Runtime ile doğrula: RKNN modeli bu grafikten dönüştürülür. Bu, özellikle INT8 için cihazda doğrulama yapmanın yerini tutmaz; çünkü niceleme çıktıları değiştirir.

  • Evet, her hızlandırıcının dışa aktarım biçimini kullanarak: RKNN modeli yalnızca Rockchip NPU'larında çalışır. NVIDIA Jetson için TensorRT, Hailo, Axelera, DeepX ve Coral Edge TPU sayfalarına bak veya genel bilgi için model dağıtım seçenekleri kılavuzuna göz at.

Yorumlar45

Bir soru sor, sonuçlarını paylaş veya başka birine yardım et.

  1. as-jacksonGitHub

    We are pleased to confirm that the following ArmSoM boards based on Rockchip RK3576 have been successfully tested with Ultralytics projects (e.g., YOLO11n):

    ArmSoM-Sige5 ArmSoM-CM5

    Validation Scope:

    Model training/inference pipeline

    1
  2. yizi72GitHub

    I tried to convert the yolo11n.pt into a rknn model through codes below: from ultralytics import YOLO model = YOLO("yolo11n.pt") model.export(format="rknn", name="rk3588") and everything went correct. A rknn model named yolo11n-rk3588.rknn was build and used to infer a very traditional yolo demo image "bus"(a blue bus with several people in front of it), but no detection result was obtained.

    I tried to convert the yolol11n.pt into onnx model through above codes firstly, and then used a convert.py offered by rknn_model_zoo/examples/yolo11/python,

    import sys from rknn.api import RKNN

    DATASET_PATH = '../../../datasets/COCO/coco_subset_20.txt' DEFAULT_RKNN_PATH = '/home/yizi/model/yolo11/yolodet.rknn' DEFAULT_QUANT = False

    def parse_arg(): if len(sys.argv) < 3: print("Usage: python3 {} onnx_model_path [platform] [dtype(optional)] [output_rknn_path(optional)]".format(sys.argv[0])) print(" platform choose from [rk3562,rk3566,rk3568,rk3588,rk3576,rk1808,rv1109,rv1126]") print(" dtype choose from [i8, fp] for [rk3562,rk3566,rk3568,rk3588,rk3576]") print(" dtype choose from [u8, fp] for [rk1808,rv1109,rv1126]") exit(1)

    model_path = sys.argv[1]
    platform = sys.argv[2]
    
    do_quant = DEFAULT_QUANT
    if len(sys.argv) > 3:
        model_type = sys.argv[3]
        if model_type not in ['i8', 'u8', 'fp']:
            print("ERROR: Invalid model type: {}".format(model_type))
            exit(1)
        elif model_type in ['i8', 'u8']:
            do_quant = True
        else:
            do_quant = False
    
    if len(sys.argv) > 4:
        output_path = sys.argv[4]
    else:
        output_path = DEFAULT_RKNN_PATH
    
    return model_path, platform, do_quant, output_path

    if name == 'main': model_path, platform, do_quant, output_path = parse_arg()

    # Create RKNN object
    rknn = RKNN(verbose=False)
    
    # Pre-process config
    print('--> Config model')
    rknn.config(mean_values=[[0, 0, 0]], std_values=[[255, 255, 255]], target_platform=platform)
    print('done')
    
    # Load model
    print('--> Loading model')
    ret = rknn.load_onnx(model=model_path)
    if ret != 0:
        print('Load model failed!')
        exit(ret)
    print('done')
    
    # Build model
    print('--> Building model')
    ret = rknn.build(do_quantization=do_quant, dataset=DATASET_PATH)
    if ret != 0:
        print('Build model failed!')
        exit(ret)
    print('done')
    
    # Export rknn model
    print('--> Export rknn model')
    ret = rknn.export_rknn(output_path)
    if ret != 0:
        print('Export rknn model failed!')
        exit(ret)
    print('done')
    
    # Release
    rknn.release()

    Still everything went correct. A rknn model was created and applied to "bus.jpg", and there was no detection at all. I wonder what's wrong in the whole process?

    1
    1. Glenn JocherUltralytics

      @yizi72 thanks for the detailed report. For RKNN inference issues with YOLO11, please ensure:

      1. You're using matching RKNN Toolkit and runtime versions (update both if needed)
      2. Input images are 640x640 with pixel values normalized 0-255
      3. You load models via YOLO('./yolo11n_rknn_model') as shown in our RKNN deployment docs

      If issues persist, please share your full environment details and validation results from both export methods.

    2. yizi72GitHub

      1、I used rknn-toolkit2-2.3.0 which is the latest version ,bu I still did "pip install rknn-toolkit2 --upgrade" again. 2、The input image is 640*640, uchar, 0-255. 3. I used the following setting to transfer yolo11n.pt to onnx, from ultralytics import YOLO

      加载一个模型,路径为 YOLO 模型的 .pt 文件

      model = YOLO("yolo11n.pt")

      导出模型,设置多种参数

      model.export( format="onnx", imgsz=(640, 640),
      keras=False,
      optimize=True,
      half=False,
      int8=False,
      dynamic=False,
      simplify=True,
      opset=12,
      #workspace=4.0,
      nms=False,
      batch=1
      ) and applied the following codes to verify yolo11n.onnx model:

      from ultralytics import YOLO from PIL import Image

      Load a model

      model = YOLO("/home/yizi/models/yolo11/yolo11n.onnx") # load an official model

      Predict with the model

      results = model("bus.jpg") # predict on an image #results = rknn_model("bus.jpg")

      Access the results

      for result in results: xywh = result.boxes.xywh # center-x, center-y, width, height xywhn = result.boxes.xywhn # normalized xyxy = result.boxes.xyxy # top-left-x, top-left-y, bottom-right-x, bottom-right-y xyxyn = result.boxes.xyxyn # normalized names = [result.names[cls.item()] for cls in result.boxes.cls.int()] # class name of each box confs = result.boxes.conf # confidence score of each box

      The results are good. All objects in bus.jpg were detected. Then I run the following code to transfer onnx to rknn:

      from rknn.api import RKNN import cv2 import numpy as np

      if name == 'main': rknn = RKNN(verbose=True,verbose_file="log.txt") rknn.config( mean_values=[[0, 0, 0]], std_values=[[255, 255, 255]], target_platform="rk3588", optimization_level=3 )

      rknn.load_onnx(
          model="/home/yizi/models/yolo11/yolo11n.onnx",
          input_size_list=[[1,3,640,640]], 

      )

      rknn.build(
          do_quantization=False 
      )
      
      rknn.export_rknn(
          export_path="/home/yizi/models/yolo11/yolo11n.rknn" 
      )
      
      rknn.release()

      The transferring process went smooth, two problems appeared.

      Firstly,when this rknn model was pushed into a rk3588 tablet, and run with a binary executable file generated by cross-compilation, no result was detected.

      Secondly, I tried to run the following codes:

      from ultralytics import YOLO from PIL import Image

      rknn_model = YOLO("/home/yizi/models/yolo11/yolo11n.rknn", task=detect)

      results = model("bus.jpg")

      An error message, "model='/home/yizi/models/yolo11/yolo11n.rknn' is not a supported model format. Ultralytics supports: ('PyTorch', 'TorchScript', 'ONNX', 'OpenVINO', 'TensorRT', 'CoreML', 'TensorFlow SavedModel', 'TensorFlow GraphDef', 'TensorFlow Lite', 'TensorFlow Edge TPU', 'TensorFlow.js', 'PaddlePaddle', 'MNN', 'NCNN', 'IMX', 'RKNN') See https://docs.ultralytics.com/modes/predict for help. " appeared.

      Last question, how many outputs does yolo11 yield? one or six?

    3. Glenn JocherUltralytics

      @yizi72 thank you for the detailed report. For RKNN deployment issues:

      1. When using Ultralytics RKNN export, load models via the exported directory (not .rknn file), as shown in our RKNN deployment docs:
      model = YOLO('./yolo11n_rknn_model')  # directory path
      1. Ensure your RK3588 runtime uses matching librknnrt.so versions with your RKNN Toolkit 2.3.0 installation

      2. YOLO11 detection models output 3 tensors by default (different from older YOLO versions). For conversion issues, we recommend using our native model.export(format='rknn') rather than manual ONNX conversion.

      Let me know if you still face issues after verifying these points.

    4. yizi72GitHub

      Thanks for replies. I did verify all points you've mentioned above. When running model("bus.jpg"), error messages show:

      File "/home/yizi/anaconda3/envs/rknn/lib/python3.9/site-packages/ultralytics/engine/model.py", line 182, in call return self.predict(source, stream, **kwargs) File "/home/yizi/anaconda3/envs/rknn/lib/python3.9/site-packages/ultralytics/engine/model.py", line 543, in predict self.predictor.setup_model(model=self.model, verbose=is_cli) File "/home/yizi/anaconda3/envs/rknn/lib/python3.9/site-packages/ultralytics/engine/predictor.py", line 378, in setup_model self.model = AutoBackend( File "/home/yizi/anaconda3/envs/rknn/lib/python3.9/site-packages/torch/utils/_contextlib.py", line 116, in decorate_context return func(*args, **kwargs) File "/home/yizi/anaconda3/envs/rknn/lib/python3.9/site-packages/ultralytics/nn/autobackend.py", line 495, in init raise OSError("RKNN inference is only supported on Rockchip devices.") OSError: RKNN inference is only supported on Rockchip devices.

      It's very strange because I did connect a RK3588 tablet with my virtual machine.

      I still have a quesiton on yolo11n output: yolo11n.pt has one output with shape (1, 84, 8400), and yolo11n-rk3588.rknn has one output with shape (1,84, 8400, 0). Are they correct? If so, can I use the similar codes to analyze rknn output, such as :

      for result in results: xywh = result.boxes.xywh # center-x, center-y, width, height xywhn = result.boxes.xywhn # normalized xyxy = result.boxes.xyxy # top-left-x, top-left-y, bottom-right-x, bottom-right-y xyxyn = result.boxes.xyxyn # normalized names = [result.names[cls.item()] for cls in result.boxes.cls.int()] # class name of each box confs = result.boxes.conf

    5. Glenn JocherUltralytics

      @yizi72 thanks for the details. For the RKNN inference error: ensure your Python script is running directly on the RK3588 hardware (not through a VM) as RKNN models require native Rockchip NPU access. Regarding outputs, YOLO11 detection models produce 3 output tensors by default (see our RKNN deployment docs), but your code should work if using the exported RKNN directory with the included postprocessing. Let me know if you still face issues after verifying native hardware execution.

  3. Yufeng Wu

    Hello, Ultralytics team. I wonder if it's possible to port yolo26n-pose to rknn? I'm not sure if it's difficult to work out on my own? Is there any model architecture problems that prevent porting the pose models to rknn?

  4. montemadjoGitHub

    It appears it does not support rv1106 platform yet

    When I try to export the model using this command

    model.export(format="rknn", name="rv1106", imgsz=320)

    It gives the following error

    E build: Current target_platform(rv1106) not support do_quantization = False!
    E export_rknn: RKNN model does not exist, please load & build model first!

    🤔

    1. Glenn JocherUltralytics(düzenlendi)

      rv1106 is an INT8-only target, so it needs a quantized RKNN build. Older Ultralytics releases always built with do_quantization=False, which fails with the message you saw. Current releases support it: upgrade with pip install -U ultralytics and export with quantize=8 plus calibration data:

      model.export(format="rknn", name="rv1106", imgsz=320, quantize=8, data="coco8.yaml")

      See the Rockchip RKNN export guide. If it still fails, share your !yolo checks output and rknn-toolkit2 version here and we can sanity-check the environment.

      1
    2. montemadjoGitHub(düzenlendi)

      Here's the quick workaround for those who want to work with yolo26 on RV1106 chip (like Luckfox pico etc). I ran into a couple of issues there, including quantization erasing my confidence results.

      Long story short - first you need to monkey-patch head.Detect.forward function in order to get two tensors - one for bboxes and one for scores. That way you escape all the heavy non-supported tensor functions. Then you export your yolo26 model to onnx format and finally to rknn like this

      import torch
      from ultralytics.nn.modules import head
      
      # 1. First we monkey-patch the forward function
      def patched_forward(self, x):
          if self.end2end:
              h = self.one2one
          else:
              h = self.one2many
      
          box_head = h["box_head"]
          cls_head = h["cls_head"]
      
          if box_head is None or cls_head is None:
              raise RuntimeError("Head moduls are None")
      
          bs = x[0].shape[0]
          boxes = torch.cat([box_head[i](x[i]).view(bs, 4 * self.reg_max, -1) for i in range(self.nl)], dim=-1)
          scores = torch.cat([cls_head[i](x[i]).view(bs, self.nc, -1) for i in range(self.nl)], dim=-1)
      
          preds = {"boxes": boxes, "scores": scores, "feats": x}
          y = self._inference(preds)
      
          # We are splitting into 2 tensors - both gets its own scale/zp at INT8 quantization
          bboxes = y[:, :4, :]   # [1, 4, 2100] — range 0-640
          scores = y[:, 4:, :]   # [1, 1, 2100] — range 0-1 (already sigmoid-ed)
          score_max_idx = scores[0, 0, :].argmax()
          return bboxes, scores
      
      head.Detect.forward = patched_forward
      
      # 2. Then we export to onnx model (we got best.pt model from ultralytics platform)
      from ultralytics import YOLO
      model = YOLO("best.pt")
      model.export(format="onnx", dynamic=False, opset=12, imgsz=320)
      
      # 3. Then we export to RKNN format
      from rknn.api import RKNN
      
      rknn = RKNN()
      
      # 3.1. Konfiguracija specifična za RV1106
      rknn.config(
          mean_values=[[0, 0, 0]], 
          std_values=[[255, 255, 255]], 
          target_platform='rv1106',
          quantized_algorithm='normal', # Ili 'mmse' za bolju preciznost
          quantized_dtype='asymmetric_quantized-8'
      )
      
      # 3.2. Load the ONNX model
      print("Loading ONNX model...")
      rknn.load_onnx(model='best.onnx')
      
      # 3.3. Build modela sa INT8 kvantizacijom
      # calib.txt should contain paths to calibration images
      print("Building RKNN model with quantization...")
      rknn.build(do_quantization=True, dataset='./calib.txt')
      
      # 3.4. Exporting final .rknn file
      print("Exporting RKNN model...")
      rknn.export_rknn('./yolo26_rv1106_model_optimized.rknn')
      
      rknn.release()

      After this you need to postprocess those two outputs like this

      yolo26_postprocess.h

      /**
       * YOLO26 Post-processing header for Fish Counter
       *
       * Supports YOLO26 2-output format: boxes [1, 4, N] + scores [1, nc, N]
       *
       * Based on the working rknn_minimal_test example.
       */
      
      #ifndef _YOLO26_POSTPROCESS_H_
      #define _YOLO26_POSTPROCESS_H_
      
      #include <stdint.h>
      #include <vector>
      #include "rknn_api.h"
      #include "rknn_detector.h"
      
      // YOLO26 model configuration defaults
      #define YOLO26_CONF_THRESHOLD 0.25f
      #define YOLO26_NMS_THRESHOLD 0.45f
      
      // Detection result (same structure as postprocess.h for compatibility)
      typedef struct
      {
          float x1, y1, x2, y2; // Bounding box (in model coordinates)
          float confidence;
          int class_id;
      } yolo26_detection_t;
      
      // YOLO26 context for format detection and caching
      typedef struct
      {
          int num_predictions;
          int num_classes;
          bool boxes_transposed; // true = [1, 4, N], false = [1, N, 4]
      } yolo26_context_t;
      
      /**
       * Initialize YOLO26 post-processing
       * Detects the output format from model attributes
       *
       * @param app_ctx The RKNN app context with model info
       * @param yolo26_ctx Output: YOLO26 context for format info
       * @return 0 on success, -1 on error
       */
      int yolo26_init_postprocess(rknn_app_context_t *app_ctx, yolo26_context_t *yolo26_ctx);
      
      /**
       * Deinitialize YOLO26 post-processing
       */
      void yolo26_deinit_postprocess();
      
      /**
       * YOLO26 post_process: processes model outputs and returns detections
       * Uses 2-output format: boxes [1, 4, N] + scores [1, nc, N]
       *
       * @param app_ctx The RKNN app context
       * @param yolo26_ctx YOLO26 context from init
       * @param outputs Pointer to output tensor memory array
       * @param letter_box Letterbox transform info for coordinate mapping
       * @param conf_threshold Confidence threshold
       * @param nms_threshold NMS threshold
       * @param od_results Output: detection results (compatible with existing code)
       * @return 0 on success, -1 on error
       */
      int yolo26_post_process(rknn_app_context_t *app_ctx, yolo26_context_t *yolo26_ctx,
                              void *outputs, letterbox_t *letter_box,
                              float conf_threshold, float nms_threshold,
                              object_detect_result_list *od_results);
      
      #endif // _YOLO26_POSTPROCESS_H_

      yolo26_postprocess.cc

      /**
       * YOLO26 Post-processing for Fish Counter on RV1106
       *
       * Supports YOLO26 2-output format: boxes [1, 4, N] + scores [1, nc, N]
       *
       * Based on the working rknn_minimal_test example.
       */
      
      #include "yolo26_postprocess.h"
      
      #include <math.h>
      #include <stdint.h>
      #include <stdio.h>
      #include <stdlib.h>
      #include <string.h>
      #include <algorithm>
      #include <vector>
      
      // Clamp value to range
      inline static int clamp(float val, int min, int max)
      {
          return val > min ? (val < max ? val : max) : min;
      }
      
      // Dequantize INT8 to float
      static inline float dequantize(int8_t qnt, int32_t zp, float scale)
      {
          return ((float)qnt - (float)zp) * scale;
      }
      
      // Sigmoid function
      static inline float sigmoid(float x)
      {
          return 1.0f / (1.0f + expf(-x));
      }
      
      // Calculate IoU between two boxes
      static float calculate_iou(float x1_a, float y1_a, float x2_a, float y2_a,
                                 float x1_b, float y1_b, float x2_b, float y2_b)
      {
          float x1 = std::max(x1_a, x1_b);
          float y1 = std::max(y1_a, y1_b);
          float x2 = std::min(x2_a, x2_b);
          float y2 = std::min(y2_a, y2_b);
      
          float inter_w = std::max(0.0f, x2 - x1);
          float inter_h = std::max(0.0f, y2 - y1);
          float inter_area = inter_w * inter_h;
      
          float area_a = (x2_a - x1_a) * (y2_a - y1_a);
          float area_b = (x2_b - x1_b) * (y2_b - y1_b);
          float union_area = area_a + area_b - inter_area;
      
          return union_area > 0 ? inter_area / union_area : 0;
      }
      
      // Non-Maximum Suppression for YOLO26 detections
      static std::vector<yolo26_detection_t> yolo26_nms(std::vector<yolo26_detection_t> &detections, float nms_threshold)
      {
          // Sort by confidence (descending)
          std::sort(detections.begin(), detections.end(),
                    [](const yolo26_detection_t &a, const yolo26_detection_t &b)
                    { return a.confidence > b.confidence; });
      
          std::vector<yolo26_detection_t> result;
          std::vector<bool> suppressed(detections.size(), false);
      
          for (size_t i = 0; i < detections.size(); i++)
          {
              if (suppressed[i])
                  continue;
      
              result.push_back(detections[i]);
      
              for (size_t j = i + 1; j < detections.size(); j++)
              {
                  if (suppressed[j])
                      continue;
      
                  // Only suppress same class
                  if (detections[i].class_id != detections[j].class_id)
                      continue;
      
                  float iou = calculate_iou(
                      detections[i].x1, detections[i].y1, detections[i].x2, detections[i].y2,
                      detections[j].x1, detections[j].y1, detections[j].x2, detections[j].y2);
      
                  if (iou > nms_threshold)
                  {
                      suppressed[j] = true;
                  }
              }
          }
      
          return result;
      }
      
      // Parse YOLO26 2-output format: boxes [1, 4, N] + scores [1, nc, N]
      static std::vector<yolo26_detection_t> parse_yolo26_2output(
          rknn_tensor_mem **output_mems,
          rknn_tensor_attr *output_attrs,
          int model_width, int model_height,
          float conf_threshold, int num_classes,
          bool boxes_transposed)
      {
          std::vector<yolo26_detection_t> detections;
      
          int8_t *boxes_data = (int8_t *)output_mems[0]->virt_addr;
          int32_t boxes_zp = output_attrs[0].zp;
          float boxes_scale = output_attrs[0].scale;
      
          int8_t *scores_data = (int8_t *)output_mems[1]->virt_addr;
          int32_t scores_zp = output_attrs[1].zp;
          float scores_scale = output_attrs[1].scale;
      
          // Determine number of anchors
          int num_anchors;
          if (boxes_transposed)
          {
              num_anchors = output_attrs[0].dims[2];
          }
          else
          {
              num_anchors = output_attrs[0].dims[1];
          }
      
          // Check if scores are already sigmoid or logits
          float scores_min = 9999, scores_max = -9999;
          for (int i = 0; i < (int)output_attrs[1].n_elems; i++)
          {
              float val = dequantize(scores_data[i], scores_zp, scores_scale);
              if (val < scores_min)
                  scores_min = val;
              if (val > scores_max)
                  scores_max = val;
          }
          bool scores_are_sigmoid = (scores_min >= -0.1f && scores_max <= 1.1f);
      
          for (int i = 0; i < num_anchors; i++)
          {
              // Get box coordinates
              float x1, y1, x2, y2;
              if (boxes_transposed)
              {
                  // [1, 4, N] - channel first
                  x1 = dequantize(boxes_data[0 * num_anchors + i], boxes_zp, boxes_scale);
                  y1 = dequantize(boxes_data[1 * num_anchors + i], boxes_zp, boxes_scale);
                  x2 = dequantize(boxes_data[2 * num_anchors + i], boxes_zp, boxes_scale);
                  y2 = dequantize(boxes_data[3 * num_anchors + i], boxes_zp, boxes_scale);
              }
              else
              {
                  // [1, N, 4] - anchor first
                  x1 = dequantize(boxes_data[i * 4 + 0], boxes_zp, boxes_scale);
                  y1 = dequantize(boxes_data[i * 4 + 1], boxes_zp, boxes_scale);
                  x2 = dequantize(boxes_data[i * 4 + 2], boxes_zp, boxes_scale);
                  y2 = dequantize(boxes_data[i * 4 + 3], boxes_zp, boxes_scale);
              }
      
              // Check if format is xywh instead of xyxy
              if (x2 < x1 || y2 < y1)
              {
                  // Assume xywh format: convert to xyxy
                  float cx = x1, cy = y1, w = x2, h = y2;
                  x1 = cx - w / 2.0f;
                  y1 = cy - h / 2.0f;
                  x2 = cx + w / 2.0f;
                  y2 = cy + h / 2.0f;
              }
      
              // Find max class score
              float max_score = -9999;
              int max_class = 0;
              for (int c = 0; c < num_classes; c++)
              {
                  float score;
                  if (boxes_transposed)
                  {
                      // [1, nc, N]
                      score = dequantize(scores_data[c * num_anchors + i], scores_zp, scores_scale);
                  }
                  else
                  {
                      // [1, N, nc]
                      score = dequantize(scores_data[i * num_classes + c], scores_zp, scores_scale);
                  }
      
                  if (!scores_are_sigmoid)
                  {
                      score = sigmoid(score);
                  }
      
                  if (score > max_score)
                  {
                      max_score = score;
                      max_class = c;
                  }
              }
      
              if (max_score < conf_threshold)
                  continue;
      
              // Clamp to model bounds
              x1 = std::max(0.0f, std::min(x1, (float)model_width));
              y1 = std::max(0.0f, std::min(y1, (float)model_height));
              x2 = std::max(0.0f, std::min(x2, (float)model_width));
              y2 = std::max(0.0f, std::min(y2, (float)model_height));
      
              // Skip invalid boxes
              if (x2 <= x1 || y2 <= y1)
                  continue;
      
              yolo26_detection_t det;
              det.x1 = x1;
              det.y1 = y1;
              det.x2 = x2;
              det.y2 = y2;
              det.confidence = max_score;
              det.class_id = max_class;
      
              detections.push_back(det);
          }
      
          return detections;
      }
      
      int yolo26_init_postprocess(rknn_app_context_t *app_ctx, yolo26_context_t *yolo26_ctx)
      {
          if (!app_ctx || !yolo26_ctx)
          {
              printf("[YOLO26] ERROR: Invalid parameters\n");
              return -1;
          }
      
          memset(yolo26_ctx, 0, sizeof(yolo26_context_t));
      
          int n_output = app_ctx->io_num.n_output;
      
          printf("[YOLO26] Initializing 2-output format (%d outputs)...\n", n_output);
      
          // Print output tensor info
          for (int i = 0; i < n_output; i++)
          {
              printf("  Output %d: dims=[%d,%d,%d,%d], size=%d\n", i,
                     app_ctx->output_attrs[i].dims[0],
                     app_ctx->output_attrs[i].dims[1],
                     app_ctx->output_attrs[i].dims[2],
                     app_ctx->output_attrs[i].dims[3],
                     app_ctx->output_attrs[i].size);
          }
      
          if (n_output != 2)
          {
              printf("[YOLO26] ERROR: Expected 2 outputs (boxes + scores), got %d\n", n_output);
              return -1;
          }
      
          // Parse 2-output format: boxes + scores
          int boxes_dim1 = app_ctx->output_attrs[0].dims[1];
          int boxes_dim2 = app_ctx->output_attrs[0].dims[2];
          int scores_dim1 = app_ctx->output_attrs[1].dims[1];
          int scores_dim2 = app_ctx->output_attrs[1].dims[2];
      
          if (boxes_dim1 == 4)
          {
              // [1, 4, N] boxes format
              yolo26_ctx->num_predictions = boxes_dim2;
              yolo26_ctx->boxes_transposed = true;
              yolo26_ctx->num_classes = scores_dim1;
              printf("[YOLO26] Format: boxes [1,4,%d], scores [1,%d,%d]\n",
                     boxes_dim2, scores_dim1, scores_dim2);
          }
          else if (boxes_dim2 == 4)
          {
              // [1, N, 4] boxes format
              yolo26_ctx->num_predictions = boxes_dim1;
              yolo26_ctx->boxes_transposed = false;
              yolo26_ctx->num_classes = scores_dim2;
              printf("[YOLO26] Format: boxes [1,%d,4], scores [1,%d,%d]\n",
                     boxes_dim1, scores_dim1, scores_dim2);
          }
          else
          {
              printf("[YOLO26] ERROR: Invalid boxes dimensions [1,%d,%d], expected [1,4,N] or [1,N,4]\n",
                     boxes_dim1, boxes_dim2);
              return -1;
          }
      
          printf("[YOLO26] Predictions: %d, Classes: %d\n",
                 yolo26_ctx->num_predictions, yolo26_ctx->num_classes);
      
          return 0;
      }
      
      void yolo26_deinit_postprocess()
      {
          // Nothing to cleanup currently
      }
      
      int yolo26_post_process(rknn_app_context_t *app_ctx, yolo26_context_t *yolo26_ctx,
                              void *outputs, letterbox_t *letter_box,
                              float conf_threshold, float nms_threshold,
                              object_detect_result_list *od_results)
      {
          if (!app_ctx || !yolo26_ctx || !outputs || !letter_box || !od_results)
          {
              return -1;
          }
      
          rknn_tensor_mem **output_mems = (rknn_tensor_mem **)outputs;
      
          int model_width = app_ctx->model_width;
          int model_height = app_ctx->model_height;
      
          // Parse 2-output format
          std::vector<yolo26_detection_t> raw_detections = parse_yolo26_2output(
              output_mems,
              app_ctx->output_attrs,
              model_width, model_height,
              conf_threshold,
              yolo26_ctx->num_classes > 0 ? yolo26_ctx->num_classes : 1,
              yolo26_ctx->boxes_transposed);
      
          // Apply NMS
          std::vector<yolo26_detection_t> final_detections = yolo26_nms(raw_detections, nms_threshold);
      
          // Convert to output format with letterbox coordinate mapping
          memset(od_results, 0, sizeof(object_detect_result_list));
          int count = 0;
      
          for (const auto &det : final_detections)
          {
              if (count >= OBJ_NUMB_MAX_SIZE)
                  break;
      
              // Map coordinates back to original image space
              float x1 = det.x1 - letter_box->x_pad;
              float y1 = det.y1 - letter_box->y_pad;
              float x2 = det.x2 - letter_box->x_pad;
              float y2 = det.y2 - letter_box->y_pad;
      
              // Scale back to original coordinates
              od_results->results[count].box.left = (int)(clamp(x1, 0, model_width) / letter_box->scale);
              od_results->results[count].box.top = (int)(clamp(y1, 0, model_height) / letter_box->scale);
              od_results->results[count].box.right = (int)(clamp(x2, 0, model_width) / letter_box->scale);
              od_results->results[count].box.bottom = (int)(clamp(y2, 0, model_height) / letter_box->scale);
              od_results->results[count].prop = det.confidence;
              od_results->results[count].cls_id = det.class_id;
      
              count++;
          }
      
          od_results->count = count;
      
          return 0;
      }

      And you're good to go! 🚀

    3. Glenn JocherUltralytics(düzenlendi)

      Thanks for sharing this—splitting the head into 2 outputs (boxes + scores) is a sensible RV1106 workaround to keep RKNN-friendly ops and avoid INT8 scale/zero-point coupling issues; just note that monkey-patching head.Detect.forward is inherently version-fragile. Current Ultralytics already provides an INT8 flow for RV1106 via quantize=8 with data= calibration images (see the Rockchip RKNN export guide), so please try that first. If you still need your custom split, open a GitHub issue linking back to this thread and include !yolo checks, your rknn-toolkit2 version, and a minimal calibration set description so we can evaluate it.

  5. dttvn0010GitHub

    99ms per image is too bad. Using rknn native with 3 npu cores, I can achieve ~11ms per image

    1. Glenn JocherUltralytics

      @Arshapjoy thanks for the detailed info; for YOLO11 detection heads the export output shape is (1, nc + 4, 8400) (4 box coords plus nc class scores), so with 2 classes (1, 6, 8400) is expected and both classes are present, whereas a postprocessor assuming 5 + nc (old YOLO layout with an extra objectness channel) will effectively drop one class. I’d suggest updating your RKNN-side decoder to treat channels [0:4] as [x, y, w, h] and [4:] as class logits for all nc classes; if you still see a true (1, 7, 8400) PyTorch output on the same checkpoint, please share your ultralytics version and yolo checks output so we can dig deeper. The overall YOLO11 head behaviour is also outlined in the YOLO11 model documentation.

      @BakhtiariB the high-level YOLO("./yolo11n_rknn_model") interface is designed to keep preprocessing, NPU inference and postprocessing together, so if you need to run only the core RKNN inference on the NPU while fully controlling pre/post on the CPU you’ll need to load the exported .rknn with Rockchip’s RKNN API directly and implement your own preprocessing and YOLO11 postprocessing around it.

      @dttvn0010 the ~99 ms figure is a conservative end-to-end pipeline measurement on our RK3588 test setup, so seeing ~11 ms from a highly tuned RKNN deployment using all three NPU cores is quite reasonable; if you are open to sharing your exact model variant, quantization mode, input size and NPU core configuration, we can use that to cross-check and better explain the gap between baseline and fully optimized numbers.

      @NikolayKash in practice, large gains like that usually come from combining INT8-quantized RKNN models, all three NPU cores enabled, a suitable input resolution and very lean Python-side pre/postprocessing, so it would be great if @dttvn0010 can share their exact script and RK3588 configuration for others to replicate.

  6. guojieliGitHub

    he YOLO11 benchmark was run by the Ultralytics team on a Radxa Rock 5B based on the Rockchip RK3588, using the RKNN model format to evaluate speed and accuracy. Could you please clarify whether this was an INT8-quantized model?

    1. Glenn JocherUltralytics(düzenlendi)

      Those RKNN benchmarks were not INT8-quantized; they used the floating-point RKNN build. INT8 RKNN export is now available with quantize=8 and data= for calibration; see the Rockchip RKNN export guide.

  7. ArshapjoyGitHub

    Exported RKNN/ONNX model only has 1 output class instead of 2


    Overview

    I’m using Ultralytics YOLOv11s with two custom classes and exporting it to ONNX and RKNN formats. After conversion, inference on the RKNN device only detects a single class, and the output tensor shape is (1, 6, 8400) instead of the expected (1, 7, 8400). I’ve validated that the source .pt model correctly reports 2 classes, but both ONNX and RKNN exports drop one class.


    Model Details

    • Checkpoint path: path/to/yolo11s_custom.pt
    • Number of classes: 2
    • Input size: 640×640

    from ultralytics import YOLO

    Load the YOLO11 model

    model = YOLO("custom_yolo11s.pt")

    Export the model to RKNN format

    rknn_path = model.export(format="rknn", name="rk3588") print(f"RKNN model saved to: {rknn_path}")

    Actual Behavior

    • Received ONNX , RKNN and metadata.yaml after conversion
    • Exported ONNX model output shape: (1, 6, 8400)
    • Exported RKNN model output shape: (1, 6, 8400)
    • Only one class is detected during inference on the RK3588 board.

    7. Logs & Metadata

    • metadata.yaml generated alongside the RKNN model:
      model:
        name: yolo11s_custom
        format: rknn
        input_shape: [1, 3, 640, 640]
        output_shape: [1, 6, 8400]
      classes: 2
    • ONNX graph info: Attached minimal onnx.shape_inference log shows only 6 channels in the final layer.

    8. Additional Notes

    • Manual ONNX export yields the same issue, so it’s unlikely to be an Ultralytics export bug alone.
    • I’ve confirmed that the PyTorch forward pass on the .pt checkpoint produces a shape (1, 7, 8400).

    9. Request Could you please:

    1. Confirm whether there’s an option/flag in the YOLO-Ultralytics or RKNN export pipeline I’m missing to preserve all classes.
    2. Suggest any workarounds or patches to ensure correct output-channel dimensionality.
    3. Identify if this might be a known issue in RKNN-Toolkit 1.5.0 or Ultralytics YOLO v11.

    Thank you for your assistance!

  8. WeiIIzzGitHub

    Hello, when I exported the rknn model, I performed int8 quantization, but I had an error like this: E build: If set do_quantization = True, dataset file need be provided. But it`s value is None! E export_rknn: RKNN model does not exist, please load build model first! My export code is: from ultralytics import YOLO

    model = YOLO("/home/ky/dfxw/runs/detect/train3/weights/best.pt") model.export(format="rknn", name="rk3576", int8=True, data="/home/ky/rknn_yolo_test/data.yaml") The path pointed to by data is the same as the training dataset. How to solve it

    1. WeiIIzzGitHub

      The content of data.yaml is as follows path: /home/ky/dfxw/split_jiaqian # dataset root dir train: images/train val: images/val

      names: 0: 0 1: 1

    2. Glenn JocherUltralytics(düzenlendi)

      @WeiIIzz INT8 export for RKNN is supported with quantize=8 (it replaces the deprecated int8=True) together with data pointing to a dataset YAML, which Ultralytics converts into the calibration image list that RKNN needs:

      from ultralytics import YOLO
      
      model = YOLO("/home/ky/dfxw/runs/detect/train3/weights/best.pt")
      model.export(format="rknn", name="rk3576", quantize=8, data="/home/ky/rknn_yolo_test/data.yaml")

      The error you saw comes from an older version that did not pass a calibration dataset to RKNN, so run pip install -U ultralytics and retry. Make sure the YAML points to existing images. Let us know if this resolves your issue!

    3. WeiIIzzGitHub

      @glenn-jocher I followed your steps to modify the code as follows. But I still encountered the same problem.

      from ultralytics import YOLO
      
      model = YOLO("/home/ky/dfxw/runs/detect/train3/weights/best.pt")
      model.export(format="rknn", name="rk3576", int8=True, data="/home/ky/rknn_yolo_test/images")

      Is there only images in the data path?

    4. Glenn JocherUltralytics(düzenlendi)

      @WeiIIzz older releases ignored int8=True for RKNN and built the model without quantization. Current Ultralytics supports INT8 RKNN export, so after pip install -U ultralytics you can export with:

      model.export(format="rknn", name="rk3576", quantize=8, data="data.yaml")

      Here data is used for the calibration images. Without quantize, the export builds a floating-point (FP16) model.

  9. VictorAbobaGitHub

    Good day,

    Is RKNN available for obb tasks? I tried to use it directly, but got an error saying that some operations (cos) are not available in RKNN. As a fix, RKNN suggested adding disable_rules = ['reduce_reshape_op_around_concat'] to my configuration. I actually did this inside the YOLO library. Model was exported first to ONNX and then from ONNX to RKNN works and returns the responses in the format (1,6,21504), which seems what I expected. However, if I use this model through YOLO ("path_to_rknn_model", task = 'obb'), will I still get the results in the standard YOLO format? I just don't want to prescribe pre - and post-processing on my own :)

    Thank you!

    1. Glenn JocherUltralytics(düzenlendi)

      @VictorAboba thank you for your question! RKNN export now supports all seven Ultralytics tasks, including OBB, so you can export OBB models directly with format="rknn" and load the exported _rknn_model directory with YOLO(...) to get standard YOLO results without writing your own pre- and post-processing. See the Rockchip RKNN guide for details.

    2. SpidrreGitHub

      Hey! Did you notice any significant decrease in quality of your model after conversion? I am also trying to find a way to convert from OBB onnx to RKNN without 'reduce_reshape_op_around_concat'.

    3. VictorAbobaGitHub

      Hey! Did you notice any significant decrease in quality of your model after conversion? I am also trying to find a way to convert from OBB onnx to RKNN without 'reduce_reshape_op_around_concat'.

      Hello, after @glenn-jocher answer, I didn't attempt to convert the OBB model. We have a few other models, and all of them except YOLO were converted to the RKNN format. We will try using this stuff (YOLO without an NPU and others with it) ^_^ After conversion, the OCR model, for example, has almost the same quality, but it doesn't need 'reduce_reshape_op_around_concat' to be used.