Déploie YOLO26 sur mobile et edge avec ExecuTorch

Le déploiement de modèles de vision par ordinateur sur des appareils edge tels que des smartphones, des tablettes et des systèmes embarqués nécessite un runtime optimisé qui équilibre performance et contraintes de ressources. ExecuTorch, la solution de PyTorch pour l'edge computing, permet une inférence efficace sur appareil pour les modèles Ultralytics YOLO.

Ce guide explique comment exporter des modèles Ultralytics YOLO au format ExecuTorch, te permettant de déployer tes modèles sur des appareils mobiles et edge avec une performance optimisée.

Pourquoi exporter vers ExecuTorch ?

ExecuTorch est la solution de bout en bout de PyTorch pour activer des capacités d'inférence sur appareil à travers les appareils mobiles et edge. Conçu dans le but d'être portable et efficace, ExecuTorch peut être utilisé pour exécuter des programmes PyTorch sur une grande variété de plateformes de calcul.

Fonctionnalités clés d'ExecuTorch

ExecuTorch fournit plusieurs fonctionnalités puissantes pour le déploiement de modèles Ultralytics YOLO sur des appareils edge :

• Format de modèle portable : ExecuTorch utilise le format .pte (PyTorch ExecuTorch), qui est optimisé pour la taille et la vitesse de chargement sur des appareils aux ressources limitées.

• Backend XNNPACK : L'intégration par défaut avec XNNPACK fournit une inférence hautement optimisée sur les CPU mobiles, offrant d'excellentes performances sans nécessiter de matériel spécialisé.

• Prise en charge de la quantification : Support intégré pour les techniques de quantification afin de réduire la taille du modèle et améliorer la vitesse d'inférence tout en maintenant la précision.

• Efficacité mémoire : La gestion optimisée de la mémoire réduit l'empreinte mémoire à l'exécution, le rendant adapté aux appareils avec une RAM limitée.

• Métadonnées du modèle : Les modèles exportés incluent des métadonnées (taille d'image, noms de classe, etc.) dans un fichier YAML séparé pour une intégration facile.

Options de déploiement avec ExecuTorch

Les modèles ExecuTorch peuvent être déployés sur diverses plateformes edge et mobiles :

• Applications mobiles : Déploie sur des applications iOS et Android avec des performances natives, permettant la détection d'objets en temps réel dans les applications mobiles.

• Systèmes embarqués : Exécute sur des appareils Linux embarqués comme Raspberry Pi, NVIDIA Jetson et d'autres systèmes basés sur ARM avec des performances optimisées.

• Appareils Edge AI : Déploie sur du matériel Edge AI spécialisé avec des délégués personnalisés pour une inférence accélérée.

• Appareils IoT : Intègre dans des appareils IoT pour une inférence sur appareil sans exigences de connectivité cloud.

Exporter des modèles Ultralytics YOLO26 vers ExecuTorch

Convertir des modèles Ultralytics YOLO26 au format ExecuTorch permet un déploiement efficace sur les appareils mobiles et edge.

Installation

L'exportation vers ExecuTorch nécessite Python 3.10 ou supérieur et des dépendances spécifiques :

# Install Ultralytics package
pip install ultralytics

Pour des instructions détaillées et les meilleures pratiques liées au processus d'installation, consulte notre guide d'installation YOLO26. Si tu rencontres des difficultés lors de l'installation des packages nécessaires pour YOLO26, consulte notre guide des problèmes courants pour des solutions et des astuces.

Utilisation

Exporter des modèles YOLO26 vers ExecuTorch est simple :

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

Arguments d'exportation

Lors de l'exportation vers le format ExecuTorch, tu peux spécifier les arguments suivants :

Structure de sortie

L'exportation ExecuTorch crée un répertoire contenant le modèle et les métadonnées :

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

Utiliser des modèles ExecuTorch exportés

Après avoir exporté ton modèle, tu devras l'intégrer dans ton application cible en utilisant le runtime ExecuTorch.

Intégration mobile

Pour les applications mobiles (iOS/Android), tu devras :

1. Ajouter le runtime ExecuTorch : Inclus la bibliothèque du runtime ExecuTorch dans ton projet mobile
2. Charger le modèle : Charge le fichier .pte dans ton application
3. Exécuter l'inférence : Traite les images et obtiens des prédictions

Exemple d'intégration 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/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);

Exemple d'intégration 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/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

Linux embarqué

Pour les systèmes Linux embarqués, utilise l'API C++ d'ExecuTorch :

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

Pour plus de détails sur l'intégration d'ExecuTorch dans tes applications, visite la documentation ExecuTorch.

Optimisation des performances

Optimisation de la taille du modèle

Pour réduire la taille du modèle pour le déploiement :

• Utiliser des modèles plus petits : Commence avec YOLO26n (nano) pour l'empreinte la plus faible
• Réduire la résolution d'entrée : Utilise des tailles d'image plus petites (par ex., imgsz=320 ou imgsz=416)
• Quantification : Applique des techniques de quantification (prises en charge dans les futures versions d'ExecuTorch)

Optimisation de la vitesse d'inférence

Pour une inférence plus rapide :

• Backend XNNPACK : Le backend XNNPACK par défaut fournit une inférence CPU optimisée
• Accélération matérielle : Utilise des délégués spécifiques à la plateforme (par ex., CoreML pour iOS)
• Traitement par lots : Traite plusieurs images si possible

Benchmarks

L'équipe Ultralytics a évalué les modèles YOLO26, en comparant la vitesse et la précision entre PyTorch et ExecuTorch.

Dépannage

Problèmes courants

Issue: Python version error

Solution : ExecuTorch nécessite Python 3.10 ou supérieur. Mets à jour ton installation Python :

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

Issue: Export fails during first run

Solution : ExecuTorch peut avoir besoin de télécharger et compiler des composants lors de la première utilisation. Assure-toi d'avoir :

pip install --upgrade executorch

Issue: Import errors for ExecuTorch modules

Solution : Assure-toi qu'ExecuTorch est correctement installé :

pip install executorch --force-reinstall

Pour plus d'aide au dépannage, visite les problèmes GitHub d'Ultralytics ou la documentation ExecuTorch.

Résumé

Exporter des modèles YOLO26 au format ExecuTorch permet un déploiement efficace sur les appareils mobiles et edge. Avec l'intégration native PyTorch, le support multiplateforme et des performances optimisées, ExecuTorch est un excellent choix pour les applications d'Edge AI.

Points clés :

• ExecuTorch fournit un déploiement edge natif PyTorch avec d'excellentes performances
• L'exportation est simple avec le paramètre format='executorch'
• Les modèles sont optimisés pour les CPU mobiles via le backend XNNPACK
• Prend en charge les plateformes iOS, Android et Linux embarqué
• Nécessite Python 3.10+ et le compilateur FlatBuffers

FAQ

Comment exporter un modèle YOLO26 au format ExecuTorch ?

Exporte un modèle YOLO26 vers ExecuTorch en utilisant Python ou la CLI :

from ultralytics import YOLO

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

ou

yolo export model=yolo26n.pt format=executorch

Quelles sont les exigences système pour l'exportation ExecuTorch ?

L'exportation ExecuTorch nécessite :

• Python 3.10 ou supérieur
• Le package executorch (installe via pip install executorch)
• PyTorch (installé automatiquement avec ultralytics)

Remarque : Lors de la première exportation, ExecuTorch téléchargera et compilera automatiquement les composants nécessaires, y compris le compilateur FlatBuffers.

Puis-je exécuter l'inférence avec des modèles ExecuTorch directement en Python ?

Les modèles ExecuTorch (fichiers .pte) sont conçus pour être déployés sur des appareils mobiles et edge en utilisant le runtime ExecuTorch. Ils ne peuvent pas être directement chargés avec YOLO() pour l'inférence en Python. Tu dois les intégrer dans ton application cible en utilisant les bibliothèques du runtime ExecuTorch.

Quelles plateformes sont prises en charge par ExecuTorch ?

ExecuTorch prend en charge :

• Mobile : iOS et Android
• Linux embarqué : Raspberry Pi, NVIDIA Jetson et autres appareils ARM
• Desktop : Linux, macOS et Windows (pour le développement)

Comment ExecuTorch se compare-t-il à TFLite pour le déploiement mobile ?

ExecuTorch et TFLite sont tous deux excellents pour le déploiement mobile :

• ExecuTorch : Meilleure intégration PyTorch, flux de travail PyTorch natif, écosystème en croissance
• TFLite : Plus mature, support matériel plus large, plus d'exemples de déploiement

Choisis ExecuTorch si tu utilises déjà PyTorch et que tu souhaites un chemin de déploiement natif. Choisis TFLite pour une compatibilité maximale et des outils matures.

Puis-je utiliser des modèles ExecuTorch avec accélération GPU ?

Oui ! ExecuTorch prend en charge l'accélération matérielle via divers backends :

• GPU mobile : Via les délégués Vulkan, Metal ou OpenCL
• NPU/DSP : Via des délégués spécifiques à la plateforme
• Par défaut : XNNPACK pour une inférence CPU optimisée

Référe-toi à la documentation ExecuTorch pour la configuration spécifique au backend.