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

Le déploiement de modèles de vision par ordinateur dans divers environnements, y compris les systèmes embarqués, les navigateurs web ou les plateformes avec un support Python limité, nécessite une solution flexible et portable. TorchScript privilégie la portabilité et la capacité d'exécuter des modèles dans des environnements où le framework Python complet n'est pas disponible. Cela le rend idéal pour les scénarios où tu dois 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 vers le format TorchScript, 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 une variété de plateformes. Exporter des modèles YOLO26 vers TorchScript est crucial pour passer de la recherche aux applications concrètes. TorchScript, partie intégrante du framework PyTorch, facilite cette transition en permettant l'utilisation de modèles PyTorch 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 de définir des 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, 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.

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

TorchScript, é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 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 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. Le JIT compile le graphe de calcul du modèle, permettant une exécution efficace sur les appareils cibles.

• Intégration inter-langages : 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 des langages différents.

• 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 travailles avec des modèles complexes ou que 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 des 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 faible surcharge et une exécution efficace des modèles TorchScript, maximisant le potentiel de performance.

• Déploiement mobile : TorchScript propose des outils pour convertir les modèles en formats facilement déployables sur des appareils mobiles. PyTorch Mobile fournit un runtime pour exécuter ces modèles dans des 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 dans le cloud en utilisant des solutions comme TorchServe. Il offre des fonctionnalités telles que le versionnage des modèles, le traitement par lots et le suivi des métriques pour un déploiement évolutif dans les environnements de production. Le déploiement dans le cloud avec TorchScript peut rendre tes modèles accessibles via des API ou d'autres services web.

Link to this sectionExporter vers TorchScript : Convertir ton modèle YOLO26#

Exporter 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.

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 meilleures 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 des 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, visite la page de documentation Ultralytics sur l'exportation.

Link to this sectionDéployer des modèles YOLO26 TorchScript exportés#

Après avoir exporté avec succès tes modèles Ultralytics YOLO26 vers le 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 approfondies sur le déploiement de tes modèles TorchScript dans d'autres paramètres, jette un œil aux 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 soient efficaces et réactives.

• Maîtriser le déploiement côté serveur : Apprends comment déployer des modèles côté serveur avec TorchServe, offrant 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 une performance et une polyvalence accrues.

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 d'autres intégrations Ultralytics YOLO26, visite notre page de guide d'intégration. Tu y trouveras de nombreuses ressources et idées 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 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 plus large applicabilité 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 inter-langages : 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 torch.export() → .pte séparé plutôt que TorchScript.

Link to this sectionQuelles sont les étapes d'installation pour exporter des modèles YOLO26 vers TorchScript ?#

Pour installer le package requis pour exporter 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 puis-je déployer mes modèles YOLO26 TorchScript exportés ?#

Après avoir exporté des modèles YOLO26 vers le 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 : Exécute des modèles TorchScript sur l'appareil avec LibTorch (le runtime PyTorch C++). 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 évolutif côté serveur.

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