MNN-Export und Bereitstellung für YOLO26-Modelle
MNN#
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.
| Aufgabe | YOLOv8 | YOLO11 | YOLO26 |
|---|---|---|---|
| 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:
# Install the required package for YOLO26 and MNN
pip install ultralytics
pip install MNNVerwendung#
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.
from ultralytics import YOLO
# Ein YOLO26-Modell laden
model = YOLO("yolo26n.pt")
# Modell ins MNN-Format exportieren
model.export(format="mnn") # erstellt 'yolo26n.mnn'from ultralytics import YOLO
# Exportiertes MNN-Modell laden
model = YOLO("yolo26n.mnn")
# Inferenz ausführen
results = model("https://ultralytics.com/images/bus.jpg")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#
| Argument | Typ | Standard | Beschreibung |
|---|---|---|---|
format | str | 'mnn' | Zielformat des exportierten Modells, das die Kompatibilität mit verschiedenen Bereitstellungsumgebungen festlegt. |
imgsz | int oder tuple | 640 | Gewünschte Bildgröße für die Modelleingabe. Kann eine Ganzzahl für quadratische Bilder oder ein Tupel (height, width) für bestimmte Abmessungen sein. |
quantize | int oder str | None | Quantisierungsgenauigkeit: 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. |
simplify | bool | True | Vereinfacht den zwischengeschalteten ONNX-Graphen mit onnxslim. |
opset | int | None | Gibt 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. |
batch | int | 1 | Gibt 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. |
dynamic | bool | False | Aktiviert variable Eingabebildabmessungen. Kann nicht mit nms=True kombiniert werden. |
nms | bool, optional | None | Wähle die Rohausgabe (None, Standard), eingebettetes NMS (True) oder den NMS-freien Kopf (False). Eingebettetes NMS unterstützt Erkennung und Pose mit dynamic=False. |
device | str | None | Legt 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.
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:
Exportierenfrom 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-GewichtenAusführliche Exportoptionen findest du auf der Seite Export in der Dokumentation.
Um Vorhersagen mit einem exportierten YOLO26-MNN-Modell auszuführen, verwende die Funktion
predictder YOLO-Klasse.Vorhersagenfrom 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 speichernMNN 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:
- Für Android erstellen: Folge der Anleitung MNN für Android.
- Für iOS erstellen: Folge der Anleitung MNN für iOS.
- Für Harmony erstellen: Folge der Anleitung MNN für Harmony.
Kommentare2
Stell eine Frage, teile deine Ergebnisse oder hilf jemand anderem.
robert-hardman
Hello Error: NameError: name 'mnn_model' is not defined ultralytics==8.3.34
Glenn JocherUltralyticsIt seems like there's a minor typo in your code. Ensure you are using
modelinstead ofmnn_modelwhen 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.