Como exporto modelos Ultralytics YOLO26 para o formato MNN?

Para exportar seu modelo Ultralytics YOLO26 para o formato MNN, siga estas etapas: Para opções detalhadas de exportação, consulta a página Export na documentação.

Quais plataformas são suportadas pelo MNN?

O MNN é versátil e suporta várias plataformas: Móvel: Android, iOS, Harmony. Sistemas Embarcados e Dispositivos IoT: Dispositivos como Raspberry Pi e NVIDIA Jetson. Desktop e servidores: Linux, Windows e macOS.

Como posso implementar modelos Ultralytics YOLO26 MNN em dispositivos móveis?

Para implementar seus modelos YOLO26 em dispositivos móveis: Compilar para Android: Segue o guia do MNN Android. Compilar para iOS: Segue o guia do MNN iOS. Compilar para Harmony: Segue o guia do MNN Harmony.

Exportação MNN para modelos YOLO26 e implementação#

MNN#

MNN mobile neural network inference framework

MNN é uma estrutura de deep learning altamente eficiente e leve. Ele suporta inferência e treinamento de modelos de deep learning e possui desempenho líder na indústria para inferência e treinamento em dispositivos. Atualmente, o MNN foi integrado a mais de 30 aplicativos da Alibaba Inc, como Taobao, Tmall, Youku, DingTalk, Xianyu, etc., cobrindo mais de 70 cenários de uso, como transmissão ao vivo, captura de vídeos curtos, recomendação de busca, busca de produtos por imagem, marketing interativo, distribuição de equidade, controle de risco de segurança. Além disso, o MNN também é usado em dispositivos embarcados, como IoT.

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

Tarefas Suportadas#

A exportação MNN suporta todas as sete tarefas do Ultralytics. A segmentação semântica e a estimativa de profundidade estão disponíveis apenas com o YOLO26, a única família que possui essas cabeças.

Tarefa	YOLOv8	YOLO11	YOLO26
Detectar	✅	✅	✅
Segmentar	✅	✅	✅
Semântica	❌	❌	✅
Profundidade	❌	❌	✅
Classificar	✅	✅	✅
Pose	✅	✅	✅
OBB	✅	✅	✅

Exportar para MNN: Convertendo seu modelo YOLO26#

Podes expandir a compatibilidade de modelos e a flexibilidade de implantação convertendo modelos do Ultralytics YOLO para o formato MNN. Esta conversão otimiza os teus modelos para ambientes móveis e embarcados, garantindo um desempenho eficiente em dispositivos com recursos limitados.

Instalação#

Para instalar os pacotes necessários, execute:

Instalação

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

Uso#

Todos os modelos Ultralytics YOLO26 são projetados para suportar exportação nativamente, facilitando a integração deles no teu fluxo de trabalho de implantação preferido. Podes ver a lista completa de formatos de exportação suportados e opções de configuração para escolher a melhor configuração para a tua aplicação.

O formato MNN suporta os modos Export, Predict e Validate. Exporta o teu modelo e, em seguida, carrega o modelo exportado para executar a inferência ou validar a sua precisão.

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'

Prever

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 Exportação#

Argumento	Tipo	Predefinição	Descrição
`format`	`str`	`'mnn'`	Formato de destino para o modelo exportado, definindo a compatibilidade com vários ambientes de implementação.
`imgsz`	`int` ou `tuple`	`640`	Tamanho de imagem desejado para a entrada do modelo. Pode ser um número inteiro para imagens quadradas ou uma tupla `(height, width)` para dimensões específicas.
`quantize`	`int` ou `str`	`None`	Precisão de quantização: `16` (FP16), `8` (quantização de pesos INT8) ou `32`/não definido (FP32). Substitui as flags obsoletas `half`/`int8`.
`simplify`	`bool`	`True`	Simplifica o grafo ONNX intermediário com `onnxslim`.
`opset`	`int`	`None`	Especifica a versão do opset ONNX para o grafo ONNX intermediário. Se não for definida, utiliza a versão mais recente suportada.
`batch`	`int`	`1`	Especifica o tamanho de inferência em lote do modelo de exportação ou o número máximo de imagens que o modelo exportado processará concorrentemente no modo `predict`.
`dynamic`	`bool`	`False`	Permite dimensões dinâmicas de imagem de entrada. Não pode ser combinado com `nms=True`.
`nms`	`bool`	`False`	Adiciona NMS para modelos de deteção e pose. Não pode ser combinado com `dynamic=True`.
`device`	`str`	`None`	Especifica o dispositivo para exportação: GPU (`device=0`), CPU (`device=cpu`), MPS para Apple silicon (`device=mps`).

Para mais detalhes sobre o processo de exportação, visita a página de documentação do Ultralytics sobre exportação.

Inferência exclusiva via MNN#

Uma função que depende exclusivamente do MNN para inferência e pré-processamento do YOLO26 foi implementada, fornecendo versões em Python e C++ para facilitar a implementação em qualquer cenário.

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)

Resumo#

Neste guia, apresentamos como exportar o modelo Ultralytics YOLO26 para MNN e usar o MNN para inferência. O formato MNN oferece excelente desempenho para aplicações de edge AI, tornando-o ideal para implantar modelos de visão computacional em dispositivos com recursos limitados.

Para mais utilizações, consulta a documentação do MNN.

FAQ#

Para exportar seu modelo Ultralytics YOLO26 para o formato MNN, siga estas etapas:

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 opções detalhadas de exportação, consulta a página Export na documentação.

Para prever com um modelo YOLO26 MNN exportado, usa a função predict da classe YOLO.