Editar página no GitHub (EN)

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 possui um desempenho líder no 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, etc., cobrindo mais de 70 cenários de utilização, tais como transmissão em direto, captura de vídeos curtos, recomendação de pesquisa, pesquisa de produtos por imagem, marketing interativo, distribuição de capitais e controlo de riscos de segurança. Além disso, o MNN é também utilizado em dispositivos integrados, como a IoT.



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

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 integrados, assegurando 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

Utilização

Todos os modelos Ultralytics YOLO26 foram concebidos para suportar a exportação imediata, facilitando a sua integração no teu fluxo de trabalho de implementação preferido. Podes ver 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.

Utilização
  from ultralytics import YOLO

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

  # Export the model to MNN format
  model.export(format="mnn")  # creates 'yolo26n.mnn'

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

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

Argumentos de Exportação

ArgumentoTipoPredefiniçãoDescrição
formatstr'mnn'Formato de destino para o modelo exportado, definindo a compatibilidade com vários ambientes de implantação.
imgszint ou tuple640Desired image size for the model input. Can be an integer for square images or a tuple (height, width) for specific dimensions.
halfboolFalseAtiva a quantização FP16 (precisão simples), reduzindo o tamanho do modelo e potencialmente acelerando a inferência em hardware suportado.
int8boolFalseAtiva a quantização INT8, comprimindo ainda mais o modelo e acelerando a inferência com perda mínima de precisão, principalmente para dispositivos de borda.
batchint1Especifica o tamanho da inferência em lote do modelo de exportação ou o número máximo de imagens que o modelo exportado processará simultaneamente no modo predict.
devicestrNoneEspecifica o dispositivo para exportação: GPU (device=0), CPU (device=cpu), MPS para silício Apple (device=mps).

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

Inferência exclusiva para MNN

Foi implementada uma função que depende exclusivamente do MNN para a inferência e pré-processamento do YOLO26, fornecendo versões em 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] -> [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 como utilizar o MNN para inferência. O formato MNN proporciona um excelente desempenho para aplicações de edge AI, tornando-o ideal para implementar modelos de visão computacional em dispositivos com recursos limitados.

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

FAQ

Como posso exportar modelos Ultralytics YOLO26 para o formato MNN?

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

Export
from ultralytics import YOLO

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

# Export to MNN format
model.export(format="mnn")  # creates 'yolo26n.mnn' with fp32 weight
model.export(format="mnn", half=True)  # creates 'yolo26n.mnn' with fp16 weight
model.export(format="mnn", int8=True)  # creates 'yolo26n.mnn' with int8 weight

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

Como posso fazer previsões com um modelo YOLO26 MNN exportado?

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

Prever
from ultralytics import YOLO

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

# Export to MNN format
results = model("https://ultralytics.com/images/bus.jpg")  # predict with `fp32`
results = model("https://ultralytics.com/images/bus.jpg", half=True)  # predict with `fp16` if device support

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

Que plataformas são suportadas pelo MNN?

O MNN é versátil e suporta várias plataformas:

  • Móvel: Android, iOS, Harmony.
  • Sistemas Integrados 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 implementares os teus modelos YOLO26 em dispositivos móveis:

  1. Criar para Android: Segue o guia MNN Android.
  2. Criar para iOS: Segue o guia MNN iOS.
  3. Criar para Harmony: Segue o guia MNN Harmony.
Contributors
Editar página no GitHub (EN)
GLglenn-jocher7LAlakshanthad3JUjules-ai2LALaughing-q1RIRizwanMunawar1WAwangzhaode1

Comentários