Commencer

Exportation Tencent NCNN

NCNN est un framework open source d’inférence de réseaux de neurones de Tencent, destiné aux téléphones, aux cartes embarquées et aux ordinateurs de bureau. L’exportation d’un modèle Ultralytics YOLO26 avec format="ncnn" crée un répertoire yolo26n_ncnn_model/ contenant le réseau sous la forme d’une paire de fichiers .param et .bin, avec des poids FP32 ou FP16.

En bref#

PropriétéDétails
Argument formatncnn
Sortieyolo26n_ncnn_model/, un répertoire contenant model.ncnn.param, model.ncnn.bin, model_ncnn.py et metadata.yaml
Fonctionne surProcesseurs ARM et x86-64, et GPU avec un pilote Vulkan : téléphones, ordinateurs monocartes comme le Raspberry Pi et ordinateurs de bureau
Environnement d’exécutionNCNN : le paquet Python ncnn ou la bibliothèque C++ NCNN dans les applications Android, iOS et embarquées
PrécisionPoids FP32 ou FP16 ; aucune exportation INT8 n’est disponible. YOLO26n fait 9,8 Mo en FP32 et 5,0 Mo avec des poids FP16.
Machine d’exportationLinux x86-64 ou ARM64, macOS ou Windows x64, les plateformes pour lesquelles pnnx propose des versions compilées. L’exportation ne nécessite pas de GPU.
Exporter dans le cloud

Ultralytics Platform peut exporter pour toi un modèle entraîné au format NCNN ; tu n’as donc pas besoin d’un environnement d’exportation local.

Démarrage rapide#

Installer le paquet Ultralytics :

pip install ultralytics

La première exportation installe les paquets ncnn et pnnx s’ils sont manquants ; la première prédiction avec un modèle exporté installe ncnn s’il est manquant. Un environnement vierge ne nécessite rien d’autre : la première exportation se termine au cours de la même exécution, après avoir affiché Restart runtime or rerun command for updates to take effect. L’exportation requiert les versions suivantes :

PaquetVersion requise
pnnx20260526 exactement. L’exportation installe cette version et remplace toute autre version.
ncnnN’importe quelle version
torch2.0 ou version ultérieure : l’exportation ne vérifie pas la version et les tests Ultralytics ignorent NCNN sur les versions antérieures, car l’inférence y plantait.

Pour les autres méthodes d’installation, consulte le guide d’installation. Exporte ensuite ton modèle et charge le répertoire exporté pour effectuer une inférence ou valider sa précision.

Export
from ultralytics import YOLO

# Charger un modèle YOLO26
model = YOLO("yolo26n.pt")

# Exporter le modèle au format NCNN
model.export(format="ncnn")  # creates 'yolo26n_ncnn_model/'

# Ou exporte plutôt avec des poids FP16, ce qui réduit de moitié la taille du fichier
model.export(format="ncnn", quantize=16)  # creates 'yolo26n_ncnn_model/'

Les deux exportations écrivent dans le même répertoire yolo26n_ncnn_model/ ; la seconde remplace donc la première.

Prédiction
from ultralytics import YOLO

# Charger le modèle exporté au format NCNN
model = YOLO("yolo26n_ncnn_model")

# Exécuter l’inférence
results = model("https://ultralytics.com/images/bus.jpg")
Valider
from ultralytics import YOLO

# Charger le modèle exporté au format NCNN
model = YOLO("yolo26n_ncnn_model")

# Valider la précision sur le jeu de données COCO8
metrics = model.val(data="coco8.yaml")

Tâches prises en charge#

L’export NCNN prend en charge les sept tâches Ultralytics avec les modèles YOLOv8, YOLO11 et YOLO26 : détection, segmentation, segmentation sémantique, estimation de profondeur, classification, estimation de pose et OBB. La segmentation sémantique et l’estimation de profondeur sont disponibles uniquement avec YOLO26, la seule famille qui intègre ces têtes. Les modèles de détection YOLOv5u, YOLOv9, YOLOv10 et YOLO12 sont également exportables. Les modèles RT-DETR, YOLO-World et YOLOE avec invite textuelle ne sont pas convertibles ; consulte Limitations et dépannage.

Arguments d’exportation#

ArgumentTypeValeur par défautDescription
formatstr'ncnn'Format cible du modèle exporté, qui définit sa compatibilité avec différents environnements de déploiement.
imgszint ou tuple640Taille d’entrée du modèle, fixe dans le modèle exporté : un entier pour les images carrées ou un tuple (height, width). Si tu ne la renseignes pas, l’export utilise la taille avec laquelle le checkpoint a été entraîné. Les checkpoints YOLO26 officiels utilisent 640 pour les modèles de détection, de segmentation et de pose, ainsi que pour les modèles sémantiques préentraînés sur ADE20K, 1024 pour les modèles OBB et les modèles sémantiques préentraînés sur Cityscapes, 768 pour la profondeur et 224 pour la classification.
quantizeint ou strNonePrécision des poids enregistrés : 16 (FP16) divise la taille du fichier par deux ; 32/non défini correspond à FP32. 8 déclenche une erreur, et un checkpoint entraîné avec quantize=8 ne peut pas être exporté vers NCNN ; consulte Limitations et dépannage. Remplace l’option obsolète half.
nmsbool, facultatifNoneLes modèles NCNN renvoient toujours des prédictions brutes pour une NMS externe. La tête sans NMS (False) et la NMS intégrée (True) ne sont pas disponibles ; consulte Limitations et dépannage.
devicestrNoneAppareil utilisé pour tracer le modèle lors de la conversion : cpu (valeur par défaut, également sur une machine équipée d’un GPU), 0 pour un GPU CUDA ou mps pour les puces Apple.

Parmi les arguments d’export propres au format, NCNN n’accepte que ceux-ci. Pour les arguments communs à tous les formats, consulte la documentation du mode Export.

Précision#

quantize définit le mode de stockage des poids dans model.ncnn.bin. Les tailles indiquées correspondent à un modèle de détection YOLO26n exporté avec imgsz=640 :

quantizePoidsTaille de YOLO26n
non défini ou 32FP329.8 MB
16FP165.0 MB
  • Poids FP16 : quantize=16 stocke les poids en demi-précision et ne nécessite aucune donnée d’étalonnage. L’entrée et les sorties restent en float32, donc le code d’inférence écrit pour le modèle FP32 fonctionne sans modification.
  • Précision : sur COCO val2017, sur un processeur de serveur x86-64, les modèles NCNN FP32 et FP16 de YOLO26n, le modèle ONNX et le modèle PyTorch (rect=False) ont tous atteint 40.9 mAPval 50-95 avec la même entrée de 640x640.
  • Calcul FP16 : NCNN peut également effectuer les calculs en demi-précision, quelle que soit la précision des poids stockés. Sur un Apple M4, c’était le cas par défaut pour les deux exports : sur une image de test, les coordonnées brutes des boîtes de l’export FP32 différaient d’au plus environ 2.1 pixels de celles du modèle ONNX pour les ancres dont la confiance dépassait 0.25, et la sortie complète correspondait à celle-ci à 0.01 près lorsque net.opt.use_fp16_storage = False était défini dans le package ncnn. Sur un processeur de serveur x86-64, les sorties brutes de l’export FP32 différaient de moins de 0.03 de celles du modèle ONNX sur la même image pour les modèles de détection, de segmentation, de profondeur, de classification, de pose et OBB. Avec des poids FP16, les coordonnées des boîtes de ces ancres différaient de celles d’ONNX d’environ 0.3 pixel sur le serveur et de 1.6 pixel sur le M4. Sur le M4, ces différences modifiaient la précision de moins de 0.1 : sur COCO128, le validateur Ultralytics a obtenu 47.7 mAP 50-95 pour l’export FP32 et 47.7 avec des poids FP16, contre 47.7 pour le modèle PyTorch (rect=False) avec la même entrée de 640x640.

Format de sortie#

L’exportation écrit un répertoire :

FichierContenu
model.ncnn.paramLe graphe du réseau sous forme de fichier texte
model.ncnn.binLes poids
model_ncnn.pyUn script Python écrit par PNNX qui exécute le modèle sur une entrée aléatoire avec le package ncnn
metadata.yamlLes noms de classes, la tâche, la taille d’image, la taille de lot, le stride et les arguments d’exportation, qu’Ultralytics lit lors du chargement du modèle

L’export crée également un dossier __pycache__ dans le répertoire, que tu peux supprimer. Le modèle prend une entrée nommée in0 de forme (3, height, width) : une image RGB, canaux en premier, float32, mise à l’échelle entre 0 et 1. Il n’y a pas de dimension de lot, et les sorties n’en ont pas non plus. Les formes ci-dessous correspondent aux checkpoints officiels YOLO26n à leur taille d’export par défaut, avec le checkpoint Cityscapes yolo26n-sem.pt pour la segmentation sémantique :

Tâcheimgsz par défautSorties
Détection640out0 (84, 8400)
Segmentation640out0 (116, 8400) et out1 (32, 160, 160)
Sémantique1024out0 (19, 1024, 1024), un score pour chaque classe et pixel
Profondeur768out0 (1, 768, 768), carte de profondeur
Classification224out0 (1000,), probabilités des classes
Pose640out0 (56, 8400)
OBB1024out0 (20, 21504)
  • Prédictions brutes : les modèles de détection, de segmentation, de pose et OBB renvoient les mêmes prédictions brutes qu’un export ONNX par défaut, sans dimension de lot : pour chaque ancre, le centre x et y de la boîte, sa largeur et sa hauteur en pixels d’entrée, puis les scores des classes et enfin les valeurs propres à la tâche (32 coefficients de masque, 17 x 3 valeurs de points clés ou l’angle OBB en radians). Applique toi-même la NMS.
  • Segmentation : out0 contient les prédictions et out1 les prototypes de masque.
  • Segmentation sémantique : la sortie contient un score pour chaque classe et chaque pixel, et non la carte des classes de l’exportation ONNX ; calcule donc l’argmax sur l’axe des classes dans ton propre code.
  • NMS : aucune sortie sans NMS ni avec NMS intégrée n’est disponible ; voir Limites et dépannage.

YOLO("yolo26n_ncnn_model") lit la disposition depuis metadata.yaml, ajoute la dimension de lot et applique la NMS ; tu n’as donc besoin de ces détails que si tu exécutes le modèle dans ton propre code. Les clés de metadata.yaml comprennent names, task, imgsz, stride, batch, end2end, args et, pour les modèles de pose, kpt_shape.

Exécuter avec le package ncnn#

Pour exécuter le modèle en dehors du package Ultralytics, charge les deux fichiers avec le package Python ncnn. Les mêmes fichiers .param et .bin se chargent dans la bibliothèque C++ NCNN sur Android, iOS et Linux embarqué.

# # Export first: yolo export model=yolo26n.pt format=ncnn
import ncnn
import numpy as np

net = ncnn.Net()
net.opt.num_threads = 4  # # définir les options avant le chargement du modèle
assert net.load_param("yolo26n_ncnn_model/model.ncnn.param") == 0
assert net.load_model("yolo26n_ncnn_model/model.ncnn.bin") == 0

image = np.zeros((3, 640, 640), dtype=np.float32)  # # ton image avec letterbox : RGB, CHW, 0-1
with net.create_extractor() as ex:
    ex.input("in0", ncnn.Mat(image).clone())
    _, out0 = ex.extract("out0")
predictions = np.array(out0)  # # forme (84, 8400), prédictions brutes nécessitant une NMS
assert predictions.shape == (84, 8400), "export a detection model at imgsz=640"

ncnn.Mat(image) lit la mémoire du tableau NumPy sans la copier ; passe donc un tableau float32 contigu en C et garde-le en mémoire jusqu’à la fin de l’extraction, ou copie-le avec .clone() comme ci-dessus. Un tableau créé avec transpose n’est pas contigu, et astype ou une division effectuée ensuite conserve cette disposition ; termine donc le prétraitement avec np.ascontiguousarray(x, dtype=np.float32). Lors d’un test avec ce modèle, un tableau non contigu s’est exécuté sans erreur et a renvoyé des prédictions incorrectes, tandis qu’un tableau float64 a fait planter Python.

Déployer#

Sur l’appareil cible, installe le package avec pip install ultralytics et copie le répertoire yolo26n_ncnn_model/ sur l’appareil. YOLO("yolo26n_ncnn_model") exécute ensuite le modèle avec le package Python ncnn, installé par Ultralytics à la première utilisation. L’argument device définit l’endroit où NCNN s’exécute :

deviceEmplacement d’exécution du modèle
non défini ou cpuNCNN sur le CPU
vulkan:0, vulkan:1, ...NCNN sur l’appareil Vulkan portant cet index ; consulte Inférence GPU avec Vulkan
0 sur une machine équipée d’un GPU CUDANCNN sur le CPU : NCNN ne dispose pas de backend CUDA
mps sur les puces AppleNCNN sur le CPU, tandis qu’Ultralytics effectue le prétraitement et le post-traitement sur le GPU Apple. Sur un M4, cela a ajouté environ 0.6 s au traitement de la première image et n’a pas accéléré l’inférence ; laisse donc device non défini
  • Forme d’entrée fixe : le modèle s’exécute toujours à la taille d’export imgsz, qu’Ultralytics lit depuis metadata.yaml. Un imgsz transmis à predict ou val est ignoré. Effectue un nouvel export pour modifier la taille de l’image.
  • Lots : le modèle prend une image, et Ultralytics traite les images d’un lot l’une après l’autre ; tu peux donc utiliser n’importe quel nombre d’images. val définit batch=1, quelle que soit la valeur que tu lui transmets.
  • Threads CPU : NCNN choisit lui-même le nombre de threads : 4 sur une Apple M4, soit le nombre de ses cœurs haute performance. Sous Linux, Ultralytics limite ce nombre à 8 et aux processeurs que le processus peut utiliser : son affinité CPU (taskset, Docker --cpuset-cpus) et un quota CPU cgroup v2 (Docker --cpus). Consulte Limitations et dépannage pour utiliser un autre nombre de threads.

Inférence GPU avec Vulkan#

NCNN s’exécute sur les GPU via Vulkan, compatible avec les GPU de fournisseurs tels qu’AMD, Intel, ARM, Qualcomm et Apple, sans CUDA. Passe device="vulkan:0" pour le premier appareil Vulkan ou vulkan:1 pour le deuxième :

Inférence Vulkan
from ultralytics import YOLO

# Charger le modèle exporté au format NCNN
model = YOLO("yolo26n_ncnn_model")

# # Exécuter l’inférence sur le premier appareil Vulkan
results = model("https://ultralytics.com/images/bus.jpg", device="vulkan:0")

Le GPU a besoin d’un pilote Vulkan, inclus dans la plupart des pilotes GPU récents ; sous Linux, vulkaninfo répertorie ceux qui sont installés. L’index correspond aux appareils Vulkan détectés par NCNN, qui ne sont pas nécessairement des GPU matériels. Affiche-les avant de te fier au résultat :

import ncnn

for i in range(ncnn.get_gpu_count()):
    print(i, ncnn.get_gpu_info(i).device_name())

Vulkan n’est pas toujours plus rapide que le CPU. Sur un Apple M4, YOLO26n prenait environ 31 ms par image sur l’appareil Vulkan et environ 12 ms sur le CPU. Mesure les performances sur ton appareil.

Guides de déploiement#

Limites et dépannage#

  • INT8 : quantize=8 échoue avec quantize=8 (INT8) is not supported; format='ncnn' supports quantize=16 (FP16), 32 or None (FP32).. Utilise FP16 pour réduire la taille du fichier, ou choisis un format prenant en charge l’export INT8, comme LiteRT ou MNN.
  • Checkpoints entraînés avec quantize=8 : un checkpoint affiné avec l’entraînement avec prise en compte de la quantification échoue avec format='ncnn' cannot export a QAT model: its Q/DQ ranges are only read by the 'onnx' and 'engine' backends. Exporte plutôt le checkpoint utilisé au début de l’affinage, ou exporte le checkpoint affiné vers ONNX ou TensorRT.
  • Tête sans NMS : les modèles NCNN renvoient toujours des prédictions brutes qui nécessitent une NMS. Avec nms=False, l’export d’un modèle YOLO26 ou YOLOv10 journalise This export format does not support end2end models, disabling the end2end branch. et utilise la tête one-to-many ; pour les autres modèles de détection, de segmentation, de pose et OBB, comme YOLO11, il journalise This model has no one-to-one head; using one-to-many outputs.
  • NMS intégrée : nms=True affiche format=ncnn does not support embedded NMS; exporting native outputs for external NMS. et écrit la sortie brute.
  • Forme d’entrée et taille de lot fixes : dynamic=True échoue avec argument 'dynamic' is not supported for format='ncnn', et une valeur de batch autre que 1 échoue avec argument 'batch' is not supported for format='ncnn'. Effectue un nouvel export pour modifier la taille de l’image.
  • Modèles non convertibles : l’export des modèles RT-DETR (rtdetr-l.pt), YOLO-Worldv2 (yolov8s-worldv2.pt) et YOLOE avec invite textuelle (yoloe-26s-seg.pt) échoue avec NCNN failed to load the exported model, it may contain layers NCNN does not support.. Un modèle YOLOE avec invite textuelle peut être exporté une fois ses classes fixées avec set_classes(), et le modèle yoloe-26s-seg-pf.pt sans invite s’exporte tel quel.
  • Version de PNNX : l’export nécessite pnnx 20260526 et remplace une version plus récente, car les modèles convertis avec PNNX 20260704 plantent à l’inférence.
  • Installation automatique désactivée : avec YOLO_AUTOINSTALL=false, l’export échoue avec No module named 'ncnn' dans un environnement où les packages ne sont pas installés. Installe-les avec pip install --no-deps ncnn et pip install pnnx==20260526.
  • Nombre de threads : predict et val ne proposent aucun argument pour définir le nombre de threads NCNN, et la variable OMP_NUM_THREADS ne le modifie pas. Sous Linux, Ultralytics utilise au maximum 8 threads, et les modèles plus grands peuvent être plus rapides avec davantage de threads sur les machines disposant de plus de cœurs : exécuté avec le package ncnn sur 16 cœurs d'un AMD EPYC 9655, YOLO26x a pris environ 177 ms par image avec 8 threads et environ 154 ms avec 16, tandis que YOLO26n a pris environ 23 ms dans les deux cas. Pour choisir le nombre de threads, exécute le modèle avec le package ncnn et définis net.opt.num_threads avant son chargement. Modifier num_threads après le chargement du modèle a ralenti l'inférence.
  • Répertoire de modèle incomplet : si model.ncnn.bin est manquant ou tronqué, par exemple après une copie interrompue vers l’appareil, Python s’arrête avec une erreur de segmentation, sans trace d’erreur. Les dernières lignes de la sortie indiquent la cause : fopen yolo26n_ncnn_model/model.ncnn.bin failed ou ModelBin read weight_data failed. Un répertoire sans model.ncnn.param échoue avec StopIteration. Copie à nouveau le répertoire.
  • device="vulkan" sans index : échoue avec IndexError: list index out of range. Écris l’index, comme dans device="vulkan:0".
  • L’appareil Vulkan n’est pas un GPU : sur le serveur Linux utilisé pour cette page, le seul appareil Vulkan répertorié par NCNN était llvmpipe, un moteur de rendu logiciel qui s’exécute sur le CPU. device="vulkan:0" s’exécute alors sans erreur et sans GPU. Un index inexistant, comme vulkan:9 sur une machine dotée d’un seul appareil, s’exécute également sans erreur.
  • Répertoire de sortie : chaque export d’un même checkpoint écrit dans le même répertoire yolo26n_ncnn_model/, quelles que soient ses valeurs quantize ou imgsz ; l’export suivant remplace donc le précédent. Renomme le répertoire pour conserver les deux, et garde _ncnn_model dans son nom, par exemple yolo26n_fp16_ncnn_model/, car Ultralytics reconnaît le format grâce à cet élément. Un répertoire qui ne le contient pas, ou le chemin du fichier .param, échoue avec is not a supported model format.

Pour les autres erreurs, consulte le guide des problèmes courants.

Benchmarks#

Ultralytics publie des benchmarks NCNN pour deux plateformes ARM. Les benchmarks Raspberry Pi 5 comparent NCNN à sept autres formats pour YOLO26n et YOLO26s, et les benchmarks NVIDIA Jetson incluent NCNN pour les cinq modèles de détection YOLO26. La page des modèles YOLO26 indique la précision des checkpoints PyTorch.

Tailles des modèles de détection YOLO26 exportés, calculées comme la somme de model.ncnn.param et model.ncnn.bin en Mo (10^6 octets) avec imgsz=640. Le journal d’export indique la taille du répertoire complet en Mio : 9.4 Mo et 4.8 Mo pour YOLO26n :

ModèlePyTorchNCNN FP32NCNN FP16
YOLO26n5.59.85.0
YOLO26s20.438.119.2
YOLO26m44.381.841.0
YOLO26l53.299.449.8
YOLO26x118.7223.0111.7

Exporté avec ultralytics 8.4.215, NCNN 1.0.20261020 et PNNX 20260526, le 16 novembre 2026.

À propos de NCNN#

NCNN est développé par Tencent et utilisé dans des applications Tencent telles que QQ et WeChat. Il ne dépend d’aucun environnement d’exécution tiers, fonctionne sur les CPU et les GPU via Vulkan, et convertit les modèles PyTorch avec son outil PNNX, utilisé par l’export Ultralytics. Pour la référence complète, consulte la documentation NCNN.

NCNN high-performance neural network inference framework

FAQ#

  • Utilise FP16 (quantize=16) lorsque la taille du modèle compte : YOLO26n fait 5.0 Mo avec des poids FP16, contre 9.8 Mo en FP32, et ne nécessite aucune donnée d’étalonnage. Sur COCO val2017, YOLO26n a atteint le même résultat de 40.9 mAPval 50-95 avec des poids FP16 qu’en FP32. Les poids FP16 réduisent la taille du fichier, mais n’accélèrent pas le modèle : NCNN choisit la précision des calculs en fonction du matériel ; consulte Précision. Valide le modèle exporté sur tes propres données et ton appareil avant de le déployer.

  • Les packages pnnx et ncnn disposent de versions pour Linux ARM 64 bits, et le guide Raspberry Pi permet d’effectuer l’export sur la carte avec la même commande format="ncnn". Tu peux aussi exporter sur un PC et copier le répertoire yolo26n_ncnn_model/ sur la carte. Sur un système ARM 32 bits, pnnx n’a pas de version disponible ; effectue donc l’export sur une autre machine. ncnn dispose de versions pour ce système, mais Ultralytics n’y a pas été testé.

  • Compile ou télécharge la bibliothèque NCNN pour ta plateforme en suivant les instructions de compilation de NCNN, ajoute model.ncnn.param et model.ncnn.bin à l’application, puis transmets l’entrée in0 comme indiqué dans le format de sortie. Ton code doit appliquer le letterbox à l’image, décoder les prédictions brutes et appliquer la NMS. Si tu préfères un composant d’application prêt à l’emploi, le plugin Ultralytics YOLO pour Flutter exécute les exports LiteRT sur Android et les exports Core ML sur iOS.

  • NCNN est conçu pour les processeurs ARM des téléphones et des cartes embarquées. Sur un serveur équipé de deux processeurs AMD EPYC 9655 à 96 cœurs, YOLO26n a pris environ 30 ms par image avec NCNN à 8 threads, contre environ 13 ms avec PyTorch et ONNX Runtime, et environ 12 ms sur une Apple M4, où NCNN choisit 4 threads. Pour les serveurs x86-64, OpenVINO et ONNX sont les formats évalués par Ultralytics.

Commentaires37

Pose une question, partage tes résultats ou aide quelqu’un d’autre.

  1. gpsamtGitHub(modifié)

    I'm testing the use of ncnn on android. I converted a yolov11 model. I've tried every way to adjust the code, but I can't. The detections are not coming out correctly. The ncnn model on windows works as can be seen in the image. I'm sharing my native code in c++. If anyone can help me I'd really appreciate it.

    Image detected with yolo predict model=C:\Users\guips\Downloads\best_ncnn_model source="C:\Users\guips\Downloads\brasil\test822.jpg" save_txt=true test822 #include <jni.h> #include <android/log.h> #include #include #include #include <opencv2/opencv.hpp> #include <ncnn/net.h> // #include <stb_image.h> // Uncomment if using stb_image

    #define LOG_TAG "NCNN_DETECTOR" #define LOGD(...) __android_log_print(ANDROID_LOG_DEBUG, LOG_TAG, VA_ARGS) #define LOGI(...) __android_log_print(ANDROID_LOG_INFO, LOG_TAG, VA_ARGS) #define LOGE(...) __android_log_print(ANDROID_LOG_ERROR, LOG_TAG, VA_ARGS)

    static ncnn::Net g_net; static std::vectorstd::string g_labels; static bool g_model_loaded = false;

    struct Detection { float x, y, width, height; int label; float prob; };

    static float sigmoid(float x) { return 1.0f / (1.0f + std::exp(-x)); }

    static float calculate_iou(const Detection& a, const Detection& b) { float x1 = std::max(a.x, b.x); float y1 = std::max(a.y, b.y); float x2 = std::min(a.x + a.width, b.x + b.width); float y2 = std::min(a.y + a.height, b.y + b.height);

    float inter_area = std::max(0.0f, x2 - x1) * std::max(0.0f, y2 - y1);
    float union_area = a.width * a.height + b.width * b.height - inter_area;
    
    return union_area > 0 ? inter_area / union_area : 0.0f;

    }

    extern "C" JNIEXPORT jboolean JNICALL Java_com_example_ncnnmy_1ok_MainActivity_loadModel( JNIEnv* env, jobject thiz, jstring param_path, jstring bin_path, jstring labels_path) {

    const char* param_path_str = env->GetStringUTFChars(param_path, nullptr);
    const char* bin_path_str = env->GetStringUTFChars(bin_path, nullptr);
    const char* labels_path_str = env->GetStringUTFChars(labels_path, nullptr);
    
    LOGI("Starting model loading...");
    LOGD("Param path: %s", param_path_str);
    LOGD("Bin path: %s", bin_path_str);
    LOGD("Labels path: %s", labels_path_str);
    
    g_net.clear();
    g_labels.clear();
    g_model_loaded = false;
    
    g_net.opt.num_threads = 4;
    g_net.opt.use_vulkan_compute = false;
    g_net.opt.use_fp16_packed = false;
    g_net.opt.use_fp16_storage = false;
    g_net.opt.use_fp16_arithmetic = false;
    
    int ret = g_net.load_param(param_path_str);
    if (ret != 0) {
        LOGE("Failed to load .param file (%d)", ret);
        env->ReleaseStringUTFChars(param_path, param_path_str);
        env->ReleaseStringUTFChars(bin_path, bin_path_str);
        env->ReleaseStringUTFChars(labels_path, labels_path_str);
        return JNI_FALSE;
    }
    
    ret = g_net.load_model(bin_path_str);
    if (ret != 0) {
        LOGE("Failed to load .bin file (%d)", ret);
        env->ReleaseStringUTFChars(param_path, param_path_str);
        env->ReleaseStringUTFChars(bin_path, bin_path_str);
        env->ReleaseStringUTFChars(labels_path, labels_path_str);
        return JNI_FALSE;
    }
    
    FILE* fp = fopen(labels_path_str, "r");
    if (!fp) {
        LOGE("Failed to open labels file: %s", labels_path_str);
        env->ReleaseStringUTFChars(param_path, param_path_str);
        env->ReleaseStringUTFChars(bin_path, bin_path_str);
        env->ReleaseStringUTFChars(labels_path, labels_path_str);
        return JNI_FALSE;
    }
    
    char buffer[256];
    while (fgets(buffer, sizeof(buffer), fp) != nullptr) {
        std::string label(buffer);
        label.erase(std::remove(label.begin(), label.end(), '\n'), label.end());
        label.erase(std::remove(label.begin(), label.end(), '\r'), label.end());
        if (!label.empty()) {
            g_labels.push_back(label);
        }
    }
    fclose(fp);
    
    if (g_labels.empty()) {
        LOGE("No labels loaded from %s", labels_path_str);
        env->ReleaseStringUTFChars(param_path, param_path_str);
        env->ReleaseStringUTFChars(bin_path, bin_path_str);
        env->ReleaseStringUTFChars(labels_path, labels_path_str);
        return JNI_FALSE;
    }
    
    LOGI("Model loaded successfully");
    LOGI("Total labels loaded: %zu", g_labels.size());
    g_model_loaded = true;
    
    env->ReleaseStringUTFChars(param_path, param_path_str);
    env->ReleaseStringUTFChars(bin_path, bin_path_str);
    env->ReleaseStringUTFChars(labels_path, labels_path_str);
    return JNI_TRUE;

    }

    extern "C" JNIEXPORT jstring JNICALL Java_com_example_ncnnmy_1ok_MainActivity_detect( JNIEnv* env, jobject thiz, jstring image_path, jdouble conf_threshold, jdouble nms_threshold) {

    LOGI("Running updated detect method (no debug image)");
    
    if (!g_model_loaded) {
        LOGE("Model not loaded");
        return env->NewStringUTF("error:model_not_loaded");
    }
    
    const char* image_path_str = env->GetStringUTFChars(image_path, nullptr);
    LOGI("Processing image: %s", image_path_str);
    
    // Option 1: Use OpenCV (current)
    cv::Mat image = cv::imread(image_path_str, cv::IMREAD_COLOR);
    env->ReleaseStringUTFChars(image_path, image_path_str);
    
    /*
    // Option 2: Use stb_image (uncomment to test)
    int width, height, channels;
    unsigned char* image_data = stbi_load(image_path_str, &width, &height, &channels, 3);
    env->ReleaseStringUTFChars(image_path, image_path_str);
    if (!image_data) {
        LOGE("Failed to load image with stb_image");
        return env->NewStringUTF("error:image_load_failed");
    }
    cv::Mat image(height, width, CV_8UC3, image_data);
    */
    
    if (image.empty()) {
        LOGE("Failed to load image");
        // stbi_image_free(image_data); // Uncomment if using stb_image
        return env->NewStringUTF("error:image_load_failed");
    }
    
    LOGD("Input image: %dx%d, channels=%d", image.cols, image.rows, image.channels());
    
    const int target_size = 640;
    int img_w = image.cols;
    int img_h = image.rows;
    
    float scale = std::min((float)target_size / img_w, (float)target_size / img_h);
    int new_w = static_cast<int>(img_w * scale);
    int new_h = static_cast<int>(img_h * scale);
    int dx = (target_size - new_w) / 2;
    int dy = (target_size - new_h) / 2;
    
    cv::Mat resized;
    cv::resize(image, resized, cv::Size(new_w, new_h));
    cv::Mat input_mat(target_size, target_size, CV_8UC3, cv::Scalar(114, 114, 114));
    resized.copyTo(input_mat(cv::Rect(dx, dy, new_w, new_h)));
    
    cv::cvtColor(input_mat, input_mat, cv::COLOR_BGR2RGB);
    input_mat.convertTo(input_mat, CV_32FC3, 1.0 / 255.0);
    
    ncnn::Mat in = ncnn::Mat::from_pixels(input_mat.data, ncnn::Mat::PIXEL_RGB, target_size, target_size);
    
    // stbi_image_free(image_data); // Uncomment if using stb_image
    
    ncnn::Extractor ex = g_net.create_extractor();
    ex.input("in0", in);
    ncnn::Mat out;
    ex.extract("out0", out);
    
    if (out.empty()) {
        LOGE("Empty output from model");
        return env->NewStringUTF("error:empty_model_output");
    }
    
    LOGD("Output dimensions: w=%d, h=%d, c=%d", out.w, out.h, out.c);
    
    int num_preds, num_classes;
    bool is_decoupled = false;
    
    if (out.c == 1) {
        LOGD("Possible decoupled heads detected, checking for additional outputs...");
        ncnn::Mat boxes, scores, classes;
        ex.extract("boxes", boxes);
        ex.extract("scores", scores);
        ex.extract("classes", classes);
        if (!boxes.empty() && !scores.empty() && !classes.empty()) {
            is_decoupled = true;
            LOGD("Decoupled heads detected: boxes=%dx%d, scores=%dx%d, classes=%dx%d",
                 boxes.w, boxes.c, scores.w, scores.c, classes.w, classes.c);
            return env->NewStringUTF("error:decoupled_heads_not_implemented");
        }
    }
    
    if (!is_decoupled) {
        if (out.c >= 5) {
            num_preds = out.h * out.w;
            num_classes = out.c - 5;
            LOGD("Interpreting as [1, num_predictions, 5 + num_classes]: num_preds=%d, num_classes=%d",
                 num_preds, num_classes);
        } else if (out.h >= 5) {
            num_preds = out.w;
            num_classes = out.h - 5;
            LOGD("Interpreting as [1, 5 + num_classes, num_predictions]: num_preds=%d, num_classes=%d",
                 num_preds, num_classes);
        } else {
            LOGE("Invalid output dimensions: w=%d, h=%d, c=%d", out.w, out.h, out.c);
            return env->NewStringUTF("error:invalid_output_dimensions");
        }
    }
    
    if (num_classes != g_labels.size()) {
        LOGE("Mismatch between model outputs (%d) and labels (%zu)",
             num_classes, g_labels.size());
        return env->NewStringUTF("error:model_labels_mismatch");
    }
    
    std::vector<Detection> detections;
    int stride = (out.c >= 5) ? out.c : out.h;
    const float* data = (float*)out.data;
    
    // Log raw outputs
    if (num_preds > 0) {
        LOGD("Raw output sample: x=%.3f, y=%.3f, w=%.3f, h=%.3f, obj=%.3f",
             data[0], data[1], data[2], data[3], data[4]);
        // Log first class score
        if (num_classes > 0) {
            LOGD("Raw class score sample: class_0=%.3f", data[5]);
        }
    }
    
    for (int i = 0; i < num_preds; i++) {
        const float* pred = data + i * stride;
    
        float obj_score = sigmoid(pred[4]);
        if (obj_score < conf_threshold) continue;
    
        int class_id = 0;
        float max_score = sigmoid(pred[5]);
        for (int j = 1; j < num_classes; j++) {
            float score = sigmoid(pred[5 + j]);
            if (score > max_score) {
                max_score = score;
                class_id = j;
            }
        }
    
        float confidence = obj_score * max_score;
        if (confidence < conf_threshold) continue;
    
        // Normalize coordinates with sigmoid (assuming logits)
        float x_center = sigmoid(pred[0]) * target_size;
        float y_center = sigmoid(pred[1]) * target_size;
        float width = sigmoid(pred[2]) * target_size;
        float height = sigmoid(pred[3]) * target_size;
    
        // Adjust for letterbox
        float x = (x_center - width / 2 - dx) / scale;
        float y = (y_center - height / 2 - dy) / scale;
        width /= scale;
        height /= scale;
    
        LOGD("Prediction %d: x_center=%.2f, y_center=%.2f, width=%.2f, height=%.2f",
             i, x_center, y_center, width, height);
        LOGD("Transformed %d: x=%.2f, y=%.2f, width=%.2f, height=%.2f",
             i, x, y, width, height);
    
        // Validate coordinates
        if (x < 0 || y < 0 || width <= 0 || height <= 0 || x + width > img_w || y + height > img_h) {
            LOGD("Skipping invalid detection %d: x=%.2f, y=%.2f, w=%.2f, h=%.2f",
                 i, x, y, width, height);
            continue;
        }
    
        // Minimum size filter
        if (width < 50 || height < 50) {
            LOGD("Skipping small detection %d: w=%.2f, h=%.2f", i, width, height);
            continue;
        }
    
        detections.push_back({x, y, width, height, class_id, confidence});
    }
    
    // NMS
    std::sort(detections.begin(), detections.end(), [](const Detection& a, const Detection& b) {
        return a.prob > b.prob;
    });
    
    std::vector<bool> suppressed(detections.size(), false);
    std::vector<Detection> final_detections;
    
    for (size_t i = 0; i < detections.size(); i++) {
        if (suppressed[i]) continue;
        final_detections.push_back(detections[i]);
    
        for (size_t j = i + 1; j < detections.size(); j++) {
            if (suppressed[j]) continue;
            float iou = calculate_iou(detections[i], detections[j]);
            if (iou > nms_threshold) {
                suppressed[j] = true;
            }
        }
    }
    
    LOGD("Detections after NMS: %zu", final_detections.size());
    
    // Format results
    std::string result_str;
    for (const auto& det : final_detections) {
        if (!result_str.empty()) result_str += ";";
        char buf[256];
        snprintf(buf, sizeof(buf), "%s:%.2f,%.0f,%.0f,%.0f,%.0f",
                 g_labels[det.label].c_str(), det.prob,
                 det.x, det.y, det.width, det.height);
        result_str += buf;
    }
    
    return env->NewStringUTF(result_str.empty() ? "none" : result_str.c_str());

    }

    Here is a log of the output of the flutter application.

    [ ] D/NCNN_DETECTOR( 9180): Prediction 3730: x_center=640.00, y_center=640.00, width=640.00, height=640.00 [ ] D/NCNN_DETECTOR( 9180): Transformed 3730: x=320.00, y=240.00, width=640.00, height=640.00 [ ] D/NCNN_DETECTOR( 9180): Skipping invalid detection 3730: x=320.00, y=240.00, w=640.00, h=640.00 [ ] D/NCNN_DETECTOR( 9180): Prediction 3731: x_center=640.00, y_center=640.00, width=640.00, height=640.00 [ ] D/NCNN_DETECTOR( 9180): Transformed 3731: x=320.00, y=240.00, width=640.00, height=640.00 [ ] D/NCNN_DETECTOR( 9180): Skipping invalid detection 3731: x=320.00, y=240.00, w=640.00, h=640.00 [ ] D/NCNN_DETECTOR( 9180): Prediction 3732: x_center=640.00, y_center=640.00, width=640.00, height=640.00 [ ] D/NCNN_DETECTOR( 9180): Transformed 3732: x=320.00, y=240.00, width=640.00, height=640.00 [ ] D/NCNN_DETECTOR( 9180): Skipping invalid detection 3732: x=320.00, y=240.00, w=640.00, h=640.00 [ ] D/NCNN_DETECTOR( 9180): Detections after NMS: 0 [ ] I/flutter ( 9180): Detection result: none [ ] I/flutter ( 9180): STATUS: No objects detected [ ] E/libEGL ( 9180): called unimplemented OpenGL ES API

    image

    1. Glenn JocherUltralytics(modifié)

      @gpsamt looking at your logs, the issue appears to be with output format parsing. YOLO11 NCNN outputs have no separate objectness score, and the class scores are already sigmoid-activated, so don't apply sigmoid again. Try parsing each prediction like this:

      // Box is x_center, y_center, width, height (no sigmoid needed)
      float x_center = pred[0];
      float y_center = pred[1];
      float width = pred[2];
      float height = pred[3];
      // pred[4 .. 4+nc) are the per-class scores; take the max class as the confidence
      
      // Convert from center format to corner format
      float x = (x_center - width / 2 - dx) / scale;
      float y = (y_center - height / 2 - dy) / scale;

      Also verify your model's actual output format by checking if coordinates are normalized (0-1) or absolute (0-640). The repeated 640.00 values suggest coordinate parsing issues. For official Android deployment examples, refer to the NCNN Android documentation.

  2. aram199922GitHub

    Hey everyone, I have trained yolo11n.pt pretrained model on my custom dataset. Run the detection on a video and got quite good results. Now trying to export ncnn with the given guide, files are being generated correctly, however the detection on the same video seems corrupted. I am trying to detect potholes on road, however ncnn model predict 300 potholes on each frame. Any suggestion?

    1. aram199922GitHub

      One more note is that I have trained my model with 736p, 640p modes are converting fine. But does this mean I can't conver higher resolution trained model to ncnn?

    2. Glenn JocherUltralytics

      @aram199922 The issue with your NCNN model detecting 300 potholes likely relates to confidence thresholds. When exporting to NCNN, default thresholds may not transfer properly. Try explicitly setting a higher confidence threshold during inference:

      # Load the NCNN model
      ncnn_model = YOLO("your_model_ncnn_model")
      
      # Run inference with higher confidence threshold
      results = ncnn_model("video.mp4", conf=0.5)  # Adjust this value as needed

      Regarding your 736p model - yes, you can export higher resolution models to NCNN by specifying the custom size during export:

      model = YOLO("your_trained_model.pt")
      model.export(format="ncnn", imgsz=736)  # Use your training resolution

      This ensures the exported model maintains the same input dimensions you used during training. Let me know if this helps resolve the issue!

    3. gpsamtGitHub

      Hello. Does anyone have any example of implementing the converted ncnn model in android?

    1. Glenn JocherUltralytics(modifié)

      @PabloBR99 YOLO12 isn't recommended for NCNN export due to training instability and performance limitations. For NCNN deployments, we strongly recommend using YOLO26 (or YOLO11), which offer optimized performance and stability across all platforms. You can find the NCNN export guide in our documentation.

  3. gpsamtGitHub

    I am exporting a YOLOv11s model to ncnn. My model has 4 classes, however, when I perform the export, it appears that it is identifying 3 classes: PyTorch: starting from '/content/drive/MyDrive/IAGeneration/yolo11/runs/detect/train3/weights/best.pt' with input shape (1, 3, 640, 640) BCHW and output shape(s) (1, 8, 8400) (18.3 MB). In Android Studio, this message appears:

    2025-03-04 17:08:58.490 3853-3853 NcnnDetector com.example.agroinsect D Starting detection 2025-03-04 17:08:58.502 3853-3853 NcnnDetector com.example.test D Param file size: 22768 bytes 2025-03-04 17:08:58.504 3853-3853 NcnnDetector com.example.test D Load param result: 0 2025-03-04 17:08:58.504 3853-3853 NcnnDetector com.example.test D Bin file size: 10633344 bytes 2025-03-04 17:08:58.596 3853-3853 NcnnDetector com.example.test D Load model result: 10633344 2025-03-04 17:08:58.597 3853-3853 NcnnDetector com.example.test D Failed to load model file

    [ +82 ms] D/CompatChangeReporter( 3853): Compat change id reported: 312399441; UID 10209; state: ENABLED [ +11 ms] D/nativeloader( 3853): Load /data/app/~~yVwXpMN1F9boaEz-oh0Bpw==/com.example.test-J2_0Fz9v3HSf0USV8uxz6Q==/lib/x86_64/libncnn_detector.so using ns clns-7 from class loader (caller=/data/app/~~yVwXpMN1F9boaEz-oh0Bpw==/com.example.test-J2_0Fz9v3HSf0USV8uxz6Q==/base.apk!classes4.dex): ok [ ] D/NcnnDetector( 3853): Library ncnn_detector loaded successfully [ ] D/NcnnDetector( 3853): Starting detection [ +10 ms] D/NcnnDetector( 3853): Param file size: 22768 bytes [ +2 ms] D/NcnnDetector( 3853): Load param result: 0 [ ] D/NcnnDetector( 3853): Bin file size: 10633344 bytes [ +97 ms] D/NcnnDetector( 3853): Load model result: 10633344 [ +1 ms] D/NcnnDetector( 3853): Failed to load model file [ ] I/flutter ( 3853): Native detect result: null [ ] I/flutter ( 3853): Detections received: [] [ ] I/flutter ( 3853): No detections found.

    I have repeated the process several times, but I have not been able to resolve it. I found this answer: 'The current problem (Load model result: 37825744) suggests difficulties in exporting or compatibility.'"

    1. Glenn JocherUltralytics

      @gpsamt thank you for reporting this issue. Let's address both aspects systematically:

      1. Class Count Mismatch:
        The output shape (1,8,8400) suggests your model is correctly configured for 4 classes (4 classes + 4 box coordinates = 8). This indicates the export itself is successful. The Android implementation might need adjustment to handle the 4-class output format.

      2. Model Loading Failure:
        The "Failed to load model file" error typically indicates either:

      • Missing/corrupted .param or .bin files in deployment
      • Architecture mismatch between PyTorch and NCNN versions
      • Incorrect Android NCNN implementation

      We recommend:

      1. Verify successful local inference with your NCNN model using yolo predict model='yolo11n_ncnn_model' before Android deployment
      2. Ensure you're using the latest NCNN Android library from Tencent's NCNN GitHub repo
      3. Double-check that all NCNN model files are properly bundled in your Android assets

      For specific Android implementation guidance, please consult NCNN's official Android deployment documentation.

    2. gpsamtGitHub(modifié)

      I made several attempts and ended up not proceeding, however I really wanted to test my trained model running on android with ncnn. I made an export on windows of a yolo11 model trained in colab. To test the converted model yolo --> ncnn I did a test with an image with two objects. C:\Users\guips\Downloads>yolo predict model=C:\Users\guips\Downloads\best_ncnn_model source="C:\Users\guips\Downloads\brasil\test129.jpg" save_txt=true WARNING ⚠️ Unable to automatically guess model task, assuming 'task=detect'. Explicitly define task for your model, i.e. 'task=detect', 'segment', 'classify','pose' or 'obb'. Ultralytics 8.3.105 🚀 Python-3.11.9 torch-2.6.0+cpu CPU (12th Gen Intel Core(TM) i7-12700KF) Loading C:\Users\guips\Downloads\best_ncnn_model for NCNN inference...

      image 1/1 C:\Users\guips\Downloads\brasil\test129.jpg: 640x640 2 Car, 103.0ms Speed: 20.4ms preprocess, 103.0ms inference, 24.2ms postprocess per image at shape (1, 3, 640, 640) Results saved to runs\detect\predict6 1 label saved to runs\detect\predict6\labels 💡 Learn more at https://docs.ultralytics.com/modes/predict
      When I try to run the same image in the android application with flutter I can't. In TFLITE the output was (1,8,8400) Now it seems to be outputting (1,9,8400). I'm not able to work with the output data. I/flutter (14031): Labels loaded: 4

      E/libEGL (14031): called unimplemented OpenGL ES API I/flutter (14031): Storage permission denied D/InsetsController(14031): hide(ime(), fromIme=false) I/ImeTracker(14031): com.example.ncnnmy_ok:e29c5e1e: onCancelled at PHASE_CLIENT_ALREADY_HIDDEN E/libEGL (14031): called unimplemented OpenGL ES API D/InsetsController(14031): hide(ime(), fromIme=false) I/ImeTracker(14031): com.example.ncnnmy_ok:6f2d251e: onCancelled at PHASE_CLIENT_ALREADY_HIDDEN E/libEGL (14031): called unimplemented OpenGL ES API D/CompatChangeReporter(14031): Compat change id reported: 312399441; UID 10223; state: ENABLED I/flutter (14031): Image dimensions: 680.0x453.0 I/flutter (14031): Running inference on /data/user/0/com.example.ncnnmy_ok/cache/a6b569b8-5ff1-4466-ad32-49121fb24aa4/38.jpg D/MainActivity(14031): Received method call: detect I/NCNN (14031): Detecting on image: /data/user/0/com.example.ncnnmy_ok/cache/a6b569b8-5ff1-4466-ad32-49121fb24aa4/38.jpg I/NCNN (14031): Original image size: 680x453 I/NCNN (14031): Output dimensions: w=8400, h=9, c=1 I/NCNN (14031): Output saved to /data/user/0/com.example.ncnnmy_ok/cache/a6b569b8-5ff1-4466-ad32-49121fb24aa4/38.jpg_ncnn_output.txt W/NCNN (14031): Output has 4424 channels, expected 8. Using first 8 channels W/NCNN (14031): Invalid box at idx=9: w=0.000000, h=0.000000 W/NCNN (14031): Invalid box at idx=15: w=-0.010868, h=-0.063400 W/NCNN (14031): Invalid box at idx=16: w=-0.630245, h=-0.447460 W/NCNN (14031): Invalid box at idx=17: w=-0.685141, h=-0.837424 . . . W/NCNN (14031): Invalid box at idx=347: w=-0.077838, h=0.846499 F/libc (14031): Fatal signal 11 (SIGSEGV), code 2 (SEGV_ACCERR), fault addr 0x71c0c2499110 in tid 14031 (ample.ncnnmy_ok), pid 14031 (ample.ncnnmy_ok)


      Build fingerprint: 'google/sdk_gphone64_x86_64/emu64xa:16/BP22.250221.010/13193326:user/release-keys' Revision: '0' ABI: 'x86_64' Timestamp: 2025-04-15 01:29:54.291432600+0000 Process uptime: 156s Cmdline: com.example.ncnnmy_ok pid: 14031, tid: 14031, name: ample.ncnnmy_ok >>> com.example.ncnnmy_ok <<< uid: 10223 signal 11 (SIGSEGV), code 2 (SEGV_ACCERR), fault addr 0x000071c0c2499110 rax 000071c0c2499100 rbx 000071c247d33be0 rcx 0000000000000004 rdx 0000000000000008 r8 00007ffc6ffc4080 r9 00007ffc6ffc40a0 r10 0000000000e8cada r11 0000000000000213 r12 00007ffc6ff903b0 r13 000071c247d33c88 r14 00007ffc6ff90718 r15 000071c247d33be0 rdi 00007ffc6ff8f840 rsi 0000000000000167 rbp 00007ffc6ff8f970 rsp 00007ffc6ff8f8b0 rip 000071c053d969ea 90 total frames backtrace: #00 pc 00000000000109ea /data/app/~~ygC8oOQ2RMgj_IeB2wDRKw==/com.example.ncnnmy_ok-1Q_3JHdbdZSe1RwVvc5qjQ==/lib/x86_64/libnative-lib.so (BuildId: 63a90d5f64ab095e3ac958c5db79324dfa15e937) #01 pc 000000000000fd3a /data/app/~~ygC8oOQ2RMgj_IeB2wDRKw==/com.example.ncnnmy_ok-1Q_3JHdbdZSe1RwVvc5qjQ==/lib/x86_64/libnative-lib.so (BuildId: 63a90d5f64ab095e3ac958c5db79324dfa15e937) #02 pc 000000000000e8aa /data/app/~~ygC8oOQ2RMgj_IeB2wDRKw==/com.example.ncnnmy_ok-1Q_3JHdbdZSe1RwVvc5qjQ==/lib/x86_64/libnative-lib.so (Java_com_example_ncnnmy_1ok_MainActivity_detect+2634) (BuildId: 63a90d5f64ab095e3ac958c5db79324dfa15e937) #03 pc 000000000022c80b /apex/com.android.art/lib64/libart.so (art_quick_generic_jni_trampoline+219) (BuildId: 53a0485d03b4e7011d7d555e293a17af) #04 pc 0000000000211dd4 /apex/com.android.art/lib64/libart.so (art_quick_invoke_stub+756) (BuildId: 53a0485d03b4e7011d7d555e293a17af) #05 pc 0000000000461715 /apex/com.android.art/lib64/libart.so (art::ArtMethod::Invoke(art::Thread*, unsigned int*, unsigned int, art::JValue*, char const*)+181) (BuildId: 53a0485d03b4e7011d7d555e293a17af) #06 pc 00000000005f74b2 /apex/com.android.art/lib64/libart.so (bool art::interpreter::DoCall(art::ArtMethod*, art::Thread*, art::ShadowFrame&, art::Instruction const*, unsigned short, bool, art::JValue*)+2402) (BuildId: 53a0485d03b4e7011d7d555e293a17af) #07 pc 0000000000233611 /apex/com.android.art/lib64/libart.so (void art::interpreter::ExecuteSwitchImplCpp(art::interpreter::SwitchImplContext*)+10625) (BuildId: 53a0485d03b4e7011d7d555e293a17af) #08 pc 000000000022eb25 /apex/com.android.art/lib64/libart.so (ExecuteSwitchImplAsm+5) (BuildId: 53a0485d03b4e7011d7d555e293a17af) #09 pc 00000000000006a4 anonymous:71c395b1d000 (com.example.ncnnmy_ok.MainActivity.configureFlutterEngine$lambda$0+0) #10 pc 00000000005ef3f2 /apex/com.android.art/lib64/libart.so (art::interpreter::Execute(art::Thread*, art::CodeItemDataAccessor const&, art::ShadowFrame&, art::JValue, bool, bool) (.__uniq.112435418011751916792819755956732575238)+466) (BuildId: 53a0485d03b4e7011d7d555e293a17af) #11 pc 00000000005f6706 /apex/com.android.art/lib64/libart.so (art::interpreter::ArtInterpreterToInterpreterBridge(art::Thread*, art::CodeItemDataAccessor const&, art::ShadowFrame*, art::JValue*)+102) (BuildId: 53a0485d03b4e7011d7d555e293a17af) #12 pc 00000000005f7498 /apex/com.android.art/lib64/libart.so (bool art::interpreter::DoCall(art::ArtMethod*, art::Thread*, art::ShadowFrame&, art::Instruction const*, unsigned short, bool, art::JValue*)+2376) (BuildId: 53a0485d03b4e7011d7d555e293a17af) #13 pc 0000000000234b05 /apex/com.android.art/lib64/libart.so (void art::interpreter::ExecuteSwitchImplCpp(art::interpreter::SwitchImplContext*)+15989) (BuildId: 53a0485d03b4e7011d7d555e293a17af) #14 pc 000000000022eb25 /apex/com.android.art/lib64/libart.so (ExecuteSwitchImplAsm+5) (BuildId: 53a0485d03b4e7011d7d555e293a17af) #15 pc 0000000000000604 anonymous:71c395b1d000 (com.example.ncnnmy_ok.MainActivity.$r8$lambda$8rE-0sywqH2S4u1lhbBM5kfBEYE+0) #16 pc 00000000005ef3f2 /apex/com.android.art/lib64/libart.so (art::interpreter::Execute(art::Thread*, art::CodeItemDataAccessor const&, art::ShadowFrame&, art::JValue, bool, bool) (.__uniq.112435418011751916792819755956732575238)+466) (BuildId: 53a0485d03b4e7011d7d555e293a17af) #17 pc 00000000005f6706 /apex/com.android.art/lib64/libart.so (art::interpreter::ArtInterpreterToInterpreterBridge(art::Thread*, art::CodeItemDataAccessor const&, art::ShadowFrame*, art::JValue*)+102) (BuildId: 53a0485d03b4e7011d7d555e293a17af) #18 pc 00000000005f7498 /apex/com.android.art/lib64/libart.so (bool art::interpreter::DoCall(art::ArtMethod*, art::Thread*, art::ShadowFrame&, art::Instruction const*, unsigned short, bool, art::JValue*)+2376) (BuildId: 53a0485d03b4e7011d7d555e293a17af) #19 pc 0000000000234b05 /apex/com.android.art/lib64/libart.so (void art::interpreter::ExecuteSwitchImplCpp(art::interpreter::SwitchImplContext*)+15989) (BuildId: 53a0485d03b4e7011d7d555e293a17af) #20 pc 000000000022eb25 /apex/com.android.art/lib64/libart.so (ExecuteSwitchImplAsm+5) (BuildId: 53a0485d03b4e7011d7d555e293a17af) #21 pc 00000000000005b8 anonymous:71c395b1d000 (com.example.ncnnmy_ok.MainActivity$$ExternalSyntheticLambda0.onMethodCall+0) #22 pc 00000000005ef3f2 /apex/com.android.art/lib64/libart.so (art::interpreter::Execute(art::Thread*, art::CodeItemDataAccessor const&, art::ShadowFrame&, art::JValue, bool, bool) (.__uniq.112435418011751916792819755956732575238)+466) (BuildId: 53a0485d03b4e7011d7d555e293a17af) #23 pc 00000000005f6706 /apex/com.android.art/lib64/libart.so (art::interpreter::ArtInterpreterToInterpreterBridge(art::Thread*, art::CodeItemDataAccessor const&, art::ShadowFrame*, art::JValue*)+102) (BuildId: 53a0485d03b4e7011d7d555e293a17af) #24 pc 00000000005f7498 /apex/com.android.art/lib64/libart.so (bool art::interpreter::DoCall(art::ArtMethod*, art::Thread*, art::ShadowFrame&, art::Instruction const*, unsigned short, bool, art::JValue*)+2376) (BuildId: 53a0485d03b4e7011d7d555e293a17af) #25 pc 00000000002346e5 /apex/com.android.art/lib64/libart.so (void art::interpreter::ExecuteSwitchImplCpp(art::interpreter::SwitchImplContext*)+14933) (BuildId: 53a0485d03b4e7011d7d555e293a17af) #26 pc 000000000022eb25 /apex/com.android.art/lib64/libart.so (ExecuteSwitchImplAsm+5) (BuildId: 53a0485d03b4e7011d7d555e293a17af) #27 pc 00000000001bfabc anonymous:71c054260000 (io.flutter.plugin.common.MethodChannel$IncomingMethodCallHandler.onMessage+0) #28 pc 00000000005ef3f2 /apex/com.android.art/lib64/libart.so (art::interpreter::Execute(art::Thread*, art::CodeItemDataAccessor const&, art::ShadowFrame&, art::JValue, bool, bool) (.__uniq.112435418011751916792819755956732575238)+466) (BuildId: 53a0485d03b4e7011d7d555e293a17af) #29 pc 00000000005f6706 /apex/com.android.art/lib64/libart.so (art::interpreter::ArtInterpreterToInterpreterBridge(art::Thread*, art::CodeItemDataAccessor const&, art::ShadowFrame*, art::JValue*)+102) (BuildId: 53a0485d03b4e7011d7d555e293a17af) #30 pc 00000000005f7498 /apex/com.android.art/lib64/libart.so (bool art::interpreter::DoCall(art::ArtMethod*, art::Thread*, art::ShadowFrame&, art::Instruction const*, unsigned short, bool, art::JValue*)+2376) (BuildId: 53a0485d03b4e7011d7d555e293a17af) #31 pc 00000000002346e5 /apex/com.android.art/lib64/libart.so (void art::interpreter::ExecuteSwitchImplCpp(art::interpreter::SwitchImplContext*)+14933) (BuildId: 53a0485d03b4e7011d7d555e293a17af) #32 pc 000000000022eb25 /apex/com.android.art/lib64/libart.so (ExecuteSwitchImplAsm+5) (BuildId: 53a0485d03b4e7011d7d555e293a17af) #33 pc 00000000001b1954 anonymous:71c054260000 (io.flutter.embedding.engine.dart.DartMessenger.invokeHandler+0) #34 pc 00000000005ef3f2 /apex/com.android.art/lib64/libart.so (art::interpreter::Execute(art::Thread*, art::CodeItemDataAccessor const&, art::ShadowFrame&, art::JValue, bool, bool) (.__uniq.112435418011751916792819755956732575238)+466) (BuildId: 53a0485d03b4e7011d7d555e293a17af) #35 pc 00000000005f6706 /apex/com.android.art/lib64/libart.so (art::interpreter::ArtInterpreterToInterpreterBridge(art::Thread*, art::CodeItemDataAccessor const&, art::ShadowFrame*, art::JValue*)+102) (BuildId: 53a0485d03b4e7011d7d555e293a17af) #36 pc 00000000005f7498 /apex/com.android.art/lib64/libart.so (bool art::interpreter::DoCall(art::ArtMethod*, art::Thread*, art::ShadowFrame&, art::Instruction const*, unsigned short, bool, art::JValue*)+2376) (BuildId: 53a0485d03b4e7011d7d555e293a17af) #37 pc 0000000000233611 /apex/com.android.art/lib64/libart.so (void art::interpreter::ExecuteSwitchImplCpp(art::interpreter::SwitchImplContext*)+10625) (BuildId: 53a0485d03b4e7011d7d555e293a17af) #38 pc 000000000022eb25 /apex/com.android.art/lib64/libart.so (ExecuteSwitchImplAsm+5) (BuildId: 53a0485d03b4e7011d7d555e293a17af) #39 pc 00000000001b19d8 anonymous:71c054260000 (io.flutter.embedding.engine.dart.DartMessenger.lambda$dispatchMessageToQueue$0$io-flutter-embedding-engine-dart-DartMessenger+0) #40 pc 00000000005ef3f2 /apex/com.android.art/lib64/libart.so (art::interpreter::Execute(art::Thread*, art::CodeItemDataAccessor const&, art::ShadowFrame&, art::JValue, bool, bool) (.__uniq.112435418011751916792819755956732575238)+466) (BuildId: 53a0485d03b4e7011d7d555e293a17af) #41 pc 00000000005f6706 /apex/com.android.art/lib64/libart.so (art::interpreter::ArtInterpreterToInterpreterBridge(art::Thread*, art::CodeItemDataAccessor const&, art::ShadowFrame*, art::JValue*)+102) (BuildId: 53a0485d03b4e7011d7d555e293a17af) #42 pc 00000000005f827f /apex/com.android.art/lib64/libart.so (bool art::interpreter::DoCall(art::ArtMethod*, art::Thread*, art::ShadowFrame&, art::Instruction const*, unsigned short, bool, art::JValue*)+2319) (BuildId: 53a0485d03b4e7011d7d555e293a17af) #43 pc 000000000023482d /apex/com.android.art/lib64/libart.so (void art::interpreter::ExecuteSwitchImplCpp(art::interpreter::SwitchImplContext*)+15261) (BuildId: 53a0485d03b4e7011d7d555e293a17af) #44 pc 000000000022eb25 /apex/com.android.art/lib64/libart.so (ExecuteSwitchImplAsm+5) (BuildId: 53a0485d03b4e7011d7d555e293a17af) #45 pc 00000000001b1168 anonymous:71c054260000 (io.flutter.embedding.engine.dart.DartMessenger$$ExternalSyntheticLambda0.run+0) #46 pc 00000000005ef3f2 /apex/com.android.art/lib64/libart.so (art::interpreter::Execute(art::Thread*, art::CodeItemDataAccessor const&, art::ShadowFrame&, art::JValue, bool, bool) (.__uniq.112435418011751916792819755956732575238)+466) (BuildId: 53a0485d03b4e7011d7d555e293a17af) #47 pc 00000000009978fb /apex/com.android.art/lib64/libart.so (artQuickToInterpreterBridge+907) (BuildId: 53a0485d03b4e7011d7d555e293a17af) #48 pc 000000000022c99c /apex/com.android.art/lib64/libart.so (art_quick_to_interpreter_bridge+140) (BuildId: 53a0485d03b4e7011d7d555e293a17af) #49 pc 0000000000160efc [anon_shmem:dalvik-jit-code-cache] (offset 0x2000000) (android.os.Handler.handleCallback+156) #50 pc 00000000000718af [anon_shmem:dalvik-jit-code-cache] (offset 0x2000000) (android.os.Handler.dispatchMessage+159) #51 pc 000000000006e9a4 [anon_shmem:dalvik-jit-code-cache] (offset 0x2000000) (android.os.Looper.loopOnce+1348) #52 pc 0000000000212136 /apex/com.android.art/lib64/libart.so (art_quick_invoke_static_stub+806) (BuildId: 53a0485d03b4e7011d7d555e293a17af) #53 pc 000000000046175c /apex/com.android.art/lib64/libart.so (art::ArtMethod::Invoke(art::Thread*, unsigned int*, unsigned int, art::JValue*, char const*)+252) (BuildId: 53a0485d03b4e7011d7d555e293a17af) #54 pc 00000000005f74b2 /apex/com.android.art/lib64/libart.so (bool art::interpreter::DoCall(art::ArtMethod*, art::Thread*, art::ShadowFrame&, art::Instruction const*, unsigned short, bool, art::JValue*)+2402) (BuildId: 53a0485d03b4e7011d7d555e293a17af) #55 pc 0000000000234b05 /apex/com.android.art/lib64/libart.so (void art::interpreter::ExecuteSwitchImplCpp(art::interpreter::SwitchImplContext*)+15989) (BuildId: 53a0485d03b4e7011d7d555e293a17af) #56 pc 000000000022eb25 /apex/com.android.art/lib64/libart.so (ExecuteSwitchImplAsm+5) (BuildId: 53a0485d03b4e7011d7d555e293a17af) #57 pc 000000000027c140 /system/framework/framework.jar (offset 0x1274000) (android.os.Looper.loop+0) #58 pc 00000000005ef3f2 /apex/com.android.art/lib64/libart.so (art::interpreter::Execute(art::Thread*, art::CodeItemDataAccessor const&, art::ShadowFrame&, art::JValue, bool, bool) (.__uniq.112435418011751916792819755956732575238)+466) (BuildId: 53a0485d03b4e7011d7d555e293a17af) #59 pc 00000000005f6706 /apex/com.android.art/lib64/libart.so (art::interpreter::ArtInterpreterToInterpreterBridge(art::Thread*, art::CodeItemDataAccessor const&, art::ShadowFrame*, art::JValue*)+102) (BuildId: 53a0485d03b4e7011d7d555e293a17af) #60 pc 00000000005f7498 /apex/com.android.art/lib64/libart.so (bool art::interpreter::DoCall(art::ArtMethod*, art::Thread*, art::ShadowFrame&, art::Instruction const*, unsigned short, bool, art::JValue*)+2376) (BuildId: 53a0485d03b4e7011d7d555e293a17af) #61 pc 0000000000234b05 /apex/com.android.art/lib64/libart.so (void art::interpreter::ExecuteSwitchImplCpp(art::interpreter::SwitchImplContext*)+15989) (BuildId: 53a0485d03b4e7011d7d555e293a17af) #62 pc 000000000022eb25 /apex/com.android.art/lib64/libart.so (ExecuteSwitchImplAsm+5) (BuildId: 53a0485d03b4e7011d7d555e293a17af) #63 pc 00000000001f1254 /system/framework/framework.jar (offset 0x7000) (android.app.ActivityThread.main+0) #64 pc 00000000005ef3f2 /apex/com.android.art/lib64/libart.so (art::interpreter::Execute(art::Thread*, art::CodeItemDataAccessor const&, art::ShadowFrame&, art::JValue, bool, bool) (.__uniq.112435418011751916792819755956732575238)+466) (BuildId: 53a0485d03b4e7011d7d555e293a17af) #65 pc 00000000009978fb /apex/com.android.art/lib64/libart.so (artQuickToInterpreterBridge+907) (BuildId: 53a0485d03b4e7011d7d555e293a17af) #66 pc 000000000022c99c /apex/com.android.art/lib64/libart.so (art_quick_to_interpreter_bridge+140) (BuildId: 53a0485d03b4e7011d7d555e293a17af) #67 pc 0000000000212136 /apex/com.android.art/lib64/libart.so (art_quick_invoke_static_stub+806) (BuildId: 53a0485d03b4e7011d7d555e293a17af) #68 pc 000000000046175c /apex/com.android.art/lib64/libart.so (art::ArtMethod::Invoke(art::Thread*, unsigned int*, unsigned int, art::JValue*, char const*)+252) (BuildId: 53a0485d03b4e7011d7d555e293a17af) #69 pc 000000000088b130 /apex/com.android.art/lib64/libart.so (_jobject* art::InvokeMethod<(art::PointerSize)8>(art::ScopedObjectAccessAlreadyRunnable const&, _jobject*, _jobject*, _jobject*, unsigned long)+2240) (BuildId: 53a0485d03b4e7011d7d555e293a17af) #70 pc 00000000007e0f1a /apex/com.android.art/lib64/libart.so (art::Method_invoke(_JNIEnv*, _jobject*, _jobject*, _jobjectArray*) (.__uniq.165753521025965369065708152063621506277)+42) (BuildId: 53a0485d03b4e7011d7d555e293a17af) #71 pc 000000000022c80b /apex/com.android.art/lib64/libart.so (art_quick_generic_jni_trampoline+219) (BuildId: 53a0485d03b4e7011d7d555e293a17af) #72 pc 0000000000211dd4 /apex/com.android.art/lib64/libart.so (art_quick_invoke_stub+756) (BuildId: 53a0485d03b4e7011d7d555e293a17af) #73 pc 0000000000461715 /apex/com.android.art/lib64/libart.so (art::ArtMethod::Invoke(art::Thread*, unsigned int*, unsigned int, art::JValue*, char const*)+181) (BuildId: 53a0485d03b4e7011d7d555e293a17af) #74 pc 00000000005f74b2 /apex/com.android.art/lib64/libart.so (bool art::interpreter::DoCall(art::ArtMethod*, art::Thread*, art::ShadowFrame&, art::Instruction const*, unsigned short, bool, art::JValue*)+2402) (BuildId: 53a0485d03b4e7011d7d555e293a17af) #75 pc 0000000000233611 /apex/com.android.art/lib64/libart.so (void art::interpreter::ExecuteSwitchImplCpp(art::interpreter::SwitchImplContext*)+10625) (BuildId: 53a0485d03b4e7011d7d555e293a17af) #76 pc 000000000022eb25 /apex/com.android.art/lib64/libart.so (ExecuteSwitchImplAsm+5) (BuildId: 53a0485d03b4e7011d7d555e293a17af) #77 pc 000000000027f6ec /system/framework/framework.jar (offset 0x2430000) (com.android.internal.os.RuntimeInit$MethodAndArgsCaller.run+0) #78 pc 00000000005ef3f2 /apex/com.android.art/lib64/libart.so (art::interpreter::Execute(art::Thread*, art::CodeItemDataAccessor const&, art::ShadowFrame&, art::JValue, bool, bool) (.__uniq.112435418011751916792819755956732575238)+466) (BuildId: 53a0485d03b4e7011d7d555e293a17af) #79 pc 00000000009978fb /apex/com.android.art/lib64/libart.so (artQuickToInterpreterBridge+907) (BuildId: 53a0485d03b4e7011d7d555e293a17af) #80 pc 000000000022c99c /apex/com.android.art/lib64/libart.so (art_quick_to_interpreter_bridge+140) (BuildId: 53a0485d03b4e7011d7d555e293a17af) #81 pc 00000000007fc865 /system/framework/x86_64/boot-framework.oat (com.android.internal.os.ZygoteInit.main+2693) (BuildId: 5539d75c58ae9a874c8bdd56a20d5ad37b7a2757) #82 pc 0000000000212136 /apex/com.android.art/lib64/libart.so (art_quick_invoke_static_stub+806) (BuildId: 53a0485d03b4e7011d7d555e293a17af) #83 pc 000000000046175c /apex/com.android.art/lib64/libart.so (art::ArtMethod::Invoke(art::Thread*, unsigned int*, unsigned int, art::JValue*, char const*)+252) (BuildId: 53a0485d03b4e7011d7d555e293a17af) #84 pc 000000000088bc46 /apex/com.android.art/lib64/libart.so (art::JValue art::InvokeWithVarArgs<_jmethodID*>(art::ScopedObjectAccessAlreadyRunnable const&, _jobject*, _jmethodID*, __va_list_tag*)+518) (BuildId: 53a0485d03b4e7011d7d555e293a17af) #85 pc 000000000072f31a /apex/com.android.art/lib64/libart.so (art::JNI::CallStaticVoidMethodV(_JNIEnv*, _jclass*, _jmethodID*, __va_list_tag*)+602) (BuildId: 53a0485d03b4e7011d7d555e293a17af) #86 pc 00000000000eefae /system/lib64/libandroid_runtime.so (_JNIEnv::CallStaticVoidMethod(_jclass*, _jmethodID*, ...)+126) (BuildId: 0e1c658a58fcbbaafa02d3d78a368ee8) #87 pc 000000000011b496 /system/lib64/libandroid_runtime.so (android::AndroidRuntime::start(char const*, android::Vectorandroid::String8 const&, bool)+966) (BuildId: 0e1c658a58fcbbaafa02d3d78a368ee8) #88 pc 0000000000004708 /system/bin/app_process64 (main+1640) (BuildId: e2134dffba60b5f40425e9c838419a02) #89 pc 0000000000054ea5 /apex/com.android.runtime/lib64/bionic/libc.so (__libc_init+117) (BuildId: 2fa253bed5a3b3aee8fce00edb55a139) Lost connection to device.

      These are the first layers of the .param file and the last ones.

      7767517 275 327 Input in0 0 1 in0 Convolution conv_0 1 1 in0 1 0=32 1=3 11=3 12=1 13=2 14=1 2=1 3=2 4=1 5=1 6=864 Swish silu_84 1 1 1 2 Convolution conv_1 1 1 2 3 0=64 1=3 11=3 12=1 13=2 14=1 2=1 3=2 4=1 5=1 6=18432 Swish silu_85 1 1 3 4 Convolution conv_2 1 1 4 5 0=64 1=1 11=1 12=1 13=1 14=0 2=1 3=1 4=0 5=1 6=4096

      Last layer

      Split splitncnn_27 1 2 313 314 315 BinaryOp add_16 2 1 310 312 316 0=0 Split splitncnn_28 1 2 316 317 318 BinaryOp add_17 2 1 314 317 319 0=0 BinaryOp div_18 1 1 319 320 0=3 1=1 2=2.000000e+00 BinaryOp sub_19 2 1 318 315 321 0=1 Concat cat_21 2 1 320 321 322 0=0 Reshape reshape_167 1 1 252 323 0=8400 1=1 BinaryOp mul_20 2 1 322 323 324 0=2 Sigmoid sigmoid_163 1 1 303 325 Concat cat_22 2 1 324 325 out0 0=0

      I thank you in advance for your attention and help.

  4. UltralyticsAssistantGitHubUltralytics

    👋 Hello, thank you for your interest in Ultralytics 🚀! It's exciting to see discussions around optimizing YOLO models for mobile and embedded devices. The link you shared regarding NCNN integration is a great starting point for exploring this topic: https://docs.ultralytics.com/zh/integrations/ncnn/.

    If you're encountering issues or have specific queries regarding the NCNN export or deployment, here are a few recommendations:

    1. If this is a 🐛 Bug Report, please provide a minimum reproducible example so our team can better understand and debug any potential issues.

    2. If this is an ❓ integration or optimization question, please provide as much context as possible, such as your model configuration, device specifications, and any logs or error messages.

    For further learning and exploration, you may also find these resources helpful:

    • Integration Examples: Comprehensive guides for integrating YOLO with various platforms and tools.
    • NCNN Documentation: Specific details about NCNN and its benefits for resource-constrained environments.

    Upgrade

    Ensure you're using the latest Ultralytics package and dependencies by upgrading your environment with the following command:

    pip install -U ultralytics

    Environments

    To experiment with YOLO in diverse, GPU-enabled environments, check out the following setups:

    Status

    Ultralytics CI

    This badge indicates the status of Ultralytics CI tests, which ensure the reliability of YOLO models across various environments. A green badge means all tests are successful ✅.

    Lastly, this is an automated response to guide you as quickly as possible, but rest assured that an Ultralytics engineer will follow up soon to assist you further. Feel free to share additional information or questions in the meantime 😊.

    1. haitao5676

      I have created a single target tracking model for deployment on Android devices. How can I export the ncnn file for deployment using my own model?

    2. haitao5676

      I have resolved the issue of using the model trained by ncnn in Python and am now preparing to deploy Java references for Android. Excuse me!

    1. Glenn JocherUltralytics

      @xiao5676wen to export your trained YOLO11 .pt model to NCNN format, load your model using the YOLO class in Python and then call the export method with format="ncnn". Example:

      from ultralytics import YOLO
      
      model = YOLO("path_to_your_trained_model.pt")
      model.export(format="ncnn")  # Creates the NCNN model

      For additional details, refer to the NCNN export documentation.

  5. trungnb34GitHub

    Hi everyone NCNN can be inferred from the int8 model I have a question. when converting Yolo model to int8 . Can ultralytics support it and Does the accuracy decrease much? Thanks

    1. Glenn JocherUltralytics(modifié)

      @trungnb34 Ultralytics can export YOLO models to NCNN in FP16 with quantize=16, but INT8 quantization is not currently supported for NCNN exports (quantize=8 is rejected for this format). For details, refer to the Export to NCNN guide.

    2. robert-hardmanGitHub

      Hello ultralytics==8.3.53 Like it doesn't support int8 yet

      File "C:\Users***\AppData\Local\Programs\Python\Python312\Lib\site-packages\ultralytics\engine\exporter.py", line 253, in call validate_args(fmt, self.args, fmts_dict["Arguments"][flags.index(True) + 1]) File "C:\Users***AppData\Local\Programs\Python\Python312\Lib\site-packages\ultralytics\engine\exporter.py", line 144, in validate_args assert arg in valid_args, f"ERROR \u274c\ufe0f argument '{arg}' is not supported for format='{format}'" ^^^^^^^^^^^^^^^^^ AssertionError: ERROR \u274c\ufe0f argument 'int8' is not supported for format='ncnn'

    3. Glenn JocherUltralytics

      @robert-hardman thank you for raising this issue. Currently, INT8 quantization is not supported for NCNN exports in Ultralytics. For updates on supported features, keep an eye on our Export documentation. Let us know if you have further questions!

      1
  6. amrboef66GitHub

    Hellooo, im trying to run interference on a raspberry Pi 5, now indeed NCNN has the fastest time, but i need it to be even quicker, so i tried reducing the image format from 640 to 480, since my model does not require such a large image size, but when i do that it misidentifies and puts bounding boxes everywhere on screen. How do i reduce image size while still allowing the model to run accurately?

    Also, do you have any thoughts on how i can make it quicker, perhaps a different method? I am already using Nano model and int8 quantisation.

    Thank you so much!

    1. Glenn JocherUltralytics

      @amrboef66 to improve accuracy with a smaller image size, consider fine-tuning your model on images of the desired size. Additionally, you might explore using a more efficient model architecture or further optimizing your inference pipeline.

  7. abdullah000123GitHub

    Can we directly export model in ncnn while training or we only can convert model which i obtained after training ie converting from pt to ncnn if we can convert directly while training whats is benefit in case of accuracy and also give me code if we can export directly while training model

    1. Paula DerrengerUltralytics

      @abdullah000123 you can only export a YOLOv8 model to NCNN format after training is complete. Direct export during training is not supported. Exporting post-training ensures that the model is fully trained and optimized before conversion, which does not impact accuracy. For exporting, you can use the following command after training:

      from ultralytics import YOLO
      model = YOLO("yolov8n.pt")
      model.export(format="ncnn")

      For more details, please refer to the NCNN export guide.

  8. woerstcaseGitHub

    Hey there!

    I tried and on my Mac M2 Mac the inference time got from around 60ms to 30ms. And in a custom Model even faster.

    But now i have the "problem" that the BBoxes are very flickering. Is there a good technique to make the bbox drawing even more smooth. I tried some approaches like drawing over 5 Frames for e.g. But if i have same classes on the image the bbox starts wandering trough the image.

    best regards

    1. Glenn JocherUltralytics

      Hey there! 👋

      Great to hear about the speed improvements on your Mac M2! For smoothing out the flickering BBoxes, one approach is to apply a moving average or some form of temporal smoothing to the bounding box coordinates across frames. This helps in making the position more stable. A simple example could be:

      # Assuming bbox is a list of bounding box coordinates for the current frame
      # prev_bboxes is a list of previous bounding boxes (could store N previous states)
      
      smoothed_bbox = current_bbox * alpha + prev_bbox * (1 - alpha)

      alpha is a weighting factor that determines the balance between the current and previous frame's information (e.g., alpha=0.6). This approach assumes prev_bbox is the bounding box coordinate from the previous frame. Adjust alpha based on your preference for smoothness vs. responsiveness.

      If you're handling multiple objects of the same class, consider incorporating an object tracker that assigns unique IDs to each object. This way, you can apply the smoothing individually to each tracked object, preventing the "wandering" effect across objects of the same class.

      Hope this helps! Let us know if you have any more questions. 😊

      Best regards

      1
    2. woerstcaseGitHub

      Worked for me! With my custom Model the inference time is around 15ms!

      This is my smoothing function:

      #Smoothing function def smooth_bbox(current_bbox, prev_bbox): if prev_bbox is None: return current_bbox smoothed_bbox = [(c * alpha + p * (1 - alpha)) for c, p in zip(current_bbox, prev_bbox)] return smoothed_bbox

      ....#later in the code i use it like this

          for box, confidence, cls in zip(boxes, confidences, classes):
              x1, y1, x2, y2 = map(int, box[:4])  # Extract bounding box coordinates
              class_name = names[int(cls)]
              
              # Generate a unique key for each bbox assuming no tracking ID available
              bbox_key = f"{x1}_{y1}_{x2}_{y2}"
              
              # Apply smoothing
              current_bbox = [x1, y1, x2, y2]
              if bbox_key in prev_bboxes:
                  smoothed_coords = smooth_bbox(current_bbox, prev_bboxes[bbox_key])
              else:
                  smoothed_coords = current_bbox
              
              # Update prev_bboxes
              prev_bboxes[bbox_key] = smoothed_coords
              
              # Calculate the center of the smoothed bbox
              center_x = int((smoothed_coords[0] + smoothed_coords[2]) / 2)
              center_y = int((smoothed_coords[1] + smoothed_coords[3]) / 2)

      best regards

    3. Glenn JocherUltralytics

      Hey there!

      Great to see your impressive inference times, and thanks for sharing your smoothing function! 🚀 It looks like a solid approach. To address the flickering and "wandering" of bounding boxes for objects of the same class, you might consider integrating an object tracking algorithm like SORT or DeepSORT that assigns unique IDs to each object. This way, you can ensure that the smoothing you apply is object-specific.

      Here's a small tweak to include object tracking by simply creating a unique key based on the object's class and center coordinates, assuming you'd implement tracking to assign IDs:

      # Assuming bbox_key generation after object tracking assigns a unique track_id
      bbox_key = f"{class_name}_{track_id}"
      
      # Use this key for previous bbox retrieval and smoothing application

      This tweak can help keep the smoothing consistent across consecutive frames for the same object, reducing "wandering."

      Hope this helps make your bboxes smooth as silk! Let me know if you have other questions or if there's more we can help with.

      Happy coding! 😊

      Best regards