Exportación a MNN para modelos YOLO26 e implementación
MNN#
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.
| Tarea | YOLOv8 | YOLO11 | YOLO26 |
|---|---|---|---|
| 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:
# Install the required package for YOLO26 and MNN
pip install ultralytics
pip install MNNUso#
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.
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'from ultralytics import YOLO
# Carga el modelo MNN exportado
model = YOLO("yolo26n.mnn")
# Ejecutar inferencia
results = model("https://ultralytics.com/images/bus.jpg")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#
| Argumento | Tipo | Predeterminado | Descripción |
|---|---|---|---|
format | str | 'mnn' | Formato de destino del modelo exportado, que define su compatibilidad con distintos entornos de implementación. |
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. |
quantize | int o str | None | Precisió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. |
simplify | bool | True | Simplifica el grafo ONNX intermedio con onnxslim. |
opset | int | None | Especifica 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. |
batch | int | 1 | Especifica 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. |
dynamic | bool | False | Activa las dimensiones dinámicas de la imagen de entrada. No se puede combinar con nms=True. |
nms | bool, opcional | None | Selecciona 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. |
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 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.
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:
Exportarfrom 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 int8Para 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
predictde la clase YOLO.Predecirfrom 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 discoMNN 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:
- Compilar para Android: Sigue la guía MNN para Android.
- Compilar para iOS: Sigue la guía MNN para iOS.
- Compilar para Harmony: Sigue la guía MNN para Harmony.
Comentarios2
Haz una pregunta, comparte tus resultados o ayuda a otra persona.
robert-hardman
Hello Error: NameError: name 'mnn_model' is not defined ultralytics==8.3.34
Glenn JocherUltralyticsIt seems like there's a minor typo in your code. Ensure you are using
modelinstead ofmnn_modelwhen 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.