Esportazione MNN per modelli YOLO26 e relativo deployment#

Q: Quali piattaforme sono supportate per MNN?

MNN è versatile e supporta diverse piattaforme: Mobile: Android, iOS, Harmony. Sistemi embedded e dispositivi IoT: dispositivi come Raspberry Pi e NVIDIA Jetson. Desktop e server: Linux, Windows e macOS.

MNN#

MNN mobile neural network inference framework

MNN è un framework di deep learning altamente efficiente e leggero. Supporta l'inferenza e l'addestramento di modelli di deep learning e vanta prestazioni leader del settore per l'inferenza e l'addestramento on-device. Attualmente, MNN è stato integrato in oltre 30 app di Alibaba Inc, come Taobao, Tmall, Youku, DingTalk, Xianyu, ecc., coprendo oltre 70 scenari di utilizzo come trasmissioni in diretta, acquisizione di brevi video, raccomandazioni di ricerca, ricerca prodotti per immagine, marketing interattivo, distribuzione azionaria e controllo dei rischi di sicurezza. Inoltre, MNN viene utilizzato anche su dispositivi embedded, come quelli IoT.

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

Attività supportate#

L'esportazione MNN supporta tutti e sette i task di Ultralytics. La segmentazione semantica e la stima della profondità sono disponibili solo con YOLO26, l'unica famiglia che include quelle teste.

Compito	YOLOv8	YOLO11	YOLO26
Detect	✅	✅	✅
Segment	✅	✅	✅
Semantic	❌	❌	✅
Depth	❌	❌	✅
Classify	✅	✅	✅
Pose	✅	✅	✅
OBB	✅	✅	✅

Esportazione in MNN: convertire il tuo modello YOLO26#

Puoi estendere la compatibilità del modello e la flessibilità di deployment convertendo i modelli Ultralytics YOLO nel formato MNN. Questa conversione ottimizza i tuoi modelli per ambienti mobile ed embedded, garantendo prestazioni efficienti su dispositivi con risorse limitate.

Installazione#

Per installare i pacchetti richiesti, esegui:

Installazione

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

Utilizzo#

Tutti i modelli Ultralytics YOLO26 sono progettati per supportare l'esportazione nativamente, rendendo semplice integrarli nel tuo flusso di lavoro di distribuzione preferito. Puoi visualizzare l'elenco completo dei formati di esportazione supportati e le opzioni di configurazione per scegliere la configurazione migliore per la tua applicazione.

Il formato MNN supporta le modalità Export, Predict e Validate. Esporta il tuo modello, quindi carica il modello esportato per eseguire l'inferenza o convalidarne l'accuratezza.

Esportazione

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'

Previsione

from ultralytics import YOLO

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

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

Convalida

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

Argomenti di esportazione#

Argomento	Tipo	Predefinito	Descrizione
`format`	`str`	`'mnn'`	Formato di destinazione per il modello esportato, che definisce la compatibilità con vari ambienti di distribuzione.
`imgsz`	`int` o `tuple`	`640`	Dimensione dell'immagine desiderata per l'input del modello. Può essere un numero intero per immagini quadrate o una tupla `(height, width)` per dimensioni specifiche.
`quantize`	`int` o `str`	`None`	Precisione di quantizzazione: `16` (FP16), `8` (quantizzazione dei pesi INT8) oppure `32`/non impostato (FP32). Sostituisce i flag obsoleti `half`/`int8`.
`simplify`	`bool`	`True`	Semplifica il grafo intermedio ONNX con `onnxslim`.
`opset`	`int`	`None`	Specifica la versione dell'opset ONNX per il grafo ONNX intermedio. Se non impostata, utilizza l'ultima versione supportata.
`batch`	`int`	`1`	Specifica la dimensione dell'inferenza batch del modello esportato o il numero massimo di immagini che il modello esportato elaborerà simultaneamente in modalità `predict`.
`dynamic`	`bool`	`False`	Abilita dimensioni dinamiche dell'immagine di input. Non può essere combinato con `nms=True`.
`nms`	`bool`	`False`	Aggiunge NMS per i modelli di rilevamento e posa. Non può essere combinato con `dynamic=True`.
`device`	`str`	`None`	Specifica il dispositivo per l'esportazione: GPU (`device=0`), CPU (`device=cpu`), MPS per Apple silicon (`device=mps`).

Per ulteriori dettagli sul processo di esportazione, visita la pagina della documentazione di Ultralytics sull'esportazione.

Inferenza esclusivamente MNN#

È implementata una funzione che si affida esclusivamente a MNN per l'inferenza e il pre-processing di YOLO26, fornendo sia versioni Python che C++ per un facile deployment in qualsiasi scenario.

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)

Riepilogo#

In questa guida ti mostriamo come esportare il modello Ultralytics YOLO26 in MNN e utilizzare MNN per l'inferenza. Il formato MNN offre prestazioni eccellenti per applicazioni di edge AI, rendendolo ideale per il deployment di modelli di computer vision su dispositivi con risorse limitate.

Per ulteriori utilizzi, consulta la documentazione MNN.

FAQ#

Come posso esportare i modelli Ultralytics YOLO26 nel formato MNN?#

Per esportare il tuo modello Ultralytics YOLO26 nel formato MNN, segui questi passaggi:

Esportazione

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

Per opzioni di esportazione dettagliate, consulta la pagina Export nella documentazione.

Come posso eseguire previsioni con un modello YOLO26 MNN esportato?#

Per eseguire previsioni con un modello YOLO26 MNN esportato, utilizza la funzione predict della classe YOLO.

Previsione

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

Quali piattaforme sono supportate per MNN?#

MNN è versatile e supporta diverse piattaforme:

Mobile: Android, iOS, Harmony.
Sistemi embedded e dispositivi IoT: dispositivi come Raspberry Pi e NVIDIA Jetson.
Desktop e server: Linux, Windows e macOS.

Come posso effettuare il deployment di modelli Ultralytics YOLO26 MNN su dispositivi mobile?#

Per effettuare il deployment dei tuoi modelli YOLO26 su dispositivi mobile:

Build per Android: segui la guida MNN Android.
Build per iOS: segui la guida MNN iOS.
Build per Harmony: segui la guida MNN Harmony.

Contributori

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

Creato 30 ott 2024Aggiornato settimana scorsa