TensorRT Export for YOLO11 Models
๊ณ ์ฑ๋ฅ ํ๊ฒฝ์์ ์ปดํจํฐ ๋น์ ๋ชจ๋ธ์ ๋ฐฐํฌํ๋ ค๋ฉด ์๋์ ํจ์จ์ฑ์ ๊ทน๋ํํ๋ ํ์์ด ํ์ํ ์ ์์ต๋๋ค. NVIDIA GPU์ ๋ชจ๋ธ์ ๋ฐฐํฌํ๋ ๊ฒฝ์ฐ ํนํ ๊ทธ๋ ์ต๋๋ค.
By using the TensorRT export format, you can enhance your Ultralytics YOLO11 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์์ ๊ฐ๋ฐํ NVIDIA ์ ๊ณ ์ ๋ฅ๋ฌ๋ ์ถ๋ก ์ ์ํด ์ค๊ณ๋ ๊ณ ๊ธ ์ํํธ์จ์ด ๊ฐ๋ฐ ํคํธ(SDK)์ ๋๋ค. ๊ฐ์ฒด ๊ฐ์ง์ ๊ฐ์ ์ค์๊ฐ ์ ํ๋ฆฌ์ผ์ด์ ์ ์ ํฉํฉ๋๋ค.
์ด ํดํท์ ๋ฅ ๋ฌ๋ ๋ชจ๋ธ์ NVIDIA GPU์ ์ต์ ํํ์ฌ ๋ ๋น ๋ฅด๊ณ ํจ์จ์ ์ธ ์์ ์ ๊ฐ๋ฅํ๊ฒ ํฉ๋๋ค. TensorRT ๋ชจ๋ธ์ ๋ ์ด์ด ์ตํฉ, ์ ๋ฐ ๋ณด์ (INT8 ๋ฐ FP16), ๋์ tensor ๋ฉ๋ชจ๋ฆฌ ๊ด๋ฆฌ ๋ฐ ์ปค๋ ์๋ ํ๋๊ณผ ๊ฐ์ ๊ธฐ์ ์ ํฌํจํ๋ TensorRT ์ต์ ํ๋ฅผ ๊ฑฐ์นฉ๋๋ค. ๋ฅ ๋ฌ๋ ๋ชจ๋ธ์ TensorRT ํ์์ผ๋ก ๋ณํํ๋ฉด ๊ฐ๋ฐ์๋ NVIDIA GPU์ ์ ์ฌ๋ ฅ์ ์์ ํ ์คํํ ์ ์์ต๋๋ค.
TensorRT ๋ฅผ ํฌํจํ ๋ค์ํ ๋ชจ๋ธ ํ์๊ณผ์ ํธํ์ฑ์ผ๋ก ์ ๋ช ํ๋ฉฐ TensorFlow, PyTorch, ONNX ๋ฑ ๋ค์ํ ํ๋ ์์ํฌ์ ๋ชจ๋ธ์ ํตํฉํ๊ณ ์ต์ ํํ ์ ์๋ ์ ์ฐํ ์๋ฃจ์ ์ ๊ฐ๋ฐ์์๊ฒ ์ ๊ณตํฉ๋๋ค. ์ด๋ฌํ ๋ค์ฉ๋์ฑ ๋๋ถ์ ๋ค์ํ ํ๋์จ์ด ๋ฐ ์ํํธ์จ์ด ํ๊ฒฝ์์ ํจ์จ์ ์ผ๋ก ๋ชจ๋ธ์ ๋ฐฐํฌํ ์ ์์ต๋๋ค.
TensorRT ๋ชจ๋ธ์ ์ฃผ์ ๊ธฐ๋ฅ
TensorRT ๋ชจ๋ธ์ ๊ณ ์ ๋ฅ ๋ฌ๋ ์ถ๋ก ์ ํจ์จ์ฑ๊ณผ ํจ๊ณผ์ ๊ธฐ์ฌํ๋ ๋ค์ํ ์ฃผ์ ๊ธฐ๋ฅ์ ์ ๊ณตํฉ๋๋ค:
-
์ ๋ฐ ๋ณด์ : TensorRT ์์๋ ์ ๋ฐ ๋ณด์ ์ ์ง์ํ์ฌ ํน์ ์ ํ๋ ์๊ฑด์ ๋ง๊ฒ ๋ชจ๋ธ์ ๋ฏธ์ธ ์กฐ์ ํ ์ ์์ต๋๋ค. ์ฌ๊ธฐ์๋ ํ์ฉ ๊ฐ๋ฅํ ์ ํ๋ ์์ค์ ์ ์งํ๋ฉด์ ์ถ๋ก ์๋๋ฅผ ๋์ฑ ๋์ผ ์ ์๋ INT8 ๋ฐ FP16๊ณผ ๊ฐ์ ๊ฐ์๋ ์ ๋ฐ๋ ํ์์ ๋ํ ์ง์์ด ํฌํจ๋ฉ๋๋ค.
-
๋ ์ด์ด ํจ์ : TensorRT ์ต์ ํ ํ๋ก์ธ์ค์๋ ์ ๊ฒฝ๋ง์ ์ฌ๋ฌ ๊ณ์ธต์ ๋จ์ผ ์ฐ์ฐ์ผ๋ก ๊ฒฐํฉํ๋ ๊ณ์ธต ์ตํฉ์ด ํฌํจ๋ฉ๋๋ค. ์ด๋ ๊ฒ ํ๋ฉด ๋ฉ๋ชจ๋ฆฌ ์ก์ธ์ค ๋ฐ ๊ณ์ฐ์ ์ต์ํํ์ฌ ๊ณ์ฐ ์ค๋ฒํค๋๋ฅผ ์ค์ด๊ณ ์ถ๋ก ์๋๋ฅผ ํฅ์์ํฌ ์ ์์ต๋๋ค.
-
๋์ Tensor ๋ฉ๋ชจ๋ฆฌ ๊ด๋ฆฌ: TensorRT ์ถ๋ก ์ค tensor ๋ฉ๋ชจ๋ฆฌ ์ฌ์ฉ๋์ ํจ์จ์ ์ผ๋ก ๊ด๋ฆฌํ์ฌ ๋ฉ๋ชจ๋ฆฌ ์ค๋ฒํค๋๋ฅผ ์ค์ด๊ณ ๋ฉ๋ชจ๋ฆฌ ํ ๋น์ ์ต์ ํํฉ๋๋ค. ๊ทธ ๊ฒฐ๊ณผ GPU ๋ฉ๋ชจ๋ฆฌ ์ฌ์ฉ๋ฅ ์ด ๋์ฑ ํจ์จ์ ์ ๋๋ค.
-
Automatic Kernel Tuning: TensorRT applies automatic kernel tuning to select the most optimized GPU kernel for each layer of the model. This adaptive approach ensures that the model takes full advantage of the GPUs computational power.
๋ฐฐํฌ ์ต์ TensorRT
Before we look at the code for exporting YOLO11 models to the TensorRT format, let's understand where TensorRT models are normally used.
TensorRT ๋ ์ฌ๋ฌ ๊ฐ์ง ๋ฐฐํฌ ์ต์ ์ ์ ๊ณตํ๋ฉฐ, ๊ฐ ์ต์ ์ ํตํฉ ์ฉ์ด์ฑ, ์ฑ๋ฅ ์ต์ ํ, ์ ์ฐ์ฑ ๊ฐ์ ๊ท ํ์ ๋ค๋ฅด๊ฒ ์ ์งํฉ๋๋ค:
- TensorFlow ๋ด์ ๋ฐฐํฌ: ์ด ๋ฐฉ๋ฒ์ TensorRT ์ TensorFlow ์ ํตํฉํ์ฌ ์ต์ํ TensorFlow ํ๊ฒฝ์์ ์ต์ ํ๋ ๋ชจ๋ธ์ ์คํํ ์ ์๋๋ก ํฉ๋๋ค. ์ง์๋๋ ๋ ์ด์ด์ ์ง์๋์ง ์๋ ๋ ์ด์ด๊ฐ ํผํฉ๋ ๋ชจ๋ธ์ ์ ์ฉํ๋ฉฐ, TF-TRT๋ ์ด๋ฅผ ํจ์จ์ ์ผ๋ก ์ฒ๋ฆฌํ ์ ์์ต๋๋ค.
-
๋ ๋ฆฝํ TensorRT ๋ฐํ์ API: ์ธ๋ถํ๋ ์ ์ด ๊ธฐ๋ฅ์ ์ ๊ณตํ์ฌ ์ฑ๋ฅ์ด ์ค์ํ ์ ํ๋ฆฌ์ผ์ด์ ์ ์ด์์ ์ ๋๋ค. ๋ ๋ณต์กํ์ง๋ง ์ง์๋์ง ์๋ ์ฐ์ฐ์๋ฅผ ์ฌ์ฉ์ ์ง์ ์ผ๋ก ๊ตฌํํ ์ ์์ต๋๋ค.
-
NVIDIA Triton ์ถ๋ก ์๋ฒ: ๋ค์ํ ํ๋ ์์ํฌ์ ๋ชจ๋ธ์ ์ง์ํ๋ ์ต์ ์ ๋๋ค. ํนํ ํด๋ผ์ฐ๋ ๋๋ ์์ง ์ถ๋ก ์ ์ ํฉํ๋ฉฐ, ๋์ ๋ชจ๋ธ ์คํ ๋ฐ ๋ชจ๋ธ ๋ถ์๊ณผ ๊ฐ์ ๊ธฐ๋ฅ์ ์ ๊ณตํฉ๋๋ค.
Exporting YOLO11 Models to TensorRT
You can improve execution efficiency and optimize performance by converting YOLO11 models to TensorRT format.
์ค์น
ํ์ํ ํจํค์ง๋ฅผ ์ค์นํ๋ ค๋ฉด ์คํํฉ๋๋ค:
์ค์น ๊ณผ์ ๊ณผ ๊ด๋ จ๋ ์์ธํ ์ง์นจ๊ณผ ๋ชจ๋ฒ ์ฌ๋ก๋ YOLO11 ์ค์น ๊ฐ์ด๋๋ฅผ ์ฐธ์กฐํ์ธ์. YOLO11 ์ ํ์ํ ํจํค์ง๋ฅผ ์ค์นํ๋ ๋์ ๋ฌธ์ ๊ฐ ๋ฐ์ํ๋ฉด ์ผ๋ฐ์ ์ธ ๋ฌธ์ ๊ฐ์ด๋๋ฅผ ์ฐธ์กฐํ์ฌ ํด๊ฒฐ ๋ฐฉ๋ฒ๊ณผ ํ์ ํ์ธํ์ธ์.
์ฌ์ฉ๋ฒ
์ฌ์ฉ ์ง์นจ์ ์ดํด๋ณด๊ธฐ ์ ์ Ultralytics ์์ ์ ๊ณตํ๋ ๋ค์ํ YOLO11 ๋ชจ๋ธ์ ํ์ธํ์ธ์. ํ๋ก์ ํธ ์๊ตฌ ์ฌํญ์ ๊ฐ์ฅ ์ ํฉํ ๋ชจ๋ธ์ ์ ํํ๋ ๋ฐ ๋์์ด ๋ ๊ฒ์ ๋๋ค.
์ฌ์ฉ๋ฒ
from ultralytics import YOLO
# Load the YOLO11 model
model = YOLO("yolo11n.pt")
# Export the model to TensorRT format
model.export(format="engine") # creates 'yolo11n.engine'
# Load the exported TensorRT model
tensorrt_model = YOLO("yolo11n.engine")
# Run inference
results = tensorrt_model("https://ultralytics.com/images/bus.jpg")
๋ด๋ณด๋ด๊ธฐ ํ๋ก์ธ์ค์ ๋ํ ์์ธํ ๋ด์ฉ์ ๋ด๋ณด๋ด๊ธฐ ๊ด๋ จ ๋ฌธ์ ํ์ด์ง(Ultralytics )๋ฅผ ์ฐธ์กฐํ์ธ์.
INT8 ์ ๋ํ๋ฅผ ์ฌ์ฉํ์ฌ TensorRT ๋ด๋ณด๋ด๊ธฐ
INT8 ์ ๋ฐ๋๋ก TensorRT ๋ฅผ ์ฌ์ฉํ์ฌ Ultralytics YOLO ๋ชจ๋ธ์ ๋ด๋ณด๋ด๋ฉด ํ์ต ํ ์ ๋ํ(PTQ)๊ฐ ์คํ๋ฉ๋๋ค. TensorRT ๋ PTQ์ ๋ํ ๋ณด์ ์ ์ฌ์ฉํ์ฌ YOLO ๋ชจ๋ธ์ด ๋ํ ์ ๋ ฅ ๋ฐ์ดํฐ์ ๋ํ ์ถ๋ก ์ ์ฒ๋ฆฌํ ๋ ๊ฐ ํ์ฑํ tensor ๋ด์ ํ์ฑํ ๋ถํฌ๋ฅผ ์ธก์ ํ ๋ค์ ์ด ๋ถํฌ๋ฅผ ์ฌ์ฉํ์ฌ ๊ฐ tensor ์ ๋ํ ์ฒ๋ ๊ฐ์ ์ถ์ ํฉ๋๋ค. ์ ๋ํ ํ๋ณด์ธ ๊ฐ ํ์ฑํ tensor ์๋ ๋ณด์ ํ๋ก์ธ์ค๋ฅผ ํตํด ์ถ๋ก ๋๋ ๊ด๋ จ ์ฒ๋๊ฐ ์์ต๋๋ค.
์์์ ์ผ๋ก ์์ํ๋ ๋คํธ์ํฌ๋ฅผ ์ฒ๋ฆฌํ ๋ 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
๋ฅผ ์ฌ์ฉํ๋ฉด ๋ณด์ ์๊ฐ์ด ๋์ด๋ ์ ์์ง๋ง TensorRT ์์ ๋ ๋์ ๋ฒ์์ ์ต์ ํ ์ ๋ต์ ํ์ํ์ฌ ์ ์ฌ์ ์ผ๋ก ๋ชจ๋ธ ์ฑ๋ฅ์ ํฅ์์ํฌ ์ ์์ต๋๋ค. ์ ํ์ฑ. ๋ฐ๋๋ก, ๋ ์์workspace
๋ฅผ ์ฌ์ฉํ๋ฉด ๋ณด์ ์๊ฐ์ ์ค์ผ ์ ์์ง๋ง ์ต์ ํ ์ ๋ต์ด ์ ํ๋์ด ์ ๋ํ๋ ๋ชจ๋ธ์ ํ์ง์ ์ํฅ์ ์ค ์ ์์ต๋๋ค. -
๊ธฐ๋ณธ๊ฐ์
workspace=None
๋ฅผ ์ค์ ํ๋ฉด TensorRT ๋ฉ๋ชจ๋ฆฌ๋ฅผ ์๋์ผ๋ก ํ ๋นํ ์ ์์ผ๋ฉฐ, ์๋์ผ๋ก ๊ตฌ์ฑํ ๊ฒฝ์ฐ ์บ๋ฆฌ๋ธ๋ ์ด์ ์ด ์ถฉ๋(๊ฒฝ๊ณ ์์ด ์ข ๋ฃ)ํ๋ ๊ฒฝ์ฐ ์ด ๊ฐ์ ๋๋ ค์ผ ํ ์ ์์ต๋๋ค. -
TensorRT ๋ณด๊ณ ํฉ๋๋ค
UNSUPPORTED_STATE
์ ๊ฐ์ ๋ด๋ณด๋ด๋ ๋์workspace
์ ๊ฐ์ด ์ฅ์น์์ ์ฌ์ฉํ ์ ์๋ ๋ฉ๋ชจ๋ฆฌ๋ณด๋ค ํฌ๋ฉดworkspace
๋ฅผ ๋ฎ์ถ๊ฑฐ๋None
. -
๋ง์ฝ
workspace
๊ฐ ์ต๋๊ฐ์ผ๋ก ์ค์ ๋์ด ์๊ณ ๋ณด์ ์ด ์คํจํ๊ฑฐ๋ ์ถฉ๋ํ๋ ๊ฒฝ์ฐ, ๋ค์์ ์ฌ์ฉํ๋ ๊ฒ์ด ์ข์ต๋๋ค.None
์ ๊ฐ์ ์ค์ด๊ฑฐ๋ ์๋ ํ ๋น์ ์ํดimgsz
๊ทธ๋ฆฌ๊ณbatch
๋ฅผ ์ฌ์ฉํ์ฌ ๋ฉ๋ชจ๋ฆฌ ์๊ตฌ ์ฌํญ์ ์ค์ผ ์ ์์ต๋๋ค. -
INT8์ ๋ํ ๋ณด์ ์ ๊ฐ ๋๋ฐ์ด์ค์ ๋ฐ๋ผ ๋ค๋ฅด๋ฉฐ, ๋ณด์ ์ ์ํด '๊ณ ๊ธ' GPU ์ ๋น๋ ค์ ์ฌ์ฉํ๋ฉด ๋ค๋ฅธ ๋๋ฐ์ด์ค์์ ์ถ๋ก ์ ์คํํ ๋ ์ฑ๋ฅ์ด ์ ํ๋ ์ ์๋ค๋ ์ ์ ๊ธฐ์ตํ์ธ์.
-
-
batch
: ์ถ๋ก ์ ์ฌ์ฉํ ์ต๋ ๋ฐฐ์น ํฌ๊ธฐ์ ๋๋ค. ์ถ๋ก ์ค์๋ ๋ ์์ ๋ฐฐ์น๋ฅผ ์ฌ์ฉํ ์ ์์ง๋ง ์ถ๋ก ์ ์ง์ ๋ ๊ฒ๋ณด๋ค ํฐ ๋ฐฐ์น๋ ํ์ฉํ์ง ์์ต๋๋ค.
์ฐธ๊ณ
๋ณด์ ํ๋ ๋์ ๋ ๋ฐฐ์ batch
ํฌ๊ธฐ๊ฐ ์ฌ์ฉ๋ฉ๋๋ค. ์์ ๋ฐฐ์น๋ฅผ ์ฌ์ฉํ๋ฉด ๋ณด์ ์ค์ ์ค์ผ์ผ๋ง์ด ๋ถ์ ํํด์ง ์ ์์ต๋๋ค. ์ด๋ ํ๋ก์ธ์ค๊ฐ ๋ณด์ด๋ ๋ฐ์ดํฐ๋ฅผ ๊ธฐ๋ฐ์ผ๋ก ์กฐ์ ํ๊ธฐ ๋๋ฌธ์
๋๋ค. ์์ ๋ฐฐ์น๋ ์ ์ฒด ๋ฒ์์ ๊ฐ์ ์บก์ฒํ์ง ๋ชปํ์ฌ ์ต์ข
๋ณด์ ์ ๋ฌธ์ ๊ฐ ๋ฐ์ํ ์ ์์ต๋๋ค. batch
ํฌ๊ธฐ๊ฐ ์๋์ผ๋ก ๋ ๋ฐฐ๊ฐ ๋ฉ๋๋ค. ์๋ ๊ฒฝ์ฐ ๋ฐฐ์น ํฌ๊ธฐ ๊ฐ ์ง์ ๋ฉ๋๋ค. 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 YOLO11n PyTorch model to TensorRT format with INT8 quantization
yolo export model=yolo11n.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
๋ชจ๋ ๋ฅผ ํด๋ฆญํ์ฌ ์ ํจ์ฑ ๊ฒ์ฌ ๊ตฌ์ฑ ์ธ์์ ๋ํด ์์ธํ ์์๋ณด์ธ์.
Deploying Exported YOLO11 TensorRT Models
Having successfully exported your Ultralytics YOLO11 models to TensorRT format, you're now ready to deploy them. For in-depth instructions on deploying your TensorRT models in various settings, take a look at the following resources:
-
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 ๋ฆฌํฌ์งํ ๋ฆฌ์ ๋๋ค.
์์ฝ
In this guide, we focused on converting Ultralytics YOLO11 models to NVIDIA's TensorRT model format. This conversion step is crucial for improving the efficiency and speed of YOLO11 models, making them more effective and suitable for diverse deployment environments.
์ฌ์ฉ๋ฒ์ ๋ํ ์์ธํ ๋ด์ฉ์ TensorRT ๊ณต์ ๋ฌธ์๋ฅผ ์ฐธ์กฐํ์ธ์.
If you're curious about additional Ultralytics YOLO11 integrations, our integration guide page provides an extensive selection of informative resources and insights.
์์ฃผ ๋ฌป๋ ์ง๋ฌธ
How do I convert YOLO11 models to TensorRT format?
To convert your Ultralytics YOLO11 models to TensorRT format for optimized NVIDIA GPU inference, follow these steps:
-
ํ์ํ ํจํค์ง๋ฅผ ์ค์นํฉ๋๋ค:
-
Export your YOLO11 model:
For more details, visit the YOLO11 Installation guide and the export documentation.
What are the benefits of using TensorRT for YOLO11 models?
Using TensorRT to optimize YOLO11 models offers several benefits:
- ์ถ๋ก ์๋ ํฅ์: TensorRT ๋ชจ๋ธ ๋ ์ด์ด๋ฅผ ์ต์ ํํ๊ณ ์ ๋ฐ ๋ณด์ (INT8 ๋ฐ FP16)์ ์ฌ์ฉํ์ฌ ์ ํ๋๋ฅผ ํฌ๊ฒ ๋จ์ด๋จ๋ฆฌ์ง ์์ผ๋ฉด์ ์ถ๋ก ์๋๋ฅผ ๋์ ๋๋ค.
- ๋ฉ๋ชจ๋ฆฌ ํจ์จ์ฑ: TensorRT ์ tensor ๋ฉ๋ชจ๋ฆฌ๋ฅผ ๋์ ์ผ๋ก ๊ด๋ฆฌํ์ฌ ์ค๋ฒํค๋๋ฅผ ์ค์ด๊ณ GPU ๋ฉ๋ชจ๋ฆฌ ์ฌ์ฉ๋ฅ ์ ๊ฐ์ ํฉ๋๋ค.
- ๋ ์ด์ด ํจ์ : ์ฌ๋ฌ ๋ ์ด์ด๋ฅผ ๋จ์ผ ์์ ์ผ๋ก ๊ฒฐํฉํ์ฌ ๊ณ์ฐ ๋ณต์ก์ฑ์ ์ค์ ๋๋ค.
- ์ปค๋ ์๋ ํ๋: ๊ฐ ๋ชจ๋ธ ๋ ์ด์ด์ ์ต์ ํ๋ GPU ์ปค๋์ ์๋์ผ๋ก ์ ํํ์ฌ ์ต๋ ์ฑ๋ฅ์ ๋ณด์ฅํฉ๋๋ค.
์์ธํ ๋ด์ฉ์ TensorRT ์์ ์์ธํ ๊ธฐ๋ฅ์ ์ดํด๋ณด๊ณ TensorRT ๊ฐ์ ์น์ ์ ์ฐธ์กฐํ์ธ์.
Can I use INT8 quantization with TensorRT for YOLO11 models?
Yes, you can export YOLO11 models using TensorRT with INT8 quantization. This process involves post-training quantization (PTQ) and calibration:
-
INT8๋ก ๋ด๋ณด๋ด๊ธฐ:
-
์ถ๋ก ์ ์คํํฉ๋๋ค:
์์ธํ ๋ด์ฉ์ INT8 ์ ๋ํ๋ฅผ ์ฌ์ฉํ์ฌ TensorRT ๋ด๋ณด๋ด๊ธฐ ์น์ ์ ์ฐธ์กฐํ์ธ์.
How do I deploy YOLO11 TensorRT models on an NVIDIA Triton Inference Server?
Deploying YOLO11 TensorRT models on an NVIDIA Triton Inference Server can be done using the following resources:
- 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 ๋ฌธ์์ ์ฑ๋ฅ ๋ถ์ ๋ณด๊ณ ์๋ฅผ ์ฐธ์กฐํ์ธ์.