Meet YOLO26: next-gen vision AI.

Link to this sectionEsportazione MNN per modelli YOLO26 e distribuzione#

Link to this sectionMNN#

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 più di 70 scenari di utilizzo come trasmissioni in diretta, acquisizione di brevi video, suggerimenti di ricerca, ricerca di prodotti tramite immagini, marketing interattivo, distribuzione di equity, controllo dei rischi di sicurezza. Inoltre, MNN viene utilizzato anche su dispositivi integrati, come l'IoT.



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

Link to this sectionEsportazione in MNN: Convertire il tuo 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 tuoi modelli per ambienti mobile e integrati, garantendo prestazioni efficienti su dispositivi con risorse limitate.

Link to this sectionInstallazione#

Per installare i pacchetti necessari, esegui:

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

Link to this sectionUtilizzo#

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

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

Export
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'
Predict
from ultralytics import YOLO

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

# Run inference
results = model("https://ultralytics.com/images/bus.jpg")
Validate
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 sectionArgomenti di esportazione#

ArgomentoTipoPredefinitoDescrizione
formatstr'mnn'Formato di destinazione per il modello esportato, che definisce la compatibilità con vari ambienti di distribuzione.
imgszint o tuple640Desired image size for the model input. Can be an integer for square images or a tuple (height, width) for specific dimensions.
halfboolFalseAbilita la quantizzazione FP16 (precisione dimezzata), riducendo le dimensioni del modello e potenzialmente accelerando l'inferenza sull'hardware supportato.
int8boolFalseAttiva la quantizzazione INT8, comprimendo ulteriormente il modello e accelerando l'inferenza con una minima perdita di accuratezza, principalmente per i dispositivi edge.
batchint1Specifica la dimensione dell'inferenza batch del modello esportato o il numero massimo di immagini che il modello esportato elaborerà simultaneamente in modalità predict.
devicestrNoneSpecifica il dispositivo per l'esportazione: GPU (device=0), CPU (device=cpu), MPS per Apple silicon (device=mps).

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

Link to this sectionInferenza solo MNN#

È stata implementata una funzione che si affida esclusivamente a MNN per l'inferenza e la pre-elaborazione di YOLO26, fornendo sia versioni Python che C++ per una facile 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]  # 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)

In questa guida, introduciamo 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 distribuire modelli di computer vision su dispositivi con risorse limitate.

Per ulteriori utilizzi, fai riferimento alla documentazione MNN.

Link to this sectionFAQ#

Link to this sectionCome esporto i modelli Ultralytics YOLO26 nel formato MNN?#

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

Export
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", half=True)  # creates 'yolo26n.mnn' with fp16 weight
model.export(format="mnn", int8=True)  # creates 'yolo26n.mnn' with int8 weight

Per opzioni di esportazione dettagliate, controlla la pagina Esportazione nella documentazione.

Link to this sectionCome effettuo predizioni con un modello MNN YOLO26 esportato?#

Per effettuare predizioni con un modello MNN YOLO26 esportato, usa la funzione predict dalla classe YOLO.

Predict
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", 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

Link to this sectionQuali piattaforme sono supportate per MNN?#

MNN è versatile e supporta varie piattaforme:

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

Link to this sectionCome posso distribuire i modelli MNN Ultralytics YOLO26 su dispositivi mobili?#

Per distribuire i tuoi modelli YOLO26 su dispositivi mobili:

  1. Build per Android: Segui la guida MNN Android.
  2. Build per iOS: Segui la guida MNN iOS.
  3. Build per Harmony: Segui la guida MNN Harmony.
Collaboratori
GLglenn-jocher9LAlakshanthad3JUjules-ai2LALaughing-q1RIRizwanMunawar1WAwangzhaode1

Commenti