İçeriğe geç

TensorRT YOLOv8 Modelleri için Dışa Aktarma

Deploying computer vision models in high-performance environments can require a format that maximizes speed and efficiency. This is especially true when you are deploying your model on NVIDIA GPUs.

By using the TensorRT export format, you can enhance your Ultralytics YOLOv8 models for swift and efficient inference on NVIDIA hardware. This guide will give you easy-to-follow steps for the conversion process and help you make the most of NVIDIA's advanced technology in your deep learning projects.

TensorRT

TensorRT Genel Bakış

TensorRT, developed by NVIDIA, is an advanced software development kit (SDK) designed for high-speed deep learning inference. It's well-suited for real-time applications like object detection.

Bu araç seti, derin öğrenme modellerini NVIDIA GPU'lar için optimize eder ve daha hızlı ve daha verimli işlemlerle sonuçlanır. TensorRT modelleri, katman füzyonu, hassas kalibrasyon (INT8 ve FP16), dinamik tensor bellek yönetimi ve çekirdek otomatik ayarlama gibi teknikleri içeren TensorRT optimizasyonundan geçer. Derin öğrenme modellerinin TensorRT formatına dönüştürülmesi, geliştiricilerin NVIDIA GPU'ların potansiyelinden tam olarak faydalanmasını sağlar.

TensorRT is known for its compatibility with various model formats, including TensorFlow, PyTorch, and ONNX, providing developers with a flexible solution for integrating and optimizing models from different frameworks. This versatility enables efficient model deployment across diverse hardware and software environments.

TensorRT Modellerinin Temel Özellikleri

TensorRT modelleri, yüksek hızlı derin öğrenme çıkarımında verimliliklerine ve etkinliklerine katkıda bulunan bir dizi temel özellik sunar:

  • Hassas Kalibrasyon: TensorRT hassas kalibrasyonu destekleyerek modellerin belirli doğruluk gereksinimleri için hassas bir şekilde ayarlanmasını sağlar. Bu, kabul edilebilir doğruluk seviyelerini korurken çıkarım hızını daha da artırabilen INT8 ve FP16 gibi azaltılmış hassasiyet formatları için destek içerir.

  • Layer Fusion: The TensorRT optimization process includes layer fusion, where multiple layers of a neural network are combined into a single operation. This reduces computational overhead and improves inference speed by minimizing memory access and computation.

TensorRT Katman Füzyonu

  • Dinamik Tensor Bellek Yönetimi: TensorRT çıkarım sırasında tensor bellek kullanımını verimli bir şekilde yöneterek bellek yükünü azaltır ve bellek tahsisini optimize eder. Bu da GPU bellek kullanımının daha verimli olmasını sağlar.

  • Otomatik Çekirdek Ayarlama: TensorRT , modelin her katmanı için en optimize edilmiş GPU çekirdeğini seçmek için otomatik çekirdek ayarlama uygular. Bu uyarlanabilir yaklaşım, modelin GPU'un hesaplama gücünden tam olarak yararlanmasını sağlar.

Dağıtım Seçenekleri TensorRT

Dışa aktarma koduna bakmadan önce YOLOv8 modellerine TensorRT formatı, nerede olduğunu anlayalım TensorRT modeller normalde kullanılır.

TensorRT çeşitli dağıtım seçenekleri sunar ve her seçenek entegrasyon kolaylığı, performans optimizasyonu ve esnekliği farklı şekilde dengeler:

  • Deploying within TensorFlow: This method integrates TensorRT into TensorFlow, allowing optimized models to run in a familiar TensorFlow environment. It's useful for models with a mix of supported and unsupported layers, as TF-TRT can handle these efficiently.

TensorRT Genel Bakış

  • Bağımsız TensorRT Runtime API: Granüler kontrol sunar, performans açısından kritik uygulamalar için idealdir. Daha karmaşıktır ancak desteklenmeyen operatörlerin özel olarak uygulanmasına izin verir.

  • NVIDIA Triton Çıkarım Sunucusu: Çeşitli çerçevelerden modelleri destekleyen bir seçenek. Özellikle bulut veya uç çıkarımı için uygundur, eşzamanlı model yürütme ve model analizi gibi özellikler sağlar.

YOLOv8 Modellerini Dışa Aktarma TensorRT

YOLOv8 modellerini TensorRT formatına dönüştürerek yürütme verimliliğini artırabilir ve performansı optimize edebilirsiniz.

Kurulum

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

Kurulum

# Install the required package for YOLOv8
pip install ultralytics

Kurulum süreciyle ilgili ayrıntılı talimatlar ve en iyi uygulamalar için YOLOv8 Kurulum kılavuzumuza göz atın. YOLOv8 için gerekli paketleri yüklerken herhangi bir zorlukla karşılaşırsanız, çözümler ve ipuçları için Ortak Sorunlar kılavuz umuza başvurun.

Kullanım

Kullanım talimatlarına geçmeden önce, Ultralytics tarafından sunulanYOLOv8 model yelpazesine göz attığınızdan emin olun. Bu, proje gereksinimleriniz için en uygun modeli seçmenize yardımcı olacaktır.

Kullanım

from ultralytics import YOLO

# Load the YOLOv8 model
model = YOLO("yolov8n.pt")

# Export the model to TensorRT format
model.export(format="engine")  # creates 'yolov8n.engine'

# Load the exported TensorRT model
tensorrt_model = YOLO("yolov8n.engine")

# Run inference
results = tensorrt_model("https://ultralytics.com/images/bus.jpg")
# Export a YOLOv8n PyTorch model to TensorRT format
yolo export model=yolov8n.pt format=engine  # creates 'yolov8n.engine''

# Run inference with the exported model
yolo predict model=yolov8n.engine source='https://ultralytics.com/images/bus.jpg'

Dışa aktarma işlemi hakkında daha fazla bilgi için, dışa aktarma ile ilgiliUltralytics dokümantasyon sayfasını ziyaret edin.

INT8 Niceleme ile TensorRT Dışa Aktarma

Exporting Ultralytics YOLO models using TensorRT with INT8 precision executes post-training quantization (PTQ). TensorRT uses calibration for PTQ, which measures the distribution of activations within each activation tensor as the YOLO model processes inference on representative input data, and then uses that distribution to estimate scale values for each tensor. Each activation tensor that is a candidate for quantization has an associated scale that is deduced by a calibration process.

Örtük olarak nicelenmiş ağları işlerken TensorRT katman yürütme süresini optimize etmek için fırsatçı bir şekilde INT8 kullanır. Bir katman INT8'de daha hızlı çalışıyorsa ve veri girişleri ve çıkışları üzerinde atanmış niceleme ölçekleri varsa, o katmana INT8 hassasiyetine sahip bir çekirdek atanır, aksi takdirde TensorRT , çekirdek için FP32 veya FP16 hassasiyetinden hangisinin o katman için daha hızlı yürütme süresiyle sonuçlandığına bağlı olarak bir hassasiyet seçer.

İpucu

Kalibrasyon sonuçları cihazlar arasında farklılık gösterebileceğinden, dağıtım için TensorRT model ağırlıklarını kullanacak olan aynı cihazın INT8 hassasiyetiyle dışa aktarma için kullanıldığından emin olmak çok önemlidir.

INT8 Dışa Aktarmayı Yapılandırma

Kullanırken sağlanan argümanlar ihracat bir Ultralytics YOLO modeli için büyük ölçüde dışa aktarılan modelin performansını etkiler. Bunların ayrıca mevcut cihaz kaynaklarına göre seçilmesi gerekecektir, ancak varsayılan argümanlar gerekir çoğu için çalışmak Ampere (veya daha yeni) NVIDIA ayrık GPU'lar. Kullanılan kalibrasyon algoritması "ENTROPY_CALIBRATION_2" ve mevcut seçenekler hakkında daha fazla ayrıntı okuyabilirsiniz TensorRT Geliştirici Kılavuzu'nda. Ultralytics testleri şunu bulmuştur "ENTROPY_CALIBRATION_2" en iyi seçimdir ve ihracat bu algoritmayı kullanmaya sabitlenmiştir.

  • workspace : Model ağırlıklarını dönüştürürken cihaz bellek tahsisinin boyutunu (GiB cinsinden) kontrol eder.

    • Ayarlamak workspace değerini kalibrasyon ihtiyaçlarınıza ve kaynak kullanılabilirliğinize göre belirleyin. Daha büyük bir workspace may increase calibration time, it allows TensorRT to explore a wider range of optimization tactics, potentially enhancing model performance and accuracy. Conversely, a smaller workspace kalibrasyon süresini kısaltabilir ancak optimizasyon stratejilerini sınırlandırarak kuantize modelin kalitesini etkileyebilir.

    • Varsayılan değer workspace=4 (GiB), kalibrasyon çökerse (uyarı vermeden çıkarsa) bu değerin artırılması gerekebilir.

    • TensorRT rapor edecek UNSUPPORTED_STATE için değer varsa dışa aktarma sırasında workspace değerinin cihaz için kullanılabilir bellekten daha büyük olduğu anlamına gelir. workspace düşürülmelidir.

    • Eğer workspace maksimum değere ayarlandığında ve kalibrasyon başarısız olduğunda/çöktüğünde, aşağıdaki değerleri azaltmayı düşünün imgsz ve batch bellek gereksinimlerini azaltmak için.

    • INT8 için kalibrasyonun her cihaza özgü olduğunuunutmayın, kalibrasyon için "üst düzey" bir GPU ödünç almak, çıkarım başka bir cihazda çalıştırıldığında düşük performansa neden olabilir.

  • batch : Çıkarım için kullanılacak maksimum yığın boyutu. Çıkarım sırasında daha küçük gruplar kullanılabilir, ancak çıkarım belirtilenden daha büyük grupları kabul etmeyecektir.

Not

Kalibrasyon sırasında, iki kez batch sağlanan boyut kullanılacaktır. Küçük partilerin kullanılması kalibrasyon sırasında yanlış ölçeklendirmeye yol açabilir. Bunun nedeni sürecin gördüğü verilere göre ayarlama yapmasıdır. Küçük partiler tüm değer aralığını yakalayamayabilir, bu da nihai kalibrasyonda sorunlara yol açabilir, bu nedenle batch size is doubled automatically. If no batch size is specified batch=1'de kalibrasyon çalıştırılacaktır. batch=1 * 2 kalibrasyon ölçekleme hatalarını azaltmak için.

NVIDIA tarafından yapılan deneyler, INT8 niceleme kalibrasyonu ile modeliniz için verileri temsil eden en az 500 kalibrasyon görüntüsü kullanılmasını önermelerine yol açmıştır. Bu bir kılavuzdur ve bir sert gerekliliği ve veri kümeniz için iyi performans göstermesi için neyin gerekli olduğunu denemeniz gerekecektir. INT8 kalibrasyonu için TensorRT adresinde kalibrasyon verileri gerektiğinden, bu verileri kullandığınızdan emin olun. data argümanı ne zaman int8=True TensorRT ve kullanım için data="my_dataset.yaml"'deki görüntüleri kullanacak olan doğrulama ile kalibre etmek için. için herhangi bir değer geçilmediğinde data INT8 niceleme ile TensorRT adresine aktarıldığında, varsayılan olarak model görevine dayalı "küçük" örnek veri kümeleri hata vermek yerine.

Örnek

from ultralytics import YOLO

model = YOLO("yolov8n.pt")
model.export(
    format="engine",
    dynamic=True,  # (1)!
    batch=8,  # (2)!
    workspace=4,  # (3)!
    int8=True,
    data="coco.yaml",  # (4)!
)

# Load the exported TensorRT INT8 model
model = YOLO("yolov8n.engine", task="detect")

# Run inference
result = model.predict("https://ultralytics.com/images/bus.jpg")
  1. Dinamik eksenlerle dışa aktarma yaparken bu özellik varsayılan olarak etkinleştirilecektir. int8=True açıkça ayarlanmamış olsa bile. Bkz. dışa aktarma argümanları ek bilgi için.
  2. ile kalibre eden dışa aktarılan model için maksimum parti boyutunu 8 olarak ayarlar. batch = 2 * 8 kalibrasyon sırasında ölçekleme hatalarını önlemek için.
  3. Dönüştürme işlemi için tüm aygıtı ayırmak yerine 4 GiB bellek ayırır.
  4. Kalibrasyon için COCO veri setini, özellikle de doğrulama için kullanılan görüntüleri (toplam 5.000) kullanır.
# Export a YOLOv8n PyTorch model to TensorRT format with INT8 quantization
yolo export model=yolov8n.pt format=engine batch=8 workspace=4 int8=True data=coco.yaml  # creates 'yolov8n.engine''

# Run inference with the exported TensorRT quantized model
yolo predict model=yolov8n.engine source='https://ultralytics.com/images/bus.jpg'
Kalibrasyon Önbelleği

TensorRT bir kalibrasyon oluşturacaktır .cache Aynı verileri kullanarak gelecekteki model ağırlıklarının dışa aktarımını hızlandırmak için yeniden kullanılabilir, ancak bu, veriler çok farklı olduğunda veya batch değeri büyük ölçüde değiştirilir. Bu durumlarda, mevcut .cache yeniden adlandırılmalı ve farklı bir dizine taşınmalı veya tamamen silinmelidir.

YOLO ile TensorRT INT8 kullanmanın avantajları

  • Azaltılmış model boyutu: FP32'den INT8'e kuantizasyon, model boyutunu 4 kat azaltabilir (diskte veya bellekte), bu da daha hızlı indirme sürelerine yol açar. daha düşük depolama gereksinimleri ve bir modeli dağıtırken daha az bellek ayak izi.

  • Daha düşük güç tüketimi: INT8 dışa aktarılan YOLO modelleri için azaltılmış hassasiyet işlemleri, özellikle pille çalışan cihazlar için FP32 modellerine kıyasla daha az güç tüketebilir.

  • Geliştirilmiş çıkarım hızları: TensorRT , modeli hedef donanım için optimize ederek GPU'larda, gömülü cihazlarda ve hızlandırıcılarda potansiyel olarak daha yüksek çıkarım hızlarına yol açar.

Çıkarım Hızları Hakkında Not

TensorRT INT8 adresine aktarılan bir modelle yapılan ilk birkaç çıkarım çağrısının normalden daha uzun ön işleme, çıkarım ve/veya son işleme sürelerine sahip olması beklenebilir. Bu durum ayrıca şu değişikliklerde de ortaya çıkabilir imgsz çıkarım sırasında, özellikle imgsz dışa aktarma sırasında belirtilenle aynı değildir (dışa aktarma imgsz TensorRT "optimal" profil olarak ayarlanmıştır).

YOLO ile TensorRT INT8 kullanmanın dezavantajları

  • Değerlendirme ölçütlerinde düşüşler: Daha düşük bir hassasiyet kullanmak şu anlama gelecektir mAP, Precision, Recall veya herhangi bir model performansını değerlendirmek için kullanılan diğer metrik biraz daha kötü olması muhtemeldir. Bakınız Performans sonuçları bölümü farklılıkları karşılaştırmak için mAP50 ve mAP50-95 çeşitli cihazların küçük bir örneğinde INT8 ile dışa aktarırken.

  • Artan geliştirme süreleri: INT8 kalibrasyonu için veri seti ve cihaza yönelik "en uygun" ayarları bulmak önemli miktarda test gerektirebilir.

  • Donanım bağımlılığı: Kalibrasyon ve performans kazanımları yüksek oranda donanıma bağlı olabilir ve model ağırlıkları daha az aktarılabilir.

Ultralytics YOLO TensorRT İhracat Performansı

NVIDIA A100

Performans

Ubuntu 22.04.3 LTS ile test edilmiştir, python 3.10.12, ultralytics==8.2.4, tensorrt==8.6.1.post1

Önceden eğitilmiş 80 sınıf içeren COCO üzerinde eğitilen bu modellerle kullanım örnekleri için Algılama Dokümanları 'na bakın.

Not

Çıkarım süreleri şunlar için gösterilmiştir mean, min (en hızlı) ve max (en yavaş) önceden eğitilmiş ağırlıkları kullanarak her test için yolov8n.engine

Hassasiyet Değerlendirme testi ortalama
(ms)
min | maks
(ms)
mAPval
50(B)
mAPval
50-95(B)
batch boyut
(piksel)
FP32 Tahmin Et 0.52 0.51 | 0.56 8 640
FP32 COCOval 0.52 0.52 0.37 1 640
FP16 Tahmin Et 0.34 0.34 | 0.41 8 640
FP16 COCOval 0.33 0.52 0.37 1 640
INT8 Tahmin Et 0.28 0.27 | 0.31 8 640
INT8 COCOval 0.29 0.47 0.33 1 640

Önceden eğitilmiş 80 sınıf içeren COCO üzerinde eğitilen bu modellerle kullanım örnekleri için Segmentasyon Dokümanları 'na bakın.

Not

Çıkarım süreleri şunlar için gösterilmiştir mean, min (en hızlı) ve max (en yavaş) önceden eğitilmiş ağırlıkları kullanarak her test için yolov8n-seg.engine

Hassasiyet Değerlendirme testi ortalama
(ms)
min | maks
(ms)
mAPval
50(B)
mAPval
50-95(B)
mAPval
50(M)
mAPval
50-95(M)
batch boyut
(piksel)
FP32 Tahmin Et 0.62 0.61 | 0.68 8 640
FP32 COCOval 0.63 0.52 0.36 0.49 0.31 1 640
FP16 Tahmin Et 0.40 0.39 | 0.44 8 640
FP16 COCOval 0.43 0.52 0.36 0.49 0.30 1 640
INT8 Tahmin Et 0.34 0.33 | 0.37 8 640
INT8 COCOval 0.36 0.46 0.32 0.43 0.27 1 640

Önceden eğitilmiş 1000 sınıf içeren ImageNet üzerinde eğitilen bu modellerle kullanım örnekleri için Classification Docs bölümüne bakın.

Not

Çıkarım süreleri şunlar için gösterilmiştir mean, min (en hızlı) ve max (en yavaş) önceden eğitilmiş ağırlıkları kullanarak her test için yolov8n-cls.engine

Hassasiyet Değerlendirme testi ortalama
(ms)
min | maks
(ms)
üst-1 ilk 5 batch boyut
(piksel)
FP32 Tahmin Et 0.26 0.25 | 0.28 8 640
FP32 ImageNetval 0.26 0.35 0.61 1 640
FP16 Tahmin Et 0.18 0.17 | 0.19 8 640
FP16 ImageNetval 0.18 0.35 0.61 1 640
INT8 Tahmin Et 0.16 0.15 | 0.57 8 640
INT8 ImageNetval 0.15 0.32 0.59 1 640

Önceden eğitilmiş 1 sınıf olan "kişi" içeren COCO üzerinde eğitilmiş bu modellerle kullanım örnekleri için Poz Tahmini Dokümanlarına bakın.

Not

Çıkarım süreleri şunlar için gösterilmiştir mean, min (en hızlı) ve max (en yavaş) önceden eğitilmiş ağırlıkları kullanarak her test için yolov8n-pose.engine

Hassasiyet Değerlendirme testi ortalama
(ms)
min | maks
(ms)
mAPval
50(B)
mAPval
50-95(B)
mAPval
50(P)
mAPval
50-95(P)
batch boyut
(piksel)
FP32 Tahmin Et 0.54 0.53 | 0.58 8 640
FP32 COCOval 0.55 0.91 0.69 0.80 0.51 1 640
FP16 Tahmin Et 0.37 0.35 | 0.41 8 640
FP16 COCOval 0.36 0.91 0.69 0.80 0.51 1 640
INT8 Tahmin Et 0.29 0.28 | 0.33 8 640
INT8 COCOval 0.30 0.90 0.68 0.78 0.47 1 640

Önceden eğitilmiş 15 sınıf içeren DOTAv1 üzerinde eğitilen bu modellerle kullanım örnekleri için Yönlendirilmiş Algılama Dokümanları 'na bakın.

Not

Çıkarım süreleri şunlar için gösterilmiştir mean, min (en hızlı) ve max (en yavaş) önceden eğitilmiş ağırlıkları kullanarak her test için yolov8n-obb.engine

Hassasiyet Değerlendirme testi ortalama
(ms)
min | maks
(ms)
mAPval
50(B)
mAPval
50-95(B)
batch boyut
(piksel)
FP32 Tahmin Et 0.52 0.51 | 0.59 8 640
FP32 DOTAv1val 0.76 0.50 0.36 1 640
FP16 Tahmin Et 0.34 0.33 | 0.42 8 640
FP16 DOTAv1val 0.59 0.50 0.36 1 640
INT8 Tahmin Et 0.29 0.28 | 0.33 8 640
INT8 DOTAv1val 0.32 0.45 0.32 1 640

Tüketici GPU'ları

Algılama Performansı (COCO)

Windows 10.0.19045 ile test edilmiştir, python 3.10.9, ultralytics==8.2.4, tensorrt==10.0.0b6

Not

Çıkarım süreleri şunlar için gösterilmiştir mean, min (en hızlı) ve max (en yavaş) önceden eğitilmiş ağırlıkları kullanarak her test için yolov8n.engine

Hassasiyet Değerlendirme testi ortalama
(ms)
min | maks
(ms)
mAPval
50(B)
mAPval
50-95(B)
batch boyut
(piksel)
FP32 Tahmin Et 1.06 0.75 | 1.88 8 640
FP32 COCOval 1.37 0.52 0.37 1 640
FP16 Tahmin Et 0.62 0.75 | 1.13 8 640
FP16 COCOval 0.85 0.52 0.37 1 640
INT8 Tahmin Et 0.52 0.38 | 1.00 8 640
INT8 COCOval 0.74 0.47 0.33 1 640

Windows 10.0.22631 ile test edilmiştir, python 3.11.9, ultralytics==8.2.4, tensorrt==10.0.1

Not

Çıkarım süreleri şunlar için gösterilmiştir mean, min (en hızlı) ve max (en yavaş) önceden eğitilmiş ağırlıkları kullanarak her test için yolov8n.engine

Hassasiyet Değerlendirme testi ortalama
(ms)
min | maks
(ms)
mAPval
50(B)
mAPval
50-95(B)
batch boyut
(piksel)
FP32 Tahmin Et 1.76 1.69 | 1.87 8 640
FP32 COCOval 1.94 0.52 0.37 1 640
FP16 Tahmin Et 0.86 0.75 | 1.00 8 640
FP16 COCOval 1.43 0.52 0.37 1 640
INT8 Tahmin Et 0.80 0.75 | 1.00 8 640
INT8 COCOval 1.35 0.47 0.33 1 640

Pop!_OS 22.04 LTS ile test edilmiştir, python 3.10.12, ultralytics==8.2.4, tensorrt==8.6.1.post1

Not

Çıkarım süreleri şunlar için gösterilmiştir mean, min (en hızlı) ve max (en yavaş) önceden eğitilmiş ağırlıkları kullanarak her test için yolov8n.engine

Hassasiyet Değerlendirme testi ortalama
(ms)
min | maks
(ms)
mAPval
50(B)
mAPval
50-95(B)
batch boyut
(piksel)
FP32 Tahmin Et 2.84 2.84 | 2.85 8 640
FP32 COCOval 2.94 0.52 0.37 1 640
FP16 Tahmin Et 1.09 1.09 | 1.10 8 640
FP16 COCOval 1.20 0.52 0.37 1 640
INT8 Tahmin Et 0.75 0.74 | 0.75 8 640
INT8 COCOval 0.76 0.47 0.33 1 640

Gömülü Cihazlar

Algılama Performansı (COCO)

JetPack 6.0 (L4T 36.3) Ubuntu 22.04.4 LTS ile test edilmiştir, python 3.10.12, ultralytics==8.2.16, tensorrt==10.0.1

Not

Çıkarım süreleri şunlar için gösterilmiştir mean, min (en hızlı) ve max (en yavaş) önceden eğitilmiş ağırlıkları kullanarak her test için yolov8n.engine

Hassasiyet Değerlendirme testi ortalama
(ms)
min | maks
(ms)
mAPval
50(B)
mAPval
50-95(B)
batch boyut
(piksel)
FP32 Tahmin Et 6.11 6.10 | 6.29 8 640
FP32 COCOval 6.17 0.52 0.37 1 640
FP16 Tahmin Et 3.18 3.18 | 3.20 8 640
FP16 COCOval 3.19 0.52 0.37 1 640
INT8 Tahmin Et 2.30 2.29 | 2.35 8 640
INT8 COCOval 2.32 0.46 0.32 1 640

Bilgi

Kurulum ve yapılandırma hakkında daha fazla bilgi edinmek için NVIDIA Jetson with Ultralytics YOLO adresindeki hızlı başlangıç kılavuzumuza bakın.

Değerlendirme yöntemleri

Bu modellerin nasıl dışa aktarıldığı ve test edildiği hakkında bilgi için aşağıdaki bölümleri genişletin.

Konfigürasyonları dışa aktarma

Dışa aktarma yapılandırma argümanlarıyla ilgili ayrıntılar için bkz.

from ultralytics import YOLO

model = YOLO("yolov8n.pt")

# TensorRT FP32
out = model.export(format="engine", imgsz=640, dynamic=True, verbose=False, batch=8, workspace=2)

# TensorRT FP16
out = model.export(format="engine", imgsz=640, dynamic=True, verbose=False, batch=8, workspace=2, half=True)

# TensorRT INT8 with calibration `data` (i.e. COCO, ImageNet, or DOTAv1 for appropriate model task)
out = model.export(
    format="engine", imgsz=640, dynamic=True, verbose=False, batch=8, workspace=2, int8=True, data="coco8.yaml"
)
Döngüyü tahmin et

Ek bilgi için tahmin moduna bakın.

import cv2

from ultralytics import YOLO

model = YOLO("yolov8n.engine")
img = cv2.imread("path/to/image.jpg")

for _ in range(100):
    result = model.predict(
        [img] * 8,  # batch=8 of the same image
        verbose=False,
        device="cuda",
    )
Doğrulama yapılandırması

Bkz. val modu doğrulama yapılandırma argümanları hakkında daha fazla bilgi edinmek için.

from ultralytics import YOLO

model = YOLO("yolov8n.engine")
results = model.val(
    data="data.yaml",  # COCO, ImageNet, or DOTAv1 for appropriate model task
    batch=1,
    imgsz=640,
    verbose=False,
    device="cuda",
)

Dışa Aktarılan YOLOv8 TensorRT Modellerini Dağıtma

Ultralytics YOLOv8 modellerinizi TensorRT biçimine başarıyla aktardıktan sonra artık bunları dağıtmaya hazırsınız. TensorRT modellerinizi çeşitli ortamlarda dağıtmaya ilişkin ayrıntılı talimatlar için aşağıdaki kaynaklara göz atın:

Özet

Bu kılavuzda, Ultralytics YOLOv8 modellerini NVIDIA'nin TensorRT model formatına dönüştürmeye odaklandık. Bu dönüştürme adımı, YOLOv8 modellerinin verimliliğini ve hızını artırmak, onları daha etkili ve çeşitli dağıtım ortamları için uygun hale getirmek için çok önemlidir.

Kullanım detayları hakkında daha fazla bilgi için TensorRT resmi belgelerine göz atın.

Ek Ultralytics YOLOv8 entegrasyonları hakkında merak ettikleriniz varsa, entegrasyon kılavuzu sayfamızda kapsamlı bir bilgilendirici kaynak ve içgörü seçkisi bulunmaktadır.

SSS

YOLOv8 modellerini TensorRT formatına nasıl dönüştürebilirim?

Optimize edilmiş NVIDIA GPU çıkarımı için Ultralytics YOLOv8 modellerinizi TensorRT biçimine dönüştürmek için aşağıdaki adımları izleyin:

  1. Gerekli paketi yükleyin:

    pip install ultralytics
    
  2. YOLOv8 modelinizi dışa aktarın:

    from ultralytics import YOLO
    
    model = YOLO("yolov8n.pt")
    model.export(format="engine")  # creates 'yolov8n.engine'
    
    # Run inference
    model = YOLO("yolov8n.engine")
    results = model("https://ultralytics.com/images/bus.jpg")
    

Daha fazla ayrıntı için YOLOv8 Kurulum kılavuzunu ve dışa aktarma belgelerini ziyaret edin.

YOLOv8 modelleri için TensorRT kullanmanın faydaları nelerdir?

YOLOv8 modellerini optimize etmek için TensorRT adresini kullanmak çeşitli avantajlar sunar:

  • Daha Hızlı Çıkarım Hızı: TensorRT model katmanlarını optimize eder ve doğruluktan önemli ölçüde ödün vermeden çıkarımı hızlandırmak için hassas kalibrasyon (INT8 ve FP16) kullanır.
  • Bellek Verimliliği: TensorRT , tensor belleğini dinamik olarak yöneterek ek yükü azaltır ve GPU bellek kullanımını iyileştirir.
  • Katman Füzyonu: Birden fazla katmanı tek bir işlemde birleştirerek hesaplama karmaşıklığını azaltır.
  • Çekirdek Otomatik Ayarlama: Her model katmanı için optimize edilmiş GPU çekirdeklerini otomatik olarak seçerek maksimum performans sağlar.

Daha fazla bilgi için TensorRT adresinin ayrıntılı özellikleriniburadan inceleyebilir ve TensorRT genel bakış bölümümüzü okuyabilirsiniz.

YOLOv8 modelleri için TensorRT ile INT8 niceleme kullanabilir miyim?

Evet, YOLOv8 modellerini INT8 niceleme ile TensorRT kullanarak dışa aktarabilirsiniz. Bu işlem, eğitim sonrası niceleme (PTQ) ve kalibrasyonu içerir:

  1. INT8 ile dışa aktarın:

    from ultralytics import YOLO
    
    model = YOLO("yolov8n.pt")
    model.export(format="engine", batch=8, workspace=4, int8=True, data="coco.yaml")
    
  2. Çıkarımları çalıştır:

    from ultralytics import YOLO
    
    model = YOLO("yolov8n.engine", task="detect")
    result = model.predict("https://ultralytics.com/images/bus.jpg")
    

Daha fazla ayrıntı için INT8 niceleme ile TensorRT dışa aktarma bölümüne bakın.

YOLOv8 TensorRT modellerini bir NVIDIA Triton Çıkarım Sunucusuna nasıl dağıtabilirim?

YOLOv8 TensorRT modellerinin bir NVIDIA Triton Çıkarım Sunucusu üzerinde dağıtılması aşağıdaki kaynaklar kullanılarak yapılabilir:

Bu kılavuzlar, YOLOv8 modellerini çeşitli dağıtım ortamlarına verimli bir şekilde entegre etmenize yardımcı olacaktır.

TensorRT adresine aktarılan YOLOv8 modelleri ile gözlemlenen performans iyileştirmeleri nelerdir?

TensorRT ile performans iyileştirmeleri kullanılan donanıma göre değişebilir. İşte bazı tipik kıyaslamalar:

  • NVIDIA A100:

    • FP32 Çıkarım: ~0,52 ms / görüntü
    • FP16 Çıkarım: ~0,34 ms / görüntü
    • INT8 Çıkarım: ~0,28 ms / görüntü
    • INT8 hassasiyeti ile mAP'de hafif azalma, ancak hızda önemli gelişme.
  • Tüketici GPU'ları (örn. RTX 3080):

    • FP32 Çıkarım: ~1,06 ms / görüntü
    • FP16 Çıkarım: ~0,62 ms / görüntü
    • INT8 Çıkarım: ~0,52 ms / görüntü

Farklı donanım konfigürasyonları için ayrıntılı performans kıyaslamaları performans bölümünde bulunabilir.

TensorRT performansına ilişkin daha kapsamlı bilgiler için Ultralytics belgelerine ve performans analizi raporlarımıza bakın.


📅 Created 8 months ago ✏️ Updated 4 days ago

Yorumlar