Déployer YOLO11 sur les mobiles et la 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 environnement d'exécution 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, ce qui vous permet de déployer vos 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 activer les capacités d’inférence sur les appareils mobiles et périphériques. 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 informatiques.

Principales caractéristiques d'ExecuTorch

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

• Format de modèle portable: ExecuTorch utilise le .pte format (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 offre 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: Prise en charge intégrée des techniques de quantification pour réduire la taille du modèle et améliorer la vitesse d'inférence tout en maintenant la précision.

• Efficacité de la mémoire : Une gestion optimisée de la mémoire réduit l’empreinte mémoire d’exécution, ce qui la rend adaptée aux appareils dotés d’une RAM limitée.

• Métadonnées du modèle : Les modèles exportés incluent des métadonnées (taille de l'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 périphériques et mobiles :

• Applications mobiles : Déploiement sur les 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 : S'exécutent 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éployez sur du matériel d’IA en périphérie spécialisé avec des délégués personnalisés pour une inférence accélérée.

• Appareils IoT : Intégration dans des appareils IoT pour l'inférence sur l'appareil sans exigences de connectivité au cloud.

Exporter les modèles Ultralytics YOLO11 vers ExecuTorch

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

Installation

L'exportation ExecuTorch nécessite Python 3.10 ou une version ultérieure et des dépendances spécifiques :

# Install Ultralytics package
pip install ultralytics

Pour des instructions détaillées et les meilleures pratiques relatives au processus d'installation, consultez notre guide d'installation YOLO11. Si vous rencontrez des difficultés lors de l'installation des packages requis pour YOLO11, consultez notre guide des problèmes courants pour obtenir des solutions et des conseils.

Utilisation

L'exportation des modèles YOLO11 vers ExecuTorch est simple :

from ultralytics import YOLO

# Load the YOLO11 model
model = YOLO("yolo11n.pt")

# Export the model to ExecuTorch format
model.export(format="executorch")  # creates 'yolo11n_executorch_model' directory

executorch_model = YOLO("yolo11n_executorch_model")

results = executorch_model.predict("https://ultralytics.com/images/bus.jpg")

# Export a YOLO11n PyTorch model to ExecuTorch format
yolo export model=yolo11n.pt format=executorch # creates 'yolo11n_executorch_model' directory

# Run inference with the exported model
yolo predict model=yolo11n_executorch_model source=https://ultralytics.com/images/bus.jpg

Arguments d'exportation

Lors de l'exportation au format ExecuTorch, vous pouvez 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 :

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

Utilisation de modèles ExecuTorch exportés

Après avoir exporté votre modèle, vous devrez l’intégrer à votre application cible à l’aide du runtime ExecuTorch.

Intégration Mobile

Pour les applications mobiles (iOS/Android), vous devrez :

1. Ajouter l’environnement d’exécution ExecuTorch : Incluez la bibliothèque d’environnement d’exécution ExecuTorch dans votre projet mobile
2. Charger le modèle: Charger le .pte fichier dans votre application
3. Exécuter l’inférence : Traiter les images et obtenir 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/yolo11n.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/yolo11n.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, utilisez l'API ExecuTorch C++ :

#include <executorch/extension/module/module.h>

// Load model
auto module = torch::executor::Module("yolo11n.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 vos applications, consultez 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 : Commencez par YOLO11n (nano) pour l’empreinte la plus petite
• Résolution d'entrée inférieure: Utilisez des tailles d'image plus petites (par exemple, imgsz=320 ou imgsz=416)
• Quantification: Appliquer des techniques de quantification (prises en charge dans les futures versions d'ExecuTorch)

Optimisation de la vitesse d'Inference

Pour une inférence plus rapide :

• Backend XNNPACK : Le backend XNNPACK par défaut offre une inférence CPU optimisée
• Accélération Matérielle : Utiliser des délégués spécifiques à la plateforme (par exemple, CoreML pour iOS).
• Traitement par lots : Traitez plusieurs images lorsque cela est possible

Bancs d'essai

L'équipe Ultralytics a évalué les modèles YOLO11, 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 une version ultérieure. Mettez à niveau votre installation de python :

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

Problème: Export fails during first run

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

pip install --upgrade executorch

Problème: Import errors for ExecuTorch modules

Solution : Assurez-vous qu’ExecuTorch est correctement installé :

pip install executorch --force-reinstall

Pour obtenir de l'aide supplémentaire sur le dépannage, consultez les problèmes GitHub d'Ultralytics ou la documentation ExecuTorch.

Résumé

L'exportation des modèles YOLO11 au format ExecuTorch permet un déploiement efficace sur les appareils mobiles et périphériques. Grâce à l'intégration native de PyTorch, à la prise en charge multiplateforme et aux performances optimisées, ExecuTorch est un excellent choix pour les applications d'IA en périphérie.

Principaux points à retenir :

• ExecuTorch offre un déploiement périphérique natif PyTorch avec d'excellentes performances
• L'exportation est simple avec format='executorch' paramètre
• 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 YOLO11 au format ExecuTorch ?

Exporter un modèle YOLO11 vers ExecuTorch en utilisant Python ou CLI :

from ultralytics import YOLO

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

ou

yolo export model=yolo11n.pt format=executorch

Quelle est la configuration système requise pour l’exportation ExecuTorch ?

L'exportation ExecuTorch nécessite :

• Python 3.10 ou supérieur
• executorch package (installer 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 ?

Modèles ExecuTorch (.pte fichiers) sont conçus pour être déployés sur des appareils mobiles et périphériques à l'aide de l'environnement d'exécution ExecuTorch. Ils ne peuvent pas être chargés directement avec YOLO() pour l'inférence en python. Vous devez les intégrer à votre application cible à l'aide des bibliothèques d'exécution 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
• Bureau : 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 de PyTorch, flux de travail PyTorch natif, écosystème en croissance
• TFLite : Plus mature, prise en charge matérielle plus large, plus d’exemples de déploiement

Choisissez ExecuTorch si vous utilisez déjà PyTorch et que vous souhaitez un chemin de déploiement natif. Choisissez 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 l'inférence CPU optimisée

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

📅 Créé il y a 1 mois ✏️ Mis à jour il y a 25 jours

Commentaires