한국어 뉴스
최신
AI & 기술

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

데이터 센터나 GPU 시스템이 아닌, 예시용 고압 송전 철탑 사진.
데이터 센터나 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.py

kernel_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의 하드웨어 행렬 곱셈 유닛을 직접 활용합니다.

더 많은 뉴스: AI & 기술