Link to this sectionStelle YOLO26 mit ExecuTorch auf Mobil- und Edge-Geräten bereit#

Die Bereitstellung von Computer-Vision-Modellen auf Edge-Geräten wie Smartphones, Tablets und eingebetteten Systemen erfordert eine optimierte Laufzeitumgebung, die Leistung mit Ressourcenbeschränkungen in Einklang bringt. 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.

Link to this sectionWarum in ExecuTorch exportieren?#

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

Link to this sectionHauptfunktionen 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, das hinsichtlich Größe und Ladegeschwindigkeit auf Geräten mit begrenzten Ressourcen optimiert ist.

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

• Quantisierung bereit: Das ExecuTorch-Ökosystem unterstützt Quantisierungstechniken, um die Modellgröße zu reduzieren und die Inferenzgeschwindigkeit zu verbessern; Ultralytics exportiert derzeit FP32-Modelle über das XNNPACK-Backend.

• Speichereffizienz: Optimierte Speicherverwaltung reduziert den Arbeitsspeicherbedarf zur Laufzeit und macht es für Geräte mit begrenztem RAM geeignet.

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

Link to this sectionBereitstellungsoptionen mit ExecuTorch#

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

• Mobile Anwendungen: Bereitstellung in 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 Delegaten für beschleunigte Inferenz.

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

Link to this sectionExportieren von Ultralytics YOLO26-Modellen nach ExecuTorch#

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

Link to this sectionInstallation#

Der ExecuTorch-Export erfordert Python 3.10-3.13 und PyTorch >= 2.9.0 zusammen mit dem executorch-Paket:

# Install Ultralytics package
pip install ultralytics

Für detaillierte Anweisungen und Best Practices zum Installationsprozess, siehe unseren YOLO26-Installationsleitfaden. Falls du bei der Installation der erforderlichen Pakete für YOLO26 auf Schwierigkeiten stößt, konsultiere unseren Leitfaden zu häufigen Problemen für Lösungen und Tipps.

Link to this sectionVerwendung#

Das Exportieren von YOLO26-Modellen nach ExecuTorch ist unkompliziert:

Das ExecuTorch-Format unterstützt die Modi Export, Predict und Validate. Exportiere dein Modell und lade es dann, um eine Inferenz auszuführen oder dessen 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")

Link to this sectionExport-Argumente#

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

Link to this sectionAusgabestruktur#

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

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

Link to this sectionVerwendung exportierter ExecuTorch-Modelle#

Nachdem du dein Modell exportiert hast, musst du es mithilfe der ExecuTorch-Laufzeitumgebung in deine Zielanwendung integrieren.

Link to this sectionMobile Integration#

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

1. ExecuTorch-Laufzeit hinzufügen: Füge die ExecuTorch-Laufzeitbibliothek zu deinem mobilen Projekt hinzu
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/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);

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

Link to this sectionEingebettetes 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.

Link to this sectionLeistungsoptimierung#

Link to this sectionOptimierung der Modellgröße#

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

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

Link to this sectionOptimierung der Inferenzgeschwindigkeit#

Für schnellere Inferenz:

• XNNPACK-Backend: Das Standard-XNNPACK-Backend bietet eine optimierte CPU-Inferenz
• Hardwarebeschleunigung: Verwende plattformspezifische Delegaten (z. B. CoreML für iOS)
• Batch-Verarbeitung: Verarbeite nach Möglichkeit mehrere Bilder gleichzeitig

Link to this sectionBenchmarks#

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

Link to this sectionFehlerbehebung#

Link to this sectionHäufige Probleme#

Problem: 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

Problem: Export fails during first run

Lösung: Stelle sicher, dass du das neueste vorkompilierte executorch-Wheel installiert hast:

pip install --upgrade executorch

Problem: 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.

Link to this sectionZusammenfassung#

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

Wichtige Punkte:

• ExecuTorch bietet eine native PyTorch-Edge-Bereitstellung mit hervorragender Leistung
• Der Export ist einfach mit dem Parameter format='executorch'
• Modelle werden für mobile CPUs über das XNNPACK-Backend optimiert
• Unterstützt iOS-, Android- und eingebettete Linux-Plattformen
• Erfordert Python 3.10-3.13 und PyTorch >= 2.9.0

Link to this sectionFAQ#

Link to this sectionWie exportiere ich ein YOLO26-Modell in das ExecuTorch-Format?#

Exportiere ein YOLO26-Modell nach ExecuTorch entweder über Python oder CLI:

from ultralytics import YOLO

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

oder

yolo export model=yolo26n.pt format=executorch

Link to this sectionWas sind die Systemvoraussetzungen 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: Das executorch-Paket enthält vorkompilierte Wheels (mit dem XNNPACK-Backend), sodass während des Exports kein zusätzlicher Kompilierungsschritt erforderlich ist.

Link to this sectionKann ich die Inferenz mit ExecuTorch-Modellen direkt in Python ausführen?#

ExecuTorch-Modelle können direkt mit YOLO() für Inferenz und Validierung in Python geladen werden (siehe die Predict-/Validate-Beispiele oben) und sie können auch auf Mobil- und Edge-Geräten mithilfe der ExecuTorch-Laufzeitbibliotheken bereitgestellt werden.

Link to this sectionWelche Plattformen werden von ExecuTorch unterstützt?#

ExecuTorch unterstützt:

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

Link to this sectionWie schneidet ExecuTorch im Vergleich zu TFLite für mobile Bereitstellungen ab?#

Sowohl ExecuTorch als auch TFLite sind hervorragend 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.

Link to this sectionKann ich ExecuTorch-Modelle mit GPU-Beschleunigung verwenden?#

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

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

Informationen zur Backend-spezifischen Einrichtung findest du in der ExecuTorch Documentation.