Link to this sectionDéploie YOLO26 sur mobile et edge avec ExecuTorch#

Le déploiement de modèles de vision par ordinateur sur des appareils edge comme les smartphones, tablettes et 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 décrit 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 des performances optimisées.

Link to this sectionPourquoi exporter vers ExecuTorch ?#

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

Link to this sectionFonctionnalité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 les 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é.

• Prêt pour la quantification : L'écosystème ExecuTorch prend en charge les techniques de quantification pour réduire la taille du modèle et améliorer la vitesse d'inférence ; Ultralytics exporte actuellement des modèles FP32 via le backend XNNPACK.

• Efficacité mémoire : Une gestion optimisée de la mémoire réduit l'empreinte mémoire à l'exécution, ce qui le rend 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 classes, etc.) dans un fichier YAML séparé pour une intégration facile.

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

Link to this sectionExporter des modèles Ultralytics YOLO26 vers ExecuTorch#

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

Link to this sectionInstallation#

L'exportation ExecuTorch nécessite Python 3.10-3.13 et PyTorch >= 2.9.0 avec le package executorch :

# 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. Lors de l'installation des packages requis pour YOLO26, si tu rencontres des difficultés, consulte notre guide des problèmes courants pour des solutions et astuces.

Link to this sectionUtilisation#

Exporter des modèles YOLO26 vers ExecuTorch est simple :

Le format ExecuTorch prend en charge les modes Export, Predict, et Validate. Exporte ton modèle, puis charge le modèle exporté pour exécuter l'inférence ou valider sa précision.

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 sectionArguments d'exportation#

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

Link to this sectionStructure de sortie#

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

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

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

Link to this sectionInté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/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);

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/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 sectionLinux embarqué#

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

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

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

Link to this sectionOptimisation des performances#

Link to this sectionOptimisation 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 réduite
• Réduire la résolution d'entrée : Utilise des tailles d'image plus petites (ex: imgsz=320 ou imgsz=416)
• Quantification : Applique des techniques de quantification (prises en charge dans les futures versions d'ExecuTorch)

Link to this sectionOptimisation 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 (ex: CoreML pour iOS)
• Traitement par lots : Traite plusieurs images lorsque cela est possible

Link to this sectionBenchmarks#

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

Link to this sectionDépannage#

Link to this sectionProblè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 : Assure-toi d'avoir la dernière roue executorch préconstruite installée :

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.

Link to this sectionRésumé#

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

Points clés à retenir :

• 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-3.13 et PyTorch >= 2.9.0

Link to this sectionFAQ#

Link to this sectionComment exporter un modèle YOLO26 au format ExecuTorch ?#

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

from ultralytics import YOLO

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

ou

yolo export model=yolo26n.pt format=executorch

Link to this sectionQuelles sont les configurations système requises 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)

Note : Le package executorch fournit des roues préconstruites (avec le backend XNNPACK), donc aucune étape de compilation supplémentaire n'est requise lors de l'exportation.

Link to this sectionPuis-je exécuter l'inférence avec des modèles ExecuTorch directement en Python ?#

Les modèles ExecuTorch peuvent être chargés directement avec YOLO() pour l'inférence et la validation en Python (vois les exemples Predict/Validate ci-dessus), et ils peuvent aussi être déployés sur des appareils mobiles et edge en utilisant les bibliothèques du runtime ExecuTorch.

Link to this sectionQuelles plateformes sont prises en charge par ExecuTorch ?#

ExecuTorch prend en charge :

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

Link to this sectionComment 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, davantage 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.

Link to this sectionPuis-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 :

• Mobile GPU : Via des 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

Consulte la documentation ExecuTorch pour la configuration spécifique au backend.