YOLO26 mit ExecuTorch auf Mobilgeräten und Edge-Geräten bereitstellen#

Die Bereitstellung von Computer-Vision-Modellen auf Edge-Geräten wie Smartphones, Tablets und eingebetteten Systemen erfordert eine optimierte Laufzeitumgebung, die Leistung und begrenzte Ressourcen in Einklang bringt. ExecuTorch, die Lösung von PyTorch für Edge Computing, ermöglicht eine effiziente Inferenz auf dem Gerät für Ultralytics YOLO-Modelle.

Dieser Leitfaden beschreibt, wie du Ultralytics YOLO-Modelle in das ExecuTorch-Format exportierst und so mit optimierter Leistung auf Mobil- und Edge-Geräten bereitstellst.

Warum nach ExecuTorch exportieren?#

ExecuTorch ist die durchgängige Lösung von PyTorch, um Inferenz auf dem Gerät für Mobil- und Edge-Geräte zu ermöglichen. ExecuTorch wurde mit dem Ziel entwickelt, portierbar und effizient zu sein, und kann PyTorch-Programme auf einer großen Vielfalt von Rechenplattformen ausführen.

Wichtige Funktionen von ExecuTorch#

ExecuTorch bietet mehrere leistungsstarke Funktionen für die Bereitstellung von Ultralytics YOLO-Modellen auf Edge-Geräten:

• Portables Modellformat: ExecuTorch verwendet das Format .pte (PyTorch ExecuTorch), das für geringe Größe und schnelles Laden auf Geräten mit begrenzten Ressourcen optimiert ist.

• XNNPACK-Backend: Die standardmäßige Integration von XNNPACK ermöglicht eine hochoptimierte Inferenz auf mobilen CPUs und liefert eine hervorragende Leistung, ohne spezielle Hardware zu erfordern.

• Bereit für Quantisierung: Das ExecuTorch-Ökosystem unterstützt Quantisierungstechniken zur Verringerung der Modellgröße und zur Beschleunigung der Inferenz; Ultralytics exportiert derzeit FP32-Modelle über das XNNPACK-Backend.

• Speichereffizienz: Eine optimierte Speicherverwaltung reduziert den Laufzeitspeicherbedarf und macht ExecuTorch für Geräte mit begrenztem RAM geeignet.

• Modellmetadaten: Exportierte Modelle enthalten Metadaten (Bildgröße, Klassennamen usw.) in einer separaten YAML-Datei, um die Integration zu vereinfachen.

Bereitstellungsoptionen mit ExecuTorch#

ExecuTorch-Modelle können auf verschiedenen Edge- und Mobilplattformen bereitgestellt werden:

• Mobile Anwendungen: Bereitstellung in iOS- und Android-Anwendungen mit nativer Leistung, um Objekterkennung in Echtzeit in mobilen Apps zu ermöglichen.

• Eingebettete Systeme: Ausführung auf eingebetteten Linux-Geräten wie Raspberry Pi, NVIDIA Jetson und anderen ARM-basierten Systemen mit optimierter Leistung.

• Edge-KI-Geräte: Bereitstellung auf spezialisierter Edge-KI-Hardware mit benutzerdefinierten Delegates für beschleunigte Inferenz.

• IoT-Geräte: Integration in IoT-Geräte für Inferenz auf dem Gerät ohne erforderliche Cloud-Verbindung.

Unterstützte Aufgaben#

Der ExecuTorch-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.

Exportieren von Ultralytics YOLO26-Modellen nach ExecuTorch#

Die Konvertierung von Ultralytics YOLO26-Modellen in das ExecuTorch-Format ermöglicht eine effiziente Bereitstellung auf Mobil- und Edge-Geräten.

Installation#

Der ExecuTorch-Export erfordert Python 3.10–3.13 und PyTorch >= 2.9.0 sowie das Paket executorch:

# Install Ultralytics package
pip install ultralytics

Ausführliche Anweisungen und bewährte Vorgehensweisen zur Installation findest du in unserem YOLO26-Installationsleitfaden. Falls bei der Installation der für YOLO26 erforderlichen Pakete Probleme auftreten, findest du in unserem Leitfaden zu häufigen Problemen Lösungen und Tipps.

Verwendung#

Der Export von YOLO26-Modellen nach ExecuTorch ist unkompliziert:

Das ExecuTorch-Format unterstützt die Modi Export, Predict und Validate. Exportiere dein Modell und lade es anschließend, um Inferenz auszuführen oder seine Genauigkeit zu validieren.

from ultralytics import YOLO

# Load a YOLO26 model
model = YOLO("yolo26n.pt")

# Export the model to ExecuTorch format
model.export(format="executorch")  # creates 'yolo26n_executorch_model'

from ultralytics import YOLO

# Load the exported ExecuTorch model
model = YOLO("yolo26n_executorch_model")

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

from ultralytics import YOLO

# Load the exported ExecuTorch model
model = YOLO("yolo26n_executorch_model")

# Validate accuracy on the COCO8 dataset
metrics = model.val(data="coco8.yaml")

Exportargumente#

Beim Export in das ExecuTorch-Format kannst du die folgenden Argumente angeben:

Ausgabestruktur#

Der ExecuTorch-Export erstellt ein Verzeichnis mit dem Modell und den Metadaten:

yolo26n_executorch_model/
├── model.pte               # ExecuTorch model file
└── metadata.yaml           # Model metadata (classes, image size, etc.)

Exportierte ExecuTorch-Modelle verwenden#

Nach dem Export deines Modells musst du es mithilfe der ExecuTorch-Laufzeitumgebung in deine Zielanwendung integrieren.

Mobile Integration#

Für mobile Anwendungen (iOS/Android) musst du:

1. ExecuTorch-Laufzeitumgebung hinzufügen: Binde die ExecuTorch-Laufzeitbibliothek in dein mobiles Projekt ein.
2. Modell laden: Lade die Datei .pte in deiner Anwendung.
3. Inferenz ausführen: Verarbeite Bilder und erhalte Vorhersagen.

iOS#

Beispiel für eine iOS-Integration (Objective-C/C++):

// iOS uses C++ APIs for model loading and inference
// See https://pytorch.org/executorch/stable/using-executorch-ios.html for complete examples

#include <executorch/extension/module/module.h>

using namespace ::executorch::extension;

// Load the model
Module module("/path/to/model.pte");

// Create input tensor
float input[1 * 3 * 640 * 640];
auto tensor = from_blob(input, {1, 3, 640, 640});

// Run inference
const auto result = module.forward(tensor);

Android#

Füge die ExecuTorch Android AAR aus Maven Central hinzu:

dependencies {
    implementation("org.pytorch:executorch-android:<version>")
}

Beispiel für eine Android-Integration (Kotlin):

import org.pytorch.executorch.EValue
import org.pytorch.executorch.Module
import org.pytorch.executorch.Tensor

// Load the model
val module = Module.load("/path/to/model.pte")

// Prepare input tensor
val inputTensor = Tensor.fromBlob(floatData, longArrayOf(1, 3, 640, 640))
val inputEValue = EValue.from(inputTensor)

// Run inference
val outputs = module.forward(inputEValue)
val scores = outputs[0].toTensor().dataAsFloatArray

Eingebettetes Linux#

Verwende für eingebettete Linux-Systeme die ExecuTorch-C++-API:

#include <executorch/extension/module/module.h>
#include <executorch/extension/tensor/tensor.h>

using namespace ::executorch::extension;

// Load model
Module module("model.pte");

// Prepare input
std::vector<float> input_data = preprocessImage(image);
auto input_tensor = from_blob(input_data.data(), {1, 3, 640, 640});

// Run inference
const auto outputs = module.forward(input_tensor);

Weitere Informationen zur Integration von ExecuTorch in deine Anwendungen findest du in der ExecuTorch-Dokumentation.

Leistungsoptimierung#

Optimierung der Modellgröße#

So reduzierst du die Modellgröße für die Bereitstellung:

• Kleinere Modelle verwenden: Beginne mit YOLO26n (nano), um den geringsten Speicherbedarf zu erzielen.
• Eingabeauflösung reduzieren: Verwende kleinere Bildgrößen (z. B. imgsz=320 oder imgsz=416).
• Quantisierung: Wende Quantisierungstechniken an (in zukünftigen ExecuTorch-Versionen unterstützt).

Optimierung der Inferenzgeschwindigkeit#

Für eine schnellere Inferenz:

• XNNPACK-Backend: Das standardmäßige XNNPACK-Backend ermöglicht eine optimierte CPU-Inferenz.
• Hardwarebeschleunigung: Verwende plattformspezifische Delegates (z. B. CoreML für iOS).
• Batch-Verarbeitung: Verarbeite nach Möglichkeit mehrere Bilder gleichzeitig.

Benchmarks#

Das Ultralytics-Team hat YOLO26-Modelle bewertet und dabei Geschwindigkeit und Genauigkeit zwischen PyTorch und ExecuTorch verglichen.

Fehlerbehebung#

Häufige Probleme#

Problem: Python version error

Lösung: ExecuTorch erfordert Python 3.10 bis 3.13. Erstelle eine Umgebung mit einer unterstützten Version:

# Using conda
conda create -n executorch python=3.10
conda activate executorch

Problem: Export fails during first run

Lösung: Stelle sicher, dass das aktuelle vorgefertigte executorch-Wheel installiert ist:

pip install --upgrade executorch

Problem: Import errors for ExecuTorch modules

Lösung: Stelle sicher, dass ExecuTorch ordnungsgemäß installiert ist:

pip install executorch --force-reinstall

Weitere Hilfe bei der Fehlerbehebung findest du in den Ultralytics-GitHub-Issues oder in der ExecuTorch-Dokumentation.

Zusammenfassung#

Der Export von YOLO26-Modellen in das ExecuTorch-Format ermöglicht eine effiziente Bereitstellung auf Mobil- und Edge-Geräten. Mit der nativen PyTorch-Integration, plattformübergreifender Unterstützung und optimierter Leistung ist ExecuTorch eine ausgezeichnete Wahl für Edge-KI-Anwendungen.

Wichtigste Erkenntnisse:

• ExecuTorch ermöglicht eine native PyTorch-Bereitstellung auf Edge-Geräten mit hervorragender Leistung.
• Der Export ist mit dem Parameter format='executorch' unkompliziert.
• Modelle sind über das XNNPACK-Backend für mobile CPUs optimiert.
• Unterstützt iOS, Android und eingebettete Linux-Plattformen.
• Erfordert Python 3.10–3.13 und PyTorch >= 2.9.0.

FAQ#