Commencer

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

PyTorch abandonne TorchScript

PyTorch a déconseillé TorchScript et supprime progressivement ses fonctionnalités. Pour les nouveaux déploiements mobiles et en périphérie, utilise l’intégration ExecuTorch prise en charge. Ultralytics conserve l’exportation TorchScript habituelle pour assurer la compatibilité avec l’ancien code C++.

Le déploiement de modèles de vision par ordinateur dans des environnements C++ sans Python nécessite une représentation sérialisée portable. TorchScript assure cette compatibilité pour les applications LibTorch existantes.

Exporte tes modèles Ultralytics YOLO26 au format TorchScript pour les sérialiser et assurer leur compatibilité multiplateforme tout en simplifiant leur déploiement. Ce guide explique comment exporter tes modèles YOLO26 au format TorchScript afin de les utiliser dans un plus grand nombre d’applications.

Pourquoi exporter vers TorchScript ?#

Présentation du flux de travail de sérialisation et de déploiement des modèles TorchScript

Développé par les créateurs de PyTorch, TorchScript est un outil permettant d’optimiser et de déployer des modèles PyTorch sur diverses plateformes. L’export de modèles YOLO26 au format TorchScript facilite leur passage de la recherche aux applications réelles. TorchScript, qui fait partie de l’écosystème PyTorch, simplifie cette transition en permettant d’utiliser des modèles PyTorch dans des environnements qui ne prennent pas en charge Python.

Le processus comprend deux techniques : le traçage et la création de scripts. Le traçage enregistre les opérations pendant l’exécution du modèle, tandis que la création de scripts permet de définir des modèles à l’aide d’un sous-ensemble de Python. Ces techniques permettent aux modèles comme YOLO26 de s’exécuter hors de leur environnement Python habituel.

Comparaison du scriptage et du traçage dans TorchScript

Les modèles TorchScript peuvent également être optimisés à l’aide de techniques comme la fusion d’opérateurs et l’amélioration de l’utilisation de la mémoire, afin de garantir une exécution efficace. L’exportation vers TorchScript peut aussi accélérer l’exécution des modèles sur différentes plateformes matérielles. Elle crée une représentation autonome, prête pour la production, de ton modèle PyTorch, qui peut être intégrée à des environnements C++.

Fonctionnalités clés des modèles TorchScript#

TorchScript, un élément clé de l’écosystème PyTorch, fournit des fonctionnalités pour optimiser et déployer des modèles d’apprentissage profond.

Présentation des fonctionnalités clés de TorchScript

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

  • Exécution à graphe statique : TorchScript utilise une représentation à graphe statique des calculs du modèle, contrairement à l’exécution à graphe dynamique de PyTorch. Avec l’exécution à graphe statique, le graphe de calcul est défini et compilé une seule fois avant l’exécution proprement dite, ce qui améliore les performances lors de l’inférence.

  • Sérialisation des modèles : TorchScript 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 le code Python d’origine, ce qui permet leur déploiement dans différents environnements d’exécution.

  • Compilation JIT : TorchScript utilise la compilation à la volée (JIT) pour convertir les modèles PyTorch en une représentation intermédiaire optimisée. La compilation JIT compile le graphe de calcul du modèle et permet une exécution efficace sur les appareils cibles.

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

Options de déploiement avec TorchScript#

Avant d’examiner le code d’export de modèles YOLO26 au format TorchScript, voici les cas d’utilisation habituels des modèles TorchScript.

TorchScript propose diverses options de déploiement pour les modèles d’apprentissage automatique, notamment :

  • API C++ : le cas d’utilisation le plus courant de TorchScript est son API C++ LibTorch, qui te permet de charger et d’exécuter des modèles TorchScript optimisés directement dans des applications C++. C’est idéal pour les environnements de production où Python n’est pas adapté ou disponible. L’API C++ permet une exécution efficace des modèles TorchScript avec une faible surcharge, afin d’exploiter au maximum leurs performances.

  • Déploiement mobile : pour une inférence à faible latence, hors ligne, et la confidentialité des données sur les appareils mobiles, utilise ExecuTorch, le remplacement de TorchScript Mobile par PyTorch.

  • Déploiement dans le cloud : les modèles TorchScript peuvent être déployés sur des serveurs cloud à l’aide de solutions comme NVIDIA Triton Inference Server. Celui-ci propose des fonctionnalités telles que le versionnement des modèles, le traitement par lots et la surveillance des métriques pour un déploiement évolutif en production. Le déploiement cloud avec TorchScript peut rendre tes modèles accessibles via des API ou d’autres services web.

Tâches prises en charge#

L’exportation TorchScript prend en charge les sept tâches Ultralytics. La segmentation sémantique et l’estimation de profondeur sont disponibles uniquement avec YOLO26, la seule famille à inclure ces têtes.

TâcheYOLOv8YOLO11YOLO26
Détecter✅✅✅
Segmenter✅✅✅
Sémantique❌❌✅
Profondeur❌❌✅
Classifier✅✅✅
Pose✅✅✅
OBB✅✅✅

Exporter vers TorchScript : convertir ton modèle YOLO26#

L’export de modèles YOLO26 au format TorchScript permet de les exécuter plus facilement sans Python, par exemple dans des applications C++ basées sur LibTorch.

Installation#

Pour installer le package requis, exécute :

Installation
# Install the required package for YOLO26
pip install ultralytics

Pour obtenir des instructions détaillées et connaître les bonnes pratiques liées à l’installation, consulte notre guide d’installation Ultralytics. Si tu rencontres des difficultés lors de l’installation des packages requis pour YOLO26, consulte notre guide des problèmes courants, qui propose des solutions et des conseils.

Utilisation#

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 à 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 configuration la mieux adaptée à 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 effectuer l’inférence ou valider sa précision.

Export
from ultralytics import YOLO

# Charger un modèle YOLO26
model = YOLO("yolo26n.pt")

# Exporter le modèle au format TorchScript
model.export(format="torchscript")  # crée 'yolo26n.torchscript'
Prédiction
from ultralytics import YOLO

# Charger le modèle TorchScript exporté
model = YOLO("yolo26n.torchscript")

# Exécuter l’inférence
results = model("https://ultralytics.com/images/bus.jpg")
Valider
from ultralytics import YOLO

# Charger le modèle TorchScript exporté
model = YOLO("yolo26n.torchscript")

# Valider la précision sur le jeu de données COCO8
metrics = model.val(data="coco8.yaml")

Arguments d’exportation#

ArgumentTypeValeur par défautDescription
formatstr'torchscript'Format cible du modèle exporté, qui définit sa compatibilité avec différents environnements de déploiement.
imgszint ou tuple640Taille d’image souhaitée pour l’entrée du modèle. Peut être un entier pour les images carrées ou un tuple (height, width) pour définir des dimensions spécifiques.
dynamicboolFalsePermet d'utiliser des tailles d'entrée dynamiques, offrant ainsi une plus grande flexibilité pour traiter des images de dimensions variables.
quantizeint ou strNonePrécision de quantification : 16 (FP16) nécessite une exportation sur GPU avec device=0 ; 32/non défini correspond à FP32. Remplace l’option obsolète half.
nmsbool, facultatifNoneSélectionne la sortie brute (None, par défaut), NMS intégrée (True) ou la tête sans NMS (False).
batchint1Indique la taille de lot pour l’inférence du modèle exporté ou le nombre maximal d’images que le modèle exporté traitera simultanément en mode predict.
devicestrNoneDéfinit l’appareil utilisé pour l’export : GPU (device=0), CPU (device=cpu), MPS pour Apple Silicon (device=mps).

Pour en savoir plus sur le processus d’export, consulte la page de la documentation Ultralytics consacrée à l’export.

Déployer 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 recommandée pour exécuter un modèle TorchScript consiste à utiliser la méthode YOLO("model.torchscript"), comme indiqué dans l’extrait de code d’utilisation précédent. Pour obtenir des instructions détaillées sur le déploiement de tes modèles TorchScript dans d’autres contextes, consulte les ressources suivantes :

  • Découvrir le déploiement mobile : utilise le pipeline distinct torch.export() → .pte d’ExecuTorch pour les déploiements mobiles actuels avec PyTorch.

  • Maîtriser le déploiement côté serveur : découvre comment servir des modèles TorchScript avec le backend PyTorch de NVIDIA Triton Inference Server pour assurer un service de modèles évolutif et efficace.

  • Mettre en œuvre le déploiement C++ : explore le tutoriel sur le chargement d’un modèle TorchScript en C++, qui facilite l’intégration de tes modèles TorchScript dans des applications C++ pour améliorer leurs performances et leur polyvalence.

Résumé#

Ce guide expliquait comment exporter des modèles Ultralytics YOLO26 au format TorchScript. En suivant les instructions fournies, tu peux optimiser les performances des modèles YOLO26 et les déployer avec souplesse sur diverses plateformes et dans différents environnements.

Pour en savoir plus sur l’utilisation, consulte la documentation officielle de TorchScript.

FAQ#

  • L’exportation d’un modèle Ultralytics YOLO26 vers TorchScript permet un déploiement flexible et multiplateforme. TorchScript, qui fait partie de l’écosystème PyTorch, permet de sérialiser les modèles, qui peuvent ensuite être exécutés dans des environnements ne prenant pas en charge Python. Il est donc utile pour déployer des modèles dans des environnements C++.

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

    Utilisation
    from ultralytics import YOLO
    
    # Charger un modèle YOLO26
    model = YOLO("yolo26n.pt")
    
    # Exporter le modèle au format TorchScript
    model.export(format="torchscript")  # crée 'yolo26n.torchscript'
    
    # Charger le modèle TorchScript exporté
    torchscript_model = YOLO("yolo26n.torchscript")
    
    # Exécuter l’inférence
    results = torchscript_model("https://ultralytics.com/images/bus.jpg")

    Pour en savoir plus sur le processus d’exportation, consulte la documentation Ultralytics sur l’exportation.

  • L’utilisation de TorchScript pour déployer des modèles YOLO26 présente plusieurs avantages :

    • Portabilité : les modèles exportés peuvent s’exécuter dans des applications C++ sans Python.
    • Optimisation : TorchScript prend en charge l’exécution à graphe statique et la compilation à la volée (JIT), qui peuvent optimiser les performances des modèles.
    • Intégration multilingage : les modèles TorchScript peuvent être intégrés à d’autres langages de programmation, ce qui améliore leur flexibilité et leur extensibilité.
    • Sérialisation : les modèles peuvent être sérialisés pour être chargés et exécutés indépendamment de la plateforme.

    Pour en savoir plus sur le déploiement, consulte le guide de déploiement C++. Pour le déploiement mobile sur appareil, PyTorch recommande désormais ExecuTorch, qui utilise son propre pipeline distinct torch.export() → .pte au lieu de TorchScript.

  • Pour installer le paquet requis pour exporter des modèles YOLO26, utilise la commande suivante :

    Installation
    # Install the required package for YOLO26
    pip install ultralytics

    Pour obtenir des instructions détaillées, consulte le guide d’installation d’Ultralytics. En cas de problème pendant l’installation, consulte le guide des problèmes courants.

  • Après avoir exporté des modèles YOLO26 au format TorchScript, tu peux les déployer sur diverses plateformes :

    • API C++ : utilise LibTorch dans les environnements de production où une faible surcharge et une grande efficacité sont essentielles.
    • Déploiement mobile : utilise ExecuTorch, le remplaçant pris en charge par PyTorch, avec un pipeline d’export distinct .pte.
    • Déploiement dans le cloud : utilise des services comme NVIDIA Triton Inference Server pour un déploiement évolutif côté serveur.

Commentaires9

Pose une question, partage tes résultats ou aide quelqu’un d’autre.

  1. amarnathreddy0201GitHub

    Load the YOLOv8 model

    model = YOLO("yolov8n.pt")

    Export the model to TorchScript format

    model.export(format="torchscript") # creates 'yolov8n.torchscript'

    Load the exported TorchScript model

    torchscript_model = YOLO("yolov8n.torchscript")

    For loading "yolov8n.torchscript" here yolo is used. is it possible to load the model using pytorch and prediction/Segmentation.

    1. Paula DerrengerUltralytics

      @amarnathreddy0201 yes, you can load and use the exported TorchScript model directly with PyTorch. After exporting your YOLOv8 model to TorchScript format, you can load it using torch.jit.load('yolov8n.torchscript') and then perform inference as usual with PyTorch. For detailed instructions, you can refer to the TorchScript documentation.

    2. amarnathreddy0201GitHub(modifié)

      @pderrenger I written small application for person detection but it's not detecting properly nd bounding boxes is some where else.

      import torch import cv2 import numpy as np

      classes = [ "person", "bicycle", "car", "motorcycle", "airplane", "bus", "train", "truck", "boat", "traffic light", "fire hydrant", "stop sign", "parking meter", "bench", "bird", "cat", "dog", "horse", "sheep", "cow", "elephant", "bear", "zebra", "giraffe", "backpack", "umbrella", "handbag", "tie", "suitcase", "frisbee", "skis", "snowboard", "sports ball", "kite", "baseball bat", "baseball glove", "skateboard", "surfboard", "tennis racket", "bottle", "wine glass", "cup", "fork", "knife", "spoon", "bowl", "banana", "apple", "sandwich", "orange", "broccoli", "carrot", "hot dog", "pizza", "donut", "cake", "chair", "couch", "potted plant", "bed", "dining table", "toilet", "tv", "laptop", "mouse", "remote", "keyboard", "cell phone", "microwave", "oven", "toaster", "sink", "refrigerator", "book", "clock", "vase", "scissors", "teddy bear", "hair drier", "toothbrush" ]

      model = torch.jit.load("yolov8n.torchscript") image_ori = cv2.imread(r"C:\Users\amarn\OneDrive\Pictures\father mother.jpg") image = cv2.resize(image_ori, (640, 640)) image = cv2.cvtColor(image, cv2.COLOR_BGR2RGB) image_tensor = torch.from_numpy(image).float() image_tensor = image_tensor.permute(2, 0, 1) # Change from HWC to CHW format image_tensor = image_tensor / 255.0 # Normalize to [0, 1] image_tensor = image_tensor.unsqueeze(0)

      with torch.no_grad(): results = model(image_tensor)

      results = results[0] # Remove the batch dimension if there's only one image

      boxes = results[:, :4]
      print(len(boxes)) object_confidences = results[:, 4] # Objectness score class_confidences = results[:, 5:] # Class scores

      conf_threshold = 0.5 # Example threshold; adjust as necessary predictions = [] for i in range(len(object_confidences)): if object_confidences[i] > conf_threshold: class_id = torch.argmax(class_confidences[i]).item() class_conf = class_confidences[i][class_id].item()

          if class_conf > conf_threshold:
              
              box_np = boxes[i].cpu().numpy() if boxes[i].is_cuda else boxes[i].numpy()
              x, y, w, h = box_np
              x1 = int((x - w / 2) )
              y1 = int((y - h / 2) )
              x2 = int((x + w / 2) )
              y2 = int((y + h / 2))
              cv2.rectangle(image_ori, (int(x1),int( y1)), (int(x1+ w), int(y1 + h)), (0, 255, 0), 2)

      cv2.imshow('image', image_ori) cv2.waitKey(0)

      classes is from yolo only

      1
    3. Paula DerrengerUltralytics

      It looks like there might be an issue with the bounding box coordinates. Ensure that the coordinates are correctly transformed from the model's output format to the image's coordinate system. Also, verify that the model is correctly loaded and that the input image is preprocessed as expected. If the issue persists, please try updating to the latest version of the Ultralytics package and check if the problem is reproducible. For more details on exporting and using TorchScript models, you can refer to the Ultralytics documentation.

    4. clausMekoGitHub(modifié)

      @amarnathreddy0201 I could make the boxes work for my One-Item only use case. I guess the tensor structure was not really clear to you as it seemed to me you have profound knowledge. ty for heavy lifting :partying_face:

      @glenn-jocher and @pderrenger if you care what use case I had and could not simply from ultralytics import YOLO: I chain YOLO with other models and have conflicts with imports, especially numpy v1 vs v2. So i figured export all as torchscript and chain them.

      import torch
      import cv2
      
      # Knwoledge: https://github.com/ultralytics/ultralytics/issues/5863
      # Knwoledge: https://github.com/orgs/ultralytics/discussions/9002
      def preprocess_image(image_ori) -> torch.Tensor:
          image = cv2.resize(image_ori, (640, 640))
          image = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)
          image_tensor = torch.from_numpy(image).float()
          image_tensor = image_tensor.permute(2, 0, 1)  # Change from HWC to CHW format
          image_tensor = image_tensor / 255.0  # Normalize to [0, 1]
          image_tensor = image_tensor.unsqueeze(0)
      
          return image_tensor
      
      def main():
          # Load the TorchScript model
          map_location = torch.device('cuda') if torch.cuda.is_available() else torch.device('cpu')
          model = torch.jit.load('./best.torchscript', map_location=map_location)
      
          cv2_img = cv2.imread("../obj-det/datasets/test/images/00018_png.rf.d602082fdf686063a7d430aba6dfedde.jpg")
          image = preprocess_image(cv2_img)
      
          with torch.no_grad():
              results: torch.Tensor = model(image.to(map_location))
      
          results = results[0]  # Remove the batch dimension if there's only one image
          boxes = results[:4, :]
          object_confidences = results[4, :]
          conf_threshold = 0.5  # Example threshold; adjust as necessary
      
          dominant_item = torch.argmax(object_confidences)
          if object_confidences[dominant_item] < conf_threshold:
              cv2.imshow('nothing found', cv2_img)
              cv2.waitKey(0)
              return
      
          box_np = boxes[:,dominant_item].cpu().numpy() if boxes[:,dominant_item].is_cuda else boxes[:,dominant_item].numpy()
          x, y, w, h = box_np
          x1 = int((x - w / 2))
          y1 = int((y - h / 2))
          x2 = int(x1 + w)
          y2 = int(y1 + h)
          cv2.rectangle(cv2_img, (x1, y1), (x2, y2), (0, 255, 0), 2)
          cv2.imshow('image', cv2_img)
          cv2.waitKey(0)
      
      if __name__ == '__main__':
          main()
      1
    5. Glenn JocherUltralytics

      Thank you for sharing your use case and detailed implementation! Exporting models as TorchScript for chaining is indeed a smart approach, especially when managing dependency conflicts. If adjustments are needed for bounding boxes or results, ensure the coordinate transformations align with the input image dimensions. For additional guidance on TorchScript usage, feel free to reference Ultralytics TorchScript Docs. Let us know if you encounter further issues!

  2. tryprncpGitHub

    hi, I'm implementing yolov8 model in android gallery's search mechanism. the purpose of yolov8 model is to scan media files and return images that has a bounding box label that matches the search query. i can make it work with yolov5s.torchscript.ptl using org.pytorch:pytorch_android_lite:1.10.0 and org.pytorch:pytorch_android_torchvision_lite:1.10.0 but it wont work with yolov8s.torchscript. i really need help with this.

    1. Glenn JocherUltralytics

      Hey there! 😊 It sounds like you've made great progress integrating YOLOv8 into your Android app's search mechanism! If you've successfully used YOLOv5 models but are facing issues with YOLOv8's TorchScript model, let's try to sort this out.

      First, ensure you've exported the YOLOv8 model to TorchScript correctly using the latest YOLOv8 and PyTorch versions. Here's a quick snippet for exporting:

      from ultralytics import YOLO
      
      # Load YOLOv8 model
      model = YOLO('yolov8s.pt')  # Use the appropriate YOLOv8 variant
      
      # Export to TorchScript
      model.export(format='torchscript')

      This creates a file named yolov8s.torchscript. Ensure that this file is what you're trying to load in your Android app.

      If you're still having trouble after confirming the export process, consider checking the PyTorch Android version compatibility. YOLOv8 may require a newer version of PyTorch Android than YOLOv5, so updating org.pytorch:pytorch_android_lite and org.pytorch:pytorch_android_torchvision_lite to the latest versions might help.

      Lastly, since YOLOv8 is more recent, make sure you're using the latest release of the Ultralytics YOLO library for any compatibility fixes or improvements.

      If these steps don't resolve the issue, feel free to share any error messages or more specifics about the problem you're encountering. I'm here to help!