YOLO Vision 2026:

Exportación a MNN para modelos YOLO26 y despliegue#

MNN#

MNN mobile neural network inference framework

MNN es un framework de aprendizaje profundo altamente eficiente y ligero. Soporta inferencia y entrenamiento de modelos de aprendizaje profundo y cuenta con un rendimiento líder en la industria para la inferencia y el entrenamiento en el dispositivo. Actualmente, MNN se ha integrado en más de 30 aplicaciones de Alibaba Inc, como Taobao, Tmall, Youku, DingTalk, Xianyu, etc., cubriendo más de 70 escenarios de uso como transmisión en directo, captura de vídeos cortos, recomendación de búsqueda, búsqueda de productos por imagen, marketing interactivo, distribución de equidad y control de riesgos de seguridad. Además, MNN también se utiliza en dispositivos embebidos, como IoT.



Watch: How to Export Ultralytics YOLO26 to MNN Format | Speed up Inference on Mobile Devices📱

Tareas compatibles#

La exportación a MNN es compatible con las siete tareas de Ultralytics. La segmentación semántica y la estimación de profundidad están disponibles solo con YOLO26, la única familia que incluye esas cabezas.

TareaYOLOv8YOLO11YOLO26
Detect✅✅✅
Segment✅✅✅
Semantic❌❌✅
Depth❌❌✅
Classify✅✅✅
Pose✅✅✅
OBB✅✅✅

Exportar a MNN: convertir tu modelo YOLO26#

Puedes ampliar la compatibilidad de modelos y la flexibilidad de despliegue convirtiendo los modelos de Ultralytics YOLO al formato MNN. Esta conversión optimiza tus modelos para entornos móviles y embebidos, asegurando un rendimiento eficiente en dispositivos con recursos limitados.

Instalación#

Para instalar los paquetes necesarios, ejecuta:

Instalación
# Install the required package for YOLO26 and MNN
pip install ultralytics
pip install MNN

Uso#

Todos los modelos de Ultralytics YOLO26 están diseñados para admitir la exportación de serie, lo que facilita su integración en tu flujo de trabajo de despliegue preferido. Puedes ver la lista completa de formatos de exportación compatibles y opciones de configuración para elegir la mejor configuración para tu aplicación.

El formato MNN es compatible con los modos Export, Predict y Validate. Exporta tu modelo y luego cárgalo para ejecutar la inferencia o validar su precisión.

Exportar
from ultralytics import YOLO

# Load a YOLO26 model
model = YOLO("yolo26n.pt")

# Export the model to MNN format
model.export(format="mnn")  # creates 'yolo26n.mnn'
Predecir
from ultralytics import YOLO

# Load the exported MNN model
model = YOLO("yolo26n.mnn")

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

# Load the exported MNN model
model = YOLO("yolo26n.mnn")

# Validate accuracy on the COCO8 dataset
metrics = model.val(data="coco8.yaml")

Argumentos de exportación#

ArgumentoTipoPredeterminadoDescripción
formatstr'mnn'Formato de destino para el modelo exportado, definiendo la compatibilidad con diversos entornos de despliegue.
imgszint o tuple640Tamaño de imagen deseado para la entrada del modelo. Puede ser un número entero para imágenes cuadradas o una tupla (height, width) para dimensiones específicas.
quantizeint o strNonePrecisión de cuantización: 16 (FP16), 8 (cuantización de pesos INT8), o 32/sin establecer (FP32). Reemplaza los flags obsoletos half/int8.
simplifyboolTrueSimplifica el grafo ONNX intermedio con onnxslim.
opsetintNoneEspecifica la versión del opset de ONNX para el grafo ONNX intermedio. Si no se establece, utiliza la última versión admitida.
batchint1Especifica el tamaño de inferencia por lotes del modelo de exportación o el número máximo de imágenes que el modelo exportado procesará simultáneamente en el modo predict.
dynamicboolFalsePermite dimensiones de imagen de entrada dinámicas. No se puede combinar con nms=True.
nmsboolFalseAñade NMS para modelos de detección y pose. No se puede combinar con dynamic=True.
devicestrNoneEspecifica el dispositivo para la exportación: GPU (device=0), CPU (device=cpu), MPS para Apple silicon (device=mps).

Para más detalles sobre el proceso de exportación, visita la página de documentación de Ultralytics sobre exportación.

Inferencia solo con MNN#

Se ha implementado una función que depende exclusivamente de MNN para la inferencia y el preprocesamiento de YOLO26, proporcionando versiones tanto en Python como en C++ para un despliegue sencillo en cualquier escenario.

MNN
import argparse

import MNN
import MNN.cv as cv2
import MNN.numpy as np

def inference(model, img, precision, backend, thread):
    config = {}
    config["precision"] = precision
    config["backend"] = backend
    config["numThread"] = thread
    rt = MNN.nn.create_runtime_manager((config,))
    # net = MNN.nn.load_module_from_file(model, ['images'], ['output0'], runtime_manager=rt)
    net = MNN.nn.load_module_from_file(model, [], [], runtime_manager=rt)
    original_image = cv2.imread(img)
    ih, iw, _ = original_image.shape
    length = max((ih, iw))
    scale = length / 640
    image = np.pad(original_image, [[0, length - ih], [0, length - iw], [0, 0]], "constant")
    image = cv2.resize(
        image, (640, 640), 0.0, 0.0, cv2.INTER_LINEAR, -1, [0.0, 0.0, 0.0], [1.0 / 255.0, 1.0 / 255.0, 1.0 / 255.0]
    )
    image = image[..., ::-1]  # BGR to RGB
    input_var = image[None]
    input_var = MNN.expr.convert(input_var, MNN.expr.NC4HW4)
    output_var = net.forward(input_var)
    output_var = MNN.expr.convert(output_var, MNN.expr.NCHW)
    output_var = output_var.squeeze()
    # output_var shape: [84, 8400]; 84 means: [cx, cy, w, h, prob * 80]
    cx = output_var[0]
    cy = output_var[1]
    w = output_var[2]
    h = output_var[3]
    probs = output_var[4:]
    # [cx, cy, w, h] -> [y0, x0, y1, x1]
    x0 = cx - w * 0.5
    y0 = cy - h * 0.5
    x1 = cx + w * 0.5
    y1 = cy + h * 0.5
    boxes = np.stack([x0, y0, x1, y1], axis=1)
    # ensure ratio is within the valid range [0.0, 1.0]
    boxes = np.clip(boxes, 0, 1)
    # get max prob and idx
    scores = np.max(probs, 0)
    class_ids = np.argmax(probs, 0)
    result_ids = MNN.expr.nms(boxes, scores, 100, 0.45, 0.25)
    print(result_ids.shape)
    # nms result box, score, ids
    result_boxes = boxes[result_ids]
    result_scores = scores[result_ids]
    result_class_ids = class_ids[result_ids]
    for i in range(len(result_boxes)):
        x0, y0, x1, y1 = result_boxes[i].read_as_tuple()
        y0 = int(y0 * scale)
        y1 = int(y1 * scale)
        x0 = int(x0 * scale)
        x1 = int(x1 * scale)
        # clamp to the original image size to handle cases where padding was applied
        x1 = min(iw, x1)
        y1 = min(ih, y1)
        print(result_class_ids[i])
        cv2.rectangle(original_image, (x0, y0), (x1, y1), (0, 0, 255), 2)
    cv2.imwrite("res.jpg", original_image)

if __name__ == "__main__":
    parser = argparse.ArgumentParser()
    parser.add_argument("--model", type=str, required=True, help="the yolo26 model path")
    parser.add_argument("--img", type=str, required=True, help="the input image path")
    parser.add_argument("--precision", type=str, default="normal", help="inference precision: normal, low, high, lowBF")
    parser.add_argument(
        "--backend",
        type=str,
        default="CPU",
        help="inference backend: CPU, OPENCL, OPENGL, NN, VULKAN, METAL, TRT, CUDA, HIAI",
    )
    parser.add_argument("--thread", type=int, default=4, help="inference using thread: int")
    args = parser.parse_args()
    inference(args.model, args.img, args.precision, args.backend, args.thread)

Resumen#

En esta guía, te mostramos cómo exportar el modelo Ultralytics YOLO26 a MNN y utilizar MNN para la inferencia. El formato MNN proporciona un rendimiento excelente para aplicaciones de edge AI, lo que lo hace ideal para desplegar modelos de visión artificial en dispositivos con recursos limitados.

Para más información sobre su uso, consulta la documentación de MNN.

FAQ#

  • Para exportar tu modelo YOLO26 de Ultralytics al formato MNN, sigue estos pasos:

    Exportar
    from ultralytics import YOLO

# Load a YOLO26 model
model = YOLO("yolo26n.pt")

# Export to MNN format
model.export(format="mnn")  # creates 'yolo26n.mnn' with fp32 weight
model.export(format="mnn", quantize=16)  # creates 'yolo26n.mnn' with fp16 weight
model.export(format="mnn", quantize=8)  # creates 'yolo26n.mnn' with int8 weight

    Para conocer las opciones de exportación detalladas, consulta la página Export en la documentación.

  • Para hacer predicciones con un modelo YOLO26 MNN exportado, utiliza la función predict de la clase YOLO.

    Predecir
    from ultralytics import YOLO

# Load the YOLO26 MNN model
model = YOLO("yolo26n.mnn")

# Run inference
results = model("https://ultralytics.com/images/bus.jpg")  # predict with `fp32`
results = model("https://ultralytics.com/images/bus.jpg", quantize=16)  # predict with `fp16` if device support

for result in results:
    result.show()  # display to screen
    result.save(filename="result.jpg")  # save to disk

  • MNN es versátil y compatible con varias plataformas:

    • Móvil: Android, iOS, Harmony.
    • Sistemas embebidos y dispositivos IoT: Dispositivos como Raspberry Pi y NVIDIA Jetson.
    • Escritorio y servidores: Linux, Windows y macOS.

  • Para desplegar tus modelos YOLO26 en dispositivos móviles:

    1. Compilar para Android: Sigue la guía de MNN Android.
    2. Compilar para iOS: Sigue la guía de MNN iOS.
    3. Compilar para Harmony: Sigue la guía de MNN Harmony.
Colaboradores
GLglenn-jocher13LAlakshanthad3JUjules-ai2AMamanharshx1Y-Y-T-G1ONonuralpszr1LALaughing-q1RIRizwanMunawar1WAwangzhaode1

Comentarios