YOLO11 auf Mobilgeräten und Edge-Geräten mit ExecuTorch bereitstellen

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

Dieser Leitfaden beschreibt, wie Ultralytics YOLO-Modelle in das ExecuTorch-Format exportiert werden, wodurch Sie Ihre Modelle mit optimierter Leistung auf mobilen und Edge-Geräten bereitstellen können.

Warum nach ExecuTorch exportieren?

ExecuTorch ist die End-to-End-Lösung von PyTorch, um On-Device-Inferenzfunktionen auf mobilen Geräten 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.

Hauptmerkmale von ExecuTorch

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

• Portables Modellformat: ExecuTorch verwendet die .pte (PyTorch ExecuTorch)-Format, das 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, die hervorragende Leistung liefert, ohne spezielle Hardware zu benötigen.

• Quantisierungsunterstützung: Integrierte Unterstützung für Quantisierungstechniken zur Reduzierung der Modellgröße und Verbesserung der Inferenzgeschwindigkeit bei gleichzeitiger Beibehaltung der Genauigkeit.

• Speichereffizienz: Optimiertes Speichermanagement reduziert den Laufzeit-Speicherbedarf, wodurch es für Geräte mit begrenztem RAM geeignet ist.

• Modellmetadaten: Exportierte Modelle enthalten Metadaten (Bildgröße, Klassennamen usw.) in einer separaten yaml-Datei zur einfachen Integration.

Bereitstellungsoptionen mit ExecuTorch

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

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

• Eingebettete Systeme: Laufen 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 Delegaten für beschleunigte Inferenz.

• IoT-Geräte: Integration in IoT-Geräte für die Inferenz auf dem Gerät ohne Cloud-Konnektivitätsanforderungen.

Export von Ultralytics YOLO11-Modellen nach ExecuTorch

Die Konvertierung von Ultralytics YOLO11-Modellen in das ExecuTorch-Format ermöglicht eine effiziente Bereitstellung auf mobilen Geräten 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

Detaillierte Anweisungen und Best Practices zum Installationsprozess finden Sie in unserem YOLO11 Installationshandbuch. Wenn Sie bei der Installation der erforderlichen Pakete für YOLO11 auf Schwierigkeiten stoßen, konsultieren Sie unseren Leitfaden zu häufigen Problemen für Lösungen und Tipps.

Nutzung

Der Export von YOLO11-Modellen nach ExecuTorch ist unkompliziert:

from ultralytics import YOLO

# Load the YOLO11 model
model = YOLO("yolo11n.pt")

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

executorch_model = YOLO("yolo11n_executorch_model")

results = executorch_model.predict("https://ultralytics.com/images/bus.jpg")

# Export a YOLO11n PyTorch model to ExecuTorch format
yolo export model=yolo11n.pt format=executorch # creates 'yolo11n_executorch_model' directory

# Run inference with the exported model
yolo predict model=yolo11n_executorch_model source=https://ultralytics.com/images/bus.jpg

Export-Argumente

Beim Export in das ExecuTorch-Format können Sie die folgenden Argumente angeben:

Ausgabestruktur

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

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

Verwenden exportierter ExecuTorch-Modelle

Nach dem Export Ihres Modells müssen Sie es mithilfe der ExecuTorch-Laufzeitumgebung in Ihre Zielanwendung integrieren.

Mobile Integration

Für mobile Anwendungen (iOS/Android) müssen Sie:

1. ExecuTorch Runtime hinzufügen: Fügen Sie die ExecuTorch Runtime-Bibliothek in Ihr mobiles Projekt ein
2. Modell laden: Lade die .pte Datei in Ihrer Anwendung
3. Inferenz ausführen: Bilder verarbeiten und Vorhersagen erhalten

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/yolo11n.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/yolo11n.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

Embedded Linux

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

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

// Load model
auto module = torch::executor::Module("yolo11n.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});

Für weitere Details zur Integration von ExecuTorch in Ihre Anwendungen besuchen Sie die ExecuTorch-Dokumentation.

Leistungsoptimierung

Optimierung der Modellgröße

Zur Reduzierung der Modellgröße für die Bereitstellung:

• Kleinere Modelle verwenden: Beginnen Sie mit YOLO11n (nano) für den kleinsten Speicherbedarf.
• Niedrigere Eingangsauflösung: Verwenden Sie kleinere Bildgrößen (z. B. imgsz=320 oder imgsz=416)
• Quantisierung: Quantisierungstechniken anwenden (in zukünftigen ExecuTorch-Versionen unterstützt)

Optimierung der Inferenzgeschwindigkeit

Für eine schnellere Inferenz:

• XNNPACK Backend: Das standardmäßige XNNPACK-Backend bietet optimierte CPU-Inferenz
• Hardware-Beschleunigung: Verwenden Sie plattformspezifische Delegaten (z. B. CoreML für iOS).
• Batch-Verarbeitung: Verarbeiten Sie nach Möglichkeit mehrere Bilder

Benchmarks

Das Ultralytics-Team hat YOLO11-Modelle einem Benchmarking unterzogen 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 oder höher. Aktualisieren Sie Ihre python-Installation:

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

Problem: Export fails during first run

Lösung: ExecuTorch muss möglicherweise beim ersten Gebrauch Komponenten herunterladen und kompilieren. Stellen Sie sicher, dass Sie Folgendes haben:

pip install --upgrade executorch

Problem: Import errors for ExecuTorch modules

Lösung: Stellen Sie sicher, dass ExecuTorch korrekt installiert ist:

pip install executorch --force-reinstall

Für weitere Hilfe bei der Fehlerbehebung besuchen Sie die Ultralytics GitHub Issues oder die ExecuTorch Dokumentation.

Zusammenfassung

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

Wichtige Erkenntnisse:

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

FAQ

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

Ein YOLO11-Modell mit Python oder CLI nach ExecuTorch exportieren:

from ultralytics import YOLO

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

oder

yolo export model=yolo11n.pt format=executorch

Welche Systemanforderungen gelten für den ExecuTorch-Export?

Der ExecuTorch-Export erfordert:

• Python 3.10 oder höher
• executorch Paket (Installation über pip install executorch)
• PyTorch (wird automatisch mit Ultralytics installiert)

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

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

ExecuTorch-Modelle (.pte Dateien) sind für die Bereitstellung auf mobilen und Edge-Geräten unter Verwendung der ExecuTorch-Laufzeitumgebung konzipiert. Sie können nicht direkt mit YOLO() für die Inferenz in Python. Sie müssen diese mithilfe der ExecuTorch-Laufzeitbibliotheken in Ihre Zielanwendung integrieren.

Welche Plattformen werden von ExecuTorch unterstützt?

ExecuTorch unterstützt:

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

Wie vergleicht sich ExecuTorch mit TFLite für die mobile Bereitstellung?

Sowohl ExecuTorch als auch TFLite eignen sich hervorragend für die mobile Bereitstellung:

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

Wählen Sie ExecuTorch, wenn Sie bereits PyTorch verwenden und einen nativen Deployment-Pfad wünschen. Wählen Sie TFLite für maximale Kompatibilität und ausgereifte Tools.

Kann ich ExecuTorch-Modelle mit GPU-Beschleunigung verwenden?

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

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

Beachten Sie die ExecuTorch-Dokumentation für die Backend-spezifische Einrichtung.

📅 Erstellt vor 1 Monat ✏️ Aktualisiert vor 29 Tagen

Kommentare