Exportação MNN para modelos YOLO26 e implementação
MNN#
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.
| 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:
# Install the required package for YOLO26 and MNN
pip install ultralytics
pip install MNNUso#
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.
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'from ultralytics import YOLO
# Carrega o modelo MNN exportado
model = YOLO("yolo26n.mnn")
# Executar inferência
results = model("https://ultralytics.com/images/bus.jpg")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 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. |
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#
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.
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:
Exportarfrom 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 int8Para 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
predictda classe YOLO.Preverfrom 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 discoO 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:
- 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.
Comentários2
Faz uma pergunta, partilha os teus resultados ou ajuda alguém.
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.