Ultralytics YOLO27:
Get Started

Esportazione MNN per modelli YOLO26 e distribuzione#

MNN#

MNN mobile neural network inference framework

MNN è un framework di deep learning altamente efficiente e leggero. Supporta l'inferenza e il training dei modelli di deep learning e offre prestazioni leader del settore per l'inferenza e il training direttamente sul dispositivo. Attualmente, MNN è integrato in oltre 30 app di Alibaba Inc, tra cui Taobao, Tmall, Youku, DingTalk e Xianyu, e copre oltre 70 scenari d'uso, come le trasmissioni in diretta, l'acquisizione di video brevi, i suggerimenti di ricerca, la ricerca di prodotti per immagini, il marketing interattivo, la distribuzione di quote e la gestione dei rischi di sicurezza. Inoltre, MNN viene usato anche su dispositivi embedded, come quelli IoT.



Guarda: Come esportare Ultralytics YOLO26 nel formato MNN | Velocizza l'inferenza sui dispositivi mobili📱

Attività supportate#

L'esportazione MNN supporta tutte e sette le attività di Ultralytics. La segmentazione semantica e la stima della profondità sono disponibili solo con YOLO26, l'unica famiglia che include queste head.

AttivitàYOLOv8YOLO11YOLO26
Rilevamento✅✅✅
Segmentazione✅✅✅
Semantica❌❌✅
Profondità❌❌✅
Classificazione✅✅✅
Stima della posa✅✅✅
OBB✅✅✅

Esportazione in MNN: conversione del modello YOLO26#

Puoi ampliare la compatibilità dei modelli e la flessibilità di distribuzione convertendo i modelli Ultralytics YOLO nel formato MNN. Questa conversione ottimizza i modelli per gli ambienti mobili ed embedded, garantendo prestazioni efficienti sui dispositivi con risorse limitate.

Installazione#

Per installare i pacchetti necessari, 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 senza configurazioni aggiuntive, semplificando l'integrazione nel workflow di distribuzione che preferisci. Puoi consultare l'elenco completo dei formati di esportazione supportati e delle opzioni di configurazione per scegliere la configurazione più adatta alla tua applicazione.

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

Esporta
from ultralytics import YOLO

# Carica un modello YOLO26
model = YOLO("yolo26n.pt")

# Esporta il modello nel formato MNN
model.export(format="mnn")  # crea 'yolo26n.mnn'
Predici
from ultralytics import YOLO

# Carica il modello MNN esportato
model = YOLO("yolo26n.mnn")

# Esegui l'inferenza
results = model("https://ultralytics.com/images/bus.jpg")
Convalida
from ultralytics import YOLO

# Carica il modello MNN esportato
model = YOLO("yolo26n.mnn")

# # Convalida l'accuratezza sul dataset COCO8
metrics = model.val(data="coco8.yaml")

Argomenti di esportazione#

ArgomentoTipoPredefinitoDescrizione
formatstr'mnn'Formato di destinazione del modello esportato, che definisce la compatibilità con i vari ambienti di distribuzione.
imgszint o tuple640Dimensione dell'immagine desiderata per l'input del modello. Può essere un intero per immagini quadrate o una tupla (height, width) per dimensioni specifiche.
quantizeint o strNonePrecisione della quantizzazione: 16 (FP16) o 8 (INT8) riducono le dimensioni dei pesi esportati; 32/non impostato esporta i pesi FP32, che MNNBackend di Ultralytics esegue comunque con precisione low, anziché FP32. Sostituisce i flag deprecati half/int8.
simplifyboolTrueSemplifica il grafo ONNX intermedio con onnxslim.
opsetintNoneSpecifica la versione opset ONNX per il grafo ONNX intermedio. Se non è impostata, viene usata l'ultima versione supportata.
batchint1Specifica la dimensione batch per l'inferenza del modello esportato o il numero massimo di immagini che il modello esportato elaborerà contemporaneamente in modalità predict.
dynamicboolFalseAbilita dimensioni dinamiche per le immagini di input. Non può essere combinato con nms=True.
nmsbool, facoltativoNoneSeleziona l'output grezzo (None, predefinito), NMS integrato (True) oppure la head senza NMS (False). L'NMS integrato supporta detect e pose con dynamic=False.
devicestrNoneSpecifica 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 Ultralytics dedicata all'esportazione.

Inferenza esclusivamente con MNN#

È stata implementata una funzione che usa esclusivamente MNN per l'inferenza e il pre-processing di YOLO26; sono disponibili versioni Python e C++ per semplificare la distribuzione 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]  # Da BGR a 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 di 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)
    # ottieni la probabilità massima e l'indice
    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)
    # box, punteggio e ID del risultato 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 alle dimensioni dell'immagine originale per gestire i casi in cui è stato applicato il padding
        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 spieghiamo come esportare il modello Ultralytics YOLO26 in MNN e usare MNN per l'inferenza. Il formato MNN offre prestazioni eccellenti per le applicazioni di AI edge, ed è quindi ideale per distribuire modelli di computer vision su dispositivi con risorse limitate.

Per ulteriori informazioni sull'utilizzo, consulta la documentazione di MNN.

Domande frequenti#

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

    Esporta
    from ultralytics import YOLO

# Carica un modello YOLO26
model = YOLO("yolo26n.pt")

# Esporta nel formato MNN
model.export(format="mnn")  # crea 'yolo26n.mnn' con pesi fp32
model.export(format="mnn", quantize=16)  # crea 'yolo26n.mnn' con pesi fp16
model.export(format="mnn", quantize=8)  # crea 'yolo26n.mnn' con pesi int8

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

  • Per eseguire predizioni con un modello YOLO26 MNN esportato, usa la funzione predict della classe YOLO.

    Predici
    from ultralytics import YOLO

# Carica il modello YOLO26 MNN
model = YOLO("yolo26n.mnn")

# Esegui l'inferenza
results = model("https://ultralytics.com/images/bus.jpg")

for result in results:
    result.show()  # visualizza sullo schermo
    result.save(filename="result.jpg")  # salva su disco

  • MNN è versatile e supporta diverse piattaforme:

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

  • Per distribuire i tuoi modelli YOLO26 sui dispositivi mobili:

    1. Compilazione per Android: segui la guida MNN Android.
    2. Compilazione per iOS: segui la guida MNN iOS.
    3. Compilazione per Harmony: segui la guida MNN Harmony.
Collaboratori
GLglenn-jocher14RAraimbekovm3LAlakshanthad3JUjules-ai2AMamanharshx1Y-Y-T-G1ONonuralpszr1LALaughing-q1RIRizwanMunawar1WAwangzhaode1

Commenti