Empezar

Exportación a Tencent NCNN

NCNN es un entorno de código abierto de redes neuronales de Tencent para inferencia en móviles, placas integradas y ordenadores de sobremesa. Al exportar un modelo Ultralytics YOLO26 con format="ncnn", se crea un directorio yolo26n_ncnn_model/ que contiene la red en un par de archivos .param y .bin, con pesos FP32 o FP16.

Resumen#

PropiedadDetalles
Argumento formatncnn
Salidayolo26n_ncnn_model/, un directorio con model.ncnn.param, model.ncnn.bin, model_ncnn.py y metadata.yaml.
Se ejecuta enCPU ARM y x86-64, y GPU con un controlador Vulkan: móviles, ordenadores de placa única como Raspberry Pi y ordenadores de sobremesa.
Entorno de ejecuciónNCNN: el paquete Python ncnn o la biblioteca NCNN C++ en aplicaciones Android, iOS e integradas.
PrecisiónPesos FP32 o FP16; no hay exportación INT8. YOLO26n ocupa 9,8 MB en FP32 y 5,0 MB con pesos FP16.
Equipo de exportaciónLinux x86-64 o ARM64, macOS o Windows x64, plataformas para las que pnnx ofrece compilaciones. La exportación no necesita GPU.
Exportar en la nube

Ultralytics Platform puede exportar por ti un modelo entrenado a NCNN, así que no necesitas un entorno de exportación local.

Inicio rápido#

Instala el paquete Ultralytics:

pip install ultralytics

La primera exportación instala los paquetes ncnn y pnnx si faltan, y la primera predicción con un modelo exportado instala ncnn si falta. En un entorno nuevo no necesitas nada más: la primera exportación termina en la misma ejecución, después de registrar Restart runtime or rerun command for updates to take effect. La exportación tiene estos requisitos de versión:

PaqueteVersión requerida
pnnxExactamente 20260526. La exportación instala esta versión y sustituye cualquier otra.
ncnnCualquier versión
torch2.0 o posterior: la exportación no comprueba la versión y las pruebas de Ultralytics omiten NCNN en versiones anteriores, porque allí la inferencia fallaba.

Para otros métodos de instalación, consulta la guía de instalación. Después, exporta tu modelo y carga el directorio exportado para ejecutar inferencias o validar su precisión.

Exportar
from ultralytics import YOLO

# Carga un modelo YOLO26
model = YOLO("yolo26n.pt")

# Exporta el modelo al formato NCNN
model.export(format="ncnn")  # creates 'yolo26n_ncnn_model/'

# O bien exporta con pesos FP16, lo que reduce a la mitad el tamaño del archivo.
model.export(format="ncnn", quantize=16)  # creates 'yolo26n_ncnn_model/'

Ambas exportaciones escriben en el mismo directorio yolo26n_ncnn_model/, así que la segunda sustituye a la primera.

Predecir
from ultralytics import YOLO

# Carga el modelo exportado a NCNN
model = YOLO("yolo26n_ncnn_model")

# Ejecutar inferencia
results = model("https://ultralytics.com/images/bus.jpg")
Validar
from ultralytics import YOLO

# Carga el modelo exportado a NCNN
model = YOLO("yolo26n_ncnn_model")

# Valida la precisión con el conjunto de datos COCO8
metrics = model.val(data="coco8.yaml")

Tareas compatibles#

La exportación a NCNN admite las siete tareas de Ultralytics con los modelos YOLOv8, YOLO11 y YOLO26: detección, segmentación, segmentación semántica, estimación de profundidad, clasificación, estimación de pose y OBB. La segmentación semántica y la estimación de profundidad solo están disponibles con YOLO26, la única familia que incluye esas cabezas. También se exportan los modelos de detección YOLOv5u, YOLOv9, YOLOv10 y YOLO12. Los modelos RT-DETR, YOLO-World y YOLOE con indicaciones de texto no se pueden convertir; consulta Limitaciones y solución de problemas.

Argumentos de exportación#

ArgumentoTipoPredeterminadoDescripción
formatstr'ncnn'Formato de destino del modelo exportado, que define su compatibilidad con distintos entornos de implementación.
imgszint o tuple640Tamaño de la imagen de entrada del modelo, fijado en el modelo exportado: un entero para imágenes cuadradas o una tupla (height, width). Si no se especifica, la exportación usa el tamaño con el que se entrenó el punto de control. Los puntos de control oficiales de YOLO26 usan 640 para los modelos de detección, segmentación y pose, así como para los modelos semánticos preentrenados en ADE20K; 1024 para los modelos OBB y los modelos semánticos preentrenados en Cityscapes; 768 para profundidad; y 224 para clasificación.
quantizeint o strNonePrecisión de los pesos almacenados: 16 (FP16) reduce a la mitad el tamaño del archivo; 32 o no especificarlo significa FP32. 8 genera un error, y un punto de control entrenado con quantize=8 no se puede exportar a NCNN; consulta Limitaciones y solución de problemas. Sustituye la opción obsoleta half.
nmsbool, opcionalNoneLos modelos NCNN siempre devuelven predicciones sin procesar para aplicar NMS externamente. La cabeza sin NMS (False) y la NMS integrada (True) no están disponibles; consulta Limitaciones y solución de problemas.
devicestrNoneDispositivo que traza el modelo para la conversión: cpu (el predeterminado, también en equipos con GPU), 0 para una GPU CUDA o mps para Apple silicon.

De los argumentos de exportación específicos del formato, NCNN solo acepta estos. Para consultar los argumentos comunes a todos los formatos, visita la documentación del modo de exportación.

Precisión#

quantize selecciona cómo se almacenan los pesos en model.ncnn.bin. Los tamaños corresponden a un modelo de detección YOLO26n exportado con imgsz=640:

quantizePesosTamaño de YOLO26n
sin especificar o 32FP329.8 MB
16FP165.0 MB
  • Pesos FP16: quantize=16 almacena los pesos en precisión media y no necesita datos de calibración. La entrada y las salidas siguen siendo float32, por lo que el código de inferencia escrito para el modelo FP32 se ejecuta sin cambios.
  • Precisión: con COCO val2017, en una CPU de servidor x86-64, los modelos NCNN FP32 y FP16 de YOLO26n, el modelo ONNX y el modelo PyTorch (rect=False) alcanzaron todos 40.9 mAPvalidación 50-95 con la misma entrada de 640x640.
  • Cálculo FP16: NCNN también puede calcular con precisión media, independientemente de la precisión de los pesos almacenados. En un Apple M4, lo hizo de forma predeterminada en ambas exportaciones: en una imagen de prueba, las coordenadas sin procesar de los cuadros de la exportación FP32 diferían del modelo ONNX en un máximo de unos 2.1 píxeles para los anclajes con confianza superior a 0.25, y toda la salida coincidía con un margen de 0.01 cuando net.opt.use_fp16_storage = False estaba configurado en el paquete ncnn. En una CPU de servidor x86-64, las salidas sin procesar de la exportación FP32 diferían del modelo ONNX menos de 0.03 en la misma imagen para los modelos de detección, segmentación, profundidad, clasificación, pose y OBB. Con pesos FP16, las coordenadas de los cuadros de esos anclajes diferían de ONNX unos 0.3 píxeles en el servidor y 1.6 píxeles en el M4. En el M4, estas diferencias cambiaron la precisión menos de 0.1: en COCO128, el validador de Ultralytics obtuvo 47.7 mAP 50-95 para la exportación FP32 y 47.7 con pesos FP16, frente a 47.7 para el modelo PyTorch (rect=False) con la misma entrada de 640x640.

Formato de salida#

La exportación escribe un directorio:

ArchivoContenido
model.ncnn.paramEl grafo de la red en un archivo de texto
model.ncnn.binLos pesos
model_ncnn.pyUn script de Python escrito por PNNX que ejecuta el modelo con una entrada aleatoria usando el paquete ncnn
metadata.yamlNombres de las clases, tarea, tamaño de imagen, tamaño del lote, stride y argumentos de exportación, que Ultralytics lee al cargar el modelo

La exportación también deja una carpeta __pycache__ en el directorio, que puedes borrar. El modelo recibe una entrada llamada in0 con la forma (3, height, width): una imagen RGB, con los canales primero, float32, escalada a 0-1. No hay dimensión de lote, y las salidas tampoco la tienen. Las formas siguientes corresponden a los puntos de control oficiales YOLO26n con el tamaño de exportación predeterminado y al punto de control de Cityscapes yolo26n-sem.pt para la segmentación semántica:

TareaValor predeterminado imgszSalidas
Detección640out0 (84, 8400)
Segmentación640out0 (116, 8400) y out1 (32, 160, 160)
Semántica1024out0 (19, 1024, 1024), una puntuación para cada clase y píxel
Profundidad768out0 (1, 768, 768), mapa de profundidad
Clasificar224out0 (1000,), probabilidades de clase
Pose640out0 (56, 8400)
OBB1024out0 (20, 21504)
  • Predicciones sin procesar: los modelos de detección, segmentación, pose y OBB devuelven las mismas predicciones sin procesar que una exportación ONNX predeterminada, pero sin la dimensión de lote: para cada anclaje, las coordenadas x e y del centro del cuadro y su anchura y altura en píxeles de entrada, seguidas de las puntuaciones de clase y, después, los valores de la tarea (32 coeficientes de máscara, 17 x 3 valores de puntos clave o el ángulo OBB en radianes). Aplica NMS tú mismo.
  • Segmentación: out0 contiene las predicciones y out1 los prototipos de máscara.
  • Segmentación semántica: la salida contiene una puntuación para cada clase y píxel, no el mapa de clases de la exportación ONNX, así que calcula el argmax sobre el eje de clases en tu propio código.
  • NMS: no hay salida sin NMS ni con NMS integrada; consulta Limitaciones y solución de problemas.

YOLO("yolo26n_ncnn_model") lee la disposición desde metadata.yaml, añade la dimensión de lote y aplica NMS, así que solo necesitas estos detalles si ejecutas el modelo con tu propio código. Las claves de metadata.yaml incluyen names, task, imgsz, stride, batch, end2end, args y, para los modelos de pose, kpt_shape.

Ejecutar con el paquete ncnn#

Para ejecutar el modelo fuera del paquete de Ultralytics, carga los dos archivos con el paquete de Python ncnn. Los mismos archivos .param y .bin se cargan en la biblioteca NCNN de C++ en Android, iOS y Linux integrado.

# Exporta primero: yolo export model=yolo26n.pt format=ncnn
import ncnn
import numpy as np

net = ncnn.Net()
net.opt.num_threads = 4  # configura las opciones antes de cargar el modelo
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)  # tu imagen con 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)  # forma (84, 8400), predicciones sin procesar que necesitan NMS
assert predictions.shape == (84, 8400), "export a detection model at imgsz=640"

ncnn.Mat(image) lee la memoria del array NumPy sin copiarla, así que pasa un array float32 contiguo en C y mantenlo en memoria hasta terminar la extracción, o cópialo con .clone(), como se muestra arriba. Un array creado con transpose no es contiguo, y astype o una división posterior conservan esa disposición; por tanto, termina el preprocesamiento con np.ascontiguousarray(x, dtype=np.float32). En una prueba con este modelo, un array no contiguo se ejecutó sin errores y devolvió predicciones incorrectas, mientras que un array float64 provocó un fallo de Python.

Despliega#

En el dispositivo de destino, instala el paquete con pip install ultralytics y copia allí el directorio yolo26n_ncnn_model/. A continuación, YOLO("yolo26n_ncnn_model") ejecuta el modelo con el paquete de Python ncnn, que Ultralytics instala la primera vez que se usa. El argumento device selecciona dónde se ejecuta NCNN:

deviceDónde se ejecuta el modelo
sin especificar o cpuNCNN en la CPU
vulkan:0, vulkan:1, ...NCNN en el dispositivo Vulkan con ese índice; consulta Inferencia en GPU con Vulkan
0 en un equipo con GPU CUDANCNN en la CPU: NCNN no tiene backend CUDA
mps en Apple siliconNCNN en la CPU, mientras Ultralytics preprocesa y posprocesa en la GPU de Apple. En un M4, esto añadió unos 0.6 s a la primera imagen y no aceleró la inferencia, así que deja device sin especificar
  • Forma de entrada fija: el modelo siempre se ejecuta con el imgsz de la exportación, que Ultralytics lee desde metadata.yaml. Se ignora cualquier imgsz que se pase a predict o val. Vuelve a exportar para cambiar el tamaño de la imagen.
  • Lotes: el modelo recibe una imagen, y Ultralytics ejecuta las imágenes de un lote una tras otra, así que puedes usar cualquier número de imágenes. val establece batch=1 con independencia del valor que pases.
  • Hilos de CPU: NCNN elige el número de hilos por sí mismo: 4 en un Apple M4, el número de núcleos de rendimiento que tiene. En Linux, Ultralytics limita ese número a 8 y a las CPU que puede usar el proceso: su afinidad de CPU (taskset, Docker --cpuset-cpus) y una cuota de CPU de cgroup v2 (Docker --cpus). Consulta Limitaciones y solución de problemas para usar un número distinto.

Inferencia en GPU con Vulkan#

NCNN se ejecuta en GPU mediante Vulkan, que funciona con proveedores de GPU como AMD, Intel, ARM, Qualcomm y Apple, sin CUDA. Pasa device="vulkan:0" para el primer dispositivo Vulkan o vulkan:1 para el segundo:

Inferencia con Vulkan
from ultralytics import YOLO

# Carga el modelo exportado a NCNN
model = YOLO("yolo26n_ncnn_model")

# Ejecuta la inferencia en el primer dispositivo Vulkan
results = model("https://ultralytics.com/images/bus.jpg", device="vulkan:0")

La GPU necesita un controlador Vulkan, que incluyen la mayoría de los controladores de GPU actuales; en Linux, vulkaninfo muestra los que están instalados. El índice cuenta los dispositivos Vulkan que encuentra NCNN, que no tienen por qué ser GPU físicas. Muéstralos antes de confiar en el resultado:

import ncnn

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

Vulkan no siempre es más rápido que la CPU. En un Apple M4, YOLO26n tardó unos 31 ms por imagen en el dispositivo Vulkan y unos 12 ms en la CPU. Mide el rendimiento en tu dispositivo.

Guías de despliegue#

Limitaciones y solución de problemas#

  • INT8: quantize=8 falla con quantize=8 (INT8) is not supported; format='ncnn' supports quantize=16 (FP16), 32 or None (FP32).. Usa FP16 para reducir el tamaño del archivo o un formato compatible con la exportación INT8, como LiteRT o MNN.
  • Puntos de control entrenados con quantize=8: un punto de control ajustado con entrenamiento con conocimiento de cuantización falla con format='ncnn' cannot export a QAT model: its Q/DQ ranges are only read by the 'onnx' and 'engine' backends. Exporta el punto de control desde el que empezaste el ajuste en su lugar, o exporta el punto de control ajustado a ONNX o TensorRT.
  • Cabeza sin NMS: los modelos NCNN siempre devuelven predicciones sin procesar que necesitan NMS. Con nms=False, la exportación de un modelo YOLO26 o YOLOv10 registra This export format does not support end2end models, disabling the end2end branch. y utiliza la cabeza uno a muchos; para otros modelos de detección, segmentación, pose y OBB, como YOLO11, registra This model has no one-to-one head; using one-to-many outputs.
  • NMS integrada: nms=True registra format=ncnn does not support embedded NMS; exporting native outputs for external NMS. y escribe la salida sin procesar.
  • Forma de entrada y tamaño de lote fijos: dynamic=True falla con argument 'dynamic' is not supported for format='ncnn', y cualquier valor de batch distinto de 1 falla con argument 'batch' is not supported for format='ncnn'. Vuelve a exportar para cambiar el tamaño de la imagen.
  • Modelos que no se pueden convertir: la exportación de los modelos RT-DETR (rtdetr-l.pt), YOLO-Worldv2 (yolov8s-worldv2.pt) y YOLOE con indicaciones de texto (yoloe-26s-seg.pt) falla con NCNN failed to load the exported model, it may contain layers NCNN does not support.. Un modelo YOLOE con indicaciones de texto se exporta después de fijar sus clases con set_classes(), y el modelo sin indicaciones yoloe-26s-seg-pf.pt se exporta tal cual.
  • Versión de PNNX: la exportación requiere pnnx 20260526 y sustituye una versión más reciente, porque los modelos convertidos con PNNX 20260704 fallan durante la inferencia.
  • Instalación automática desactivada: con YOLO_AUTOINSTALL=false, la exportación falla con No module named 'ncnn' si el entorno no contiene los paquetes. Instálalos con pip install --no-deps ncnn y pip install pnnx==20260526.
  • Número de hilos: predict y val no tienen ningún argumento para definir el número de hilos de NCNN, y la variable OMP_NUM_THREADS no lo cambia. En Linux, Ultralytics usa como máximo 8 hilos, y los modelos más grandes pueden ejecutarse más rápido con más hilos en máquinas con más núcleos: al ejecutar el paquete ncnn en 16 núcleos de un AMD EPYC 9655, YOLO26x tardó unos 177 ms por imagen con 8 hilos y unos 154 ms con 16, mientras que YOLO26n tardó unos 23 ms con cualquiera de las dos configuraciones. Para elegir el número de hilos, ejecuta el modelo con el paquete ncnn y configura net.opt.num_threads antes de cargarlo. Cambiar num_threads después de cargar el modelo ralentizó la inferencia.
  • Directorio del modelo incompleto: si falta model.ncnn.bin o está incompleto, por ejemplo, tras una copia interrumpida al dispositivo, Python se detiene con un fallo de segmentación y sin rastreo de la pila. Las últimas líneas de la salida indican la causa: fopen yolo26n_ncnn_model/model.ncnn.bin failed o ModelBin read weight_data failed. Un directorio sin model.ncnn.param falla con StopIteration. Vuelve a copiar el directorio.
  • device="vulkan" sin índice: falla con IndexError: list index out of range. Especifica el índice, como en device="vulkan:0".
  • El dispositivo Vulkan no es una GPU: en el servidor Linux usado para esta página, el único dispositivo Vulkan que enumeró NCNN fue llvmpipe, un renderizador de software que se ejecuta en la CPU. device="vulkan:0" se ejecuta entonces sin errores y sin GPU. Un índice inexistente, como vulkan:9 en un equipo con un único dispositivo, también se ejecuta sin errores.
  • Directorio de salida: cada exportación de un mismo punto de control escribe en el mismo directorio yolo26n_ncnn_model/, sean cuales sean sus valores quantize o imgsz, por lo que la exportación posterior sustituye a la anterior. Cambia el nombre del directorio para conservar ambas y mantén _ncnn_model en el nombre, por ejemplo yolo26n_fp16_ncnn_model/, porque Ultralytics reconoce el formato por esa cadena. Un directorio sin ella, o la ruta del archivo .param, falla con is not a supported model format.

Para otros errores, consulta la guía de problemas habituales.

Pruebas de rendimiento#

Ultralytics publica pruebas de rendimiento de NCNN en dos plataformas ARM. Las pruebas de rendimiento en Raspberry Pi 5 comparan NCNN con otros siete formatos para YOLO26n y YOLO26s, y las pruebas de rendimiento en NVIDIA Jetson incluyen NCNN para los cinco modelos de detección YOLO26. La página de modelos YOLO26 indica la precisión de los puntos de control PyTorch.

Tamaños de los modelos de detección YOLO26 exportados, calculados como la suma de model.ncnn.param y model.ncnn.bin en MB (10^6 bytes) con imgsz=640. El registro de exportación muestra el tamaño del directorio completo en MiB: 9.4 MB y 4.8 MB para YOLO26n:

ModeloPyTorchNCNN FP32NCNN FP16
YOLO26n5.59.85.0
YOLO26s20.438.119.2
YOLO26m44.381.841.0
YOLO26l53.299.449.8
YOLO26x118.7223.0111.7

Exportado con ultralytics 8.4.215, NCNN 1.0.20261020 y PNNX 20260526 el 16 de noviembre de 2026.

Acerca de NCNN#

NCNN está desarrollado por Tencent y se utiliza en aplicaciones de Tencent como QQ y WeChat. No tiene dependencias de ejecución de terceros, funciona en CPU y GPU mediante Vulkan, y convierte modelos PyTorch con su herramienta PNNX, que utiliza la exportación de Ultralytics. Para consultar la referencia completa, visita la documentación de NCNN.

NCNN high-performance neural network inference framework

Preguntas frecuentes#

  • Usa FP16 (quantize=16) cuando el tamaño del modelo sea importante: YOLO26n ocupa 5.0 MB con pesos FP16, frente a 9.8 MB en FP32, y no necesita datos de calibración. En COCO val2017, YOLO26n alcanzó el mismo 40.9 mAPvalidación 50-95 con pesos FP16 que en FP32. Los pesos FP16 reducen el tamaño del archivo, pero no aceleran el modelo: NCNN determina la precisión de cálculo según el hardware; consulta Precisión. Valida el modelo exportado con tus propios datos y dispositivo antes de implementarlo.

  • Los paquetes pnnx y ncnn tienen versiones para Linux ARM de 64 bits, y la guía de Raspberry Pi permite exportar en la placa con el mismo comando format="ncnn". También puedes exportar en un PC y copiar el directorio yolo26n_ncnn_model/ a la placa. En un sistema ARM de 32 bits, pnnx no tiene una versión disponible, así que exporta en otro equipo; ncnn sí tiene versiones, pero Ultralytics no se ha probado allí.

  • Compila o descarga la biblioteca NCNN para tu plataforma siguiendo las instrucciones para compilar NCNN, añade model.ncnn.param y model.ncnn.bin a la aplicación y proporciona la entrada in0 tal como se describe en el formato de salida. Tu código debe aplicar letterbox a la imagen, decodificar las predicciones sin procesar y aplicar NMS. Si prefieres un componente de aplicación listo para usar, el complemento Ultralytics YOLO para Flutter ejecuta exportaciones LiteRT en Android y exportaciones Core ML en iOS.

  • NCNN está diseñado para CPU ARM de teléfonos y placas integradas. En un servidor con dos procesadores AMD EPYC 9655 de 96 núcleos, YOLO26n tardó unos 30 ms por imagen con NCNN y 8 hilos, frente a unos 13 ms tanto con PyTorch como con ONNX Runtime; en un Apple M4, donde NCNN elige 4 hilos, tardó unos 12 ms. Para servidores x86-64, los formatos que Ultralytics evalúa son OpenVINO y ONNX.

Comentarios37

Haz una pregunta, comparte tus resultados o ayuda a otra persona.

  1. gpsamtGitHub(editado)

    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(editado)

      @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(editado)

      @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(editado)

      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(editado)

      @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