Erste Schritte

YOLO26-Modelle für eine schnelle Bereitstellung nach TorchScript exportieren

PyTorch stellt TorchScript ein

PyTorch hat TorchScript als veraltet eingestuft und entfernt dessen Funktionen schrittweise. Verwende für neue Bereitstellungen auf Mobilgeräten und Edge-Geräten die unterstützte ExecuTorch-Integration. Ultralytics unterstützt weiterhin den regulären TorchScript-Export für die Kompatibilität mit älteren C++-Anwendungen.

Für die Bereitstellung von Computer-Vision-Modellen in C++-Umgebungen ohne Python ist eine portable serialisierte Darstellung erforderlich. TorchScript bietet diese Kompatibilität für ältere LibTorch-Anwendungen.

Exportiere deine Ultralytics YOLO26-Modelle als TorchScript, um sie für plattformübergreifende Kompatibilität und eine reibungslose Bereitstellung zu serialisieren. Dieser Leitfaden zeigt dir, wie du deine YOLO26-Modelle in das TorchScript-Format exportierst, damit du sie in einem größeren Spektrum von Anwendungen einsetzen kannst.

Warum solltest du nach TorchScript exportieren?#

Übersicht über den Workflow zur Serialisierung und Bereitstellung von TorchScript-Modellen

TorchScript wurde von den Entwicklern von PyTorch entwickelt und ist ein Werkzeug zur Optimierung und Bereitstellung von PyTorch-Modellen auf verschiedenen Plattformen. Der Export von YOLO26-Modellen als TorchScript erleichtert den Übergang von der Forschung zu realen Anwendungen. Als Teil des PyTorch-Frameworks erleichtert TorchScript diesen Übergang, indem es ermöglicht, PyTorch-Modelle in Umgebungen ohne Python-Unterstützung einzusetzen.

Der Prozess umfasst zwei Techniken: Tracing und Scripting. Beim Tracing werden Operationen während der Modellausführung aufgezeichnet, während sich beim Scripting Modelle mithilfe einer Teilmenge von Python definieren lassen. Mit diesen Techniken können Modelle wie YOLO26 außerhalb ihrer üblichen Python-Umgebung ausgeführt werden.

Vergleich von TorchScript-Scripting und -Tracing

TorchScript-Modelle lassen sich außerdem mit Verfahren wie der Zusammenführung von Operatoren und einer optimierten Speichernutzung verbessern, um eine effiziente Ausführung sicherzustellen. Ein weiterer Vorteil des Exports nach TorchScript ist die Möglichkeit, die Modellausführung auf verschiedenen Hardwareplattformen zu beschleunigen. Dabei entsteht eine eigenständige, produktionsreife Darstellung deines PyTorch-Modells, die sich in C++-Umgebungen integrieren lässt.

Wichtige Merkmale von TorchScript-Modellen#

TorchScript ist ein wichtiger Bestandteil des PyTorch-Ökosystems und bietet Funktionen zur Optimierung und Bereitstellung von Deep-Learning-Modellen.

Übersicht über die wichtigsten Funktionen von TorchScript

Hier sind die wichtigsten Funktionen, die TorchScript zu einem wertvollen Werkzeug für Entwickler machen:

  • Ausführung mit statischem Graphen: TorchScript verwendet eine statische Graphdarstellung der Modellberechnungen, anders als die dynamische Graphausführung von PyTorch. Bei der Ausführung mit statischem Graphen wird der Berechnungsgraph vor der eigentlichen Ausführung einmal definiert und kompiliert. Das verbessert die Leistung während der Inferenz.

  • Modellserialisierung: Mit TorchScript kannst du PyTorch-Modelle in ein plattformunabhängiges Format serialisieren. Serialisierte Modelle lassen sich ohne den ursprünglichen Python-Code laden und so in unterschiedlichen Laufzeitumgebungen bereitstellen.

  • JIT-Kompilierung: TorchScript verwendet die Just-in-Time-Kompilierung (JIT), um PyTorch-Modelle in eine optimierte Zwischendarstellung umzuwandeln. JIT kompiliert den Berechnungsgraphen des Modells und ermöglicht so eine effiziente Ausführung auf Zielgeräten.

  • Schrittweise Umwandlung: TorchScript ermöglicht eine schrittweise Umwandlung, sodass du Teile deines PyTorch-Modells nach und nach in TorchScript umwandeln kannst. Diese Flexibilität ist besonders nützlich bei komplexen Modellen oder wenn du bestimmte Teile des Codes optimieren möchtest.

Bereitstellungsoptionen für TorchScript#

Bevor wir uns den Code für den Export von YOLO26-Modellen in das TorchScript-Format ansehen, folgt ein Überblick über die üblichen Einsatzbereiche von TorchScript-Modellen.

TorchScript bietet verschiedene Bereitstellungsoptionen für Machine-Learning-Modelle, zum Beispiel:

  • C++-API: TorchScript wird am häufigsten über die LibTorch-C++-API verwendet. Damit kannst du optimierte TorchScript-Modelle direkt in C++-Anwendungen laden und ausführen. Das eignet sich ideal für Produktionsumgebungen, in denen Python ungeeignet oder nicht verfügbar ist. Die C++-API führt TorchScript-Modelle mit geringem Mehraufwand und effizient aus und schöpft so ihr Leistungspotenzial aus.

  • Bereitstellung auf Mobilgeräten: Für Inferenz mit geringer Latenz und ohne Netzwerkverbindung sowie für Datenschutz auf Mobilgeräten solltest du ExecuTorch verwenden, den Ersatz von PyTorch für TorchScript Mobile.

  • Bereitstellung in der Cloud: TorchScript-Modelle lassen sich mit Lösungen wie NVIDIA Triton Inference Server auf Cloud-Servern bereitstellen. NVIDIA Triton Inference Server bietet Funktionen wie Modellversionierung, Stapelverarbeitung und Metriküberwachung für eine skalierbare Bereitstellung in Produktionsumgebungen. Durch die Bereitstellung von TorchScript in der Cloud können deine Modelle über APIs oder andere Webdienste zugänglich gemacht werden.

Unterstützte Aufgaben#

Der TorchScript-Export unterstützt alle sieben Ultralytics-Aufgaben. Semantische Segmentierung und Tiefenschätzung sind nur mit YOLO26 verfügbar, der einzigen Modellfamilie mit diesen Köpfen.

AufgabeYOLOv8YOLO11YOLO26
Erkennung✅✅✅
Segmentierung✅✅✅
Semantik❌❌✅
Tiefe❌❌✅
Klassifizierung✅✅✅
Pose✅✅✅
OBB✅✅✅

Nach TorchScript exportieren: Dein YOLO26-Modell umwandeln#

Der Export von YOLO26-Modellen als TorchScript erleichtert ihre Ausführung außerhalb von Python, zum Beispiel in C++-Anwendungen auf Basis von LibTorch.

Installation#

Führe zum Installieren des erforderlichen Pakets Folgendes aus:

Installation
# Install the required package for YOLO26
pip install ultralytics

Ausführliche Anweisungen und bewährte Vorgehensweisen zur Installation findest du in unserer Installationsanleitung von Ultralytics. Falls bei der Installation der für YOLO26 erforderlichen Pakete Probleme auftreten, findest du Lösungen und Tipps in unserer Anleitung zu häufigen Problemen.

Verwendung#

Alle Ultralytics YOLO26-Modelle sind so ausgelegt, dass sie sofort exportiert werden können. Dadurch lassen sie sich problemlos in deinen bevorzugten Bereitstellungsablauf integrieren. In der vollständigen Liste der unterstützten Exportformate und Konfigurationsoptionen findest du die passende Konfiguration für deine Anwendung.

Das TorchScript-Format unterstützt die Modi Export, Predict und Validate. Exportiere dein Modell und lade anschließend das exportierte Modell, um Inferenz auszuführen oder seine Genauigkeit zu validieren.

Exportieren
from ultralytics import YOLO

# Ein YOLO26-Modell laden
model = YOLO("yolo26n.pt")

# Modell in das TorchScript-Format exportieren
model.export(format="torchscript")  # creates 'yolo26n.torchscript'
Vorhersagen
from ultralytics import YOLO

# Exportiertes TorchScript-Modell laden
model = YOLO("yolo26n.torchscript")

# Inferenz ausführen
results = model("https://ultralytics.com/images/bus.jpg")
Validieren
from ultralytics import YOLO

# Exportiertes TorchScript-Modell laden
model = YOLO("yolo26n.torchscript")

# Die Genauigkeit anhand des COCO8-Datensatzes validieren
metrics = model.val(data="coco8.yaml")

Exportargumente#

ArgumentTypStandardBeschreibung
formatstr'torchscript'Zielformat des exportierten Modells, das die Kompatibilität mit verschiedenen Bereitstellungsumgebungen festlegt.
imgszint oder tuple640Gewünschte Bildgröße für die Modelleingabe. Kann eine Ganzzahl für quadratische Bilder oder ein Tupel (height, width) für bestimmte Abmessungen sein.
dynamicboolFalseErmöglicht dynamische Eingabegrößen und sorgt so für mehr Flexibilität beim Umgang mit unterschiedlichen Bildabmessungen.
quantizeint oder strNoneQuantisierungsgenauigkeit: 16 (FP16) erfordert einen GPU-Export mit device=0; 32/nicht festgelegt entspricht FP32. Ersetzt das veraltete Flag half.
nmsbool, optionalNoneWähle die Rohausgabe (None, Standard), eingebettetes NMS (True) oder den NMS-freien Kopf (False).
batchint1Gibt die Batchgröße für die Inferenz des Exportmodells oder die Höchstzahl der Bilder an, die das exportierte Modell gleichzeitig im predict-Modus verarbeiten kann.
devicestrNoneLegt das Exportgerät fest: GPU (device=0), CPU (device=cpu), MPS für Apple Silicon (device=mps).

Weitere Informationen zum Exportvorgang findest du auf der Ultralytics-Dokumentationsseite zum Export.

Exportierte YOLO26-TorchScript-Modelle bereitstellen#

Nachdem du deine Ultralytics-YOLO26-Modelle erfolgreich in das TorchScript-Format exportiert hast, kannst du sie nun bereitstellen. Als ersten und empfohlenen Schritt zum Ausführen eines TorchScript-Modells verwendest du die Methode YOLO("model.torchscript"), wie im vorherigen Codebeispiel zur Verwendung gezeigt. Ausführliche Anleitungen zur Bereitstellung deiner TorchScript-Modelle in anderen Umgebungen findest du in den folgenden Ressourcen:

  • Bereitstellung auf Mobilgeräten entdecken: Verwende für die aktuelle PyTorch-Bereitstellung auf Mobilgeräten die separate torch.export() → .pte-Pipeline von ExecuTorch.

  • Serverseitige Bereitstellung meistern: Erfahre, wie du TorchScript-Modelle mit dem PyTorch-Backend von NVIDIA Triton Inference Server skalierbar und effizient bereitstellst.

  • C++-Bereitstellung umsetzen: Wirf einen Blick auf die Anleitung zum Laden eines TorchScript-Modells in C++ und erfahre, wie du deine TorchScript-Modelle in C++-Anwendungen integrierst, um Leistung und Vielseitigkeit zu steigern.

Zusammenfassung#

In diesem Leitfaden haben wir den Export von Ultralytics YOLO26-Modellen in das TorchScript-Format behandelt. Wenn du die beschriebenen Anweisungen befolgst, kannst du YOLO26-Modelle für bessere Leistung optimieren und sie flexibel auf verschiedenen Plattformen und in unterschiedlichen Umgebungen bereitstellen.

Weitere Informationen zur Verwendung findest du in der offiziellen TorchScript-Dokumentation.

Häufig gestellte Fragen#

  • Wenn du ein Ultralytics-YOLO26-Modell nach TorchScript exportierst, kannst du es flexibel und plattformübergreifend bereitstellen. TorchScript ist Teil des PyTorch-Ökosystems und ermöglicht die Serialisierung von Modellen, die sich anschließend in Umgebungen ohne Python-Unterstützung ausführen lassen. Dadurch eignet es sich für die Bereitstellung von Modellen in C++-Umgebungen.

  • Zum Export eines YOLO26-Modells nach TorchScript kannst du den folgenden Beispielcode verwenden:

    Verwendung
    from ultralytics import YOLO
    
    # Ein YOLO26-Modell laden
    model = YOLO("yolo26n.pt")
    
    # Modell in das TorchScript-Format exportieren
    model.export(format="torchscript")  # creates 'yolo26n.torchscript'
    
    # Exportiertes TorchScript-Modell laden
    torchscript_model = YOLO("yolo26n.torchscript")
    
    # Inferenz ausführen
    results = torchscript_model("https://ultralytics.com/images/bus.jpg")

    Weitere Informationen zum Exportvorgang findest du in der Ultralytics-Dokumentation zum Export.

  • Die Bereitstellung von YOLO26-Modellen mit TorchScript bietet mehrere Vorteile:

    • Portabilität: Exportierte Modelle lassen sich ohne Python in C++-Anwendungen ausführen.
    • Optimierung: TorchScript unterstützt die Ausführung mit statischem Graphen und die Just-in-Time-Kompilierung (JIT), wodurch sich die Modellleistung optimieren lässt.
    • Sprachübergreifende Integration: TorchScript-Modelle lassen sich in andere Programmiersprachen integrieren, was Flexibilität und Erweiterbarkeit verbessert.
    • Serialisierung: Modelle lassen sich serialisieren und dadurch plattformunabhängig laden und für Inferenz verwenden.

    Weitere Informationen zur Bereitstellung findest du im Leitfaden zur C++-Bereitstellung. Für die Bereitstellung auf Mobilgeräten empfiehlt PyTorch inzwischen ExecuTorch, das eine eigene, separate Pipeline torch.export() → .pte anstelle von TorchScript verwendet.

  • Installiere das erforderliche Paket für den Export von YOLO26-Modellen mit folgendem Befehl:

    Installation
    # Install the required package for YOLO26
    pip install ultralytics

    Eine detaillierte Anleitung findest du im Ultralytics-Installationsleitfaden. Falls bei der Installation Probleme auftreten, lies den Leitfaden zu häufigen Problemen.

  • Nachdem du YOLO26-Modelle in das TorchScript-Format exportiert hast, kannst du sie auf verschiedenen Plattformen bereitstellen:

    • C++-API: Verwende LibTorch für Produktionsumgebungen mit geringem Overhead und hoher Effizienz.
    • Bereitstellung auf Mobilgeräten: Verwende ExecuTorch, den von PyTorch unterstützten Ersatz mit einer separaten Exportpipeline .pte.
    • Bereitstellung in der Cloud: Nutze Dienste wie NVIDIA Triton Inference Server für eine skalierbare serverseitige Bereitstellung.

Kommentare9

Stell eine Frage, teile deine Ergebnisse oder hilf jemand anderem.

  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(bearbeitet)

      @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(bearbeitet)

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