Bereitstellung von YOLO26 auf Mobile & Edge mit ExecuTorch

Das Bereitstellen von Computer-Vision-Modellen auf Edge-Geräten wie Smartphones, Tablets und eingebetteten Systemen erfordert eine optimierte Runtime, die Leistung und Ressourcenbeschränkungen ausbalanciert. ExecuTorch, die Lösung von PyTorch für Edge-Computing, ermöglicht eine effiziente On-Device-Inferenz für Ultralytics YOLO Modelle.

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

Warum der Export in ExecuTorch?

ExecuTorch ist die End-to-End-Lösung von PyTorch, um On-Device-Inferenzfunktionen auf Mobil- und Edge-Geräten zu ermöglichen. ExecuTorch wurde mit dem Ziel entwickelt, portabel und effizient zu sein, und kann verwendet werden, um PyTorch-Programme auf einer Vielzahl von Computerplattformen auszuführen.

Hauptfunktionen von ExecuTorch

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

• Portables Modellformat: ExecuTorch verwendet das .pte (PyTorch ExecuTorch) Format, welches für Größe und Ladegeschwindigkeit auf ressourcenbeschränkten Geräten optimiert ist.

• XNNPACK-Backend: Die Standardintegration mit XNNPACK bietet eine hochoptimierte Inferenz auf mobilen CPUs und liefert hervorragende Leistung, ohne dass spezialisierte Hardware erforderlich ist.

• Quantisierungsunterstützung: Integrierte Unterstützung für Quantisierungstechniken, um die Modellgröße zu reduzieren und die Inferenzgeschwindigkeit zu verbessern, während die Genauigkeit erhalten bleibt.

• Speichereffizienz: Ein optimiertes Speichermanagement reduziert den Runtime-Speicherbedarf, was es für Geräte mit begrenztem RAM geeignet macht.

• Modell-Metadaten: Exportierte Modelle enthalten Metadaten (Bildgröße, Klassennamen usw.) in einer separaten YAML-Datei für eine einfache Integration.

Bereitstellungsoptionen mit ExecuTorch

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

• Mobile Anwendungen: Bereitstellung auf iOS- und Android-Anwendungen mit nativer Leistung, was eine Objekterkennung in Echtzeit in mobilen Apps ermöglicht.

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

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

• IoT-Geräte: Integration in IoT-Geräte für On-Device-Inferenz ohne Anforderungen an Cloud-Konnektivität.

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 oder höher und spezifische Abhängigkeiten:

# Install Ultralytics package
pip install ultralytics

Für detaillierte Anweisungen und Best Practices rund um den Installationsprozess, schau dir unsere YOLO26-Installationsanleitung an. Wenn du bei der Installation der erforderlichen Pakete für YOLO26 auf Schwierigkeiten stößt, konsultiere unsere Anleitung für häufige Probleme für Lösungen und Tipps.

Verwendung

Der Export von YOLO26-Modellen nach ExecuTorch ist unkompliziert:

from ultralytics import YOLO

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

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

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

# Run inference on a single image
results = executorch_model.predict("https://ultralytics.com/images/bus.jpg")

Export-Argumente

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

Ausgabestruktur

Der ExecuTorch-Export erstellt ein Verzeichnis, das das Modell und Metadaten enthält:

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

Verwendung exportierter ExecuTorch-Modelle

Nachdem du dein Modell exportiert hast, musst du es unter Verwendung der ExecuTorch-Runtime in deine Zielanwendung integrieren.

Mobile Integration

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

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

Beispiel für 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/yolo26n.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);

Beispiel für 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/yolo26n.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

Für eingebettete Linux-Systeme verwende die ExecuTorch C++ API:

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

// Load model
auto module = torch::executor::Module("yolo26n.pte");

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

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

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

Leistungsoptimierung

Optimierung der Modellgröße

Um die Modellgröße für die Bereitstellung zu reduzieren:

• Verwende kleinere Modelle: Starte mit YOLO26n (nano) für den kleinsten Speicherbedarf
• Niedrigere Eingabeauflösung: Verwende kleinere Bildgrößen (z. B. imgsz=320 oder imgsz=416)
• Quantisierung: Wende Quantisierungstechniken an (unterstützt in zukünftigen ExecuTorch-Versionen)

Optimierung der Inferenzgeschwindigkeit

Für eine schnellere Inferenz:

• XNNPACK-Backend: Das standardmäßige XNNPACK-Backend bietet eine optimierte CPU-Inferenz
• Hardware-Beschleunigung: Verwende plattformspezifische Delegates (z. B. CoreML für iOS)
• Batch-Verarbeitung: Verarbeite wenn möglich mehrere Bilder gleichzeitig

Benchmarks

Das Ultralytics-Team hat YOLO26-Modelle gebenchmarkt und die Geschwindigkeit und Genauigkeit zwischen PyTorch und ExecuTorch verglichen.

Fehlerbehebung

Häufige Probleme

Issue: Python version error

Lösung: ExecuTorch erfordert Python 3.10 oder höher. Aktualisiere deine Python-Installation:

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

Issue: Export fails during first run

Lösung: ExecuTorch muss möglicherweise beim ersten Gebrauch Komponenten herunterladen und kompilieren. Stelle sicher, dass du hast:

pip install --upgrade executorch

Issue: Import errors for ExecuTorch modules

Lösung: Stelle sicher, dass ExecuTorch korrekt installiert ist:

pip install executorch --force-reinstall

Für weitere Hilfe zur Fehlerbehebung besuche die Ultralytics GitHub Issues oder die ExecuTorch Dokumentation.

Zusammenfassung

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

Wichtige Erkenntnisse:

• ExecuTorch bietet PyTorch-native Edge-Bereitstellung mit exzellenter Leistung
• Der Export ist einfach mit dem Parameter format='executorch'
• Modelle sind über das XNNPACK-Backend für mobile CPUs optimiert
• Unterstützt iOS-, Android- und eingebettete Linux-Plattformen
• Erfordert Python 3.10+ und den FlatBuffers-Compiler

FAQ

Wie exportiere ich ein YOLO26-Modell in das ExecuTorch-Format?

Exportiere ein YOLO26-Modell mit Python oder CLI nach ExecuTorch:

from ultralytics import YOLO

model = YOLO("yolo26n.pt")
model.export(format="executorch")

oder

yolo export model=yolo26n.pt format=executorch

Was sind die Systemanforderungen für den ExecuTorch-Export?

Der ExecuTorch-Export erfordert:

• Python 3.10 oder höher
• executorch-Paket (Installation via pip install executorch)
• PyTorch (wird automatisch mit ultralytics installiert)

Hinweis: Beim ersten Export lädt und kompiliert ExecuTorch notwendige Komponenten, einschließlich des FlatBuffers-Compilers, automatisch.

Kann ich die Inferenz mit ExecuTorch-Modellen direkt in Python ausführen?

ExecuTorch-Modelle (.pte-Dateien) sind für die Bereitstellung auf Mobil- und Edge-Geräten unter Verwendung der ExecuTorch-Runtime konzipiert. Sie können nicht direkt mit YOLO() für die Inferenz in Python geladen werden. Du musst sie unter Verwendung der ExecuTorch-Runtime-Bibliotheken in deine Zielanwendung integrieren.

Welche Plattformen werden von ExecuTorch unterstützt?

ExecuTorch unterstützt:

• Mobile: iOS und Android
• Eingebettetes Linux: Raspberry Pi, NVIDIA Jetson und andere ARM-Geräte
• Desktop: Linux, macOS und Windows (für die Entwicklung)

Wie schneidet ExecuTorch im Vergleich zu TFLite für die mobile Bereitstellung ab?

Sowohl ExecuTorch als auch TFLite sind ausgezeichnet für die mobile Bereitstellung geeignet:

• ExecuTorch: Bessere PyTorch-Integration, nativer PyTorch-Workflow, wachsendes Ökosystem
• TFLite: Ausgereifter, breitere Hardware-Unterstützung, mehr Bereitstellungsbeispiele

Wähle ExecuTorch, wenn du bereits PyTorch verwendest und einen nativen Bereitstellungspfad möchtest. Wähle TFLite für maximale Kompatibilität und ausgereifte Tools.

Kann ich ExecuTorch-Modelle mit GPU-Beschleunigung verwenden?

Ja! ExecuTorch unterstützt Hardware-Beschleunigung über verschiedene Backends:

• Mobile GPU: Über Vulkan, Metal oder OpenCL Delegates
• NPU/DSP: Über plattformspezifische Delegates
• Standard: XNNPACK für optimierte CPU-Inferenz

Beziehe dich auf die ExecuTorch Dokumentation für die Backend-spezifische Einrichtung.