Exportation du modèle YOLO26 vers TorchScript pour un déploiement rapide

Le déploiement de modèles de vision par ordinateur dans divers environnements, notamment les systèmes embarqués, les navigateurs web ou les plateformes avec un support limité de Python, nécessite une solution flexible et portable. TorchScript se concentre sur la portabilité et la capacité à exécuter des modèles dans des environnements où l'ensemble du framework Python n'est pas disponible. Cela le rend idéal pour les scénarios où tu as besoin de déployer tes capacités de vision par ordinateur sur divers appareils ou plateformes.

Exporte vers TorchScript pour sérialiser tes modèles Ultralytics YOLO26 afin d'assurer une compatibilité multiplateforme et un déploiement simplifié. Dans ce guide, nous te montrerons comment exporter tes modèles YOLO26 au format TorchScript, facilitant ainsi leur utilisation dans un plus large éventail d'applications.

Pourquoi exporter vers TorchScript ?

Développé par les créateurs de PyTorch, TorchScript est un outil puissant pour optimiser et déployer des modèles PyTorch sur diverses plateformes. L'exportation des modèles YOLO26 vers TorchScript est cruciale pour passer de la recherche aux applications réelles. TorchScript, faisant partie du framework PyTorch, aide à rendre cette transition plus fluide en permettant aux modèles PyTorch d'être utilisés dans des environnements qui ne prennent pas en charge Python.

Le processus implique deux techniques : le tracing et le scripting. Le tracing enregistre les opérations pendant l'exécution du modèle, tandis que le scripting permet la définition de modèles en utilisant un sous-ensemble de Python. Ces techniques garantissent que des modèles comme YOLO26 peuvent toujours opérer leur magie même en dehors de leur environnement Python habituel.

Les modèles TorchScript peuvent également être optimisés grâce à des techniques telles que la fusion d'opérateurs et des améliorations de l'utilisation de la mémoire, garantissant une exécution efficace. Un autre avantage de l'exportation vers TorchScript est son potentiel à accélérer l'exécution des modèles sur diverses plateformes matérielles. Il crée une représentation autonome et prête pour la production de ton modèle PyTorch, qui peut être intégrée dans des environnements C++, des systèmes embarqués, ou déployée dans des applications web ou mobiles.

Fonctionnalités clés des modèles TorchScript

TorchScript, un élément clé de l'écosystème PyTorch, fournit des fonctionnalités puissantes pour optimiser et déployer des modèles de deep learning.

Voici les fonctionnalités clés qui font de TorchScript un outil précieux pour les développeurs :

• Exécution par graphe statique : TorchScript utilise une représentation par graphe statique du calcul du modèle, ce qui est différent de l'exécution par graphe dynamique de PyTorch. Dans l'exécution par graphe statique, le graphe de calcul est défini et compilé une fois avant l'exécution réelle, ce qui améliore les performances pendant l'inférence.

• Sérialisation de modèle : TorchScript te permet de sérialiser des modèles PyTorch dans un format indépendant de la plateforme. Les modèles sérialisés peuvent être chargés sans nécessiter le code Python original, permettant un déploiement dans différents environnements d'exécution.

• Compilation JIT : TorchScript utilise la compilation Just-In-Time (JIT) pour convertir les modèles PyTorch en une représentation intermédiaire optimisée. JIT compile le graphe de calcul du modèle, permettant une exécution efficace sur les appareils cibles.

• Intégration multi-langage : Avec TorchScript, tu peux exporter des modèles PyTorch vers d'autres langages tels que C++, Java et JavaScript. Cela facilite l'intégration des modèles PyTorch dans des systèmes logiciels existants écrits dans des langages différents.

• Conversion progressive : TorchScript propose une approche de conversion progressive, te permettant de convertir progressivement des parties de ton modèle PyTorch en TorchScript. Cette flexibilité est particulièrement utile lorsque tu traites des modèles complexes ou lorsque tu souhaites optimiser des portions spécifiques du code.

Options de déploiement dans TorchScript

Avant de regarder le code pour exporter les modèles YOLO26 au format TorchScript, comprenons où les modèles TorchScript sont normalement utilisés.

TorchScript offre diverses options de déploiement pour les modèles de machine learning, telles que :

• API C++ : Le cas d'utilisation le plus courant pour TorchScript est son API C++, qui te permet de charger et d'exécuter des modèles TorchScript optimisés directement au sein d'applications C++. C'est idéal pour les environnements de production où Python peut ne pas être adapté ou disponible. L'API C++ offre une exécution efficace et à faible surcharge des modèles TorchScript, maximisant le potentiel de performance.

• Déploiement mobile : TorchScript propose des outils pour convertir les modèles dans des formats facilement déployables sur les appareils mobiles. PyTorch Mobile fournit un runtime pour exécuter ces modèles au sein d'applications iOS et Android. Cela permet des capacités d'inférence hors ligne à faible latence, améliorant l'expérience utilisateur et la confidentialité des données.

• Déploiement cloud : Les modèles TorchScript peuvent être déployés sur des serveurs basés sur le cloud en utilisant des solutions comme TorchServe. Il fournit des fonctionnalités comme le versionnage de modèles, le batching et la surveillance des métriques pour un déploiement évolutif dans des environnements de production. Le déploiement cloud avec TorchScript peut rendre tes modèles accessibles via des API ou d'autres services web.

Exporter vers TorchScript : Conversion de ton modèle YOLO26

L'exportation des modèles YOLO26 vers TorchScript facilite leur utilisation dans différents endroits et les aide à fonctionner plus rapidement et plus efficacement. C'est idéal pour quiconque cherche à utiliser des modèles de deep learning plus efficacement dans des applications réelles.

Installation

Pour installer le package requis, exécute :

# Install the required package for YOLO26
pip install ultralytics

Pour des instructions détaillées et les meilleures pratiques liées au processus d'installation, consulte notre guide d'installation d'Ultralytics. Pendant l'installation des paquets requis pour YOLO26, si tu rencontres des difficultés, consulte notre guide des problèmes courants pour des solutions et astuces.

Utilisation

Tous les modèles Ultralytics YOLO26 sont conçus pour prendre en charge l'exportation dès la sortie de la boîte, ce qui facilite leur intégration dans ton flux de déploiement préféré. Tu peux consulter la liste complète des formats d'exportation pris en charge et des options de configuration pour choisir la meilleure configuration pour ton application.

from ultralytics import YOLO

# Load the YOLO26 model
model = YOLO("yolo26n.pt")

# Export the model to TorchScript format
model.export(format="torchscript")  # creates 'yolo26n.torchscript'

# Load the exported TorchScript model
torchscript_model = YOLO("yolo26n.torchscript")

# Run inference
results = torchscript_model("https://ultralytics.com/images/bus.jpg")

Arguments d'exportation

Pour plus de détails sur le processus d'exportation, visite la page de documentation Ultralytics sur l'exportation.

Déploiement des modèles YOLO26 TorchScript exportés

Après avoir exporté avec succès tes modèles Ultralytics YOLO26 au format TorchScript, tu peux maintenant les déployer. La première étape principale et recommandée pour exécuter un modèle TorchScript est d'utiliser la méthode YOLO("model.torchscript"), comme décrit dans l'extrait de code d'utilisation précédent. Pour des instructions détaillées sur le déploiement de tes modèles TorchScript dans d'autres contextes, consulte les ressources suivantes :

• Explorer le déploiement mobile : La documentation de PyTorch Mobile fournit des directives complètes pour déployer des modèles sur des appareils mobiles, garantissant que tes applications sont efficaces et réactives.

• Maîtriser le déploiement côté serveur : Apprends à déployer des modèles côté serveur avec TorchServe, en proposant un tutoriel étape par étape pour un service de modèles évolutif et efficace.

• Implémenter le déploiement C++ : Plonge dans le tutoriel sur le chargement d'un modèle TorchScript en C++, facilitant l'intégration de tes modèles TorchScript dans des applications C++ pour des performances et une polyvalence améliorées.

Résumé

Dans ce guide, nous avons exploré le processus d'exportation des modèles Ultralytics YOLO26 au format TorchScript. En suivant les instructions fournies, tu peux optimiser les modèles YOLO26 pour la performance et gagner la flexibilité de les déployer sur diverses plateformes et environnements.

Pour plus de détails sur l'utilisation, visite la documentation officielle de TorchScript.

De plus, si tu souhaites en savoir plus sur d'autres intégrations d'Ultralytics YOLO26, visite notre page de guide d'intégration. Tu y trouveras de nombreuses ressources et perspectives utiles.

FAQ

Qu'est-ce que l'exportation du modèle Ultralytics YOLO26 vers TorchScript ?

Exporter un modèle Ultralytics YOLO26 vers TorchScript permet un déploiement flexible et multiplateforme. TorchScript, une partie de l'écosystème PyTorch, facilite la sérialisation des modèles, qui peuvent ensuite être exécutés dans des environnements dépourvus de support Python. Cela le rend idéal pour déployer des modèles sur des systèmes embarqués, des environnements C++, des applications mobiles et même des navigateurs web. L'exportation vers TorchScript permet une performance efficace et une applicabilité plus large de tes modèles YOLO26 sur diverses plateformes.

Comment puis-je exporter mon modèle YOLO26 vers TorchScript en utilisant Ultralytics ?

Pour exporter un modèle YOLO26 vers TorchScript, tu peux utiliser l'exemple de code suivant :

from ultralytics import YOLO

# Load the YOLO26 model
model = YOLO("yolo26n.pt")

# Export the model to TorchScript format
model.export(format="torchscript")  # creates 'yolo26n.torchscript'

# Load the exported TorchScript model
torchscript_model = YOLO("yolo26n.torchscript")

# Run inference
results = torchscript_model("https://ultralytics.com/images/bus.jpg")

Pour plus de détails sur le processus d'exportation, réfère-toi à la documentation Ultralytics sur l'exportation.

Pourquoi devrais-je utiliser TorchScript pour déployer des modèles YOLO26 ?

L'utilisation de TorchScript pour déployer des modèles YOLO26 offre plusieurs avantages :

• Portabilité : Les modèles exportés peuvent fonctionner dans des environnements sans avoir besoin de Python, tels que des applications C++, des systèmes embarqués ou des appareils mobiles.
• Optimisation : TorchScript prend en charge l'exécution par graphe statique et la compilation Just-In-Time (JIT), ce qui peut optimiser les performances du modèle.
• Intégration multi-langage : Les modèles TorchScript peuvent être intégrés dans d'autres langages de programmation, améliorant la flexibilité et l'évolutivité.
• Sérialisation : Les modèles peuvent être sérialisés, permettant un chargement et une inférence indépendants de la plateforme.

Pour plus d'informations sur le déploiement, visite la documentation de PyTorch Mobile, la documentation de TorchServe et le guide de déploiement C++.

Quelles sont les étapes d'installation pour exporter des modèles YOLO26 vers TorchScript ?

Pour installer le package requis pour l'exportation des modèles YOLO26, utilise la commande suivante :

# Install the required package for YOLO26
pip install ultralytics

Pour des instructions détaillées, visite le guide d'installation d'Ultralytics. Si des problèmes surviennent lors de l'installation, consulte le guide des problèmes courants.

Comment déployer mes modèles YOLO26 TorchScript exportés ?

Après avoir exporté les modèles YOLO26 au format TorchScript, tu peux les déployer sur une variété de plateformes :

• API C++ : Idéal pour les environnements de production à faible surcharge et hautement efficaces.
• Déploiement mobile : Utilise PyTorch Mobile pour les applications iOS et Android.
• Déploiement cloud : Utilise des services comme TorchServe pour un déploiement évolutif côté serveur.

Explore les directives complètes pour déployer des modèles dans ces environnements afin de tirer pleinement parti des capacités de TorchScript.