Başla

Hızlı Dağıtım için YOLO26 Modelini TorchScript'e Aktarma

PyTorch, TorchScript'i kullanımdan kaldırıyor

PyTorch, TorchScript'i kullanımdan kaldırdı ve özelliklerini aşamalı olarak kaldırıyor. Yeni mobil ve uç dağıtımlarda desteklenen ExecuTorch entegrasyonunu kullan. Ultralytics, eski C++ uyumluluğu için standart TorchScript dışa aktarımını sürdürüyor.

Python olmadan C++ ortamlarında bilgisayarlı görü modellerini dağıtmak için taşınabilir, serileştirilmiş bir gösterim gerekir. TorchScript, eski LibTorch uygulamalarına bu uyumluluğu sağlar.

Ultralytics YOLO26 modellerini platformlar arası uyumluluk ve kolaylaştırılmış dağıtım için serileştirmek üzere TorchScript'e aktar. Bu kılavuz, YOLO26 modellerini TorchScript biçimine nasıl aktaracağını ve böylece modelleri daha geniş bir uygulama yelpazesinde nasıl kullanabileceğini gösterir.

Neden TorchScript'e aktarmalısın?#

TorchScript model serileştirme ve dağıtım iş akışına genel bakış

PyTorch geliştiricileri tarafından oluşturulan TorchScript, PyTorch modellerini çeşitli platformlarda optimize edip dağıtmaya yönelik bir araçtır. YOLO26 modellerini TorchScript'e aktarmak, modelleri araştırma ortamından gerçek dünyadaki uygulamalara taşımaya yardımcı olur. PyTorch çatısının bir parçası olan TorchScript, PyTorch modellerinin Python'ı desteklemeyen ortamlarda kullanılmasını sağlayarak bu geçişi kolaylaştırır.

Süreç iki tekniği kapsar: izleme ve betikleme. İzleme, model çalışırken işlemleri kaydederken betikleme, Python'ın bir alt kümesini kullanarak modeller tanımlamayı sağlar. Bu teknikler, YOLO26 gibi modellerin alışıldık Python ortamlarının dışında çalışmasına olanak tanır.

TorchScript betikleme ve izleme karşılaştırması

TorchScript modelleri, operatör birleştirme ve bellek kullanımını iyileştirme gibi tekniklerle de optimize edilerek verimli yürütme sağlanabilir. TorchScript'e aktarmanın bir diğer avantajı, çeşitli donanım platformlarında model yürütmesini hızlandırma potansiyelidir. Bu işlem, C++ ortamlarına entegre edilebilen, bağımsız ve üretime hazır bir PyTorch model gösterimi oluşturur.

TorchScript Modellerinin Temel Özellikleri#

PyTorch ekosisteminin önemli bir parçası olan TorchScript, derin öğrenme modellerini optimize edip dağıtmaya yönelik özellikler sunar.

TorchScript'in temel özelliklerine genel bakış

TorchScript'i geliştiriciler için değerli bir araç haline getiren temel özellikler şunlardır:

  • Statik Grafik Yürütme: TorchScript, PyTorch'un dinamik grafik yürütmesinden farklı olarak model hesaplamasının statik grafik gösterimini kullanır. Statik grafik yürütmede hesaplama grafiği, gerçek yürütmeden önce bir kez tanımlanıp derlenir; böylece çıkarım sırasında performans artar.

  • Model Serileştirme: TorchScript, PyTorch modellerini platformdan bağımsız bir biçimde serileştirmeni sağlar. Serileştirilmiş modeller, özgün Python kodu gerektirmeden yüklenebilir ve farklı çalışma zamanı ortamlarına dağıtılabilir.

  • JIT Derlemesi: TorchScript, PyTorch modellerini optimize edilmiş bir ara gösterime dönüştürmek için Tam Zamanında (JIT) derlemesini kullanır. JIT, modelin hesaplama grafiğini derleyerek hedef cihazlarda verimli yürütme sağlar.

  • Aşamalı Dönüştürme: TorchScript, PyTorch modelinin bazı kısımlarını aşamalı olarak TorchScript'e dönüştürmeni sağlayan bir yaklaşım sunar. Bu esneklik, özellikle karmaşık modellerle çalışırken veya kodun belirli bölümlerini optimize etmek istediğinde kullanışlıdır.

TorchScript'te Dağıtım Seçenekleri#

YOLO26 modellerini TorchScript biçimine aktarma koduna geçmeden önce, TorchScript modellerinin genellikle nerelerde kullanıldığına bakalım.

TorchScript, makine öğrenimi modelleri için aşağıdakiler gibi çeşitli dağıtım seçenekleri sunar:

  • C++ API'si: TorchScript'in en yaygın kullanım alanı, optimize edilmiş TorchScript modellerini doğrudan C++ uygulamalarında yükleyip çalıştırmanı sağlayan LibTorch C++ API'sidir. Bu, Python'ın uygun veya kullanılabilir olmayabileceği üretim ortamları için idealdir. C++ API'si, TorchScript modellerini düşük ek yükle ve verimli biçimde çalıştırarak performans potansiyelini en üst düzeye çıkarır.

  • Mobil Dağıtım: Mobil cihazlarda düşük gecikmeli, çevrimdışı çıkarım ve veri gizliliği için PyTorch'un TorchScript Mobile yerine sunduğu ExecuTorch'u kullan.

  • Bulut Dağıtımı: TorchScript modelleri, NVIDIA Triton Inference Server gibi çözümler kullanılarak bulut tabanlı sunuculara dağıtılabilir. Bu çözüm, üretim ortamlarında ölçeklenebilir dağıtım için model sürümleme, toplu işleme ve metrik izleme gibi özellikler sunar. TorchScript ile bulut dağıtımı, modellerini API'ler veya diğer web hizmetleri aracılığıyla erişilebilir hâle getirebilir.

Desteklenen Görevler#

TorchScript dışa aktarımı, yedi Ultralytics görevinin tamamını destekler. Anlamsal segmentasyon ve derinlik tahmini yalnızca bu başlıkları içeren tek aile olan YOLO26 ile kullanılabilir.

GörevYOLOv8YOLO11YOLO26
Algılama✅✅✅
Segmentasyon✅✅✅
Anlamsal❌❌✅
Derinlik❌❌✅
Sınıflandırma✅✅✅
Poz✅✅✅
OBB✅✅✅

TorchScript'e Aktarma: YOLO26 Modelini Dönüştürme#

YOLO26 modellerini TorchScript'e aktarmak, modelleri Python dışında çalıştırmayı kolaylaştırır; örneğin LibTorch üzerine kurulu C++ uygulamalarında.

Kurulum#

Gerekli paketi yüklemek için şu komutu çalıştır:

Kurulum
# Install the required package for YOLO26
pip install ultralytics

Kurulum süreciyle ilgili ayrıntılı talimatlar ve en iyi uygulamalar için Ultralytics Kurulum kılavuzumuza göz at. YOLO26 için gerekli paketleri yüklerken zorluk yaşarsan çözüm ve ipuçları için Yaygın Sorunlar kılavuzumuza başvur.

Kullanım#

Tüm Ultralytics YOLO26 modelleri, kutudan çıktığı gibi dışa aktarmayı destekleyecek şekilde tasarlanmıştır; bu sayede tercih ettiğin dağıtım iş akışına kolayca entegre edebilirsin. Uygulaman için en uygun kurulumu seçmek üzere desteklenen dışa aktarma biçimlerinin ve yapılandırma seçeneklerinin tam listesini görüntüleyebilirsin.

TorchScript biçimi Dışa Aktar, Tahmin ve Doğrula modlarını destekler. Modelini dışa aktar, ardından çıkarım yapmak veya doğruluğunu doğrulamak için dışa aktarılan modeli yükle.

Dışa aktar
from ultralytics import YOLO

# YOLO26 modelini yükle
model = YOLO("yolo26n.pt")

# Modeli TorchScript biçimine aktar
model.export(format="torchscript")  # 'yolo26n.torchscript' dosyasını oluşturur
Tahmin
from ultralytics import YOLO

# Dışa aktarılan TorchScript modelini yükle
model = YOLO("yolo26n.torchscript")

# Çıkarımı çalıştır
results = model("https://ultralytics.com/images/bus.jpg")
Doğrula
from ultralytics import YOLO

# Dışa aktarılan TorchScript modelini yükle
model = YOLO("yolo26n.torchscript")

# COCO8 veri kümesinde doğruluğu doğrula
metrics = model.val(data="coco8.yaml")

Dışa Aktarma Bağımsız Değişkenleri#

Bağımsız değişkenTürVarsayılanAçıklama
formatstr'torchscript'Dışa aktarılan modelin hedef biçimi; çeşitli dağıtım ortamlarıyla uyumluluğu tanımlar.
imgszint veya tuple640Model girişi için istenen görüntü boyutu. Kare görüntüler için bir tam sayı, belirli boyutlar içinse (height, width) demeti kullanılabilir.
dynamicboolFalseDinamik giriş boyutlarına izin vererek farklı görüntü boyutlarını işleme esnekliğini artırır.
quantizeint veya strNoneNicemleme hassasiyeti: 16 (FP16), device=0 ile GPU dışa aktarımı gerektirir; 32/ayarlanmamış değer FP32'dir. Kullanımdan kaldırılan half bayrağının yerini alır.
nmsbool, isteğe bağlıNoneHam çıktıyı (None, varsayılan), gömülü NMS'yi (True) veya NMS'siz başlığı (False) seç.
batchint1Dışa aktarılan modelin toplu çıkarım boyutunu veya predict kipinde eşzamanlı işleyeceği en fazla görüntü sayısını belirtir.
devicestrNoneDışa aktarma aygıtını belirtir: GPU (device=0), CPU (device=cpu), Apple silikon için MPS (device=mps).

Dışa aktarma süreci hakkında daha fazla bilgi için Ultralytics dışa aktarma belgeleri sayfasını ziyaret et.

Dışa Aktarılan YOLO26 TorchScript Modellerini Dağıtma#

Ultralytics YOLO26 modellerini TorchScript biçimine başarıyla aktardıktan sonra modelleri dağıtabilirsin. TorchScript modelini çalıştırmak için önerilen ilk ve temel adım, önceki kullanım kodu örneğinde gösterildiği gibi YOLO("model.torchscript") yöntemini kullanmaktır. TorchScript modellerini diğer ortamlarda dağıtmaya yönelik ayrıntılı talimatlar için aşağıdaki kaynaklara göz at:

  • Mobil Dağıtımı Keşfet: Güncel PyTorch mobil dağıtımı için ExecuTorch'un ayrı torch.export() → .pte işlem hattını kullan.

  • Sunucu Tarafı Dağıtımında Uzmanlaş: Ölçeklenebilir ve verimli model sunumu için NVIDIA Triton Inference Server'ın PyTorch arka ucuyla TorchScript modellerini nasıl sunacağını öğren.

  • C++ Dağıtımını Uygula: TorchScript modellerini daha yüksek performans ve çok yönlülük için C++ uygulamalarına entegre etmeyi sağlayan, C++'ta TorchScript Modeli Yükleme eğitimini incele.

Özet#

Bu kılavuzda Ultralytics YOLO26 modellerini TorchScript biçimine aktarmayı ele aldık. Verilen talimatları izleyerek YOLO26 modellerini performans için optimize edebilir ve çeşitli platformlarda ve ortamlarda dağıtma esnekliği kazanabilirsin.

Kullanımla ilgili daha fazla ayrıntı için TorchScript'in resmi belgelerini ziyaret et.

Sık Sorulan Sorular#

  • Bir Ultralytics YOLO26 modelini TorchScript'e aktarmak, esnek ve platformlar arası dağıtım olanağı sağlar. PyTorch ekosisteminin bir parçası olan TorchScript, modellerin serileştirilmesini sağlar; ardından modeller Python desteği olmayan ortamlarda çalıştırılabilir. Bu özellik, modellerin C++ ortamlarına dağıtılmasını kullanışlı hale getirir.

  • Bir YOLO26 modelini TorchScript'e aktarmak için aşağıdaki örnek kodu kullanabilirsin:

    Kullanım
    from ultralytics import YOLO
    
    # YOLO26 modelini yükle
    model = YOLO("yolo26n.pt")
    
    # Modeli TorchScript biçimine aktar
    model.export(format="torchscript")  # 'yolo26n.torchscript' dosyasını oluşturur
    
    # Dışa aktarılan TorchScript modelini yükle
    torchscript_model = YOLO("yolo26n.torchscript")
    
    # Çıkarımı çalıştır
    results = torchscript_model("https://ultralytics.com/images/bus.jpg")

    Dışa aktarma süreci hakkında daha fazla bilgi için Ultralytics dışa aktarma belgelerine bak.

  • YOLO26 modellerini dağıtmak için TorchScript kullanmanın çeşitli avantajları vardır:

    • Taşınabilirlik: Dışa aktarılan modeller, Python olmadan C++ uygulamalarında çalışabilir.
    • Optimizasyon: TorchScript, model performansını optimize edebilen statik grafik yürütmeyi ve Tam Zamanında (JIT) derlemesini destekler.
    • Diller Arası Entegrasyon: TorchScript modelleri diğer programlama dillerine entegre edilebilir; bu da esnekliği ve genişletilebilirliği artırır.
    • Serileştirme: Modeller serileştirilerek platformdan bağımsız yükleme ve çıkarım olanağı sağlanabilir.

    Dağıtım hakkında daha fazla bilgi için C++ Dağıtım Kılavuzu sayfasını ziyaret et. Cihaz üzerinde mobil dağıtım için PyTorch artık TorchScript yerine kendi ayrı torch.export() → .pte işlem hattını kullanan ExecuTorch çözümünü öneriyor.

  • YOLO26 modellerini dışa aktarmak için gereken paketi kurmak üzere şu komutu kullan:

    Kurulum
    # Install the required package for YOLO26
    pip install ultralytics

    Ayrıntılı yönergeler için Ultralytics Installation guide sayfasını ziyaret et. Kurulum sırasında herhangi bir sorunla karşılaşırsan Common Issues guide sayfasına başvur.

  • YOLO26 modellerini TorchScript biçimine aktardıktan sonra bunları çeşitli platformlarda dağıtabilirsin:

    • C++ API: Düşük ek yük ve yüksek verimlilik gerektiren üretim ortamları için LibTorch kullan.
    • Mobil Dağıtım: PyTorch'un desteklediği, ayrı bir .pte dışa aktarma işlem hattına sahip alternatif çözüm ExecuTorch kullan.
    • Bulut Dağıtımı: Ölçeklenebilir sunucu tarafı dağıtımı için NVIDIA Triton Inference Server gibi hizmetleri kullan.

Yorumlar9

Bir soru sor, sonuçlarını paylaş veya başka birine yardım et.

  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(düzenlendi)

      @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(düzenlendi)

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