Começar

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

MNN#

MNN mobile neural network inference framework

O MNN é uma estrutura leve de aprendizagem profunda da Alibaba que permite a inferência e o treino de modelos de aprendizagem profunda no dispositivo. O MNN está integrado em mais de 30 aplicações da Alibaba, como Taobao, Tmall, Youku, DingTalk e Xianyu, abrangendo mais de 70 cenários de utilização, incluindo transmissões em direto, captura de vídeos curtos, recomendações de pesquisa, pesquisa de produtos por imagem, marketing interativo, distribuição de participações e controlo de riscos de segurança. O MNN também funciona em dispositivos embarcados e IoT.



Assista: Como exportar Ultralytics YOLO para o formato MNN | Acelere a inferência em dispositivos móveis📱

Tarefas suportadas#

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

TarefaYOLOv8YOLO11YOLO26
Detetar✅✅✅
Segmentar✅✅✅
Semântica❌❌✅
Profundidade❌❌✅
Classificar✅✅✅
Pose✅✅✅
OBB✅✅✅

Exportar para MNN: converter o teu modelo YOLO26#

Podes ampliar a compatibilidade e a flexibilidade de implementação dos modelos convertendo os modelos Ultralytics YOLO para o formato MNN. Esta conversão otimiza os modelos para ambientes móveis e integrados, garantindo um desempenho eficiente em dispositivos com recursos limitados.

Instalação#

Para instalar os pacotes necessários, executa:

Instalação
# Install the required package for YOLO26 and MNN
pip install ultralytics
pip install MNN

Uso#

Todos os modelos Ultralytics YOLO26 são compatíveis com a exportação desde o início, para que possas integrá-los no teu fluxo de implementação preferido. Podes consultar a lista completa de formatos de exportação compatíveis e opções de configuração para escolher a melhor configuração para a tua aplicação.

O formato MNN suporta os modos Exportar, Prever e Validar. Exporta o teu modelo e, em seguida, carrega o modelo exportado para executar a inferência ou validar a respetiva precisão.

Exportar
from ultralytics import YOLO

# Carrega um modelo YOLO26
model = YOLO("yolo26n.pt")

# Exporta o modelo para o formato MNN
model.export(format="mnn")  # cria 'yolo26n.mnn'
Prever
from ultralytics import YOLO

# Carrega o modelo MNN exportado
model = YOLO("yolo26n.mnn")

# Executar inferência
results = model("https://ultralytics.com/images/bus.jpg")
Validar
from ultralytics import YOLO

# Carrega o modelo MNN exportado
model = YOLO("yolo26n.mnn")

# Validar a precisão no conjunto de dados COCO8
metrics = model.val(data="coco8.yaml")

Argumentos de exportação#

ArgumentoTipoPadrãoDescrição
formatstr'mnn'Formato de destino do modelo exportado, que define a compatibilidade com vários ambientes de implantação.
imgszint ou tuple640Tamanho de imagem desejado para a entrada do modelo. Pode ser um inteiro para imagens quadradas ou uma tupla (height, width) para dimensões específicas.
quantizeint ou strNonePrecisão da quantização: 16 (FP16) ou 8 (INT8) reduzem o tamanho dos pesos exportados; 32/não definido exporta pesos FP32, que o MNNBackend do Ultralytics continua a executar com precisão low, em vez de FP32. Substitui as opções obsoletas half/int8.
simplifyboolTrueSimplifica o grafo ONNX intermediário com onnxslim.
opsetintNoneEspecifica a versão do opset do ONNX para o grafo ONNX intermediário. Se não for definido, usa o opset 18 (uma versão inferior no PyTorch < 2.4), limitado à versão instalada onnx.
batchint1Especifica o tamanho do lote de inferência do modelo exportado ou o número máximo de imagens que o modelo exportado processará em simultâneo no modo predict.
dynamicboolFalseAtiva dimensões dinâmicas para as imagens de entrada. Não pode ser combinado com nms=True.
nmsbool, opcionalNoneSeleciona a saída bruta (None, predefinição), NMS integrado (True) ou a cabeça sem NMS (False). O NMS integrado suporta deteção e pose com dynamic=False.
devicestrNoneEspecifica 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 da documentação da Ultralytics sobre exportação.

Inferência apenas com MNN#

Os exemplos seguintes executam o pré-processamento, a inferência e o pós-processamento do YOLO26 apenas com MNN, tanto em Python como em C++, para que possas implementar sem PyTorch ou o pacote Ultralytics.

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 para 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ém a probabilidade máxima e o í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)
    # caixa, pontuação e IDs resultantes do 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 ao tamanho da imagem original para tratar os casos em que foi aplicado preenchimento
        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#

Este guia mostrou como exportar modelos Ultralytics YOLO26 para MNN e executar inferências com o MNN. O formato MNN é adequado a aplicações de IA de borda que implementam modelos de visão computacional em dispositivos com recursos limitados.

Perguntas frequentes#

  • Para exportares o teu modelo Ultralytics YOLO26 para o formato MNN, segue estes passos:

    Exportar
    from ultralytics import YOLO
    
    # Carrega um modelo YOLO26
    model = YOLO("yolo26n.pt")
    
    # Exportar para o formato MNN
    model.export(format="mnn")  # cria 'yolo26n.mnn' com pesos fp32
    model.export(format="mnn", quantize=16)  # cria 'yolo26n.mnn' com pesos fp16
    model.export(format="mnn", quantize=8)  # cria 'yolo26n.mnn' com pesos int8

    Para ver as opções de exportação detalhadas, consulta a página Exportar na documentação.

  • Para fazer previsões com um modelo YOLO26 MNN exportado, utiliza a função predict da classe YOLO.

    Prever
    from ultralytics import YOLO
    
    # Carrega o modelo YOLO26 MNN
    model = YOLO("yolo26n.mnn")
    
    # Executar inferência
    results = model("https://ultralytics.com/images/bus.jpg")
    
    for result in results:
        result.show()  # exibe na tela
        result.save(filename="result.jpg")  # salva no disco
  • O MNN é compatível com várias plataformas:

    • Dispositivos móveis: Android, iOS, Harmony.
    • Sistemas embarcados e dispositivos IoT: Dispositivos como o Raspberry Pi e o NVIDIA Jetson.
    • Computadores e servidores: Linux, Windows e macOS.
  • Para implementar os teus modelos YOLO26 em dispositivos móveis:

    1. Compilar para Android: segue o guia MNN para Android.
    2. Compilar para iOS: segue o guia MNN para iOS.
    3. Compilar para Harmony: segue o guia MNN para Harmony.

Comentários2

Faz uma pergunta, partilha os teus resultados ou ajuda alguém.

    1. Glenn JocherUltralytics

      It seems like there's a minor typo in your code. Ensure you are using model instead of mnn_model when 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.