๐ ํ๋์จ์ด ์ ๊ทธ๋ ์ด๋ ์์ด ๋ฅ๋ฌ๋ ํ์ต ์๊ฐ์ 45% ๋จ์ถํ ๋ฐฉ๋ฒ
Source: Dev.to
๐ ๋ฅ๋ฌ๋ ํ์ต ์๊ฐ์ 45% ๋จ์ถํ ๋ฐฉ๋ฒ โ ํ๋์จ์ด ์ ๊ทธ๋ ์ด๋ ์์ด
๋จธ์ ๋ฌ๋ ์์ง๋์ด๋ค์ ์ข ์ข ๋์ ์ ํ๋, ๋ ์ข์ ์ํคํ ์ฒ, ์ต์ ๋ชจ๋ธ์ ์ถํํ์ง๋ง, ๊ฑฐ์ ์ฃผ๋ชฉ๋ฐ์ง ๋ชปํ๋ ๋ ๋ค๋ฅธ ๊ฐ๋ ฅํ ๋ ๋ฒ๊ฐ ์์ต๋๋ค:
ํ์ต ํจ์จ์ฑ โ ์คํ, ๋ฐ๋ณต, ๊ฐ์ ์ ์ผ๋ง๋ ๋น ๋ฅด๊ฒ ํ ์ ์๋๊ฐ.
์ค์ ์์ง๋์ด๋ง ํ๊ฒฝ์์๋ ์๋ = ์์ฐ์ฑ ์ ๋๋ค. ๋ชจ๋ธ ํ์ต์ด ๋นจ๋ผ์ง๋ฉด:
- ํ๋ฃจ์ ๋ ๋ง์ ์คํ ์ํ
- ํผ๋๋ฐฑ ๋ฃจํ ๊ฐ์ํ
- ์ปดํจํ ๋น์ฉ ์ ๊ฐ
- ๋ฐฐํฌ ์๋ ํฅ์
๋ ํฐ GPU๋ก ์ ๊ทธ๋ ์ด๋ํ๊ฑฐ๋ ๋น์ผ ํด๋ผ์ฐ๋ ์๋ฒ๋ฅผ ์๋ํ๋ ๋์ , ๋๋ ์ํํธ์จ์ด ์์ค ๊ธฐ๋ฒ์ ํ์ฉํด ํ์ต์ ์ผ๋ง๋ ์ต์ ํํ ์ ์๋์ง ์คํํ์ต๋๋ค.
๐ฏ ์คํ ์ค์
๋ฐ์ดํฐ์
- MNIST โ ํ์ต ์ํ 20,000๊ฐ + ํ ์คํธ 5,000๊ฐ (๋น ๋ฅธ ๋น๊ต๋ฅผ ์ํ ์๋ธ์ )
ํ๋ ์์ํฌ
- TensorFlow 2
- Google Colab GPU ํ๊ฒฝ
ํ ์คํธํ ๊ธฐ๋ฒ
| Technique | Description |
|---|---|
| Baseline | ๊ธฐ๋ณธ ํ์ต (float32), ์ต์ ํ ์์ |
| Caching + Prefetching | ๋ฐ์ดํฐ ๋ก๋ฉ ๋ณ๋ชฉ ์ ๊ฑฐ |
| Mixed Precision | FP16 + FP32 ํผํฉ ์ฐ์ฐ ์ฌ์ฉ |
| Gradient Accumulation | ํฐ VRAM ์์ด ํฐ ๋ฐฐ์น ์ฌ์ด์ฆ ์๋ฎฌ๋ ์ด์ |
๐ ํ์ต ์๊ฐ ๊ฒฐ๊ณผ (5 Epoch)
| Technique | Time (seconds) |
|---|---|
| Baseline | 20.03 |
| Caching + Prefetching | 11.27 (โโฏ45โฏ% faster) |
| Mixed Precision | 15.89 |
| Gradient Accumulation | 14.65 |
Caching + Prefetching๋ง์ผ๋ก๋ ํ์ต ์๊ฐ์ด ๊ฑฐ์ ์ ๋ฐ์ผ๋ก ์ค์ด๋ค์์ต๋๋ค.
๐ง ํต์ฌ ์ธ์ฌ์ดํธ
์์ ๋ฐ์ดํฐ์ ์์๋ ๋ฐ์ดํฐ ๋ก๋ฉ โ GPU ์ ํด ์๊ฐ์ด ๋ณ๋ชฉ์ด ๋๋ ๊ฒฝ์ฐ๊ฐ ๋ง์ต๋๋ค. ๋ชจ๋ธ์ด ์๋๋ผ ํ์ดํ๋ผ์ธ์ ๊ณ ์น์ธ์.
๐งฉ ๊ธฐ๋ฒ ์์ธ ๋ถ์
1. Data Caching + Prefetching
train_ds = train_ds.cache().prefetch(tf.data.AUTOTUNE)
์ ๋์์ด ๋๋๊ฐ
- ๋ฐ์ดํฐ๋ฅผ ํ ๋ฒ๋ง ๋ก๋ํ๊ณ RAM์ ์ ์ฅ
- Prefetch๊ฐ ๋ฐ์ดํฐ ์ค๋น์ GPU ์ฐ์ฐ์ ๊ฒน์น๊ฒ ํจ
- GPU ๋๊ธฐ ์๊ฐ ์ ๊ฑฐ
ํธ๋ ์ด๋์คํ
- ์ถฉ๋ถํ RAM ํ์
- ์ปดํจํ ์ด ๋ณ๋ชฉ์ด๋ฉด ํจ๊ณผ๊ฐ ์ ์
2. Mixed Precision Training
from tensorflow.keras import mixed_precision
mixed_precision.set_global_policy('mixed_float16')
์ ๋์์ด ๋๋๊ฐ
- FP16 ์ฐ์ฐ์ด ๋ ๋น ๋ฅด๊ณ ๋ฉ๋ชจ๋ฆฌ ์ฌ์ฉ๋์ด ์ ์
- Tensor Core๊ฐ ํ๋ ฌ ์ฐ์ฐ์ ๊ฐ์ํ
๊ฐ์ฅ ์ ํฉํ ๊ฒฝ์ฐ
- CNN, Transformer, diffusion ๋ชจ๋ธ
- ๋๊ท๋ชจ ๋ฐ์ดํฐ์ + ์ต์ GPU (T4, A100, RTXโฏ30/40 ์๋ฆฌ์ฆ)
ํธ๋ ์ด๋์คํ
- ์ ํ๋ ์ฝ๊ฐ์ ๋๋ฆฌํํธ ๊ฐ๋ฅ์ฑ
- CPU ์ ์ฉ ์์คํ ์์๋ ์ด์ ์์
3. Gradient Accumulation
loss = loss / accumulation_steps
loss.backward()
if (step + 1) % accumulation_steps == 0:
optimizer.step()
optimizer.zero_grad()
์ ๋์์ด ๋๋๊ฐ
- VRAM์ด ์ ์ GPU์์๋ ํฐ ๋ฐฐ์น ์ฌ์ด์ฆ๋ฅผ ์๋ฎฌ๋ ์ด์
- ๊ทธ๋๋์ธํธ ์์ ์ฑ ํฅ์
ํธ๋ ์ด๋์คํ
- ์ํฌํฌ๋น ์ค์ ์๊ฐ์ ๋๋ ค์ง
- ์ปค์คํ ๋ฃจํ ๊ตฌํ ํ์
โ ์ค์ ํ์ฅ ๊ด์ : ํธ๋ ์ด๋์คํ๊ฐ ์ค์
| Technique | Main Benefit | Potential Issue |
|---|---|---|
| Caching + Prefetching | GPU ํ์ฉ๋ ๊ทน๋ํ | ๋์ RAM ์ฌ์ฉ๋ |
| Mixed Precision | ํฐ ์๋ ํฅ์ | ํธํ ํ๋์จ์ด ํ์ |
| Gradient Accumulation | ์์ GPU์์๋ ๋ํ ๋ชจ๋ธ ํ์ต | ๋จ๊ณ๋น ์๊ฐ ์ฆ๊ฐ |
์๋ฒฝํ ๊ธฐ๋ฒ์ ์์ต๋๋คโ์ค์ง ์ํฉ์ ๋ง๋ ํ๋จ๋ง์ด ์กด์ฌํฉ๋๋ค. ์ต๊ณ ์ ์์ง๋์ด๋ ์ค์ ๋ณ๋ชฉ์ ๋ฐ๋ผ ์ ํํฉ๋๋ค.
๐ง ์ธ์ ์ด๋ค ๊ธฐ๋ฒ์ ์จ์ผ ํ ๊น
| Problem | Best Solution |
|---|---|
| ๋๋ฆฐ ๋ฐ์ดํฐ ๋๋ฌธ์ GPU๊ฐ ์ ํด ์ํ | Caching + Prefetch |
| GPU ๋ฉ๋ชจ๋ฆฌ๊ฐ ๋ถ์กฑ | Gradient Accumulation |
| ์ฐ์ฐ์ด ๋ณ๋ชฉ์ธ ์ํฌ๋ก๋ | Mixed Precision |
๐ฏ ์ต์ข ์ ๋ฆฌ
ํญ์ ํฐ GPU๊ฐ ํ์ํ ๊ฒ์ ์๋๋๋ค. ๋ ๋๋ํ ํ์ต์ด ํ์ํฉ๋๋ค.
ํจ์จ์ฑ ์์ง๋์ด๋ง์ ํนํ ๋๊ท๋ชจ ํ๊ฒฝ์์ ์ค์ํฉ๋๋ค.
๐ ์ ์ฒด ๋ ธํธ๋ถ + ๊ตฌํ
- ํ์ต ์๊ฐ ๋น๊ต
- ์ฑ๋ฅ ์๊ฐํ ์ฐจํธ
- ๋ฐ๋ก ์คํ ๊ฐ๋ฅํ Colab ๋ ธํธ๋ถ
- ์์ ์ฌํ ๊ฐ๋ฅํ ๊ตฌํ
๐ฌ ๋ค์์ ํ๊ตฌํ ๋ด์ฉ
- ๋ถ์ฐ ํ์ต (DDP / Horovod)
- XLA & ONNX Runtime ๊ฐ์
- ResNet / EfficientNet / Transformer ๋ฒค์น๋งํฌ
- ํ์ดํ๋ผ์ธ ๋ณ๋ชฉ ํ๋กํ์ผ๋ง
๐ค ์ปค๋ฎค๋ํฐ ์ง๋ฌธ
์ฌ๋ฌ๋ถ์ด ๋ฌ์ฑํ ๊ฐ์ฅ ํฐ ํ์ต ์๋ ํฅ์์ ๋ฌด์์ด๋ฉฐ, ์ด๋ป๊ฒ ์ด๋ฃจ์๋์?