Link to this sectionExportation de modèle YOLO26 vers TorchScript pour un déploiement rapide#

Déployer des modèles de vision par ordinateur dans différents environnements, notamment les systèmes embarqués, les navigateurs web ou les plateformes avec une prise en charge limitée de Python, nécessite une solution flexible et portable. TorchScript met l'accent sur la portabilité et la capacité d'exécuter des modèles dans des environnements où l'intégralité 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 la compatibilité multiplateforme et une rationalisation du déploiement. Dans ce guide, nous te montrerons comment exporter tes modèles YOLO26 au format TorchScript, te facilitant ainsi leur utilisation dans un plus large éventail d'applications.

Link to this sectionPourquoi 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 concrètes. TorchScript, partie intégrante 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 traçage et le script. Le traçage enregistre les opérations pendant l'exécution du modèle, tandis que le script 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 via des techniques telles que la fusion d'opérateurs et des améliorations de l'utilisation de la mémoire, assurant 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.

Link to this sectionFonctionnalités clés des modèles TorchScript#

TorchScript, une partie 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 diffère 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 lors de 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. Le 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 le C++, Java et JavaScript. Cela facilite l'intégration des modèles PyTorch dans des systèmes logiciels existants écrits dans différents langages.

• Conversion graduelle : TorchScript propose une approche de conversion graduelle, 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.

Link to this sectionOptions de déploiement dans TorchScript#

Avant de regarder le code pour exporter les modèles YOLO26 vers le 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 à faible surcharge et efficace des modèles TorchScript, maximisant le potentiel de performance.

• Déploiement mobile : TorchScript propose des outils pour convertir des modèles en formats facilement déployables sur des 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 telles que le versioning de modèle, le traitement par lots et le monitoring des métriques pour un déploiement évolutif dans les environnements de production. Le déploiement cloud avec TorchScript peut rendre tes modèles accessibles via des API ou d'autres services web.

Link to this sectionExporter 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 parfait pour quiconque cherche à utiliser des modèles de deep learning plus efficacement dans des applications réelles.

Link to this sectionInstallation#

Pour installer le package requis, exécute :

# Install the required package for YOLO26
pip install ultralytics

Pour des instructions détaillées et les bonnes pratiques liées au processus d'installation, consulte notre guide d'installation Ultralytics. Lors de l'installation des packages requis pour YOLO26, si tu rencontres des difficultés, consulte notre guide des problèmes courants pour des solutions et conseils.

Link to this sectionUtilisation#

Tous les modèles Ultralytics YOLO26 sont conçus pour prendre en charge l'exportation dès leur installation, ce qui facilite leur intégration dans ton workflow 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.

Le format TorchScript 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 TorchScript format
model.export(format="torchscript")  # creates 'yolo26n.torchscript'

from ultralytics import YOLO

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

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

from ultralytics import YOLO

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

# Validate accuracy on the COCO8 dataset
metrics = model.val(data="coco8.yaml")

Link to this sectionArguments d'exportation#

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

Link to this sectionDé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 indiqué 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 configurations, jette un œil aux ressources suivantes :

• Explorer le déploiement mobile : La documentation de PyTorch Mobile fournit des directives complètes pour le déploiement de 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 plus de performance et de polyvalence.

Link to this sectionRésumé#

Dans ce guide, nous avons exploré le processus d'exportation des modèles Ultralytics YOLO26 vers le 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 les autres intégrations Ultralytics YOLO26, visite notre page de guide d'intégration. Tu y trouveras de nombreuses ressources et informations utiles.

Link to this sectionFAQ#

Link to this sectionQu'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 prise en charge de 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.

Link to this sectionComment 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 a 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.

Link to this sectionPourquoi devrais-je utiliser TorchScript pour déployer des modèles YOLO26 ?#

Utiliser TorchScript pour déployer des modèles YOLO26 offre plusieurs avantages :

• Portabilité : Les modèles exportés peuvent s'exécuter dans des environnements sans avoir besoin de Python, comme 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 TorchServe et le Guide de déploiement C++. Pour le déploiement mobile sur appareil, PyTorch recommande désormais ExecuTorch, qui utilise son propre pipeline séparé torch.export() → .pte plutôt que TorchScript.

Link to this sectionQuelles sont les étapes d'installation pour exporter les 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 Ultralytics. Si des problèmes surviennent lors de l'installation, consulte le guide des problèmes courants.

Link to this sectionComment 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 très efficaces.
• Déploiement mobile : Exécute des modèles TorchScript sur l'appareil avec LibTorch (le runtime C++ de PyTorch). Pour les nouveaux projets mobiles, PyTorch recommande ExecuTorch, un pipeline d'exportation .pte séparé.
• Déploiement cloud : Utilise des services comme TorchServe pour un déploiement côté serveur évolutif.

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