Ultralytics YOLO27:

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. É compatível com inferência e treino de modelos de aprendizagem profunda e oferece um desempenho líder do setor para inferência e treino no dispositivo. Atualmente, o MNN foi 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õ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. Além disso, o MNN também é utilizado em dispositivos incorporados, como dispositivos IoT.



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

Tarefas suportadas#

A exportação MNN é compatível com todas as sete tarefas da Ultralytics. A segmentação semântica e a estimativa de profundidade estão disponíveis apenas com 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 expandir a compatibilidade e a flexibilidade de implementação do modelo convertendo modelos Ultralytics YOLO para o formato MNN. Esta conversão otimiza os teus modelos para ambientes móveis e incorporados, garantindo um desempenho eficiente em dispositivos com recursos limitados.

Instalação#

Para instalares os pacotes necessários, executa:

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

Utilização#

Todos os modelos Ultralytics YOLO26 foram concebidos para suportar a exportação imediatamente, facilitando a sua integração no teu fluxo de trabalho de implementação preferido. Podes consultar a lista completa de formatos de exportação e opções de configuração compatíveis para escolher a melhor configuração para a tua aplicação.

O formato MNN é compatível com 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 sua precisão.

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

ArgumentoTipoPredefiniçãoDescrição
formatstr'mnn'Formato de destino do modelo exportado, que define a compatibilidade com vários ambientes de implementação.
imgszint ou tuple640Tamanho de imagem pretendido para a entrada do modelo. Pode ser um número inteiro para imagens quadradas ou um tuplo (height, width) para dimensões específicas.
quantizeint ou strNonePrecisão da quantização: 16 (FP16) ou 8 (INT8) reduzem os pesos exportados; 32/não definido exporta pesos FP32, que o runtime de CPU do MNN ainda calcula na sua precisão predefinida low, em vez de FP32. Substitui os sinalizadores obsoletos half/int8.
simplifyboolTrueSimplifica o grafo ONNX intermédio com onnxslim.
opsetintNoneEspecifica a versão do opset ONNX para o grafo ONNX intermédio. Se não for definida, utiliza a versão mais recente suportada.
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 da imagem de entrada. Não pode ser combinado com nms=True.
nmsbool, opcionalNoneSeleciona a saída em bruto (None, predefinição), o NMS incorporado (True) ou a cabeça sem NMS (False). O NMS incorporado suporta deteção e pose com dynamic=False.
devicestrNoneEspecifica o dispositivo para a exportação: GPU (device=0), CPU (device=cpu), MPS para Apple Silicon (device=mps).

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

Inferência exclusiva do MNN#

Foi implementada uma função que depende exclusivamente do MNN para a inferência e o pré-processamento do YOLO26, disponibilizando versões Python e C++ para uma implementação fácil 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] -> [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)
    # 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 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 obter mais informações sobre a utilização, consulta a documentação do MNN.

Perguntas frequentes#

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

    Exportação
    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 obter opções detalhadas de exportação, 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.

    Previsão
    from ultralytics import YOLO

# Load the YOLO26 MNN model
model = YOLO("yolo26n.mnn")

# Run inference
results = model("https://ultralytics.com/images/bus.jpg")

for result in results:
    result.show()  # display to screen
    result.save(filename="result.jpg")  # save to disk

  • O MNN é versátil e é compatível com várias plataformas:

    • Dispositivos móveis: Android, iOS, Harmony.
    • Sistemas incorporados 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 Android.
    2. Compilar para iOS: segue o guia MNN iOS.
    3. Compilar para Harmony: segue o guia MNN Harmony.
Contribuidores
GLglenn-jocher14LAlakshanthad3RAraimbekovm2JUjules-ai2AMamanharshx1Y-Y-T-G1ONonuralpszr1LALaughing-q1RIRizwanMunawar1WAwangzhaode1

Comentários