Link to this sectionExportación a MNN para modelos YOLO26 y despliegue#

Link to this sectionMNN#

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 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 retransmisiones en directo, captura de vídeos cortos, recomendaciones de búsqueda, búsqueda de productos por imagen, marketing interactivo, distribución de capital 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📱

Link to this sectionExportar a MNN: Convertir tu modelo YOLO26#

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

Link to this sectionInstalación#

Para instalar los paquetes necesarios, ejecuta:

Instalación

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

Link to this sectionUso#

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

El formato MNN soporta los modos Exportar, Predecir y Validar. Exporta tu modelo y luego carga el modelo exportado 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")

Link to this sectionArgumentos de exportación#

Argumento	Tipo	Predeterminado	Descripción
`format`	`str`	`'mnn'`	Formato de destino para el modelo exportado, definiendo la compatibilidad con varios entornos de despliegue.
`imgsz`	`int` o `tuple`	`640`	Tamañ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.
`half`	`bool`	`False`	Activa la cuantización FP16 (media precisión), reduciendo el tamaño del modelo y acelerando potencialmente la inferencia en hardware compatible.
`int8`	`bool`	`False`	Activa la cuantización INT8, comprimiendo aún más el modelo y acelerando la inferencia con una pérdida mínima de precisión, principalmente para dispositivos de borde (edge devices).
`batch`	`int`	`1`	Especifica 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`.
`device`	`str`	`None`	Especifica el dispositivo para la exportación: GPU (`device=0`), CPU (`device=cpu`), MPS para Apple silicon (`device=mps`).

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

Link to this sectionInferencia solo con MNN#

Se ha implementado una función que depende únicamente de MNN para la inferencia y 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)

Link to this sectionResumen#

En esta guía, presentamos cómo exportar el modelo Ultralytics YOLO26 a MNN y cómo usar MNN para la inferencia. El formato MNN proporciona un rendimiento excelente para aplicaciones de IA en el borde, lo que lo hace ideal para desplegar modelos de visión por computador en dispositivos con recursos limitados.

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

Link to this sectionPreguntas frecuentes#

Link to this section¿Cómo exporto modelos Ultralytics YOLO26 al formato MNN?#

Para exportar tu modelo Ultralytics YOLO26 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", half=True)  # creates 'yolo26n.mnn' with fp16 weight
model.export(format="mnn", int8=True)  # creates 'yolo26n.mnn' with int8 weight

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

Link to this section¿Cómo realizo predicciones con un modelo YOLO26 MNN exportado?#

Para realizar predicciones con un modelo YOLO26 MNN exportado, usa 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", 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

Link to this section¿Qué plataformas son compatibles con MNN?#

MNN es versátil y soporta 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.

Link to this section¿Cómo puedo desplegar modelos Ultralytics YOLO26 MNN en dispositivos móviles?#

Para desplegar tus modelos YOLO26 en dispositivos móviles:

Compilar para Android: Sigue la guía de MNN Android.
Compilar para iOS: Sigue la guía de MNN iOS.
Compilar para Harmony: Sigue la guía de MNN Harmony.

Colaboradores

GLglenn-jocher⁹ LAlakshanthad³ JUjules-ai² LALaughing-q¹ RIRizwanMunawar¹ WAwangzhaode¹

Creado 30 oct 2024Actualizado la semana pasada