Ultralytics YOLO27: Iscriviti alla lista d'attesa.
Inizia

Esportazione del modello YOLO26 in TorchScript per una distribuzione rapida#

PyTorch sta ritirando TorchScript

PyTorch ha dichiarato deprecato TorchScript e ne sta gradualmente rimuovendo le funzionalità. Per le nuove distribuzioni su dispositivi mobili ed edge, usa l'integrazione ExecuTorch supportata. Ultralytics mantiene l'esportazione regolare in TorchScript per la compatibilità con il codice C++ legacy.

La distribuzione di modelli di visione artificiale in ambienti C++ senza Python richiede una rappresentazione serializzata portabile. TorchScript garantisce questa compatibilità per le applicazioni LibTorch legacy.

Esporta in TorchScript per serializzare i tuoi modelli Ultralytics YOLO26, garantendo compatibilità multipiattaforma e una distribuzione più semplice. Questa guida mostra come esportare i modelli YOLO26 nel formato TorchScript, così potrai usarli in una più ampia gamma di applicazioni.

Perché esportare in TorchScript?#

Panoramica del flusso di lavoro di serializzazione e distribuzione dei modelli TorchScript

Sviluppato dagli autori di PyTorch, TorchScript è uno strumento per ottimizzare e distribuire modelli PyTorch su diverse piattaforme. Esportare i modelli YOLO26 in TorchScript aiuta a trasferirli dalla ricerca alle applicazioni reali. TorchScript, parte del framework PyTorch, semplifica questa transizione consentendo di usare i modelli PyTorch in ambienti che non supportano Python.

Il processo prevede due tecniche: tracing e scripting. Il tracing registra le operazioni durante l'esecuzione del modello, mentre lo scripting consente di definire i modelli usando un sottoinsieme di Python. Queste tecniche permettono a modelli come YOLO26 di funzionare al di fuori del loro consueto ambiente Python.

Confronto tra scripting e tracing in TorchScript

I modelli TorchScript possono essere ottimizzati anche con tecniche come la fusione degli operatori e il miglioramento dell'uso della memoria, così da garantire un'esecuzione efficiente. Un altro vantaggio dell'esportazione in TorchScript è la possibilità di accelerare l'esecuzione dei modelli su diverse piattaforme hardware. Crea una rappresentazione autonoma e pronta per la produzione del tuo modello PyTorch, integrabile in ambienti C++.

Caratteristiche principali dei modelli TorchScript#

TorchScript, componente fondamentale dell'ecosistema PyTorch, offre funzionalità per ottimizzare e distribuire modelli di deep learning.

Panoramica delle funzionalità principali di TorchScript

Ecco le caratteristiche principali che rendono TorchScript uno strumento prezioso per gli sviluppatori:

  • Esecuzione con grafo statico: TorchScript usa una rappresentazione a grafo statico dei calcoli del modello, diversa dall'esecuzione con grafo dinamico di PyTorch. Nell'esecuzione con grafo statico, il grafo di calcolo viene definito e compilato una sola volta prima dell'esecuzione vera e propria, migliorando così le prestazioni durante l'inferenza.

  • Serializzazione del modello: TorchScript consente di serializzare i modelli PyTorch in un formato indipendente dalla piattaforma. I modelli serializzati possono essere caricati senza richiedere il codice Python originale, consentendo la distribuzione in diversi ambienti di runtime.

  • Compilazione JIT: TorchScript usa la compilazione Just-In-Time (JIT) per convertire i modelli PyTorch in una rappresentazione intermedia ottimizzata. JIT compila il grafo di calcolo del modello, consentendo un'esecuzione efficiente sui dispositivi di destinazione.

  • Conversione graduale: TorchScript offre un approccio di conversione graduale che consente di convertire progressivamente parti del modello PyTorch in TorchScript. Questa flessibilità è particolarmente utile con i modelli complessi o quando vuoi ottimizzare parti specifiche del codice.

Opzioni di distribuzione con TorchScript#

Prima di esaminare il codice per esportare i modelli YOLO26 nel formato TorchScript, ecco alcuni contesti in cui vengono solitamente usati i modelli TorchScript.

TorchScript offre diverse opzioni per distribuire modelli di machine learning, ad esempio:

  • API C++: il caso d'uso più comune di TorchScript è la sua API C++ LibTorch, che consente di caricare ed eseguire modelli TorchScript ottimizzati direttamente nelle applicazioni C++. È ideale negli ambienti di produzione in cui Python potrebbe non essere adatto o disponibile. L'API C++ offre un'esecuzione efficiente dei modelli TorchScript con un overhead ridotto, massimizzando le prestazioni potenziali.

  • Distribuzione su dispositivi mobili: per l'inferenza a bassa latenza e offline e la privacy dei dati sui dispositivi mobili, usa ExecuTorch, il sostituto di PyTorch per TorchScript Mobile.

  • Distribuzione nel cloud: i modelli TorchScript possono essere distribuiti su server cloud utilizzando soluzioni come NVIDIA Triton Inference Server. Offre funzionalità come il controllo delle versioni dei modelli, l'elaborazione in batch e il monitoraggio delle metriche per una distribuzione scalabile negli ambienti di produzione. La distribuzione nel cloud con TorchScript può rendere i tuoi modelli accessibili tramite API o altri servizi web.

Attività supportate#

L'esportazione TorchScript supporta tutti e sette i task Ultralytics. La segmentazione semantica e la stima della profondità sono disponibili solo con YOLO26, l'unica famiglia che include queste head.

AttivitàYOLOv8YOLO11YOLO26
Rilevamento✅✅✅
Segmentazione✅✅✅
Semantica❌❌✅
Profondità❌❌✅
Classificazione✅✅✅
Stima della posa✅✅✅
OBB✅✅✅

Esportazione in TorchScript: conversione del modello YOLO26#

Esportare i modelli YOLO26 in TorchScript semplifica l'esecuzione al di fuori di Python, ad esempio nelle applicazioni C++ basate su LibTorch.

Installazione#

Per installare il pacchetto richiesto, esegui:

Installazione
# Install the required package for YOLO26
pip install ultralytics

Per istruzioni dettagliate e best practice sulla procedura di installazione, consulta la nostra guida all'installazione di Ultralytics. Se durante l'installazione dei pacchetti necessari per YOLO26 riscontri difficoltà, consulta la nostra guida ai problemi comuni per trovare soluzioni e suggerimenti.

Utilizzo#

Tutti i modelli Ultralytics YOLO26 sono progettati per supportare l'esportazione senza configurazioni aggiuntive, semplificando l'integrazione nel workflow di distribuzione che preferisci. Puoi consultare l'elenco completo dei formati di esportazione supportati e delle opzioni di configurazione per scegliere la configurazione più adatta alla tua applicazione.

Il formato TorchScript supporta le modalità Esporta, Prevedi e Convalida. Esporta il modello, quindi carica il modello esportato per eseguire inferenze o convalidarne la precisione.

Esporta
from ultralytics import YOLO

# Carica un modello YOLO26
model = YOLO("yolo26n.pt")

# Esporta il modello nel formato TorchScript
model.export(format="torchscript")  # crea 'yolo26n.torchscript'
Predici
from ultralytics import YOLO

# Carica il modello TorchScript esportato
model = YOLO("yolo26n.torchscript")

# Esegui l'inferenza
results = model("https://ultralytics.com/images/bus.jpg")
Convalida
from ultralytics import YOLO

# Carica il modello TorchScript esportato
model = YOLO("yolo26n.torchscript")

# # Convalida l'accuratezza sul dataset COCO8
metrics = model.val(data="coco8.yaml")

Argomenti di esportazione#

ArgomentoTipoPredefinitoDescrizione
formatstr'torchscript'Formato di destinazione del modello esportato, che definisce la compatibilità con i vari ambienti di distribuzione.
imgszint o tuple640Dimensione dell'immagine desiderata per l'input del modello. Può essere un intero per immagini quadrate o una tupla (height, width) per dimensioni specifiche.
dynamicboolFalseConsente dimensioni di input dinamiche, aumentando la flessibilità nella gestione di immagini con dimensioni diverse.
quantizeint o strNonePrecisione della quantizzazione: 16 (FP16) richiede l'esportazione su GPU con device=0; 32/non specificato corrisponde a FP32. Sostituisce il flag deprecato half.
nmsbool, facoltativoNoneSeleziona l'output grezzo (None, predefinito), NMS integrato (True) oppure la testa senza NMS (False).
batchint1Specifica la dimensione batch per l'inferenza del modello esportato o il numero massimo di immagini che il modello esportato elaborerà contemporaneamente in modalità predict.
devicestrNoneSpecifica il dispositivo per l'esportazione: GPU (device=0), CPU (device=cpu), MPS per Apple silicon (device=mps).

Per ulteriori dettagli sul processo di esportazione, visita la pagina della documentazione Ultralytics dedicata all'esportazione.

Distribuzione dei modelli YOLO26 TorchScript esportati#

Dopo aver esportato correttamente i modelli Ultralytics YOLO26 nel formato TorchScript, puoi distribuirli. Il primo passaggio consigliato per eseguire un modello TorchScript consiste nell'usare il metodo YOLO("model.torchscript"), come illustrato nello snippet di codice d'uso precedente. Per istruzioni dettagliate sulla distribuzione dei modelli TorchScript in altri contesti, consulta le seguenti risorse:

  • Scopri la distribuzione su dispositivi mobili: per l'attuale distribuzione di PyTorch su dispositivi mobili, usa la pipeline separata torch.export() → .pte di ExecuTorch.

  • Padroneggia la distribuzione lato server: scopri come servire modelli TorchScript con il backend PyTorch di NVIDIA Triton Inference Server per un servizio dei modelli scalabile ed efficiente.

  • Implementa la distribuzione in C++: approfondisci il tutorial sul caricamento di un modello TorchScript in C++, che facilita l'integrazione dei tuoi modelli TorchScript nelle applicazioni C++ per migliorare prestazioni e versatilità.

Riepilogo#

Questa guida ha illustrato l'esportazione dei modelli Ultralytics YOLO26 nel formato TorchScript. Seguendo le istruzioni fornite, puoi ottimizzare le prestazioni dei modelli YOLO26 e distribuirli con flessibilità su diverse piattaforme e in vari ambienti.

Per ulteriori dettagli sull'utilizzo, consulta la documentazione ufficiale di TorchScript.

Domande frequenti#

  • L'esportazione di un modello Ultralytics YOLO26 in TorchScript consente una distribuzione flessibile e multipiattaforma. TorchScript, parte dell'ecosistema PyTorch, permette di serializzare i modelli, che possono quindi essere eseguiti in ambienti privi di supporto per Python. Questa caratteristica è utile per distribuire modelli in ambienti C++.

  • Per esportare un modello YOLO26 in TorchScript, puoi usare il seguente codice di esempio:

    Utilizzo
    from ultralytics import YOLO
    
    # Carica un modello YOLO26
    model = YOLO("yolo26n.pt")
    
    # Esporta il modello nel formato TorchScript
    model.export(format="torchscript")  # crea 'yolo26n.torchscript'
    
    # Carica il modello TorchScript esportato
    torchscript_model = YOLO("yolo26n.torchscript")
    
    # Esegui l'inferenza
    results = torchscript_model("https://ultralytics.com/images/bus.jpg")

    Per ulteriori dettagli sul processo di esportazione, consulta la documentazione Ultralytics sull'esportazione.

  • L'uso di TorchScript per distribuire i modelli YOLO26 offre diversi vantaggi:

    • Portabilità: i modelli esportati possono essere eseguiti in applicazioni C++ senza Python.
    • Ottimizzazione: TorchScript supporta l'esecuzione con grafo statico e la compilazione Just-In-Time (JIT), che possono ottimizzare le prestazioni del modello.
    • Integrazione tra linguaggi: i modelli TorchScript possono essere integrati in altri linguaggi di programmazione, aumentando flessibilità ed espandibilità.
    • Serializzazione: i modelli possono essere serializzati, consentendo il caricamento e l'inferenza indipendenti dalla piattaforma.

    Per ulteriori informazioni sulla distribuzione, consulta la Guida alla distribuzione in C++. Per la distribuzione mobile su dispositivo, PyTorch ora consiglia ExecuTorch, che utilizza una pipeline separata torch.export() → .pte anziché TorchScript.

  • Per installare il pacchetto necessario per esportare i modelli YOLO26, usa il seguente comando:

    Installazione
    # Install the required package for YOLO26
    pip install ultralytics

    Per istruzioni dettagliate, consulta la guida all'installazione di Ultralytics. Se si verificano problemi durante l'installazione, consulta la guida ai problemi comuni.

  • Dopo aver esportato i modelli YOLO26 nel formato TorchScript, puoi distribuirli su diverse piattaforme:

    • API C++: usa LibTorch per ambienti di produzione ad alta efficienza e con overhead ridotto.
    • Distribuzione mobile: usa ExecuTorch, il sostituto supportato da PyTorch con una pipeline di esportazione separata .pte.
    • Distribuzione nel cloud: utilizza servizi come NVIDIA Triton Inference Server per una distribuzione scalabile lato server.

Commenti9

Fai una domanda, condividi i tuoi risultati o aiuta qualcun altro.

  1. amarnathreddy0201amarnathreddy0201GitHub

    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 DerrengerPaula 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. amarnathreddy0201amarnathreddy0201GitHub(modificato)

      @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 DerrengerPaula 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. clausMekoclausMekoGitHub(modificato)

      @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 JocherGlenn 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. tryprncptryprncpGitHub

    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 JocherGlenn 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!