Como exporto modelos Ultralytics YOLO26 para o formato MNN?

Para exportares o teu modelo Ultralytics YOLO26 para o formato MNN, segue estes passos: Para ver as opções de exportação detalhadas, consulta a página Exportar na documentação.

Que plataformas são suportadas pelo MNN?

O MNN é versátil e suporta várias plataformas: Dispositivos móveis: Android, iOS, Harmony. Sistemas integrados e dispositivos IoT: dispositivos como Raspberry Pi e NVIDIA Jetson. Computadores e servidores: Linux, Windows e macOS.

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

Para implementares os teus modelos YOLO26 em dispositivos móveis: Compilar para Android: segue o guia MNN para Android. Compilar para iOS: segue o guia MNN para iOS. Compilar para Harmony: segue o guia MNN para Harmony.

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

MNN#

MNN mobile neural network inference framework

MNN é uma estrutura de aprendizagem profunda altamente eficiente e leve. Suporta inferência e treino de modelos de aprendizagem profunda e oferece desempenho líder no setor para inferência e treino no dispositivo. Atualmente, o MNN está integrado em mais de 30 aplicações da Alibaba Inc., como Taobao, Tmall, Youku, DingTalk, Xianyu, entre outras, abrangendo mais de 70 cenários de utilização, como transmissão em direto, captura de vídeos curtos, recomendação em pesquisas, pesquisa de produtos por imagem, marketing interativo, distribuição de participações e controlo de riscos de segurança. Além disso, o MNN também é utilizado em dispositivos integrados, como dispositivos IoT.

Assista: Como exportar Ultralytics YOLO26 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.

Tarefa	YOLOv8	YOLO11	YOLO26
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 foram concebidos para suportar a exportação de origem, o que facilita a integração no fluxo de trabalho de implementação que preferires. Podes consultar a lista completa de formatos de exportação suportados e opções de configuração para escolheres 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#

Argumento	Tipo	Padrão	Descrição
`format`	`str`	`'mnn'`	Formato de destino do modelo exportado, que define a compatibilidade com vários ambientes de implantação.
`imgsz`	`int` ou `tuple`	`640`	Tamanho 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.
`quantize`	`int` ou `str`	`None`	Precisã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`.
`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, usa a versão mais recente compatível.
`batch`	`int`	`1`	Especifica 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`.
`dynamic`	`bool`	`False`	Ativa dimensões dinâmicas para as imagens de entrada. Não pode ser combinado com `nms=True`.
`nms`	`bool`, opcional	`None`	Seleciona 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`.
`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 da documentação da Ultralytics sobre exportação.

Inferência apenas com MNN#

Foi implementada uma função que utiliza exclusivamente o MNN para a inferência e o pré-processamento do YOLO26, com 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 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.45, 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#

Neste guia, explicamos como exportar o modelo Ultralytics YOLO26 para MNN e utilizar o MNN para inferência. O formato MNN oferece um desempenho excelente para aplicações de IA na periferia, sendo ideal para implementar modelos de visão computacional em dispositivos com recursos limitados.

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

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 é versátil e suporta várias plataformas:
- Dispositivos móveis: Android, iOS, Harmony.
- Sistemas integrados e dispositivos IoT: dispositivos como Raspberry Pi e NVIDIA Jetson.
- Computadores e servidores: Linux, Windows e macOS.
Para implementares 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.

Colaboradores

GLglenn-jocher¹⁴ RAraimbekovm³ LAlakshanthad³ JUjules-ai² AMamanharshx¹ Y-Y-T-G¹ ONonuralpszr¹ LALaughing-q¹ RIRizwanMunawar¹ WAwangzhaode¹

Criado 30 de out. de 2024Atualizado semana passada

Get Started

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

MNN#

Tarefas suportadas#

Exportar para MNN: converter o teu modelo YOLO26#

Instalação#

Uso#

Argumentos de exportação#

Inferência apenas com MNN#

Resumo#

Perguntas frequentes#

Comentários

Get Started

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

MNN#

Tarefas suportadas#

Exportar para MNN: converter o teu modelo YOLO26#

Instalação#

Uso#

Argumentos de exportação#

Inferência apenas com MNN#

Resumo#

Perguntas frequentes#

Como exporto modelos Ultralytics YOLO26 para o formato MNN?

Como faço previsões com um modelo YOLO26 MNN exportado?

Que plataformas são suportadas pelo MNN?

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

Comentários