Déploie YOLO26 sur mobile et en périphérie avec ExecuTorch#

Le déploiement de modèles de vision par ordinateur sur des appareils périphériques tels que les smartphones, les tablettes et les systèmes embarqués nécessite un runtime optimisé qui équilibre les performances et les 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 explique comment exporter les modèles Ultralytics YOLO au format ExecuTorch, afin de te permettre de déployer tes modèles sur des appareils mobiles et périphériques avec des performances optimisées.

Pourquoi exporter vers ExecuTorch ?#

ExecuTorch est la solution de bout en bout de PyTorch pour permettre l’inférence sur l’appareil sur les appareils mobiles et périphériques. Conçu pour être portable et efficace, ExecuTorch peut être utilisé pour exécuter des programmes PyTorch sur une grande variété de plateformes informatiques.

Fonctionnalités clés d’ExecuTorch#

ExecuTorch offre plusieurs fonctionnalités puissantes pour déployer les modèles Ultralytics YOLO sur des appareils périphériques :

• Format de modèle portable : ExecuTorch utilise le format .pte (PyTorch ExecuTorch), optimisé pour la taille et la vitesse de chargement sur les appareils soumis à des contraintes de ressources.

• Backend XNNPACK : l’intégration par défaut de XNNPACK fournit une inférence hautement optimisée sur les CPU mobiles, avec 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 des modèles et améliorer la vitesse d’inférence ; Ultralytics exporte actuellement des modèles FP32 via le backend XNNPACK.

• Efficacité mémoire : la gestion optimisée de la mémoire réduit l’empreinte mémoire à l’exécution, ce qui convient aux appareils disposant d’une RAM limitée.

• Métadonnées des modèles : les modèles exportés incluent les métadonnées (taille des images, noms des classes, etc.) dans un fichier YAML distinct pour faciliter l’intégration.

Options de déploiement avec ExecuTorch#

Les modèles ExecuTorch peuvent être déployés sur différentes plateformes mobiles et périphériques :

• Applications mobiles : déploie-les dans des applications iOS et Android avec des performances natives, afin de permettre la détection d’objets en temps réel dans les applications mobiles.

• Systèmes embarqués : exécute-les sur des appareils Linux embarqués tels que Raspberry Pi, NVIDIA Jetson et d’autres systèmes basés sur ARM, avec des performances optimisées.

• Appareils d’IA en périphérie : déploie-les sur du matériel spécialisé d’IA en périphérie avec des délégués personnalisés pour accélérer l’inférence.

• Appareils IoT : intègre-les à des appareils IoT pour effectuer l’inférence sur l’appareil sans nécessiter de connexion au cloud.

Tâches prises en charge#

L’export ExecuTorch prend en charge les sept tâches Ultralytics. La segmentation sémantique et l’estimation de profondeur sont disponibles uniquement avec YOLO26, la seule famille à fournir ces têtes.

Exporter les modèles Ultralytics YOLO26 vers ExecuTorch#

La conversion des modèles Ultralytics YOLO26 au format ExecuTorch permet un déploiement efficace sur les appareils mobiles et périphériques.

Installation#

L’export ExecuTorch nécessite Python 3.10-3.13 et PyTorch >= 2.9.0, ainsi que le package executorch :

# Install Ultralytics package
pip install ultralytics

Pour obtenir des instructions détaillées et connaître les bonnes pratiques liées au processus d’installation, consulte notre guide d’installation de YOLO26. Si tu rencontres des difficultés lors de l’installation des packages requis pour YOLO26, consulte notre guide des problèmes courants pour trouver des solutions et des conseils.

Utilisation#

L’export 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’export au format ExecuTorch, tu peux spécifier les arguments suivants :

Structure de sortie#

L’export 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 les modèles ExecuTorch exportés#

Après avoir exporté ton modèle, tu devras l’intégrer à ton application cible à l’aide du runtime ExecuTorch.

Intégration mobile#

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

1. Ajouter le runtime ExecuTorch : inclure la bibliothèque du runtime ExecuTorch dans ton projet mobile
2. Charger le modèle : charger le fichier .pte dans ton application
3. Exécuter l’inférence : traiter les images et obtenir les 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 l’AAR Android ExecuTorch 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, consulte la documentation d’ExecuTorch.

Optimisation des performances#

Optimisation de la taille des modèles#

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

• Utiliser des modèles plus petits : commence avec YOLO26n (nano) pour obtenir l’empreinte la plus réduite
• Réduire la résolution d’entrée : utilise des tailles d’image plus petites (par exemple, imgsz=320 ou imgsz=416)
• Quantification : applique des techniques de quantification (prises en charge dans les prochaines versions d’ExecuTorch)

Optimisation de la vitesse d’inférence#

Pour accélérer l’inférence :

• 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 exemple, CoreML pour iOS)
• Traitement par lots : traite plusieurs images lorsque cela est possible

Benchmarks#

L’équipe Ultralytics a évalué les performances des 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 requiert Python 3.10 à 3.13. Crée un environnement avec une version prise en charge :

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

Problème : Export fails during first run

Solution : vérifie que la dernière wheel précompilée executorch est installée :

pip install --upgrade executorch

Problème : Import errors for ExecuTorch modules

Solution : vérifie qu’ExecuTorch est correctement installé :

pip install executorch --force-reinstall

Pour obtenir davantage d’aide concernant le dépannage, consulte les problèmes Ultralytics sur GitHub ou la documentation d’ExecuTorch.

Résumé#

L’export des modèles YOLO26 au format ExecuTorch permet un déploiement efficace sur les appareils mobiles et périphériques. Grâce à son intégration native à PyTorch, à sa prise en charge multiplateforme et à ses performances optimisées, ExecuTorch constitue un excellent choix pour les applications d’IA en périphérie.

Points clés à retenir :

• ExecuTorch fournit un déploiement en périphérie natif de PyTorch avec d’excellentes performances
• L’export 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#