Link to this sectionExportação MNN para modelos YOLO26 e implementação#

Q: Quais plataformas são suportadas pelo MNN?

O MNN é versátil e suporta várias plataformas: Móvel: Android, iOS, Harmony. Sistemas embarcados e dispositivos IoT: Dispositivos como Raspberry Pi e NVIDIA Jetson. Desktop e servidores: Linux, Windows e macOS.

Link to this sectionMNN#

MNN mobile neural network inference framework

MNN é uma estrutura de aprendizado profundo altamente eficiente e leve. Ela suporta inferência e treinamento de modelos de aprendizado profundo e tem um desempenho líder do setor para inferência e treinamento em dispositivos. Atualmente, o MNN foi integrado a mais de 30 aplicativos do Alibaba Inc., como Taobao, Tmall, Youku, DingTalk, Xianyu, etc., cobrindo mais de 70 cenários de uso, como transmissão ao vivo, captura de vídeos curtos, recomendação de pesquisa, busca de produtos por imagem, marketing interativo, distribuição de capital e controle de risco de segurança. Além disso, o MNN também é usado em dispositivos embarcados, como IoT.

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

Link to this sectionExportar para MNN: Convertendo seu modelo YOLO26#

Você pode expandir a compatibilidade de modelos e a flexibilidade de implementação convertendo modelos Ultralytics YOLO para o formato MNN. Essa conversão otimiza seus modelos para ambientes móveis e embarcados, garantindo um desempenho eficiente em dispositivos com recursos limitados.

Link to this sectionInstalação#

Para instalar os pacotes necessários, execute:

Instalação

# Install the required package for YOLO26 and MNN
pip install ultralytics
pip install MNN

Link to this sectionUso#

Todos os modelos Ultralytics YOLO26 são projetados para suportar exportação pronta para uso, tornando fácil integrá-los ao seu fluxo de trabalho de implantação preferido. Você pode ver a lista completa de formatos de exportação suportados e opções de configuração para escolher a melhor configuração para sua aplicação.

O formato MNN suporta os modos Export, Predict e Validate. Exporte seu modelo e, em seguida, carregue o modelo exportado para executar a inferência ou validar sua precisão.

Exportar

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'

Prever

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")

Link to this sectionArgumentos de Exportação#

Argumento	Tipo	Predefinição	Descrição
`format`	`str`	`'mnn'`	Formato de destino para o modelo exportado, definindo a compatibilidade com vários ambientes de implementação.
`imgsz`	`int` ou `tuple`	`640`	Tamanho de imagem desejado para a entrada do modelo. Pode ser um número inteiro para imagens quadradas ou uma tupla `(height, width)` para dimensões específicas.
`quantize`	`int` ou `str`	`None`	Precisão de quantização: `16` (FP16), `8` (quantização de pesos INT8), ou `32`/não definido (FP32). Substitui as flags obsoletas `half`/`int8`.
`batch`	`int`	`1`	Especifica 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`.
`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, visite a página de documentação do Ultralytics sobre exportação.

Link to this sectionInferência exclusiva via MNN#

Uma função que depende exclusivamente do MNN para inferência e pré-processamento do YOLO26 foi implementada, fornecendo 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 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)

Link to this sectionResumo#

Neste guia, apresentamos como exportar o modelo Ultralytics YOLO26 para MNN e usar o MNN para inferência. O formato MNN oferece 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 detalhes sobre o uso, consulte a documentação do MNN.

Link to this sectionFAQ#

Link to this sectionComo exporto modelos Ultralytics YOLO26 para o formato MNN?#

Para exportar seu modelo Ultralytics YOLO26 para o formato MNN, siga estas etapas:

Exportar

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 opções detalhadas de exportação, verifique a página Export na documentação.

Link to this sectionComo faço previsões com um modelo YOLO26 MNN exportado?#

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

Prever

from ultralytics import YOLO

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

# Run inference
results = model("https://ultralytics.com/images/bus.jpg")  # predict with `fp32`
results = model("https://ultralytics.com/images/bus.jpg", quantize=16)  # predict with `fp16` if device support

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

Link to this sectionQuais plataformas são suportadas pelo MNN?#

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

Móvel: Android, iOS, Harmony.
Sistemas embarcados e dispositivos IoT: Dispositivos como Raspberry Pi e NVIDIA Jetson.
Desktop e servidores: Linux, Windows e macOS.

Link to this sectionComo posso implementar modelos Ultralytics YOLO26 MNN em dispositivos móveis?#

Para implementar seus modelos YOLO26 em dispositivos móveis:

Compilar para Android: Siga o guia MNN Android.
Compilar para iOS: Siga o guia MNN iOS.
Compilar para Harmony: Siga o guia MNN Harmony.

Contribuidores

GLglenn-jocher¹¹ LAlakshanthad³ JUjules-ai² ONonuralpszr¹ LALaughing-q¹ RIRizwanMunawar¹ WAwangzhaode¹

Criado 30 de out. de 2024Atualizado anteontem