Ultralytics YOLO27:

Exportación a MNN para modelos YOLO26 y despliegue#

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 del sector 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., y abarca 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 participaciones y control de riesgos de seguridad. Además, MNN también se utiliza en dispositivos integrados, como los de IoT.



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

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 esas cabezas.

TareaYOLOv8YOLO11YOLO26
Detección✅✅✅
Segmentación✅✅✅
Semántica❌❌✅
Profundidad❌❌✅
Clasificación✅✅✅
Pose✅✅✅
OBB✅✅✅

Exportación a MNN: conversión de tu modelo YOLO26#

Puedes ampliar la compatibilidad de los 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 e integrados, garantizando 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 de forma nativa, lo que facilita su integración en tu flujo de trabajo de despliegue preferido. 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 de Exportación, Predicción y Validación. Exporta tu modelo y, después, 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")

Argumentos de exportación#

ArgumentoTipoPredeterminadoDescripción
formatstr'mnn'Formato de destino del modelo exportado, que define la compatibilidad con diversos entornos de despliegue.
imgszint o tuple640Tamaño de imagen deseado para la entrada del modelo. Puede ser un 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 los pesos exportados; 32/sin establecer exporta pesos FP32, que el runtime de CPU de MNN sigue calculando con su precisión predeterminada low en lugar de FP32. Sustituye a 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, 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 dimensiones dinámicas para las imágenes de entrada. No se puede combinar con nms=True.
nmsbool, opcionalNoneSelecciona la salida en bruto (None, predeterminada), la NMS integrada (True) o la cabeza sin NMS (False). La NMS integrada admite detección y estimación de poses con dynamic=False.
devicestrNoneEspecifica el dispositivo para la exportación: GPU (device=0), CPU (device=cpu) o MPS para Apple silicon (device=mps).

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

Inferencia exclusiva de MNN#

Se ha implementado una función que depende exclusivamente de MNN para la inferencia y el preprocesamiento de YOLO26, con versiones tanto en Python como en C++ para facilitar el despliegue 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] -> [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)
    # 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 explicamos cómo exportar el modelo Ultralytics YOLO26 a MNN y utilizar MNN para la inferencia. El formato MNN ofrece un rendimiento excelente para aplicaciones de IA perimetral, por lo que es ideal para desplegar modelos de visión por ordenador en dispositivos con recursos limitados.

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

Preguntas frecuentes#

  • 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", quantize=16)  # creates 'yolo26n.mnn' with fp16 weight
model.export(format="mnn", quantize=8)  # creates 'yolo26n.mnn' with int8 weight

    Para consultar las opciones de exportación detalladas, visita la página de Exportación de 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")

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

  • 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.
    • Ordenadores de sobremesa y servidores: Linux, Windows y macOS.

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

    1. Compilación para Android: sigue la guía de MNN para Android.
    2. Compilación para iOS: sigue la guía de MNN para iOS.
    3. Compilación para Harmony: sigue la guía de MNN para Harmony.
Colaboradores
GLglenn-jocher14LAlakshanthad3RAraimbekovm2JUjules-ai2AMamanharshx1Y-Y-T-G1ONonuralpszr1LALaughing-q1RIRizwanMunawar1WAwangzhaode1

Comentarios