TensorRT YOLOv8 ๋ชจ๋ธ์ฉ ๋ด๋ณด๋ด๊ธฐ
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.
์ด ํดํท์ ๋ฅ ๋ฌ๋ ๋ชจ๋ธ์ NVIDIA GPU์ ์ต์ ํํ์ฌ ๋ ๋น ๋ฅด๊ณ ํจ์จ์ ์ธ ์์ ์ ๊ฐ๋ฅํ๊ฒ ํฉ๋๋ค. TensorRT ๋ชจ๋ธ์ ๋ ์ด์ด ์ตํฉ, ์ ๋ฐ ๋ณด์ (INT8 ๋ฐ FP16), ๋์ tensor ๋ฉ๋ชจ๋ฆฌ ๊ด๋ฆฌ ๋ฐ ์ปค๋ ์๋ ํ๋๊ณผ ๊ฐ์ ๊ธฐ์ ์ ํฌํจํ๋ TensorRT ์ต์ ํ๋ฅผ ๊ฑฐ์นฉ๋๋ค. ๋ฅ ๋ฌ๋ ๋ชจ๋ธ์ TensorRT ํ์์ผ๋ก ๋ณํํ๋ฉด ๊ฐ๋ฐ์๋ NVIDIA GPU์ ์ ์ฌ๋ ฅ์ ์์ ํ ์คํํ ์ ์์ต๋๋ค.
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 ๋ชจ๋ธ์ ์ฃผ์ ๊ธฐ๋ฅ
TensorRT ๋ชจ๋ธ์ ๊ณ ์ ๋ฅ ๋ฌ๋ ์ถ๋ก ์ ํจ์จ์ฑ๊ณผ ํจ๊ณผ์ ๊ธฐ์ฌํ๋ ๋ค์ํ ์ฃผ์ ๊ธฐ๋ฅ์ ์ ๊ณตํฉ๋๋ค:
-
์ ๋ฐ ๋ณด์ : TensorRT ์์๋ ์ ๋ฐ ๋ณด์ ์ ์ง์ํ์ฌ ํน์ ์ ํ๋ ์๊ฑด์ ๋ง๊ฒ ๋ชจ๋ธ์ ๋ฏธ์ธ ์กฐ์ ํ ์ ์์ต๋๋ค. ์ฌ๊ธฐ์๋ ํ์ฉ ๊ฐ๋ฅํ ์ ํ๋ ์์ค์ ์ ์งํ๋ฉด์ ์ถ๋ก ์๋๋ฅผ ๋์ฑ ๋์ผ ์ ์๋ INT8 ๋ฐ FP16๊ณผ ๊ฐ์ ๊ฐ์๋ ์ ๋ฐ๋ ํ์์ ๋ํ ์ง์์ด ํฌํจ๋ฉ๋๋ค.
-
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.
-
๋์ Tensor ๋ฉ๋ชจ๋ฆฌ ๊ด๋ฆฌ: TensorRT ์ถ๋ก ์ค tensor ๋ฉ๋ชจ๋ฆฌ ์ฌ์ฉ๋์ ํจ์จ์ ์ผ๋ก ๊ด๋ฆฌํ์ฌ ๋ฉ๋ชจ๋ฆฌ ์ค๋ฒํค๋๋ฅผ ์ค์ด๊ณ ๋ฉ๋ชจ๋ฆฌ ํ ๋น์ ์ต์ ํํฉ๋๋ค. ๊ทธ ๊ฒฐ๊ณผ GPU ๋ฉ๋ชจ๋ฆฌ ์ฌ์ฉ๋ฅ ์ด ๋์ฑ ํจ์จ์ ์ ๋๋ค.
-
์๋ ์ปค๋ ํ๋: TensorRT ์๋ ์ปค๋ ํ๋์ ์ ์ฉํ์ฌ ๋ชจ๋ธ์ ๊ฐ ๋ ์ด์ด์ ๊ฐ์ฅ ์ต์ ํ๋ GPU ์ปค๋์ ์ ํํฉ๋๋ค. ์ด ์ ์ํ ์ ๊ทผ ๋ฐฉ์์ ๋ชจ๋ธ์ด GPU ์ ๊ณ์ฐ ๋ฅ๋ ฅ์ ์ต๋ํ ํ์ฉํ ์ ์๋๋ก ํฉ๋๋ค.
๋ฐฐํฌ ์ต์ TensorRT
YOLOv8 ๋ชจ๋ธ์ TensorRT ํ์์ผ๋ก ๋ด๋ณด๋ด๋ ์ฝ๋๋ฅผ ์ดํด๋ณด๊ธฐ ์ ์ TensorRT ๋ชจ๋ธ์ด ์ผ๋ฐ์ ์ผ๋ก ์ฌ์ฉ๋๋ ์์น๋ฅผ ์ดํดํด ๋ณด๊ฒ ์ต๋๋ค.
TensorRT ๋ ์ฌ๋ฌ ๊ฐ์ง ๋ฐฐํฌ ์ต์ ์ ์ ๊ณตํ๋ฉฐ, ๊ฐ ์ต์ ์ ํตํฉ ์ฉ์ด์ฑ, ์ฑ๋ฅ ์ต์ ํ, ์ ์ฐ์ฑ ๊ฐ์ ๊ท ํ์ ๋ค๋ฅด๊ฒ ์ ์งํฉ๋๋ค:
- 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 ๋ฐํ์ API: ์ธ๋ถํ๋ ์ ์ด ๊ธฐ๋ฅ์ ์ ๊ณตํ์ฌ ์ฑ๋ฅ์ด ์ค์ํ ์ ํ๋ฆฌ์ผ์ด์ ์ ์ด์์ ์ ๋๋ค. ๋ ๋ณต์กํ์ง๋ง ์ง์๋์ง ์๋ ์ฐ์ฐ์๋ฅผ ์ฌ์ฉ์ ์ง์ ์ผ๋ก ๊ตฌํํ ์ ์์ต๋๋ค.
-
NVIDIA Triton ์ถ๋ก ์๋ฒ: ๋ค์ํ ํ๋ ์์ํฌ์ ๋ชจ๋ธ์ ์ง์ํ๋ ์ต์ ์ ๋๋ค. ํนํ ํด๋ผ์ฐ๋ ๋๋ ์์ง ์ถ๋ก ์ ์ ํฉํ๋ฉฐ, ๋์ ๋ชจ๋ธ ์คํ ๋ฐ ๋ชจ๋ธ ๋ถ์๊ณผ ๊ฐ์ ๊ธฐ๋ฅ์ ์ ๊ณตํฉ๋๋ค.
YOLOv8 ๋ชจ๋ธ๋ก ๋ด๋ณด๋ด๊ธฐ TensorRT
YOLOv8 ๋ชจ๋ธ์ TensorRT ํ์์ผ๋ก ๋ณํํ์ฌ ์คํ ํจ์จ์ฑ์ ๊ฐ์ ํ๊ณ ์ฑ๋ฅ์ ์ต์ ํํ ์ ์์ต๋๋ค.
์ค์น
ํ์ํ ํจํค์ง๋ฅผ ์ค์นํ๋ ค๋ฉด ์คํํฉ๋๋ค:
์ค์น ๊ณผ์ ๊ณผ ๊ด๋ จ๋ ์์ธํ ์ง์นจ๊ณผ ๋ชจ๋ฒ ์ฌ๋ก๋ YOLOv8 ์ค์น ๊ฐ์ด๋๋ฅผ ์ฐธ์กฐํ์ธ์. YOLOv8 ์ ํ์ํ ํจํค์ง๋ฅผ ์ค์นํ๋ ๋์ ๋ฌธ์ ๊ฐ ๋ฐ์ํ๋ฉด ์ผ๋ฐ์ ์ธ ๋ฌธ์ ๊ฐ์ด๋๋ฅผ ์ฐธ์กฐํ์ฌ ํด๊ฒฐ ๋ฐฉ๋ฒ๊ณผ ํ์ ํ์ธํ์ธ์.
์ฌ์ฉ๋ฒ
์ฌ์ฉ ์ง์นจ์ ์ดํด๋ณด๊ธฐ ์ ์ Ultralytics ์์ ์ ๊ณตํ๋ ๋ค์ํ YOLOv8 ๋ชจ๋ธ์ ํ์ธํ์ธ์. ํ๋ก์ ํธ ์๊ตฌ ์ฌํญ์ ๊ฐ์ฅ ์ ํฉํ ๋ชจ๋ธ์ ์ ํํ๋ ๋ฐ ๋์์ด ๋ ๊ฒ์ ๋๋ค.
์ฌ์ฉ๋ฒ
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")
๋ด๋ณด๋ด๊ธฐ ํ๋ก์ธ์ค์ ๋ํ ์์ธํ ๋ด์ฉ์ ๋ด๋ณด๋ด๊ธฐ ๊ด๋ จ ๋ฌธ์ ํ์ด์ง(Ultralytics )๋ฅผ ์ฐธ์กฐํ์ธ์.
INT8 ์ ๋ํ๋ฅผ ์ฌ์ฉํ์ฌ TensorRT ๋ด๋ณด๋ด๊ธฐ
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.
์์์ ์ผ๋ก ์์ํ๋ ๋คํธ์ํฌ๋ฅผ ์ฒ๋ฆฌํ ๋ TensorRT ์ ๊ณ์ธต ์คํ ์๊ฐ์ ์ต์ ํํ๊ธฐ ์ํด ๊ธฐํ์ฃผ์์ ์ผ๋ก INT8์ ์ฌ์ฉํฉ๋๋ค. ๋ ์ด์ด๊ฐ INT8์์ ๋ ๋น ๋ฅด๊ฒ ์คํ๋๊ณ ๋ฐ์ดํฐ ์ ๋ ฅ ๋ฐ ์ถ๋ ฅ์ ์์ํ ์ค์ผ์ผ์ด ํ ๋น๋ ๊ฒฝ์ฐ, ํด๋น ๋ ์ด์ด์ INT8 ์ ๋ฐ๋๋ฅผ ๊ฐ์ง ์ปค๋์ด ํ ๋น๋๊ณ , ๊ทธ๋ ์ง ์์ ๊ฒฝ์ฐ TensorRT ๋ ํด๋น ๋ ์ด์ด์ ์คํ ์๊ฐ์ด ๋ ๋น ๋ฅธ ๊ฒ์ ๊ธฐ์ค์ผ๋ก ์ปค๋์ ๋ํด FP32 ๋๋ FP16์ ์ ๋ฐ๋๋ฅผ ์ ํํ๊ฒ ๋ฉ๋๋ค.
ํ
์บ๋ฆฌ๋ธ๋ ์ด์ ๊ฒฐ๊ณผ๋ ๊ธฐ๊ธฐ๋ง๋ค ๋ค๋ฅผ ์ ์์ผ๋ฏ๋ก ๋ฐฐํฌ์ TensorRT ๋ชจ๋ธ ๊ฐ์ค์น๋ฅผ ์ฌ์ฉํ ๋์ผํ ๊ธฐ๊ธฐ๋ฅผ INT8 ์ ๋ฐ๋๋ก ๋ด๋ณด๋ด๋ ๋ฐ ์ฌ์ฉํ๋ ๊ฒ์ด ์ค์ํฉ๋๋ค.
INT8 ๋ด๋ณด๋ด๊ธฐ ๊ตฌ์ฑ
์ฌ์ฉ ์ ์ ๊ณต๋๋ ์ธ์ ๋ด๋ณด๋ด๊ธฐ Ultralytics YOLO ๋ชจ๋ธ์ ๊ฒฝ์ฐ ํฌ๊ฒ ๋ ๋ด๋ณด๋ธ ๋ชจ๋ธ์ ์ฑ๋ฅ์ ์ํฅ์ ์ค๋๋ค. ๋ํ ์ฌ์ฉ ๊ฐ๋ฅํ ์ฅ์น ๋ฆฌ์์ค์ ๋ฐ๋ผ ์ ํํด์ผ ํ์ง๋ง ๊ธฐ๋ณธ ์ธ์๋ ๋ค์๊ณผ ๊ฐ์ต๋๋ค. should ๋๋ถ๋ถ์ ์์
Ampere(๋๋ ์ต์ ๋ฒ์ ) NVIDIA ์ธ์ฅํ GPU. ์ฌ์ฉ๋๋ ๋ณด์ ์๊ณ ๋ฆฌ์ฆ์ "ENTROPY_CALIBRATION_2"
์์ ์ฌ์ฉ ๊ฐ๋ฅํ ์ต์
์ ๋ํ ์์ธํ ๋ด์ฉ์ ํ์ธํ ์ ์์ต๋๋ค. TensorRT ๊ฐ๋ฐ์ ๊ฐ์ด๋์์. Ultralytics ํ
์คํธ ๊ฒฐ๊ณผ "ENTROPY_CALIBRATION_2"
๊ฐ ์ต์ ์ ์ ํ์ด์์ผ๋ฉฐ ๋ด๋ณด๋ด๊ธฐ๋ ์ด ์๊ณ ๋ฆฌ์ฆ์ ์ฌ์ฉํ๋๋ก ๊ณ ์ ๋์ด ์์ต๋๋ค.
-
workspace
: ๋ชจ๋ธ ๊ฐ์ค์น๋ฅผ ๋ณํํ๋ ๋์ ๋๋ฐ์ด์ค ๋ฉ๋ชจ๋ฆฌ ํ ๋น์ ํฌ๊ธฐ(GiB ๋จ์)๋ฅผ ์ ์ดํฉ๋๋ค.-
์กฐ์
workspace
๊ฐ์ ๋ฐ๋ผ ๋ณด์ ์๊ตฌ ์ฌํญ๊ณผ ๋ฆฌ์์ค ๊ฐ์ฉ์ฑ์ ๋ฐ๋ผ ์กฐ์ ํ ์ ์์ต๋๋ค. ๋ ํฐworkspace
may increase calibration time, it allows TensorRT to explore a wider range of optimization tactics, potentially enhancing model performance and accuracy. Conversely, a smallerworkspace
๋ฅผ ์ฌ์ฉํ๋ฉด ๋ณด์ ์๊ฐ์ ์ค์ผ ์ ์์ง๋ง ์ต์ ํ ์ ๋ต์ด ์ ํ๋์ด ์ ๋ํ๋ ๋ชจ๋ธ์ ํ์ง์ ์ํฅ์ ๋ฏธ์น ์ ์์ต๋๋ค. -
๊ธฐ๋ณธ๊ฐ์
workspace=4
(๊ธฐ๊ฐ๋ฐ์ดํธ)๋ฅผ ์ด๊ณผํ๋ ๊ฒฝ์ฐ ๋ณด์ ์ด ์ถฉ๋(๊ฒฝ๊ณ ์์ด ์ข ๋ฃ)ํ๋ ๊ฒฝ์ฐ ์ด ๊ฐ์ ๋๋ ค์ผ ํ ์ ์์ต๋๋ค. -
TensorRT ๋ณด๊ณ ํฉ๋๋ค
UNSUPPORTED_STATE
์ ๊ฐ์ ๋ด๋ณด๋ด๋ ๋์workspace
์ ๊ฐ์ด ์ฅ์น์์ ์ฌ์ฉํ ์ ์๋ ๋ฉ๋ชจ๋ฆฌ๋ณด๋ค ํฌ๋ฉดworkspace
๋ฅผ ๋ฎ์ถฐ์ผ ํฉ๋๋ค. -
๋ง์ฝ
workspace
๊ฐ ์ต๋ ๊ฐ์ผ๋ก ์ค์ ๋์ด ์๊ณ ๋ณด์ ์ ์คํจ/์ถฉ๋ํ๋ ๊ฒฝ์ฐ ๋ค์ ๊ฐ์ ์ค์ด๋ ๊ฒ์ ๊ณ ๋ คํ์ญ์์ค.imgsz
๊ทธ๋ฆฌ๊ณbatch
๋ฅผ ์ฌ์ฉํ์ฌ ๋ฉ๋ชจ๋ฆฌ ์๊ตฌ ์ฌํญ์ ์ค์ผ ์ ์์ต๋๋ค. -
INT8์ ๋ํ ๋ณด์ ์ ๊ฐ ๋๋ฐ์ด์ค๋ง๋ค ๋ค๋ฅด๋ฉฐ, ๋ณด์ ์ ์ํด 'ํ์ด์๋' GPU ๋ฅผ ์ฐจ์ฉํ๋ฉด ๋ค๋ฅธ ๋๋ฐ์ด์ค์์ ์ถ๋ก ์ ์คํํ ๋ ์ฑ๋ฅ์ด ์ ํ๋ ์ ์๋ค๋ ์ ์ ๊ธฐ์ตํ์ธ์.
-
-
batch
: ์ถ๋ก ์ ์ฌ์ฉํ ์ต๋ ๋ฐฐ์น ํฌ๊ธฐ์ ๋๋ค. ์ถ๋ก ์ค์๋ ๋ ์์ ๋ฐฐ์น๋ฅผ ์ฌ์ฉํ ์ ์์ง๋ง ์ถ๋ก ์ ์ง์ ๋ ๊ฒ๋ณด๋ค ํฐ ๋ฐฐ์น๋ ํ์ฉํ์ง ์์ต๋๋ค.
์ฐธ๊ณ
๋ณด์ ํ๋ ๋์ ๋ ๋ฐฐ์ batch
ํฌ๊ธฐ๊ฐ ์ฌ์ฉ๋ฉ๋๋ค. ์์ ๋ฐฐ์น๋ฅผ ์ฌ์ฉํ๋ฉด ๋ณด์ ์ค์ ์ค์ผ์ผ๋ง์ด ๋ถ์ ํํด์ง ์ ์์ต๋๋ค. ์ด๋ ํ๋ก์ธ์ค๊ฐ ๋ณด์ด๋ ๋ฐ์ดํฐ๋ฅผ ๊ธฐ๋ฐ์ผ๋ก ์กฐ์ ํ๊ธฐ ๋๋ฌธ์
๋๋ค. ์์ ๋ฐฐ์น๋ ์ ์ฒด ๋ฒ์์ ๊ฐ์ ์บก์ฒํ์ง ๋ชปํ์ฌ ์ต์ข
๋ณด์ ์ ๋ฌธ์ ๊ฐ ๋ฐ์ํ ์ ์์ต๋๋ค. batch
size is doubled automatically. If no batch size is specified batch=1
์์ ๋ณด์ ์ด ์คํ๋ฉ๋๋ค. batch=1 * 2
๋ฅผ ์ฌ์ฉํ์ฌ ๋ณด์ ์ค์ผ์ผ๋ง ์ค๋ฅ๋ฅผ ์ค์ผ ์ ์์ต๋๋ค.
NVIDIA ์ ์คํ ๊ฒฐ๊ณผ, INT8 ์ ๋ํ ๋ณด์ ์ ํตํด ๋ชจ๋ธ์ ๋ฐ์ดํฐ๋ฅผ ๋ํํ๋ 500๊ฐ ์ด์์ ๋ณด์ ์ด๋ฏธ์ง๋ฅผ ์ฌ์ฉํ ๊ฒ์ ๊ถ์ฅํ์ต๋๋ค. ์ด๋ ๊ฐ์ด๋๋ผ์ธ์ผ ๋ฟ hard ์๊ตฌ ์ฌํญ ๋ฐ ๋ฐ์ดํฐ ์ธํธ์ ์ฑ๋ฅ์ ์ ๋ฐํํ๋ ๋ฐ ํ์ํ ๊ฒ์ด ๋ฌด์์ธ์ง ์คํํด ๋ณด์์ผ ํฉ๋๋ค. INT8 ์บ๋ฆฌ๋ธ๋ ์ด์
์๋ TensorRT ์ ์ฌ์ฉํ ์บ๋ฆฌ๋ธ๋ ์ด์
๋ฐ์ดํฐ๊ฐ ํ์ํ๋ฏ๋ก ๋ฐ๋์ data
์ธ์๋ฅผ ์ฌ์ฉํ ๋ int8=True
TensorRT ๋ฅผ ํด๋ฆญํ๊ณ data="my_dataset.yaml"
์ ์ด๋ฏธ์ง๋ฅผ ์ฌ์ฉํฉ๋๋ค. ์ ํจ์ฑ ๊ฒ์ฌ ๋ฅผ ์ฌ์ฉํ์ฌ ๋ณด์ ํฉ๋๋ค. ๊ฐ์ด ์ ๋ฌ๋์ง ์์ ๊ฒฝ์ฐ data
๋ก ๋ด๋ณด๋ด๋ ๊ฒฝ์ฐ INT8 ์ ๋ํ๋ฅผ ์ฌ์ฉํ์ฌ TensorRT ๋ก ๋ด๋ณด๋ด๋ฉด ๊ธฐ๋ณธ๊ฐ์ ๋ค์ ์ค ํ๋๋ฅผ ์ฌ์ฉํ๋ ๊ฒ์
๋๋ค. ๋ชจ๋ธ ์์
์ ๊ธฐ๋ฐํ "์์" ์์ ๋ฐ์ดํฐ ์ธํธ ๋ฅผ ๋ฐํํฉ๋๋ค.
์
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")
- ๋์ ์ถ์ ์ฌ์ฉํ์ฌ ๋ด๋ณด๋ผ ๋ ๊ธฐ๋ณธ์ ์ผ๋ก ์ด ์ต์
์ด ํ์ฑํ๋ฉ๋๋ค.
int8=True
๋ช ์์ ์ผ๋ก ์ค์ ํ์ง ์์ ๊ฒฝ์ฐ์๋ ๋ง์ฐฌ๊ฐ์ง์ ๋๋ค. ์ฐธ์กฐ ๋ด๋ณด๋ด๊ธฐ ์ธ์ ๋ฅผ ํด๋ฆญํด ์์ธํ ์ ๋ณด๋ฅผ ํ์ธํ์ธ์. - ๋ด๋ณด๋ธ ๋ชจ๋ธ์ ๋ํด ์ต๋ ๋ฐฐ์น ํฌ๊ธฐ๋ฅผ 8๋ก ์ค์ ํ๊ณ ๋ค์์ ์ฌ์ฉํ์ฌ ๋ณด์ ํฉ๋๋ค.
batch = 2 * 8
๋ฅผ ์ฌ์ฉํ์ฌ ๋ณด์ ์ค ์ค์ผ์ผ๋ง ์ค๋ฅ๋ฅผ ๋ฐฉ์งํ ์ ์์ต๋๋ค. - ๋ณํ ํ๋ก์ธ์ค๋ฅผ ์ํด ์ ์ฒด ๋๋ฐ์ด์ค๋ฅผ ํ ๋นํ๋ ๋์ 4๊ธฐ๊ฐ๋ฐ์ดํธ์ ๋ฉ๋ชจ๋ฆฌ๋ฅผ ํ ๋นํฉ๋๋ค.
- ๋ณด์ , ํนํ ์ ํจ์ฑ ๊ฒ์ฌ์ ์ฌ์ฉ๋๋ ์ด๋ฏธ์ง(์ด 5,000๊ฐ)์ COCO ๋ฐ์ดํฐ ์ธํธ๋ฅผ ์ฌ์ฉํฉ๋๋ค.
# 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'
๋ณด์ ์บ์
TensorRT ์ ์บ๋ฆฌ๋ธ๋ ์ด์
์ ์์ฑํฉ๋๋ค. .cache
๋ฅผ ์ฌ์ฌ์ฉํ์ฌ ๋์ผํ ๋ฐ์ดํฐ๋ฅผ ์ฌ์ฉํ์ฌ ํฅํ ๋ชจ๋ธ ๊ฐ์ค์น ๋ด๋ณด๋ด๊ธฐ ์๋๋ฅผ ๋์ผ ์ ์์ง๋ง ๋ฐ์ดํฐ๊ฐ ํฌ๊ฒ ๋ค๋ฅด๊ฑฐ๋ batch
๊ฐ์ด ํฌ๊ฒ ๋ณ๊ฒฝ๋ฉ๋๋ค. ์ด๋ฌํ ์ํฉ์์๋ ๊ธฐ์กด .cache
์ ์ด๋ฆ์ ๋ณ๊ฒฝํ์ฌ ๋ค๋ฅธ ๋๋ ํ ๋ฆฌ๋ก ์ฎ๊ธฐ๊ฑฐ๋ ์์ ํ ์ญ์ ํด์ผ ํฉ๋๋ค.
TensorRT INT8๊ณผ ํจ๊ป YOLO ์ฌ์ฉ์ ์ฅ์
-
๋ชจ๋ธ ํฌ๊ธฐ ๊ฐ์: FP32์์ INT8๋ก ์์ํํ๋ฉด ๋ชจ๋ธ ํฌ๊ธฐ๊ฐ 4๋ฐฐ(๋์คํฌ ๋๋ ๋ฉ๋ชจ๋ฆฌ)๋ก ์ค์ด๋ค์ด ๋ค์ด๋ก๋ ์๊ฐ์ด ๋จ์ถ๋๊ณ , ์คํ ๋ฆฌ์ง ์๊ตฌ ์ฌํญ์ด ๋ฎ์์ง๋ฉฐ, ๋ชจ๋ธ ๋ฐฐํฌ ์ ๋ฉ๋ชจ๋ฆฌ ๊ณต๊ฐ์ ์ค์ผ ์ ์์ต๋๋ค.
-
์ ๋ ฅ ์๋น ๊ฐ์: INT8 ์์ถ์ฉ YOLO ๋ชจ๋ธ์ ์ ๋ฐ ์ฐ์ฐ ๊ฐ์๋ ํนํ ๋ฐฐํฐ๋ฆฌ๋ก ๊ตฌ๋๋๋ ์ฅ์น์ ๊ฒฝ์ฐ FP32 ๋ชจ๋ธ์ ๋นํด ์ ๋ ฅ ์๋น๊ฐ ์ ์ต๋๋ค.
-
์ถ๋ก ์๋ ํฅ์: TensorRT ์ ๋์ ํ๋์จ์ด์ ๋ง๊ฒ ๋ชจ๋ธ์ ์ต์ ํํ์ฌ ์ ์ฌ์ ์ผ๋ก GPU, ์๋ฒ ๋๋ ์ฅ์น ๋ฐ ๊ฐ์๊ธฐ์์ ๋ ๋น ๋ฅธ ์ถ๋ก ์๋๋ฅผ ์ด๋์ด๋ ๋๋ค.
์ถ๋ก ์๋์ ๋ํ ์ฐธ๊ณ ์ฌํญ
TensorRT INT8๋ก ๋ด๋ณด๋ธ ๋ชจ๋ธ์ ์ฌ์ฉํ๋ ์ฒ์ ๋ช ๋ฒ์ ์ถ๋ก ํธ์ถ์ ์ผ๋ฐ์ ์ธ ์ ์ฒ๋ฆฌ, ์ถ๋ก ๋ฐ/๋๋ ํ์ฒ๋ฆฌ ์๊ฐ๋ณด๋ค ๋ ์ค๋ ๊ฑธ๋ฆด ์ ์์ต๋๋ค. ์ด๋ ๋ค์์ ๋ณ๊ฒฝํ ๋๋ ๋ฐ์ํ ์ ์์ต๋๋ค. imgsz
์ถ๋ก ํ๋ ๋์, ํนํ ๋ค์๊ณผ ๊ฐ์ ๊ฒฝ์ฐ imgsz
๊ฐ ๋ด๋ณด๋ด๊ธฐ ์ ์ง์ ํ ๊ฒ๊ณผ ๋์ผํ์ง ์์ ๊ฒฝ์ฐ(๋ด๋ณด๋ด๊ธฐ imgsz
TensorRT "์ต์ " ํ๋กํ๋ก ์ค์ ๋จ).
TensorRT INT8๊ณผ YOLO ์ฌ์ฉ์ ๋จ์
-
ํ๊ฐ ์งํ๊ฐ ๊ฐ์ํฉ๋๋ค: ๋ ๋ฎ์ ์ ๋ฐ๋๋ฅผ ์ฌ์ฉํ๋ฉด
mAP
,Precision
,Recall
๋๋ ๋ชจ๋ธ ์ฑ๋ฅ์ ํ๊ฐํ๋ ๋ฐ ์ฌ์ฉ๋๋ ๊ธฐํ ๋ฉํธ๋ฆญ ๋ ๋ค์ ์ ํ๋ ๊ฐ๋ฅ์ฑ์ด ๋์ต๋๋ค. ์์ธํ ๋ด์ฉ์ ์ฑ๋ฅ ๊ฒฐ๊ณผ ์น์ ์ ์ฐจ์ด์ ์ ๋น๊ตํ๋ ค๋ฉดmAP50
๊ทธ๋ฆฌ๊ณmAP50-95
๋ค์ํ ๊ธฐ๊ธฐ์ ์์ ์ํ์์ INT8๋ก ๋ด๋ณด๋ผ ๋ ์ฌ์ฉํฉ๋๋ค. -
๊ฐ๋ฐ ์๊ฐ ์ฆ๊ฐ: ๋ฐ์ดํฐ ์ธํธ์ ๋๋ฐ์ด์ค์ ๋ํ INT8 ์บ๋ฆฌ๋ธ๋ ์ด์ ์ '์ต์ ' ์ค์ ์ ์ฐพ์ผ๋ ค๋ฉด ์๋นํ ์์ ํ ์คํธ๊ฐ ํ์ํ ์ ์์ต๋๋ค.
-
ํ๋์จ์ด ์ข ์์ฑ: ๋ณด์ ๋ฐ ์ฑ๋ฅ ํฅ์์ ํ๋์จ์ด์ ๋ฐ๋ผ ํฌ๊ฒ ๋ฌ๋ผ์ง ์ ์์ผ๋ฉฐ ๋ชจ๋ธ ๊ฐ์ค์น๋ ์ด์ ํ ์ ์์ต๋๋ค.
Ultralytics YOLO TensorRT ์์ถ ์ค์
NVIDIA A100
์ฑ๋ฅ
์ฐ๋ถํฌ 22.04.3 LTS์์ ํ
์คํธํ์ต๋๋ค, python 3.10.12
, ultralytics==8.2.4
, tensorrt==8.6.1.post1
์ฌ์ ํ์ต๋ 80๊ฐ์ ํด๋์ค๋ฅผ ํฌํจํ์ฌ COCO์์ ํ์ต๋ ์ด๋ฌํ ๋ชจ๋ธ์ ์ฌ์ฉ ์์ ๋ ํ์ง ๋ฌธ์๋ฅผ ์ฐธ์กฐํ์ธ์.
์ฐธ๊ณ
๋ค์์ ๋ํ ์ถ๋ก ์๊ฐ์ด ํ์๋ฉ๋๋ค. mean
, min
(๊ฐ์ฅ ๋น ๋ฆ), ๊ทธ๋ฆฌ๊ณ max
(๊ฐ์ฅ ๋๋ฆฐ) ์ฌ์ ํ์ต๋ ๊ฐ์ค์น๋ฅผ ์ฌ์ฉํ์ฌ ๊ฐ ํ
์คํธ์ ๋ํด yolov8n.engine
์ ๋ฐ๋ | ํ๊ฐ ํ ์คํธ | ํ๊ท (ms) |
์ต์ | ์ต๋ (ms) |
mAPval 50(B) |
mAPval 50-95(B) |
batch |
ํฌ๊ธฐ (ํฝ์ ) |
---|---|---|---|---|---|---|---|
FP32 | ์์ธก | 0.52 | 0.51 | 0.56 | 8 | 640 | ||
FP32 | COCOval | 0.52 | 0.52 | 0.37 | 1 | 640 | |
FP16 | ์์ธก | 0.34 | 0.34 | 0.41 | 8 | 640 | ||
FP16 | COCOval | 0.33 | 0.52 | 0.37 | 1 | 640 | |
INT8 | ์์ธก | 0.28 | 0.27 | 0.31 | 8 | 640 | ||
INT8 | COCOval | 0.29 | 0.47 | 0.33 | 1 | 640 |
์ธ๋ถํ ๋ฌธ์์์ 80๊ฐ์ ์ฌ์ ํ๋ จ๋ ํด๋์ค๋ฅผ ํฌํจํ์ฌ COCO์์ ํ๋ จ๋ ์ด๋ฌํ ๋ชจ๋ธ์ ์ฌ์ฉ ์์๋ฅผ ํ์ธํ์ธ์.
์ฐธ๊ณ
๋ค์์ ๋ํ ์ถ๋ก ์๊ฐ์ด ํ์๋ฉ๋๋ค. mean
, min
(๊ฐ์ฅ ๋น ๋ฆ), ๊ทธ๋ฆฌ๊ณ max
(๊ฐ์ฅ ๋๋ฆฐ) ์ฌ์ ํ์ต๋ ๊ฐ์ค์น๋ฅผ ์ฌ์ฉํ์ฌ ๊ฐ ํ
์คํธ์ ๋ํด yolov8n-seg.engine
์ ๋ฐ๋ | ํ๊ฐ ํ ์คํธ | ํ๊ท (ms) |
์ต์ | ์ต๋ (ms) |
mAPval 50(B) |
mAPval 50-95(B) |
mAPval 50(M) |
mAPval 50-95(M) |
batch |
ํฌ๊ธฐ (ํฝ์ ) |
---|---|---|---|---|---|---|---|---|---|
FP32 | ์์ธก | 0.62 | 0.61 | 0.68 | 8 | 640 | ||||
FP32 | COCOval | 0.63 | 0.52 | 0.36 | 0.49 | 0.31 | 1 | 640 | |
FP16 | ์์ธก | 0.40 | 0.39 | 0.44 | 8 | 640 | ||||
FP16 | COCOval | 0.43 | 0.52 | 0.36 | 0.49 | 0.30 | 1 | 640 | |
INT8 | ์์ธก | 0.34 | 0.33 | 0.37 | 8 | 640 | ||||
INT8 | COCOval | 0.36 | 0.46 | 0.32 | 0.43 | 0.27 | 1 | 640 |
1000๊ฐ์ ์ฌ์ ํ์ต๋ ํด๋์ค๊ฐ ํฌํจ๋ ImageNet์์ ํ์ต๋ ์ด๋ฌํ ๋ชจ๋ธ์ ์ฌ์ฉ ์๋ ๋ถ๋ฅ ๋ฌธ์๋ฅผ ์ฐธ์กฐํ์ธ์.
์ฐธ๊ณ
๋ค์์ ๋ํ ์ถ๋ก ์๊ฐ์ด ํ์๋ฉ๋๋ค. mean
, min
(๊ฐ์ฅ ๋น ๋ฆ), ๊ทธ๋ฆฌ๊ณ max
(๊ฐ์ฅ ๋๋ฆฐ) ์ฌ์ ํ์ต๋ ๊ฐ์ค์น๋ฅผ ์ฌ์ฉํ์ฌ ๊ฐ ํ
์คํธ์ ๋ํด yolov8n-cls.engine
์ ๋ฐ๋ | ํ๊ฐ ํ ์คํธ | ํ๊ท (ms) |
์ต์ | ์ต๋ (ms) |
top-1 | ์์ 5์ | batch |
ํฌ๊ธฐ (ํฝ์ ) |
---|---|---|---|---|---|---|---|
FP32 | ์์ธก | 0.26 | 0.25 | 0.28 | 8 | 640 | ||
FP32 | ์ด๋ฏธ์ง๋ท๋ฐธ | 0.26 | 0.35 | 0.61 | 1 | 640 | |
FP16 | ์์ธก | 0.18 | 0.17 | 0.19 | 8 | 640 | ||
FP16 | ์ด๋ฏธ์ง๋ท๋ฐธ | 0.18 | 0.35 | 0.61 | 1 | 640 | |
INT8 | ์์ธก | 0.16 | 0.15 | 0.57 | 8 | 640 | ||
INT8 | ์ด๋ฏธ์ง๋ท๋ฐธ | 0.15 | 0.32 | 0.59 | 1 | 640 |
์ฌ์ ํ์ต๋ ํด๋์ค์ธ '์ฌ๋' 1๊ฐ๋ฅผ ํฌํจํ์ฌ COCO์์ ํ์ต๋ ์ด๋ฌํ ๋ชจ๋ธ์ ์ฌ์ฉ ์๋ ํฌ์ฆ ์ถ์ ๋ฌธ์๋ฅผ ์ฐธ์กฐํ์ธ์.
์ฐธ๊ณ
๋ค์์ ๋ํ ์ถ๋ก ์๊ฐ์ด ํ์๋ฉ๋๋ค. mean
, min
(๊ฐ์ฅ ๋น ๋ฆ), ๊ทธ๋ฆฌ๊ณ max
(๊ฐ์ฅ ๋๋ฆฐ) ์ฌ์ ํ์ต๋ ๊ฐ์ค์น๋ฅผ ์ฌ์ฉํ์ฌ ๊ฐ ํ
์คํธ์ ๋ํด yolov8n-pose.engine
์ ๋ฐ๋ | ํ๊ฐ ํ ์คํธ | ํ๊ท (ms) |
์ต์ | ์ต๋ (ms) |
mAPval 50(B) |
mAPval 50-95(B) |
mAPval 50(P) |
mAPval 50-95(P) |
batch |
ํฌ๊ธฐ (ํฝ์ ) |
---|---|---|---|---|---|---|---|---|---|
FP32 | ์์ธก | 0.54 | 0.53 | 0.58 | 8 | 640 | ||||
FP32 | COCOval | 0.55 | 0.91 | 0.69 | 0.80 | 0.51 | 1 | 640 | |
FP16 | ์์ธก | 0.37 | 0.35 | 0.41 | 8 | 640 | ||||
FP16 | COCOval | 0.36 | 0.91 | 0.69 | 0.80 | 0.51 | 1 | 640 | |
INT8 | ์์ธก | 0.29 | 0.28 | 0.33 | 8 | 640 | ||||
INT8 | COCOval | 0.30 | 0.90 | 0.68 | 0.78 | 0.47 | 1 | 640 |
์ฌ์ ํ์ต๋ 15๊ฐ์ ํด๋์ค๊ฐ ํฌํจ๋ DOTAv1์์ ํ์ต๋ ์ด๋ฌํ ๋ชจ๋ธ์ ์ฌ์ฉ ์์ ๋ ์งํฅ ํ์ง ๋ฌธ์๋ฅผ ์ฐธ์กฐํ์ธ์.
์ฐธ๊ณ
๋ค์์ ๋ํ ์ถ๋ก ์๊ฐ์ด ํ์๋ฉ๋๋ค. mean
, min
(๊ฐ์ฅ ๋น ๋ฆ), ๊ทธ๋ฆฌ๊ณ max
(๊ฐ์ฅ ๋๋ฆฐ) ์ฌ์ ํ์ต๋ ๊ฐ์ค์น๋ฅผ ์ฌ์ฉํ์ฌ ๊ฐ ํ
์คํธ์ ๋ํด yolov8n-obb.engine
์ ๋ฐ๋ | ํ๊ฐ ํ ์คํธ | ํ๊ท (ms) |
์ต์ | ์ต๋ (ms) |
mAPval 50(B) |
mAPval 50-95(B) |
batch |
ํฌ๊ธฐ (ํฝ์ ) |
---|---|---|---|---|---|---|---|
FP32 | ์์ธก | 0.52 | 0.51 | 0.59 | 8 | 640 | ||
FP32 | DOTAv1val | 0.76 | 0.50 | 0.36 | 1 | 640 | |
FP16 | ์์ธก | 0.34 | 0.33 | 0.42 | 8 | 640 | ||
FP16 | DOTAv1val | 0.59 | 0.50 | 0.36 | 1 | 640 | |
INT8 | ์์ธก | 0.29 | 0.28 | 0.33 | 8 | 640 | ||
INT8 | DOTAv1val | 0.32 | 0.45 | 0.32 | 1 | 640 |
์๋น์์ฉ GPU
ํ์ง ์ฑ๋ฅ(COCO)
Windows 10.0.19045์์ ํ
์คํธ๋์์ต๋๋ค, python 3.10.9
, ultralytics==8.2.4
, tensorrt==10.0.0b6
์ฐธ๊ณ
๋ค์์ ๋ํ ์ถ๋ก ์๊ฐ์ด ํ์๋ฉ๋๋ค. mean
, min
(๊ฐ์ฅ ๋น ๋ฆ), ๊ทธ๋ฆฌ๊ณ max
(๊ฐ์ฅ ๋๋ฆฐ) ์ฌ์ ํ์ต๋ ๊ฐ์ค์น๋ฅผ ์ฌ์ฉํ์ฌ ๊ฐ ํ
์คํธ์ ๋ํด yolov8n.engine
์ ๋ฐ๋ | ํ๊ฐ ํ ์คํธ | ํ๊ท (ms) |
์ต์ | ์ต๋ (ms) |
mAPval 50(B) |
mAPval 50-95(B) |
batch |
ํฌ๊ธฐ (ํฝ์ ) |
---|---|---|---|---|---|---|---|
FP32 | ์์ธก | 1.06 | 0.75 | 1.88 | 8 | 640 | ||
FP32 | COCOval | 1.37 | 0.52 | 0.37 | 1 | 640 | |
FP16 | ์์ธก | 0.62 | 0.75 | 1.13 | 8 | 640 | ||
FP16 | COCOval | 0.85 | 0.52 | 0.37 | 1 | 640 | |
INT8 | ์์ธก | 0.52 | 0.38 | 1.00 | 8 | 640 | ||
INT8 | COCOval | 0.74 | 0.47 | 0.33 | 1 | 640 |
Windows 10.0.22631์์ ํ
์คํธ๋์์ต๋๋ค, python 3.11.9
, ultralytics==8.2.4
, tensorrt==10.0.1
์ฐธ๊ณ
๋ค์์ ๋ํ ์ถ๋ก ์๊ฐ์ด ํ์๋ฉ๋๋ค. mean
, min
(๊ฐ์ฅ ๋น ๋ฆ), ๊ทธ๋ฆฌ๊ณ max
(๊ฐ์ฅ ๋๋ฆฐ) ์ฌ์ ํ์ต๋ ๊ฐ์ค์น๋ฅผ ์ฌ์ฉํ์ฌ ๊ฐ ํ
์คํธ์ ๋ํด yolov8n.engine
์ ๋ฐ๋ | ํ๊ฐ ํ ์คํธ | ํ๊ท (ms) |
์ต์ | ์ต๋ (ms) |
mAPval 50(B) |
mAPval 50-95(B) |
batch |
ํฌ๊ธฐ (ํฝ์ ) |
---|---|---|---|---|---|---|---|
FP32 | ์์ธก | 1.76 | 1.69 | 1.87 | 8 | 640 | ||
FP32 | COCOval | 1.94 | 0.52 | 0.37 | 1 | 640 | |
FP16 | ์์ธก | 0.86 | 0.75 | 1.00 | 8 | 640 | ||
FP16 | COCOval | 1.43 | 0.52 | 0.37 | 1 | 640 | |
INT8 | ์์ธก | 0.80 | 0.75 | 1.00 | 8 | 640 | ||
INT8 | COCOval | 1.35 | 0.47 | 0.33 | 1 | 640 |
Pop!_OS 22.04 LTS์์ ํ
์คํธ๋์์ต๋๋ค, python 3.10.12
, ultralytics==8.2.4
, tensorrt==8.6.1.post1
์ฐธ๊ณ
๋ค์์ ๋ํ ์ถ๋ก ์๊ฐ์ด ํ์๋ฉ๋๋ค. mean
, min
(๊ฐ์ฅ ๋น ๋ฆ), ๊ทธ๋ฆฌ๊ณ max
(๊ฐ์ฅ ๋๋ฆฐ) ์ฌ์ ํ์ต๋ ๊ฐ์ค์น๋ฅผ ์ฌ์ฉํ์ฌ ๊ฐ ํ
์คํธ์ ๋ํด yolov8n.engine
์ ๋ฐ๋ | ํ๊ฐ ํ ์คํธ | ํ๊ท (ms) |
์ต์ | ์ต๋ (ms) |
mAPval 50(B) |
mAPval 50-95(B) |
batch |
ํฌ๊ธฐ (ํฝ์ ) |
---|---|---|---|---|---|---|---|
FP32 | ์์ธก | 2.84 | 2.84 | 2.85 | 8 | 640 | ||
FP32 | COCOval | 2.94 | 0.52 | 0.37 | 1 | 640 | |
FP16 | ์์ธก | 1.09 | 1.09 | 1.10 | 8 | 640 | ||
FP16 | COCOval | 1.20 | 0.52 | 0.37 | 1 | 640 | |
INT8 | ์์ธก | 0.75 | 0.74 | 0.75 | 8 | 640 | ||
INT8 | COCOval | 0.76 | 0.47 | 0.33 | 1 | 640 |
์๋ฒ ๋๋ ๋๋ฐ์ด์ค
ํ์ง ์ฑ๋ฅ(COCO)
JetPack 6.0(L4T 36.3) ์ฐ๋ถํฌ 22.04.4 LTS๋ก ํ
์คํธํ์ต๋๋ค, python 3.10.12
, ultralytics==8.2.16
, tensorrt==10.0.1
์ฐธ๊ณ
๋ค์์ ๋ํ ์ถ๋ก ์๊ฐ์ด ํ์๋ฉ๋๋ค. mean
, min
(๊ฐ์ฅ ๋น ๋ฆ), ๊ทธ๋ฆฌ๊ณ max
(๊ฐ์ฅ ๋๋ฆฐ) ์ฌ์ ํ์ต๋ ๊ฐ์ค์น๋ฅผ ์ฌ์ฉํ์ฌ ๊ฐ ํ
์คํธ์ ๋ํด yolov8n.engine
์ ๋ฐ๋ | ํ๊ฐ ํ ์คํธ | ํ๊ท (ms) |
์ต์ | ์ต๋ (ms) |
mAPval 50(B) |
mAPval 50-95(B) |
batch |
ํฌ๊ธฐ (ํฝ์ ) |
---|---|---|---|---|---|---|---|
FP32 | ์์ธก | 6.11 | 6.10 | 6.29 | 8 | 640 | ||
FP32 | COCOval | 6.17 | 0.52 | 0.37 | 1 | 640 | |
FP16 | ์์ธก | 3.18 | 3.18 | 3.20 | 8 | 640 | ||
FP16 | COCOval | 3.19 | 0.52 | 0.37 | 1 | 640 | |
INT8 | ์์ธก | 2.30 | 2.29 | 2.35 | 8 | 640 | ||
INT8 | COCOval | 2.32 | 0.46 | 0.32 | 1 | 640 |
์ ๋ณด
์ค์ ๋ฐ ๊ตฌ์ฑ์ ๋ํด ์์ธํ ์์๋ณด๋ ค๋ฉด Ultralytics YOLO ์์ ๋น ๋ฅธ ์์ ๊ฐ์ด๋( NVIDIA Jetson)๋ฅผ ์ฐธ์กฐํ์ธ์.
ํ๊ฐ ๋ฐฉ๋ฒ
์๋ ์น์ ์ ํ์ฅํ์ฌ ์ด๋ฌํ ๋ชจ๋ธ์ ๋ด๋ณด๋ด๊ณ ํ ์คํธํ ๋ฐฉ๋ฒ์ ๋ํ ์ ๋ณด๋ฅผ ํ์ธํ์ธ์.
๊ตฌ์ฑ ๋ด๋ณด๋ด๊ธฐ
๋ด๋ณด๋ด๊ธฐ ๊ตฌ์ฑ ์ธ์์ ๋ํ ์์ธํ ๋ด์ฉ์ ๋ด๋ณด๋ด๊ธฐ ๋ชจ๋๋ฅผ ์ฐธ์กฐํ์ธ์.
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"
)
์์ธก ๋ฃจํ
์์ธํ ๋ด์ฉ์ ์์ธก ๋ชจ๋๋ฅผ ์ฐธ์กฐํ์ธ์.
์ ํจ์ฑ ๊ฒ์ฌ ๊ตฌ์ฑ
์ฐธ์กฐ val
๋ชจ๋ ๋ฅผ ํด๋ฆญํ์ฌ ์ ํจ์ฑ ๊ฒ์ฌ ๊ตฌ์ฑ ์ธ์์ ๋ํด ์์ธํ ์์๋ณด์ธ์.
๋ด๋ณด๋ธ YOLOv8 TensorRT ๋ชจ๋ธ ๋ฐฐํฌ
Ultralytics YOLOv8 ๋ชจ๋ธ์ TensorRT ํ์์ผ๋ก ์ฑ๊ณต์ ์ผ๋ก ๋ด๋ณด๋์ผ๋ฉด ์ด์ ๋ฐฐํฌํ ์ค๋น๊ฐ ๋์์ต๋๋ค. ๋ค์ํ ์ค์ ์์ TensorRT ๋ชจ๋ธ์ ๋ฐฐํฌํ๋ ๋ฐฉ๋ฒ์ ๋ํ ์์ธํ ์ง์นจ์ ๋ค์ ๋ฆฌ์์ค๋ฅผ ์ฐธ์กฐํ์ธ์:
-
Triton ์๋ฒ์ ํจ๊ป Ultralytics ๋ฐฐํฌ: NVIDIA ์ Triton ์ถ๋ก (์ด์ TensorRT ์ถ๋ก ) ์๋ฒ๋ฅผ Ultralytics YOLO ๋ชจ๋ธ๊ณผ ํจ๊ป ์ฌ์ฉํ๋ ๋ฐฉ๋ฒ์ ๋ํ ๊ฐ์ด๋์ ๋๋ค.
-
๋ฅผ ์ฌ์ฉํ์ฌ ์ฌ์ธต ์ ๊ฒฝ๋ง ๋ฐฐํฌ NVIDIA TensorRT: ์ด ๋ฌธ์์์๋ NVIDIA TensorRT ์ ์ฌ์ฉํ์ฌ GPU ๊ธฐ๋ฐ ๋ฐฐํฌ ํ๋ซํผ์ ์ฌ์ธต ์ ๊ฒฝ๋ง์ ํจ์จ์ ์ผ๋ก ๋ฐฐํฌํ๋ ๋ฐฉ๋ฒ์ ์ค๋ช ํฉ๋๋ค.
-
NVIDIA-๊ธฐ๋ฐ PC๋ฅผ ์ํ ์๋ํฌ์๋ AI: NVIDIA TensorRT ๋ฐฐํฌ: ์ด ๋ธ๋ก๊ทธ ๊ฒ์๋ฌผ์์๋ NVIDIA-๊ธฐ๋ฐ PC์์ AI ๋ชจ๋ธ์ ์ต์ ํํ๊ณ ๋ฐฐํฌํ๊ธฐ ์ํ NVIDIA TensorRT ์ ์ฌ์ฉ์ ๋ํด ์ค๋ช ํฉ๋๋ค.
-
NVIDIA TensorRT ์ ๋ํ ๊นํ๋ธ ์ ์ฅ์:: NVIDIA TensorRT ์ ์์ค ์ฝ๋์ ๋ฌธ์๊ฐ ํฌํจ๋ ๊ณต์ GitHub ๋ฆฌํฌ์งํ ๋ฆฌ์ ๋๋ค.
์์ฝ
์ด ๊ฐ์ด๋์์๋ Ultralytics YOLOv8 ๋ชจ๋ธ์ NVIDIA ์ TensorRT ๋ชจ๋ธ ํ์์ผ๋ก ๋ณํํ๋ ๋ฐ ์ค์ ์ ๋์์ต๋๋ค. ์ด ๋ณํ ๋จ๊ณ๋ YOLOv8 ๋ชจ๋ธ์ ํจ์จ์ฑ๊ณผ ์๋๋ฅผ ๊ฐ์ ํ์ฌ ๋ณด๋ค ํจ๊ณผ์ ์ด๊ณ ๋ค์ํ ๋ฐฐํฌ ํ๊ฒฝ์ ์ ํฉํ๊ฒ ๋ง๋๋ ๋ฐ ๋งค์ฐ ์ค์ํฉ๋๋ค.
์ฌ์ฉ๋ฒ์ ๋ํ ์์ธํ ๋ด์ฉ์ TensorRT ๊ณต์ ๋ฌธ์๋ฅผ ์ฐธ์กฐํ์ธ์.
์ถ๊ฐ ํตํฉ์ ๋ํด ๊ถ๊ธํ ์ ์ด ์๋ค๋ฉด Ultralytics YOLOv8 ํตํฉ ๊ฐ์ด๋ ํ์ด์ง์์ ๋ค์ํ ๋ฆฌ์์ค์ ์ธ์ฌ์ดํธ๋ฅผ ํ์ธํ ์ ์์ต๋๋ค.
์์ฃผ ๋ฌป๋ ์ง๋ฌธ
YOLOv8 ๋ชจ๋ธ์ TensorRT ํ์์ผ๋ก ๋ณํํ๋ ค๋ฉด ์ด๋ป๊ฒ ํด์ผ ํ๋์?
์ต์ ํ๋ NVIDIA GPU ์ถ๋ก ์ ์ํด Ultralytics YOLOv8 ๋ชจ๋ธ์ TensorRT ํ์์ผ๋ก ๋ณํํ๋ ค๋ฉด ๋ค์ ๋จ๊ณ๋ฅผ ๋ฐ๋ฅด์ธ์:
-
ํ์ํ ํจํค์ง๋ฅผ ์ค์นํฉ๋๋ค:
-
YOLOv8 ๋ชจ๋ธ์ ๋ด๋ณด๋ ๋๋ค:
์์ธํ ๋ด์ฉ์ YOLOv8 ์ค์น ๊ฐ์ด๋ ๋ฐ ๋ด๋ณด๋ด๊ธฐ ์ค๋ช ์๋ฅผ ์ฐธ์กฐํ์ธ์.
YOLOv8 ๋ชจ๋ธ์ TensorRT ์ ์ฌ์ฉํ๋ฉด ์ด๋ค ์ด์ ์ด ์๋์?
YOLOv8 ๋ชจ๋ธ์ ์ต์ ํํ๊ธฐ ์ํด TensorRT ์ ์ฌ์ฉํ๋ฉด ๋ช ๊ฐ์ง ์ด์ ์ด ์์ต๋๋ค:
- ์ถ๋ก ์๋ ํฅ์: TensorRT ๋ชจ๋ธ ๋ ์ด์ด๋ฅผ ์ต์ ํํ๊ณ ์ ๋ฐ ๋ณด์ (INT8 ๋ฐ FP16)์ ์ฌ์ฉํ์ฌ ์ ํ๋๋ฅผ ํฌ๊ฒ ๋จ์ด๋จ๋ฆฌ์ง ์์ผ๋ฉด์ ์ถ๋ก ์๋๋ฅผ ๋์ ๋๋ค.
- ๋ฉ๋ชจ๋ฆฌ ํจ์จ์ฑ: TensorRT ์ tensor ๋ฉ๋ชจ๋ฆฌ๋ฅผ ๋์ ์ผ๋ก ๊ด๋ฆฌํ์ฌ ์ค๋ฒํค๋๋ฅผ ์ค์ด๊ณ GPU ๋ฉ๋ชจ๋ฆฌ ์ฌ์ฉ๋ฅ ์ ๊ฐ์ ํฉ๋๋ค.
- ๋ ์ด์ด ํจ์ : ์ฌ๋ฌ ๋ ์ด์ด๋ฅผ ๋จ์ผ ์์ ์ผ๋ก ๊ฒฐํฉํ์ฌ ๊ณ์ฐ ๋ณต์ก์ฑ์ ์ค์ ๋๋ค.
- ์ปค๋ ์๋ ํ๋: ๊ฐ ๋ชจ๋ธ ๋ ์ด์ด์ ์ต์ ํ๋ GPU ์ปค๋์ ์๋์ผ๋ก ์ ํํ์ฌ ์ต๋ ์ฑ๋ฅ์ ๋ณด์ฅํฉ๋๋ค.
์์ธํ ๋ด์ฉ์ TensorRT ์์ ์์ธํ ๊ธฐ๋ฅ์ ์ดํด๋ณด๊ณ TensorRT ๊ฐ์ ์น์ ์ ์ฐธ์กฐํ์ธ์.
YOLOv8 ๋ชจ๋ธ์ TensorRT ์ผ๋ก INT8 ์ ๋ํ๋ฅผ ์ฌ์ฉํ ์ ์๋์?
์, INT8 ์ ๋ํ์ ํจ๊ป TensorRT ๋ชจ๋ธ์ ์ฌ์ฉํ์ฌ YOLOv8 ๋ชจ๋ธ์ ๋ด๋ณด๋ผ ์ ์์ต๋๋ค. ์ด ๊ณผ์ ์๋ ํ๋ จ ํ ์ ๋ํ(PTQ) ๋ฐ ๋ณด์ ์ด ํฌํจ๋ฉ๋๋ค:
-
INT8๋ก ๋ด๋ณด๋ด๊ธฐ:
-
์ถ๋ก ์ ์คํํฉ๋๋ค:
์์ธํ ๋ด์ฉ์ INT8 ์ ๋ํ๋ฅผ ์ฌ์ฉํ์ฌ TensorRT ๋ด๋ณด๋ด๊ธฐ ์น์ ์ ์ฐธ์กฐํ์ธ์.
NVIDIA Triton ์ถ๋ก ์๋ฒ์ YOLOv8 TensorRT ๋ชจ๋ธ์ ๋ฐฐํฌํ๋ ค๋ฉด ์ด๋ป๊ฒ ํด์ผ ํ๋์?
NVIDIA Triton ์ถ๋ก ์๋ฒ์ YOLOv8 TensorRT ๋ชจ๋ธ์ ๋ฐฐํฌํ๋ ์์ ์ ๋ค์ ๋ฆฌ์์ค๋ฅผ ์ฌ์ฉํ์ฌ ์ํํ ์ ์์ต๋๋ค:
- Triton ์๋ฒ์ ํจ๊ป Ultralytics YOLOv8 ๋ฐฐํฌ: Triton ์ถ๋ก ์๋ฒ ์ค์ ๋ฐ ์ฌ์ฉ์ ๋ํ ๋จ๊ณ๋ณ ์๋ด.
- NVIDIA Triton ์ถ๋ก ์๋ฒ ๋ฌธ์: ์์ธํ ๋ฐฐํฌ ์ต์ ๋ฐ ๊ตฌ์ฑ์ ๋ํ ๊ณต์ NVIDIA ๋ฌธ์๋ฅผ ์ฐธ์กฐํ์ธ์.
์ด ๊ฐ์ด๋๋ ๋ค์ํ ๋ฐฐํฌ ํ๊ฒฝ์์ YOLOv8 ๋ชจ๋ธ์ ํจ์จ์ ์ผ๋ก ํตํฉํ๋ ๋ฐ ๋์์ด ๋ฉ๋๋ค.
TensorRT ์ผ๋ก ๋ด๋ณด๋ธ YOLOv8 ๋ชจ๋ธ์์๋ ์ด๋ค ์ฑ๋ฅ ๊ฐ์ ์ด ๊ด์ฐฐ๋๋์?
TensorRT ์ ์ฑ๋ฅ ํฅ์์ ์ฌ์ฉํ๋ ํ๋์จ์ด์ ๋ฐ๋ผ ๋ฌ๋ผ์ง ์ ์์ต๋๋ค. ๋ค์์ ๋ช ๊ฐ์ง ์ผ๋ฐ์ ์ธ ๋ฒค์น๋งํฌ์ ๋๋ค:
-
NVIDIA A100:
- FP32 ์ถ๋ก : ~0.52ms/์ด๋ฏธ์ง
- FP16 ์ถ๋ก : ~0.34ms/์ด๋ฏธ์ง
- INT8 ์ถ๋ก : ~0.28ms/์ด๋ฏธ์ง
- INT8 ์ ๋ฐ๋๋ก ๋งต์ ์ฝ๊ฐ ๊ฐ์ํ์ง๋ง ์๋๋ ํฌ๊ฒ ํฅ์๋์์ต๋๋ค.
-
์๋น์์ฉ GPU(์: RTX 3080):
- FP32 ์ถ๋ก : ~1.06ms/์ด๋ฏธ์ง
- FP16 ์ถ๋ก : ~0.62ms/์ด๋ฏธ์ง
- INT8 ์ถ๋ก : ~0.52ms/์ด๋ฏธ์ง
๋ค์ํ ํ๋์จ์ด ๊ตฌ์ฑ์ ๋ํ ์์ธํ ์ฑ๋ฅ ๋ฒค์น๋งํฌ๋ ์ฑ๋ฅ ์น์ ์์ ํ์ธํ ์ ์์ต๋๋ค.
TensorRT ์ฑ๋ฅ์ ๋ํ ๋ณด๋ค ํฌ๊ด์ ์ธ ์ธ์ฌ์ดํธ๋ Ultralytics ๋ฌธ์์ ์ฑ๋ฅ ๋ถ์ ๋ณด๊ณ ์๋ฅผ ์ฐธ์กฐํ์ธ์.