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, 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.
-
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.
-
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 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")
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 birworkspace
may increase calibration time, it allows TensorRT to explore a wider range of optimization tactics, potentially enhancing model performance and accuracy. Conversely, a smallerworkspace
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ındaworkspace
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ünimgsz
vebatch
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")
- 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. - 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. - Dönüştürme işlemi için tüm aygıtı ayırmak yerine 4 GiB bellek ayırır.
- 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çinmAP50
vemAP50-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.
Doğrulama yapılandırması
Bkz. val
modu doğrulama yapılandırma argümanları hakkında daha fazla bilgi edinmek için.
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:
-
Ultralytics adresini bir Triton Sunucusu ile dağıtın: Özellikle Ultralytics YOLO modelleriyle kullanım için NVIDIA'un Triton Inference (eski adıyla TensorRT Inference) Sunucusunun nasıl kullanılacağına ilişkin kılavuzumuz.
-
Derin Sinir Ağları ile Dağıtım NVIDIA TensorRT: Bu makalede, GPU tabanlı dağıtım platformlarında derin sinir ağlarını verimli bir şekilde dağıtmak için NVIDIA TensorRT adresinin nasıl kullanılacağı açıklanmaktadır.
-
NVIDIA Tabanlı Bilgisayarlar için Uçtan Uca Yapay Zeka: NVIDIA TensorRT Dağıtım: Bu blog yazısı, NVIDIA tabanlı bilgisayarlarda yapay zeka modellerini optimize etmek ve dağıtmak için NVIDIA TensorRT adresinin kullanımını açıklamaktadır.
-
GitHub Repository for NVIDIA TensorRT :: Bu, NVIDIA TensorRT için kaynak kodu ve belgeleri içeren resmi GitHub deposudur.
Ö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:
-
Gerekli paketi yükleyin:
-
YOLOv8 modelinizi dışa aktarın:
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:
-
INT8 ile dışa aktarın:
-
Çıkarımları çalıştır:
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:
- Ultralytics YOLOv8 adresini Triton Server ile dağıtın: Triton Inference Server'ın kurulumu ve kullanımı hakkında adım adım rehberlik.
- NVIDIA Triton Çıkarım Sunucusu Dokümantasyonu: Ayrıntılı dağıtım seçenekleri ve yapılandırmalar için resmi NVIDIA belgeleri.
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.