Editar página en GitHub (EN)

Exportación a MNN para modelos YOLO26 y despliegue

MNN

MNN mobile neural network inference framework

MNN es un framework de deep learning altamente eficiente y ligero. Soporta la inferencia y el entrenamiento de modelos de deep learning y posee un rendimiento líder en la industria para la inferencia y el entrenamiento en dispositivos. 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 tales como retransmisiones en directo, captura de vídeos cortos, recomendaciones de búsqueda, búsqueda de productos mediante imagen, marketing interactivo, distribución de capital y control de riesgos de seguridad. Además, MNN también se utiliza en dispositivos integrados, como IoT.



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

Exportar a MNN: Convertir tu modelo YOLO26

Puedes ampliar la compatibilidad y la flexibilidad de despliegue de tus modelos convirtiendo modelos de Ultralytics YOLO al formato MNN. Esta conversión optimiza tus modelos para entornos móviles e integrados, 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 Ultralytics YOLO26 están diseñados para soportar la exportación de forma inmediata, facilitando 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.

Uso
  from ultralytics import YOLO

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

  # Export the model to MNN format
  model.export(format="mnn")  # creates 'yolo26n.mnn'

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

  # Run inference
  results = mnn_model("https://ultralytics.com/images/bus.jpg")

Argumentos de exportación

ArgumentoTipoPredeterminadoDescripción
formatstr'mnn'Formato de destino para el modelo exportado, que define la compatibilidad con varios 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.
halfboolFalseActiva la cuantización FP16 (precisión media), reduciendo el tamaño del modelo y acelerando potencialmente la inferencia en hardware compatible.
int8boolFalseActiva la cuantización INT8, comprimiendo aún más el modelo y acelerando la inferencia con una pérdida de precisión mínima, principalmente para dispositivos de borde (edge).
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 modo predict.
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 únicamente 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, presentamos cómo exportar el modelo Ultralytics YOLO26 a MNN y utilizar MNN para la inferencia. El formato MNN proporciona un excelente rendimiento 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.

Preguntas frecuentes

¿Cómo exporto modelos Ultralytics YOLO26 al formato MNN?

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

Exportar (Export)
from ultralytics import YOLO

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

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

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

¿Cómo realizo predicciones con un modelo YOLO26 MNN exportado?

Para predecir 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")

# Export to MNN format
results = model("https://ultralytics.com/images/bus.jpg")  # predict with `fp32`
results = model("https://ultralytics.com/images/bus.jpg", half=True)  # predict with `fp16` if device support

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

¿Qué plataformas son compatibles con MNN?

MNN es versátil y soporta varias plataformas:

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

¿Cómo puedo desplegar modelos Ultralytics YOLO26 MNN en dispositivos móviles?

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.
Contributors
Editar página en GitHub (EN)
GLglenn-jocher7LAlakshanthad3JUjules-ai2LALaughing-q1RIRizwanMunawar1WAwangzhaode1

Comentarios