Empezar

Exportación a MNN para modelos YOLO26 e implementación

MNN#

MNN mobile neural network inference framework

MNN es un framework ligero de aprendizaje profundo de Alibaba que admite la inferencia y el entrenamiento de modelos de aprendizaje profundo en el dispositivo. MNN está integrado en más de 30 aplicaciones de Alibaba, como Taobao, Tmall, Youku, DingTalk y Xianyu, y cubre más de 70 casos de uso, entre ellos retransmisiones en directo, grabación de vídeos cortos, recomendaciones de búsqueda, búsqueda de productos por imagen, marketing interactivo, distribución de acciones y control de riesgos de seguridad. MNN también funciona en dispositivos integrados y de IoT.



Ver: Cómo exportar Ultralytics YOLO al formato MNN | Acelera la inferencia en dispositivos móviles📱

Tareas compatibles#

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

TareaYOLOv8YOLO11YOLO26
Detectar✅✅✅
Segmentar✅✅✅
Semántica❌❌✅
Profundidad❌❌✅
Clasificar✅✅✅
Pose✅✅✅
OBB✅✅✅

Exportar a MNN: convertir tu modelo YOLO26#

Puedes ampliar la compatibilidad de los modelos y la flexibilidad de implementación convirtiendo los modelos Ultralytics YOLO al formato MNN. Esta conversión optimiza los modelos para entornos móviles e integrados y garantiza 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 Ultralytics YOLO26 admiten la exportación de forma nativa, por lo que puedes integrarlos en el flujo de implementación que prefieras. Puedes consultar la lista completa de formatos de exportación y opciones de configuración compatibles para elegir la configuración más adecuada para tu aplicación.

El formato MNN admite los modos Exportar, Predecir y Validar. Exporta tu modelo y, a continuación, carga el modelo 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 MNN
model.export(format="mnn")  # crea 'yolo26n.mnn'
Predecir
from ultralytics import YOLO

# Carga el modelo MNN exportado
model = YOLO("yolo26n.mnn")

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

# Carga el modelo MNN exportado
model = YOLO("yolo26n.mnn")

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

Argumentos de exportación#

ArgumentoTipoPredeterminadoDescripción
formatstr'mnn'Formato de destino del modelo exportado, que define su compatibilidad con distintos entornos de implementación.
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) o 8 (INT8) reducen el tamaño de los pesos exportados; 32 o dejarlo sin definir exporta pesos FP32, que el MNNBackend de Ultralytics sigue ejecutando con precisión low en lugar de FP32. Sustituye las marcas obsoletas 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, se usa el opset 18 (inferior en PyTorch < 2.4), limitado a la versión instalada de onnx.
batchint1Especifica el tamaño del lote de inferencia del modelo exportado o el número máximo de imágenes que el modelo exportado procesará simultáneamente en el modo predict.
dynamicboolFalseActiva las dimensiones dinámicas de la imagen de entrada. No se puede combinar con nms=True.
nmsbool, opcionalNoneSelecciona la salida sin procesar (None, valor predeterminado), NMS integrado (True) o el cabezal sin NMS (False). NMS integrado admite detección y pose con dynamic=False.
devicestrNoneEspecifica el dispositivo para la exportación: GPU (device=0), CPU (device=cpu), MPS para Apple silicon (device=mps).

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

Inferencia solo con MNN#

Los siguientes ejemplos ejecutan el preprocesamiento, la inferencia y el posprocesamiento de YOLO26 solo con MNN, tanto en Python como en C++, para que puedas implementar sin PyTorch ni el paquete Ultralytics.

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]  # De BGR a 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()
    # forma de output_var: [84, 8400]; 84 significa: [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] -> [x0, y0, x1, y1]
    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)
    # obtén la probabilidad máxima y el índice
    scores = np.max(probs, 0)
    class_ids = np.argmax(probs, 0)
    result_ids = MNN.expr.nms(boxes, scores, 100, 0.5, 0.25)
    print(result_ids.shape)
    # caja, puntuación e identificadores del resultado de NMS
    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)
        # limita al tamaño de la imagen original para gestionar los casos en los que se haya aplicado relleno
        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 se explica cómo exportar modelos Ultralytics YOLO26 a MNN y ejecutar inferencias con MNN. El formato MNN es idóneo para aplicaciones de IA en el borde que implementan modelos de visión artificial en dispositivos con recursos limitados.

Preguntas frecuentes#

  • Sigue estos pasos para exportar tu modelo Ultralytics YOLO26 al formato MNN:

    Exportar
    from ultralytics import YOLO
    
    # Carga un modelo YOLO26
    model = YOLO("yolo26n.pt")
    
    # Exporta al formato MNN
    model.export(format="mnn")  # crea 'yolo26n.mnn' con pesos fp32
    model.export(format="mnn", quantize=16)  # crea 'yolo26n.mnn' con pesos fp16
    model.export(format="mnn", quantize=8)  # crea 'yolo26n.mnn' con pesos int8

    Para ver las opciones de exportación detalladas, consulta la página Exportar de la documentación.

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

    Predecir
    from ultralytics import YOLO
    
    # Carga el modelo YOLO26 MNN
    model = YOLO("yolo26n.mnn")
    
    # Ejecutar inferencia
    results = model("https://ultralytics.com/images/bus.jpg")
    
    for result in results:
        result.show()  # mostrar en pantalla
        result.save(filename="result.jpg")  # guardar en el disco
  • MNN es compatible con varias plataformas:

    • Móviles: Android, iOS, Harmony.
    • Sistemas integrados y dispositivos de IoT: Dispositivos como Raspberry Pi y NVIDIA Jetson.
    • Equipos de escritorio y servidores: Linux, Windows y macOS.
  • Para implementar tus modelos YOLO26 en dispositivos móviles:

    1. Compilar para Android: Sigue la guía MNN para Android.
    2. Compilar para iOS: Sigue la guía MNN para iOS.
    3. Compilar para Harmony: Sigue la guía MNN para Harmony.

Comentarios2

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

    1. Glenn JocherUltralytics

      It seems like there's a minor typo in your code. Ensure you are using model instead of mnn_model when calling the inference function. Here's a quick fix:

      from ultralytics import YOLO
      
      # Load the YOLO11 MNN model
      model = YOLO("yolo11n.mnn")
      
      # Run inference
      results = model("https://ultralytics.com/images/bus.jpg")

      This should resolve the NameError. If you need more help, please check the MNN documentation.