Stelle 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 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 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 in ExecuTorch exportieren?#

ExecuTorch ist die End-to-End-Lösung von PyTorch zur Ermöglichung von On-Device-Inferenzfunktionen auf Mobil- und Edge-Geräten. Mit dem Ziel entwickelt, portabel und effizient zu sein, kann ExecuTorch 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 Format .pte (PyTorch ExecuTorch), 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 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.

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

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 Familie, die diese Heads enthält.

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

Installation#

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

# Install Ultralytics package
pip install ultralytics

Detaillierte Anweisungen und Best Practices zum Installationsprozess findest du in unserer YOLO26-Installationsanleitung. Solltest du bei der Installation der erforderlichen Pakete für YOLO26 auf Schwierigkeiten stoßen, ziehe unsere Anleitung für häufige Probleme für Lösungen und Tipps heran.

Verwendung#

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 dann das exportierte Modell, um 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")

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/
├── model.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 mithilfe der ExecuTorch-Laufzeitumgebung in deine Zielanwendung integrieren.

Mobile 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 deiner Anwendung
3. Inferenz ausführen: Verarbeite Bilder und erhalte Vorhersagen

iOS#

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

Android#

Füge das ExecuTorch Android AAR von Maven Central hinzu:

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

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

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 Details zur Integration von ExecuTorch in deine Anwendungen findest du in der ExecuTorch Documentation.

Leistungsoptimierung#

Optimierung 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
• Geringere 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 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

Benchmarks#

Das Ultralytics-Team hat YOLO26-Modelle einem Benchmark 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. 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 vorgefertigte 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

Weitere Hilfe zur Fehlerbehebung findest du bei den Ultralytics GitHub Issues oder in der ExecuTorch Documentation.

Zusammenfassung#

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 mit dem Parameter format='executorch' einfach
• 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

FAQ#