Einsatz von YOLO11 auf Mobile & Edge mit ExecuTorch

Der Einsatz von Computer-Vision-Modellen auf Endgeräten wie Smartphones, Tablets und eingebetteten Systemen erfordert eine optimierte Laufzeit, die Leistung und Ressourcenbeschränkungen 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.

In diesem Leitfaden wird beschrieben, wie Ultralytics YOLO in das ExecuTorch-Format exportiert werden, damit Sie Ihre Modelle mit optimierter Leistung auf mobilen und Edge-Geräten einsetzen können.

Warum in ExecuTorch exportieren?

ExecuTorch ist die End-to-End-Lösung von PyTorch für die Ermöglichung von Inferenzfunktionen auf mobilen Geräten und Edge-Geräten. ExecuTorch wurde mit dem Ziel entwickelt, portabel und effizient zu sein und kann verwendet werden, um PyTorch auf einer Vielzahl von Computerplattformen auszuführen.

Hauptmerkmale von ExecuTorch

ExecuTorch bietet mehrere leistungsstarke Funktionen für den Einsatz von Ultralytics YOLO auf Edge-Geräten:

• Portable Model Format: 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 hoch optimierte Inferenz auf mobilen CPUs und liefert eine hervorragende Leistung, ohne dass spezielle Hardware erforderlich ist.

• Quantisierungsunterstützung: Integrierte Unterstützung für Quantisierungstechniken zur Verringerung der Modellgröße und zur Verbesserung der Schlussfolgerungsgeschwindigkeit bei gleichbleibender Genauigkeit.

• Speichereffizienz: Die optimierte Speicherverwaltung reduziert den Speicherbedarf zur Laufzeit und eignet sich daher für Geräte mit begrenztem RAM.

• Modell-Metadaten: Exportierte Modelle enthalten Metadaten (Bildgröße, Klassennamen, etc.) in einer separaten YAML-Datei zur einfachen Integration.

Bereitstellungsoptionen mit ExecuTorch

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

• Mobile Anwendungen: Einsatz in iOS und Android mit nativer Leistung, die Objekterkennung in Echtzeit in mobilen Anwendungen 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-KI-Geräte: Einsatz auf spezieller Edge-KI-Hardware mit benutzerdefinierten Delegierten für beschleunigte Inferenz.

• IoT-Geräte: Integration in IoT-Geräte für geräteinterne Inferenzen ohne Anforderungen an die Cloud-Konnektivität.

Exportieren von Ultralytics YOLO11 nach ExecuTorch

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

Installation

Der ExecuTorch-Export erfordert Python 3.10 oder höher und bestimmte 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 nach ExecuTorch ist sehr einfach:

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 Exportieren in das ExecuTorch-Format können Sie die folgenden Argumente angeben:

Struktur der Ausgabe

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.)

Exportierte ExecuTorch-Modelle verwenden

Nachdem Sie Ihr Modell exportiert haben, müssen Sie es mit Hilfe der ExecuTorch-Laufzeitumgebung in Ihre Zielanwendung integrieren.

Mobile Integration

Für mobile AnwendungeniOSAndroid) müssen Sie das tun:

1. ExecuTorch Runtime hinzufügen: Binden Sie die ExecuTorch-Laufzeitbibliothek in Ihr mobiles Projekt ein
2. Lastmodell: Laden Sie die .pte Datei in Ihrer Anwendung
3. Inferenz ausführen: Bilder verarbeiten und Vorhersagen erhalten

Beispiel iOS (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 Android (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

Eingebettetes 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});

Weitere Details zur Integration von ExecuTorch in Ihre Anwendungen finden Sie in der ExecuTorch Dokumentation.

Optimierung der Leistung

Optimierung der Modellgröße

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

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

Optimierung der Inferenzgeschwindigkeit

Für schnellere Schlussfolgerungen:

• XNNPACK-Backend: Das Standard-XNNPACK-Backend bietet optimierte CPU
• Hardware-Beschleunigung: Plattformspezifische Delegierte verwenden (z. B. CoreML für iOS)
• Stapelverarbeitung: Wenn möglich, mehrere Bilder verarbeiten

Benchmarks

Das Ultralytics hat YOLO11 einem Benchmarking unterzogen und dabei Geschwindigkeit und Genauigkeit von PyTorch und ExecuTorch verglichen.

Fehlerbehebung

Häufige Probleme

Problem: Python version error

Lösung: ExecuTorch benötigt Python 3.10 oder höher. Aktualisieren Sie Ihre Python :

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

Problem: Export fails during first run

Lösung: ExecuTorch muss bei der ersten Verwendung möglicherweise Komponenten herunterladen und kompilieren. Stellen Sie sicher, dass Sie über:

```bash
pip install --upgrade executorch
```

Problem: Import errors for ExecuTorch modules

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

```bash
pip install executorch --force-reinstall
```

Weitere Hilfe zur Fehlerbehebung finden Sie in den Ultralytics GitHub Issues oder in der ExecuTorch-Dokumentation.

Zusammenfassung

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

Die wichtigsten Erkenntnisse:

• ExecuTorch bietet einen PyTorch Edge-Einsatz mit hervorragender Leistung
• Der Export ist einfach mit format='executorch' Parameter
• Modelle werden über XNNPACK-Backend für mobile CPUs optimiert
• Unterstützt iOS, Android und eingebettete Linux-Plattformen
• Benötigt Python 3.10+ und FlatBuffers Compiler

FAQ

Wie exportiere ich ein YOLO11 in das ExecuTorch-Format?

Exportieren Sie ein YOLO11 nach ExecuTorch entweder mit Python oder CLI:

```python
from ultralytics import YOLO
model = YOLO("yolo11n.pt")
model.export(format="executorch")
```

oder

```bash
yolo export model=yolo11n.pt format=executorch
```

Was sind die Systemanforderungen für ExecuTorch Export?

ExecuTorch-Export erforderlich:

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

Hinweis: Während des ersten Exports wird ExecuTorch die notwendigen Komponenten einschließlich des FlatBuffers-Compilers automatisch herunterladen und kompilieren.

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

ExecuTorch-Modelle (.pte Dateien) sind für den Einsatz auf mobilen und Edge-Geräten unter Verwendung der ExecuTorch-Laufzeit konzipiert. Sie können nicht direkt geladen werden mit YOLO() für die Inferenz in Python. Sie müssen sie mit Hilfe der ExecuTorch-Laufzeitbibliotheken in Ihre Zielanwendung integrieren.

Welche Plattformen werden von ExecuTorch unterstützt?

ExecuTorch unterstützt:

• Mobil: 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 beim mobilen Einsatz ab?

Sowohl ExecuTorch als auch TFLite eignen sich hervorragend für den mobilen Einsatz:

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

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

Kann ich ExecuTorch-Modelle mit GPU verwenden?

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

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

Siehe die ExecuTorch-Dokumentation für die Backend-spezifische Einrichtung.

📅 Erstellt vor 0 Tagen ✏️ Aktualisiert vor 0 Tagen

Kommentare