Déploie YOLO26 sur mobile et edge avec ExecuTorch#

Le déploiement de modèles de vision par ordinateur sur des appareils de périphérie tels que les smartphones, les tablettes et les systèmes embarqués nécessite un environnement d'exécution optimisé qui équilibre performance et contraintes de ressources. ExecuTorch, la solution de PyTorch pour l'informatique en périphérie, permet une inférence efficace sur l'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.

Pourquoi exporter vers ExecuTorch ?#

ExecuTorch est la solution de bout en bout de PyTorch pour activer des capacités d'inférence sur l'appareil sur les appareils mobiles et de périphérie. Conçu dans un objectif de portabilité et d'efficacité, 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 les appareils aux ressources contraintes.

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

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.

Tâches prises en charge#

L'export ExecuTorch prend en charge les sept tâches d'Ultralytics. La segmentation sémantique et l'estimation de la profondeur ne sont disponibles qu'avec YOLO26, la seule famille qui intègre ces têtes.

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

Installation#

L'exportation ExecuTorch nécessite Python 3.10-3.13 et PyTorch >= 2.9.0 ainsi que le paquet executorch :

# Install Ultralytics package
pip install ultralytics

Pour des instructions détaillées et les meilleures pratiques concernant le processus d'installation, consulte notre YOLO26 Installation guide. Si tu rencontres des difficultés lors de l'installation des packages requis pour YOLO26, consulte notre Common Issues guide pour trouver des solutions et des astuces.

Utilisation#

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

Arguments d'exportation#

Lors de l'exportation au 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/
├── model.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

iOS#

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

Android#

Ajoute ExecuTorch Android AAR depuis Maven Central :

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

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

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

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 réduite
• Résolution d'entrée inférieure : 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 (ex: CoreML pour iOS)
• Traitement par lots : Traite plusieurs images lorsque cela est 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#

Problème : 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

Problème : Export fails during first run

Solution : Assure-toi d'avoir installé le dernier wheel précompilé executorch :

pip install --upgrade executorch

Problème : 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 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

FAQ#