Ultralytics YOLO27:
Get Started

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

MNN#

MNN mobile neural network inference framework

MNN es un framework de aprendizaje profundo muy eficiente y ligero. Admite la inferencia y el entrenamiento de modelos de aprendizaje profundo, y ofrece un rendimiento líder en el sector para la inferencia y el entrenamiento en el dispositivo. Actualmente, MNN está integrado en más de 30 aplicaciones de Alibaba Inc., como Taobao, Tmall, Youku, DingTalk y Xianyu, entre otras, y abarca más de 70 casos de uso, como retransmisiones en directo, grabación de vídeos cortos, recomendaciones en búsquedas, búsqueda de productos por imagen, marketing interactivo, distribución de participaciones y control de riesgos de seguridad. Además, MNN también se utiliza en dispositivos integrados, como los de IoT.



Ver: Cómo exportar Ultralytics YOLO26 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 están diseñados para admitir la exportación desde el primer momento, lo que facilita su integración en el flujo de trabajo 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 conjunto de operaciones de ONNX para el grafo ONNX intermedio. Si no se establece, se utiliza la última versión compatible.
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#

Se ha implementado una función que utiliza exclusivamente MNN para la inferencia y el preprocesamiento de YOLO26. Incluye versiones tanto de Python como de C++ para facilitar la implementación en cualquier entorno.

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.45, 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 explicamos cómo exportar el modelo Ultralytics YOLO26 a MNN y usar MNN para la inferencia. El formato MNN ofrece un rendimiento excelente para aplicaciones de IA en el borde, por lo que es ideal para implementar modelos de visión artificial en dispositivos con recursos limitados.

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

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 versátil y admite varias plataformas:

    • Móviles: Android, iOS, Harmony.
    • Sistemas integrados y dispositivos 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.
Colaboradores
GLglenn-jocher14RAraimbekovm3LAlakshanthad3JUjules-ai2AMamanharshx1Y-Y-T-G1ONonuralpszr1LALaughing-q1RIRizwanMunawar1WAwangzhaode1

Comentarios