Erste Schritte

MNN-Export und Bereitstellung für YOLO26-Modelle

MNN#

MNN mobile neural network inference framework

MNN ist ein leichtgewichtiges Framework für Deep Learning von Alibaba, das die Inferenz und das Training von Deep-Learning-Modellen direkt auf dem Gerät unterstützt. MNN ist in mehr als 30 Alibaba-Apps integriert, darunter Taobao, Tmall, Youku, DingTalk und Xianyu. Dabei deckt es mehr als 70 Anwendungsfälle ab, etwa Liveübertragungen, kurze Videoaufnahmen, Such- und Produktempfehlungen, die Produktsuche per Bild, interaktives Marketing, die Verteilung von Anteilen und die Kontrolle von Sicherheitsrisiken. MNN läuft auch auf eingebetteten und IoT-Geräten.



Ansehen: Ultralytics YOLO ins MNN-Format exportieren | Inferenz auf Mobilgeräten beschleunigen📱

Unterstützte Aufgaben#

Der MNN-Export unterstützt alle sieben Ultralytics-Aufgaben. Semantische Segmentierung und Tiefenschätzung sind nur mit YOLO26 verfügbar, der einzigen Modellfamilie, die diese Köpfe enthält.

AufgabeYOLOv8YOLO11YOLO26
Erkennung✅✅✅
Segmentierung✅✅✅
Semantik❌❌✅
Tiefe❌❌✅
Klassifizierung✅✅✅
Pose✅✅✅
OBB✅✅✅

Export nach MNN: YOLO26-Modell konvertieren#

Du kannst die Modellkompatibilität und Flexibilität bei der Bereitstellung erweitern, indem du Ultralytics YOLO-Modelle ins MNN-Format konvertierst. Durch diese Konvertierung werden deine Modelle für mobile und eingebettete Umgebungen optimiert, sodass sie auch auf Geräten mit begrenzten Ressourcen effizient laufen.

Installation#

Führe zum Installieren der erforderlichen Pakete Folgendes aus:

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

Verwendung#

Alle Ultralytics YOLO26-Modelle unterstützen den Export ohne zusätzliche Einrichtung, sodass du sie in deinen bevorzugten Bereitstellungsablauf integrieren kannst. Du kannst die vollständige Liste der unterstützten Exportformate und Konfigurationsoptionen anzeigen, um die optimale Konfiguration für deine Anwendung auszuwählen.

Das MNN-Format unterstützt die Modi Export, Vorhersage und Validierung. Exportiere dein Modell und lade anschließend das exportierte Modell, um Inferenz auszuführen oder seine Genauigkeit zu überprüfen.

Exportieren
from ultralytics import YOLO

# Ein YOLO26-Modell laden
model = YOLO("yolo26n.pt")

# Modell ins MNN-Format exportieren
model.export(format="mnn")  # erstellt 'yolo26n.mnn'
Vorhersagen
from ultralytics import YOLO

# Exportiertes MNN-Modell laden
model = YOLO("yolo26n.mnn")

# Inferenz ausführen
results = model("https://ultralytics.com/images/bus.jpg")
Validieren
from ultralytics import YOLO

# Exportiertes MNN-Modell laden
model = YOLO("yolo26n.mnn")

# Die Genauigkeit anhand des COCO8-Datensatzes validieren
metrics = model.val(data="coco8.yaml")

Exportargumente#

ArgumentTypStandardBeschreibung
formatstr'mnn'Zielformat des exportierten Modells, das die Kompatibilität mit verschiedenen Bereitstellungsumgebungen festlegt.
imgszint oder tuple640Gewünschte Bildgröße für die Modelleingabe. Kann eine Ganzzahl für quadratische Bilder oder ein Tupel (height, width) für bestimmte Abmessungen sein.
quantizeint oder strNoneQuantisierungsgenauigkeit: 16 (FP16) oder 8 (INT8) reduziert die Größe der exportierten Gewichte; mit 32 oder ohne Angabe werden FP32-Gewichte exportiert, die Ultralytics-MNNBackend dennoch mit low-Genauigkeit statt mit FP32 ausführt. Ersetzt die veralteten Flags half/int8.
simplifyboolTrueVereinfacht den zwischengeschalteten ONNX-Graphen mit onnxslim.
opsetintNoneGibt die ONNX-opset-Version für den Zwischen-ONNX-Graphen an. Wenn nicht angegeben, wird opset 18 verwendet (niedriger bei PyTorch < 2.4), höchstens jedoch die installierte Version onnx.
batchint1Gibt die Batchgröße für die Inferenz des Exportmodells oder die Höchstzahl der Bilder an, die das exportierte Modell gleichzeitig im predict-Modus verarbeiten kann.
dynamicboolFalseAktiviert variable Eingabebildabmessungen. Kann nicht mit nms=True kombiniert werden.
nmsbool, optionalNoneWähle die Rohausgabe (None, Standard), eingebettetes NMS (True) oder den NMS-freien Kopf (False). Eingebettetes NMS unterstützt Erkennung und Pose mit dynamic=False.
devicestrNoneLegt das Exportgerät fest: GPU (device=0), CPU (device=cpu), MPS für Apple Silicon (device=mps).

Weitere Informationen zum Exportvorgang findest du auf der Ultralytics-Dokumentationsseite zum Export.

Inferenz ausschließlich mit MNN#

Die folgenden Beispiele führen Vorverarbeitung, Inferenz und Nachverarbeitung für YOLO26 ausschließlich mit MNN aus, sowohl in Python als auch in C++. So kannst du Modelle ohne PyTorch oder das Ultralytics-Paket bereitstellen.

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 zu 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()
    # Form von output_var: [84, 8400]; 84 bedeutet: [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)
    # max. Wahrscheinlichkeit und Index abrufen
    scores = np.max(probs, 0)
    class_ids = np.argmax(probs, 0)
    result_ids = MNN.expr.nms(boxes, scores, 100, 0.5, 0.25)
    print(result_ids.shape)
    # NMS-Ergebnis: 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)
        # Auf die Größe des Originalbilds begrenzen, um Fälle mit angewendetem Padding zu behandeln
        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)

Zusammenfassung#

In dieser Anleitung wurde gezeigt, wie du Ultralytics YOLO26-Modelle nach MNN exportierst und mit MNN Inferenz ausführst. Das MNN-Format eignet sich gut für Edge-KI-Anwendungen, bei denen Modelle für maschinelles Sehen auf Geräten mit begrenzten Ressourcen bereitgestellt werden.

Häufig gestellte Fragen#

  • Führe die folgenden Schritte aus, um dein Ultralytics-YOLO26-Modell ins MNN-Format zu exportieren:

    Exportieren
    from ultralytics import YOLO
    
    # Ein YOLO26-Modell laden
    model = YOLO("yolo26n.pt")
    
    # Ins MNN-Format exportieren
    model.export(format="mnn")  # erstellt 'yolo26n.mnn' mit FP32-Gewichten
    model.export(format="mnn", quantize=16)  # erstellt 'yolo26n.mnn' mit FP16-Gewichten
    model.export(format="mnn", quantize=8)  # erstellt 'yolo26n.mnn' mit INT8-Gewichten

    Ausführliche Exportoptionen findest du auf der Seite Export in der Dokumentation.

  • Um Vorhersagen mit einem exportierten YOLO26-MNN-Modell auszuführen, verwende die Funktion predict der YOLO-Klasse.

    Vorhersagen
    from ultralytics import YOLO
    
    # YOLO26-MNN-Modell laden
    model = YOLO("yolo26n.mnn")
    
    # Inferenz ausführen
    results = model("https://ultralytics.com/images/bus.jpg")
    
    for result in results:
        result.show()  # auf dem Bildschirm anzeigen
        result.save(filename="result.jpg")  # auf dem Datenträger speichern
  • MNN unterstützt verschiedene Plattformen:

    • Mobilgeräte: Android, iOS, Harmony.
    • Eingebettete Systeme und IoT-Geräte: Geräte wie Raspberry Pi und NVIDIA Jetson.
    • Desktop und Server: Linux, Windows und macOS.
  • So stellst du deine YOLO26-Modelle auf Mobilgeräten bereit:

    1. Für Android erstellen: Folge der Anleitung MNN für Android.
    2. Für iOS erstellen: Folge der Anleitung MNN für iOS.
    3. Für Harmony erstellen: Folge der Anleitung MNN für Harmony.

Kommentare2

Stell eine Frage, teile deine Ergebnisse oder hilf jemand anderem.

    1. Glenn JocherUltralytics

      It seems like there's a minor typo in your code. Ensure you are using model instead of mnn_model when calling the inference function. Here's a quick fix:

      from ultralytics import YOLO
      
      # Load the YOLO11 MNN model
      model = YOLO("yolo11n.mnn")
      
      # Run inference
      results = model("https://ultralytics.com/images/bus.jpg")

      This should resolve the NameError. If you need more help, please check the MNN documentation.