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 temps d'exécution optimisé qui concilie les performances et les contraintes de ressources. ExecuTorch, la solution de PyTorch pour l'informatique périphérique, permet une inférence efficace sur l'appareil pour les modèles de vision artificielle. Ultralytics YOLO d'Ultralytics.

Ce guide explique comment exporter les modèlesYOLO d'Ultralytics 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 permettre des 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 fonctions puissantes pour déployer les modèlesYOLO d'Ultralytics sur les appareils périphériques :

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

• XNNPACK Backend: L'intégration par défaut avec XNNPACK permet une inférence hautement optimisée sur les processeurs 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: La gestion optimisée de la mémoire réduit l'encombrement de la mémoire d'exécution, ce qui permet de l'utiliser sur des appareils dotés d'une mémoire vive limitée.

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

• Applications mobiles: Déployez 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: Exécutez 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.

• Dispositifs d'IA de pointe: Déploiement sur du matériel d'IA de pointe spécialisé avec des délégués personnalisés pour une inférence accélérée.

• Appareils IoT: Intégration dans les appareils IoT pour une inférence sur l'appareil sans nécessiter de connectivité dans le nuage.

Exportation des modèlesYOLO11 d'Ultralytics vers ExecuTorch

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

Installation

L'exportation d'ExecuTorch nécessite Python 3.10 ou plus 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 des modèles ExecuTorch exportés

Après avoir exporté votre modèle, vous devrez l'intégrer dans votre application cible à l'aide du moteur d'exécution ExecuTorch.

Intégration mobile

Pour les applications mobilesiOSAndroidiOS, vous devrez :

1. Ajouter la bibliothèque d'exécution ExecuTorch: Inclure la bibliothèque d'exécution ExecuTorch dans votre projet mobile.
2. Modèle de charge: Charger le .pte 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 C++ d'ExecuTorch :

#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 d'ExecuTorch.

Optimisation des performances

Optimisation de la taille du modèle

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

• Utiliser des modèles plus petits: Commencez par YOLO11n (nano) pour un encombrement minimal.
• Résolution d'entrée inférieure: Utilisez des images de plus petite taille (par ex, 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'inférence

Pour une inférence plus rapide :

• XNNPACK Backend: Le backend XNNPACK par défaut fournit 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: Traiter plusieurs images lorsque cela est possible

Bancs d'essai

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

Dépannage

Problèmes courants

Problème: Python version error

Solution: ExecuTorch nécessite Python 3.10 ou une version plus récente. Mettez à jour votre installation de Python :

```bash
# 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 :

```bash
pip install --upgrade executorch
```

Problème: Import errors for ExecuTorch modules

Solution: Assurez-vous que ExecuTorch est correctement installé :

```bash
pip install executorch --force-reinstall
```

Pour plus d'aide au dépannage, visitez le site Ultralytics GitHub Issues 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 PyTorch, à la prise en charge multiplateforme et aux performances optimisées, ExecuTorch est un excellent choix pour les applications d'IA périphérique.

Principaux enseignements :

• ExecuTorch permet un déploiement périphérique 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.
• Prise en charge des plateformes iOS, Android et Linux embarquées
• Requiert 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:

```python
from ultralytics import YOLO
model = YOLO("yolo11n.pt")
model.export(format="executorch")
```

ou

```bash
yolo export model=yolo11n.pt format=executorch
```

Quelle est la configuration requise pour ExecuTorch export ?

L'exportation d'ExecuTorch nécessite :

• Python 3.10 ou supérieur
• executorch (à installer via pip install executorch)
• PyTorch (installé automatiquement avec ultralytics)

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

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

Modèles ExecuTorch (.pte ) sont conçus pour être déployés sur des appareils mobiles et périphériques utilisant le moteur 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 dans votre application cible en utilisant les bibliothèques d'exécution ExecuTorch.

Quelles sont les plates-formes 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 un déploiement mobile :

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

Choisissez ExecuTorch si vous utilisez déjà PyTorch et souhaitez un chemin de déploiement natif. Choisissez TFLite pour une compatibilité maximale et un outillage mature.

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

Oui ! ExecuTorch prend en charge l'accélération matérielle par le biais de différents backends :

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

Se reporter à la documentation ExecuTorch pour la configuration spécifique au backend.

📅 Créé il y a 0 jour ✏️ Mis à jour il y a 0 jour

Commentaires