FSDP2, GPU 프로파일링과 모바일 컴퓨팅

프로덕션 AI 엔지니어링은 분산 멀티 GPU 실행, 하드웨어 수준 프로파일링, 크로스 플랫폼 모바일/엣지 런타임을 하나로 연결합니다. 아래에서 세 가지 영역 모두를 심층적으로 살펴봅니다.
1. PyTorch FSDP2를 이용한 멀티 GPU 분산 학습
PyTorch의 최신 FSDP2 (fully_shard)는 DTensor를 사용해 모델 파라미터, 그래디언트, 옵티마이저 상태를 파라미터 단위로 GPU 전체에 샤딩하여, 통신과 연산을 겹쳐 실행하면서 메모리 중복을 제거합니다.
아래는 완전한 멀티 GPU 학습 스크립트입니다. torchrun --nproc_per_node=4 train_fsdp.py 명령으로 4개의 GPU에서 실행하세요.
import os
import torch
import torch.nn as nn
import torch.distributed as dist
from torch.distributed._composable.fsdp import fully_shard, MixedPrecisionPolicy
class TransformerBlock(nn.Module):
def __init__(self, dim=2048, n_heads=16):
super().__init__()
self.norm1 = nn.RMSNorm(dim)
self.attn = nn.MultiheadAttention(dim, n_heads, batch_first=True)
self.norm2 = nn.RMSNorm(dim)
self.ffn = nn.Sequential(
nn.Linear(dim, dim * 4, bias=False),
nn.SiLU(),
nn.Linear(dim * 4, dim, bias=False),
)
def forward(self, x):
h = self.norm1(x)
attn_out, _ = self.attn(h, h, h, need_weights=False)
x = x + attn_out
return x + self.ffn(self.norm2(x))
class MiniLLM(nn.Module):
def __init__(self, vocab_size=32000, dim=2048, n_layers=12):
super().__init__()
self.embed = nn.Embedding(vocab_size, dim)
self.layers = nn.ModuleList([TransformerBlock(dim) for _ in range(n_layers)])
self.head = nn.Linear(dim, vocab_size, bias=False)
def forward(self, idx):
x = self.embed(idx)
for layer in self.layers:
x = layer(x)
return self.head(x)
def main():
# 1. Initialize NCCL process group
dist.init_process_group(backend="nccl")
local_rank = int(os.environ["LOCAL_RANK"])
torch.cuda.set_device(local_rank)
device = torch.device("cuda", local_rank)
# 2. Build model on meta device or standard CUDA, then shard layer-by-layer
model = MiniLLM().to(device)
mp_policy = MixedPrecisionPolicy(
param_dtype=torch.bfloat16,
reduce_dtype=torch.float32,
)
# Shard each TransformerBlock independently to prefetch weights on the fly
for layer in model.layers:
fully_shard(layer, mp_policy=mp_policy)
fully_shard(model, mp_policy=mp_policy)
optimizer = torch.optim.AdamW(model.parameters(), lr=3e-4)
# 3. Distributed Training Step (All-Gather -> Compute -> Reduce-Scatter)
for step in range(5):
tokens = torch.randint(0, 32000, (8, 1024), device=device)
targets = torch.randint(0, 32000, (8, 1024), device=device)
optimizer.zero_grad()
logits = model(tokens)
loss = nn.functional.cross_entropy(logits.view(-1, 32000), targets.view(-1))
loss.backward()
optimizer.step()
if local_rank == 0:
mem_gb = torch.cuda.max_memory_allocated(device) / 1e9
print(f"Step {step} | Loss: {loss.item():.4f} | Peak VRAM/GPU: {mem_gb:.2f} GB")
dist.destroy_process_group()
if __name__ == "__main__":
main()- 내부 동작: 각 레이어의 순전파 전에 FSDP는 NVLink를 통해 비동기 NCCL All-Gather를 실행해 해당 블록의 전체 bfloat16 가중치만 복원하고, 연산을 수행한 뒤 비샤딩된 가중치를 즉시 폐기합니다. loss.backward() 동안 그래디언트는 Reduce-Scatter를 통해 평균화되어 GPU 전체에 다시 분할됩니다.
2. PyTorch 모델 프로파일링: PyTorch Profiler & NVIDIA Nsight Compute (ncu)
GPU 코드를 최적화하려면 커널이 메모리 대역폭 바운드(HBM 읽기/쓰기를 기다리며 정체하는 경우)인지, 컴퓨트 바운드(Tensor Core FLOPS를 포화시키는 경우)인지 알아야 합니다.
단계 A: torch.profiler를 이용한 거시 수준 트레이스
PyTorch Profiler를 사용해 CPU 커널 실행 공백, 느린 데이터 로더, 가장 많은 시간을 소비하는 CUDA 커널을 찾아내세요.
import torch
from torch.profiler import profile, ProfilerActivity
model = torch.nn.Linear(4096, 4096, device="cuda", dtype=torch.float16)
x = torch.randn(1024, 4096, device="cuda", dtype=torch.float16)
with profile(
activities=[ProfilerActivity.CPU, ProfilerActivity.CUDA],
record_shapes=True,
profile_memory=True,
) as prof:
for _ in range(5):
out = model(x)
out.sum().backward()
torch.cuda.synchronize()
print(prof.key_averages().table(sort_by="cuda_time_total", row_limit=10))
prof.export_chrome_trace("trace.json") # Open in ui.perfetto.dev단계 B: NVIDIA Nsight Compute (ncu)를 이용한 미세 수준 루프라인 분석
torch.profiler가 느린 커널을 찾아내면, 터미널에서 ncu를 실행해 Streaming Multiprocessors (SMs)에서 하드웨어 성능 카운터를 직접 검사하세요:
ncu --set full --target-processes all -o kernel_report python my_script.pykernel_report.ncu-rep 안의 Speed of Light (SOL)와 Roofline Chart를 검사할 때는 두 가지 숫자를 확인하세요:
| 하드웨어 지표 | 메모리 바운드 커널 (예: LayerNorm, Softmax, Decode) | 컴퓨트 바운드 커널 (예: 대규모 배치 GEMM, Prefill) |
|---|---|---|
| 컴퓨트 (SM) 처리량 | 낮음 (< 25%) - Tensor Cores가 유휴 상태입니다. | 높음 (> 75%) - Tensor Cores가 최대 FLOPS에 근접하게 동작합니다. |
| 메모리 (HBM) 처리량 | 높음 (> 75%) - HBM 버스가 완전히 포화됩니다. | 낮음-중간 (< 50%) - 데이터가 온칩 SRAM 캐시를 재사용합니다. |
| 주요 해결책 | 커널 퓨전 (Triton/torch.compile), 양자화 (FP8/INT4), 또는 배치 크기 증가. | 더 낮은 정밀도 (FP8/NVFP4), Tensor Core 타일 정렬 (64/128의 배수), 또는 더 큰 GPU. |
3. 엣지 & 모바일 GPU 실행: Apple Metal & Vulkan Compute
스마트폰, 노트북, 임베디드 디바이스에 신경망을 배포하려면 NVIDIA 드라이버나 막대한 전력 예산 없이 실행해야 하며, 대신 Unified Memory Architectures (UMA)를 갖춘 Apple Metal과 Vulkan Compute에 의존합니다.
- 통합 메모리 아키텍처 (제로 카피 실행).
- PCIe를 통해 CPU RAM에서 VRAM으로 텐서를 복사해야 하는 디스크리트 NVIDIA GPU와 달리, Apple Silicon (M-시리즈 / A-시리즈)과 모바일 SoC (Qualcomm Snapdragon, ARM Mali)는 CPU, GPU, NPU가 하나의 물리적 LPDDR5/LPDDR5X 메모리 풀을 공유합니다.
- Apple MLX, llama.cpp, ExecuTorch 같은 프레임워크는 모델 가중치를 공유 주소 공간 (MTLResourceStorageModeShared)에 직접 매핑해 호스트-디바이스 전송 지연을 완전히 제거합니다.
- Apple Metal & Metal Performance Shaders (MPS).
- macOS와 iOS에서 Metal은 CUDA를 대체합니다. 개발자는 Metal Shading Language (MSL)(C++14 파생 언어)로 컴퓨트 셰이더를 작성하고, Apple GPU 코어와 Simdgroup Matrix 명령(Apple의 NVIDIA Tensor Cores에 해당하는 유닛) 전체에 스레드그룹을 디스패치합니다.
- PyTorch에서 device="mps"로 설정하면 텐서 연산이 Apple의 MPSGraph 컴파일러를 통해 라우팅되며, 이 컴파일러는 연산을 동적으로 퓨전하고 GPU 실행 유닛 전체에 작업을 스케줄링합니다.
- 크로스 플랫폼 Vulkan Compute & SPIR-V.
- Android, Windows, Linux, AMD/Intel/Qualcomm GPU 전반에서 Vulkan Compute는 범용 벤더 중립적 GPU 백엔드 역할을 합니다.
- 컴퓨트 커널(GLSL, HLSL로 작성되거나 MLIR/IREE에서 컴파일됨)은 SPIR-V 바이트코드로 컴파일됩니다. Cooperative Matrix 확장 (VK_KHR_cooperative_matrix)을 사용해 Vulkan 커널은 하나의 이식 가능한 바이너리로 Qualcomm Adreno, ARM Mali, AMD RDNA, Intel Arc GPU의 하드웨어 행렬 곱셈 유닛을 직접 활용합니다.