V17 Training System

1 GPU memory 4 bucket 학습 시 점유 주체 PGOA

• Param: forward에 필요한 weight
• Grad: backward가 채우는 ∂L/∂W
• Opt state: Adam momentum·variance 등
• Activation: backward용 중간 tensor

2 Model state 정의 고정 비용

• Activation은 batch·seq 따라 변동
• ZeRO는 model state 만을 shard (↗ §3)
• Gradient checkpointing은 activation만 감소 (↗ §7)

3 메모리 단위 공식 byte/param

4 Bucket 비율 ★ Adam·FP16 mixed

base: Rajbhandari 2020 (ZeRO) Table 1, Adam + FP16 mixed

5 ASCII bar chart ★

param (FP16)  ██        2B
grad  (FP16)  ██        2B
master(FP32)  ████      4B
moment(FP32)  ████      4B
var   (FP32)  ████      4B
         └─── model state 16B/param
act/ws  ████ ~3B (batch·seq 의존)

6 7B 모델 숫자 예 single-GPU 기준

∴ 7B조차 단일 GPU 학습 불가 → ZeRO/FSDP 필수

7 Activation factor c_act

Korthikanti 2022 (Reducing Activation Recomputation)

8 경계선 정리 out-of-scope 핑

• 수치 안정성 (loss NaN, under/overflow) ↗ V09 §3
• Inference KV cache ↗ V16 §4
• NCCL primitive 대역폭 식 ↗ V15 §2

1 Mixed precision 구성 정의

• master copy가 있어야 누적 오차 발산 방지
• BF16: exponent 8bit → loss scaling 불필요 경향
• FP16: exponent 5bit → loss scaling 필요 (↗ §13)

2 Adam 메모리 공식 ★ 2+2+4+4+4=16

3 FP32 baseline 비교

∴ mixed의 이점은 용량이 아니라 throughput(TC) · compute cost

4 왜 FP32 master인가 수치

• update: w ← w − η·(m̂/√(v̂)+ε)
• η·gradient는 종종 |w|의 10⁻⁷ scale
• FP16 mantissa 10bit → round-to-zero
• ∴ master를 FP32로 보존 → precision 유지

5 Forward/Backward bucket 흐름

FP32 master ──cast──► FP16 param
  │                      │ forward (TC)
  │                      ▼
  │                   activation (FP16)
  │                      │ backward
  │                      ▼
  │                   FP16 grad
  │                      │ unscale
  ▼                      ▼
FP32 m,v ◄──── grad (FP32) ← cast up
  │
update → master (in-place)

6 BF16 vs FP16 학습 관점

7 Grad 저장 dtype 옵션

8 Apex/AMP 경로 요약

• torch.cuda.amp.autocast: dtype 자동 캐스트
• GradScaler: scale / unscale / skip
• O1·O2·O3 mode (Apex) 유산 — 현재는 autocast 단일화
• 수치 상세 ↗ V09 §5

9 흔한 실수 주의

• loss.backward() 전에 scale 안 걸면 grad=0
• optimizer step 후 unscale 누락 → η 실효 ×scale
• master copy 안 두고 FP16 파라미터 직접 업데이트 → 수렴 불가

1 ZeRO 아이디어 ★ DP 중복 제거 OGP

• 통신 증가 vs 메모리 절감의 trade
• NCCL 식: allreduce ≡ reduce-scatter + all-gather (↗ V15)

2 Stage 정의 ★

AG = all-gather · RS = reduce-scatter

3 메모리 절감 공식 ★★

4 숫자 예 ★ P=7B, Adam

16·P/N → N=64일 때 1.75 GB/GPU

5 통신량 per step

AR ≡ RS+AG · 전체 bytes 기준

6 Stage 선택 결정표

• model ≤ 1B · NVLink: DP + ZeRO-1 충분
• 1B~10B: ZeRO-2 (grad shard)
• 10B+: ZeRO-3 (param shard) or FSDP/Megatron TP

7 ZeRO-3 life cycle per layer

[layer L]
 ┌── all-gather param (N→full) ──┐
 │           forward              │
 │      free param (→1/N)         │
 ▼                                ▼
 ...
 ┌── all-gather param ────────────┐
 │         backward                │
 │    reduce-scatter grad (→1/N)   │
 │    free param again             │
 ▼                                 ▼
 step: local shard만 update

8 ZeRO ≡ FSDP

• DeepSpeed ZeRO = Microsoft 진영
• FSDP = Meta/PyTorch 진영 (↗ §5)
• fairseq FSDP → torch.distributed.fsdp

9 K 상수 정리 optimizer별

1 Offload 동기 GPU가 부족할 때

• param/grad/opt state 중 일부를 offload
• opt state는 update에서만 필요 → 먼 저장소 적합
• param·grad은 fwd/bwd마다 접근 → swap 비쌈

2 ZeRO-Offload 구성

Ren 2021 (ZeRO-Offload)

3 ZeRO-Infinity 계층

GPU HBM   ← hot (param tile)
   ↕ NVLink/PCIe
CPU DRAM  ← warm (grad, opt state)
   ↕ PCIe
NVMe SSD  ← cold (huge opt state)

• partitioned param prefetch
• NVMe GDS (GPUDirect Storage)

4 Bandwidth 계산 ★

5 수치 예 P=13B, PCIe4

6 Offload 유효성 조건

• opt state ≫ param (Adam 12:4) → offload ROI ↑
• step이 매우 길어 swap을 감춤 (큰 batch)
• CPU-side optimizer 효율 (DeepSpeed CPU-Adam, fused kernel)
• bandwidth = NVLink > NVMe+GDS > PCIe SSD

7 적합 상황 vs 부적합

8 CPU-Adam fused DeepSpeed

• CPU intrinsic: AVX-512 · FMA로 32-lane
• grad FP16 → FP32 unscale + update를 단일 kernel
• GPU→CPU grad stream 비동기화

9 체크포인트와의 상호작용

• offload 중이면 master/m/v가 CPU에 → save 시 consolidation 필요 (↗ §15)
• NVMe에 체크포인트 직접 쓰기 가능
• resume 시 dtype·shard map 일치해야

1 FSDP 정의 ★ ZeRO-3 native

• unit = Transformer block 단위가 표준
• FSDP1 (legacy)·FSDP2 (per-param) 두 세대
• ZeRO-3와 동일 메모리식 (↗ §3)

2 FlatParameter FSDP1

• 장점: NCCL 호출 1회/unit (묶음 통신)
• 단점: mixed dtype 불가·일부 hook 부적합
• FSDP2: per-param sharding으로 해결

3 Unit wrapping 전략

transformer_auto_wrap_policy가 대부분 최적

4 Sharding 전략 옵션

HYBRID: intra-node shard + inter-node replicate

5 MixedPrecision config ★

MixedPrecision(
  param_dtype  = bfloat16,
  reduce_dtype = float32,
  buffer_dtype = bfloat16)

• param_dtype: shard·compute dtype
• reduce_dtype: gradient reduce 정밀도
• buffer_dtype: BN running stats 등

6 Prefetch 옵션 통신 은폐

BACKWARD_PRE가 보통 최적 (compute와 overlap)

7 FSDP2 per-param 최신

• fully_shard API · DTensor 기반
• 각 param이 독립 ShardedTensor
• mixed dtype unit·expert shard 가능
• hooks·LoRA 호환성 ↑

PyTorch 2.4+, torch.distributed._composable

8 메모리 구성 요소별 저장

[unit i, rank r]
  local shard: P_i / N
  full param (AG 직후): P_i  ← temporary
  grad shard: P_i / N
  opt state: P_i / N
  (AG buffer == compute buffer 재사용)

9 안티패턴 FSDP

• 너무 작은 unit: comm 횟수 ↑ · BW 비효율
• 너무 큰 unit: peak full-param GB ↑ · OOM
• root module 전체 wrap: prefetch 기회 상실
• grad clip 구현 미스: shard만 clip → norm 계산 틀림

1 Forward 5단계 ★ AG·F·RE

1. all-gather unit param (shard → full)
2. forward compute
3. reshard param (free full → keep shard)
4. activation은 unit 외부로 전달
5. 다음 unit 반복

activation은 full param 보존 없음 → backward에 재-AG

2 Backward 6단계 ★

1. activation에 ∂L 도달
2. all-gather param 다시 (unshard)
3. backward compute → grad_full
4. reduce-scatter grad → grad_shard
5. reshard param
6. 다음 unit (이전 layer)

3 Timeline ASCII

fwd[L0]: AG→compute→reshard
fwd[L1]: AG→compute→reshard
 ...
fwd[Ln]: loss
bwd[Ln]: AG→bwd→RS→reshard
bwd[Ln-1]: AG→bwd→RS→reshard
 ...
step: local shard update

4 통신량 공식

5 Compute-comm overlap prefetch

comp stream: | F(L0) | F(L1) | F(L2) |...
comm stream: |   AG(L1) | AG(L2) |...

bwd:
comp stream: | B(Ln) | B(Ln-1) |...
comm stream: | AG(Ln-1) | RS(Ln) + AG(Ln-2) |...

• compute stream ≠ comm stream
• CUDA event로 dependency

6 Root unit 특수 처리

• 최초 forward 직전: root all-gather 누적
• 최후 backward 이후: root reduce-scatter 대기
• root만 sharding 안 하는 경우 있음 (lazy init)

7 Gradient accumulation no_sync

• comm을 K배 절감 (K=accum steps)
• 단, 누적 grad는 rank-local → 마지막 step에 RS
• 상세 ↗ §11

8 Freeze param (LoRA 등)

• FSDP1: frozen param을 unit에 포함하면 AG·RS 낭비
• 해결: 별도 unit wrap, or NO_SHARD
• FSDP2: per-param shard로 해결 용이

9 흔한 실수

• unit 외부에서 param 접근: shard 상태라 shape 불일치
• grad clip 전 unshard 누락: grad_norm 전체 합산 못함 → clip_grad_norm_ FSDP API 사용
• optimizer에 full param 전달: 실제론 shard만 존재

1 동기 activation 메모리

• 메모리 O(L) → O(√L)
• compute: +1 forward pass (≈ +33%)
• Chen 2016 (Training Deep Nets with Sublinear Memory)

2 √N 공식 ★

3 적용 단위

4 Selective checkpoint ★

layer: [QKV proj] [SDPA] [out proj] [FFN]
store:    ✓          ✗       ✓       partial
recomp:              ✓              FFN 하위

Korthikanti 2022 · Megatron selective activation recompute

5 API 형태 PyTorch

from torch.utils.checkpoint import checkpoint

def block(x):
  return layer2(layer1(x))

y = checkpoint(block, x,
     use_reentrant=False)

• use_reentrant=False: autograd 2세대, 권장
• RNG state 저장·복원으로 dropout 재현

6 수치 재현성 RNG

• dropout mask가 fwd·recompute 달라지면 grad 틀림
• preserve_rng_state=True 기본값
• Megatron: CUDA RNG tracker로 tensor parallel RNG 분리

7 Trade-off 표

8 Offload activation

• GPU → CPU pinned으로 activation 이동
• backward에서 prefetch
• compute·comm overlap이 되면 거의 공짜

GPU HBM 해제·CPU DRAM 사용 — PCIe BW 여유 필요

9 FA와의 상호작용

• FlashAttention은 이미 O(N) activation (softmax statistics만 저장)
• attention block checkpoint는 추가 recompute (↗ V07)
• QKV proj·FFN block에 집중 적용이 ROI 높음

10 흔한 실수

• in-place op 내부에 checkpoint → recompute 후 상태 손상
• non-deterministic kernel (e.g. atomicAdd) → grad mismatch
• training loop 밖 RNG 변경 → dropout divergence

1 문제 상황 padding 낭비

• 평균/최대 길이 비 ≤ 0.5 인 dataset 흔함
• pad는 loss masking으로 무시되나 compute는 수행됨

2 Packing 정의 ★

raw: [s1: 123 ][s2:12][s3:1234]
pack: [123 12 1234]  seq=9
bdry:  0    3  5     (누적 시작)

3 cu_seqlens 자료구조

cu_seqlens = [0, 3, 5, 9]
max_seqlen  = 4
total_tok   = 9

FlashAttention varlen API 입력 ↗ V07 §12

4 Attention mask 구성 ★

  s1 s2 s3
s1 ██ ░░ ░░
s2 ░░ ██ ░░
s3 ░░ ░░ ██   (block-diagonal)

• 각 block 내 causal mask 추가
• dense mask(N²) 대신 cu_seqlens로 구현
• FA varlen: block-level skip (↗ V07)

5 FLOP 절약 공식

6 Position ID 재설정

• packed seq 전체에 0~N-1 쓰면 RoPE 엇나감
• 각 sample 내에서 0부터 다시 시작
• position_ids = [0,1,2, 0,1, 0,1,2,3]

7 Loss mask 주의

• SFT: prompt 영역 loss=0, completion만 loss
• packing 시 sample 경계에서 shift 조심
• attention mask ≠ loss mask (둘 다 필요)

8 Curriculum & bin packing

• 길이 bucket → 비슷한 길이끼리 배치 (bucket batching)
• greedy·first-fit decreasing으로 bin에 채움
• throughput 평탄화·OOM 예방

9 구현 체크리스트

10 흔한 실수

• packing 시 RNG seed 동일 → 재배치 없음, 고정 셔플
• cross-sample leak: mask 누락 → sample 간 attention 오염
• varlen + padding 혼재: 한쪽 통일

1 5 axis 정리 ★ 분할 대상 DP·TP·PP·EP·CP

상세 통신식 ↗ V15 §3

2 Megatron TP 구조

FFN: y = GeLU(x·W1)·W2
  W1 : col-parallel (split N)
  W2 : row-parallel (split K)
  마지막 all-reduce (sum)

QKV proj: col-parallel (head 분할)
Attn out: row-parallel + all-reduce

1 layer당 fwd 1× AR · bwd 1× AR

3 조합 기하 ★

4 통신 패턴

B:batch, S:seq, H:hidden, L:layer, M:microbatch, P:PP stages

5 TP NVLink 제약 ★

• A100·H100 single node: NVLink 8-way full mesh
• cross-node TP는 InfiniBand BW 제약

6 실전 구성표 ★

TP=intra-node · PP=inter-node · DP 가장 바깥

7 SP (Sequence Parallelism)

• TP 안에서 LayerNorm·Dropout의 seq 축을 분할
• all-gather·reduce-scatter가 TP all-reduce를 대체 (동일 bytes)
• activation 메모리 추가 절감
• Korthikanti 2022

8 축 순서 관습

inner  TP  (NVLink)
         │
         PP  (node-to-node P2P)
         │
outer  DP  (ZeRO/FSDP 가능)

TP는 가장 fast fabric, DP는 가장 slow에 배치

1 Bubble ratio 공식 ★

• M이 크면 bubble ↓ (파이프라인 채움)
• M 제한: activation 메모리 (각 micro별)

2 GPipe 기본 all-fwd-then-bwd

P=4, M=4
t: 0 1 2 3 4 5 6 7 8 9 A B
G0 F F F F       B B B B
G1   F F F F   B B B B
G2     F F F F B B B B
G3       F F F F B B B B
     └─fwd warm─┘└─bwd tail─┘
bubble = 2(P-1)/M

∴ activation이 모든 micro 저장 → 메모리 많음

3 1F1B schedule ★ Megatron

P=4, M=8, 1F1B:
t: 0 1 2 3 4 5 6 7 8 9 A B C D
G0 F F F F B F B F B F B B B B
G1   F F F B F B F B F B F B B
G2     F F F B F B F B F B F B
G3       F B F B F B F B F B F
 warm-up    steady (1F1B)    drain
bubble = (P-1)/M (GPipe의 절반)

• 정상 구간: 각 stage가 F,B를 교대
• activation 보존 ≤ P (stage 수)

4 Interleaved (virtual pipeline)

P=4, v=2 (virtual stages/GPU), M=8:
G0: [s0]...[s4]  F F F F B B B B (교차)
G1: [s1]...[s5]  ...
bubble = (P-1) / (v·M)

• 각 GPU가 v개 stage 담당
• bubble v배 ↓ · P2P 통신 v배 ↑
• Narayanan 2021 (Megatron)

5 Zero-Bubble ★ 최신

1F1B-BW:
G0 F F F F B W B W B W B W W W
           └─ B·W 교차 ─┘
Qi, Zero Bubble Pipeline (2023)

bubble → 근사 0 · 구현 복잡도 ↑

6 3종 비교표

7 선택 결정

• M ≥ 4·P 가능 → 1F1B 충분
• M 제약 있고 P 큼 → interleaved
• 극한 throughput·구현 여유 → zero-bubble

1 원리 CUDA stream

• SM 자원 분할: NCCL은 일부 SM만 사용
• HBM BW 공유가 병목이 됨

2 Bucketed grad reduce ★

bwd:  G_L1 G_L2 G_L3 G_L4 ...
              └bkt┘└bkt┘
              RS starts asap (overlap next B)

DDP·FSDP 기본 동작

3 Parameter prefetch

• 다음 layer의 AG를 현재 compute와 겹침
• FSDP: BACKWARD_PRE (↗ §5)
• pipeline depth = prefetch 횟수

4 no_sync() ★

for i, batch in enumerate(loader):
  if (i+1) % accum != 0:
    with model.no_sync():
      loss = model(batch)
      loss.backward()
  else:
    loss = model(batch)
    loss.backward()  # sync
    optimizer.step()

5 FSDP fine-grained overlap

3중 overlap이 가능하나 구현이 복잡

6 TP overlap Megatron

• SP all-gather를 다음 GEMM과 overlap
• UserBuffers / CUDA graphs로 kernel launch 비용 감소
• TE 모듈에 "ub_overlap_ag" flag

7 PP P2P overlap

• P2P send/recv은 NCCL sendrecv group
• compute가 길면 자연 은폐
• short stage → P2P bound 가능

8 진단 포인트

Nsight Systems trace 기준 ↗ V18 §12

9 흔한 실수

• bucket 크기 과소: NCCL 호출 횟수 ↑ · BW ↓
• single stream: NCCL이 compute 차단
• event 누락: grad race → NaN

1 Adam 업데이트 식 복습

2 Adam vs AdamW weight decay

• Loshchilov 2019 · LLM 사실상 표준은 AdamW
• decay가 m/v 통해 왜곡되지 않음

3 메모리 B/param 비교

master copy 4B/p 별도 추가

4 Adafactor ★ T5 학습

• matrix 한 축이 크면 메모리 O(m+n) vs O(mn)
• 수렴 속도는 Adam 대비 약간 느릴 수 있음
• Shazeer 2018

5 8-bit Adam ★ bitsandbytes

Dettmers 2022 · 수렴 품질 Adam과 동등

6 Lion 최신 대안

• sign-based update: w ← w − η·sign(m̃)
• state: momentum만 → 4B/p
• LR·WD 튜닝 민감도 높음
• Chen 2023 (EvoLved Sign Momentum)

7 품질-메모리 trade ★

master 4B 포함 값 · LLM pretrain 기준

8 Fused optimizer kernel

• Apex FusedAdam·PyTorch foreach·fused=True
• element-wise update를 단일 kernel
• CUDA graph 친화·launch overhead ↓

9 흔한 실수

• β₂ 기본값 0.999 고수: LLM에서 0.95가 통상 안정
• ε=1e-8 FP16에서 0: 1e-6 권장
• Adam + L2 대신 AdamW 혼동

1 왜 loss scaling FP16

• backward 후 grad / S 로 복원 (unscale)
• BF16은 range가 FP32와 같아 scaling 불필요
• 수치 상세 ↗ V09 §4

2 Dynamic loss scale ★ up·skip·down

state:
  S (scale factor)   init ~2^16
  growth_interval    e.g. 2000
  n_ok               success 카운트

per step:
  if any(grad = ±inf, NaN):
      skip step
      S ← S / 2; n_ok ← 0
  else:
      apply step
      n_ok ← n_ok + 1
      if n_ok == growth_interval:
          S ← S · 2; n_ok ← 0

3 GradScaler API

scaler = GradScaler()
for x,y in loader:
  with autocast(dtype=FP16):
    loss = model(x,y)
  scaler.scale(loss).backward()
  scaler.unscale_(opt)       # for clip
  clip_grad_norm_(...)
  scaler.step(opt)           # skip if inf
  scaler.update()            # adjust S

4 FP8 formats ★ H100+

Micikevicius 2022 · IEEE binary8 candidate

5 FP8 scaling 전략

• per-tensor scale factor (delayed scaling)
• amax history 유지 → next-step scale 예측
• TE가 amax·scale graph로 관리

6 Transformer Engine path ★

x (BF16) ─cast→ E4M3 ─┐
W (BF16) ─cast→ E4M3 ─┤ WGMMA (FP8×FP8)
                       └→ FP32 accum → BF16
grad (BF16) ─cast→ E5M2 (더 큰 range)
amax history → per-tensor scale

• TE module이 자동 관리
• 수치 상세 ↗ V09 §6

7 FP8 safe layer 경계

8 흔한 실수

• unscale 전 clip: norm이 S배 왜곡
• skip시 step 집계: global_step 증가 금지
• FP8 amax 미동기화: DP 간 scale 불일치 → NaN

1 목표

2 PyTorch DataLoader

3 Sharding 분산 학습

• DistributedSampler: rank별 index 분할
• 각 rank는 dataset의 1/N만 읽음
• epoch마다 seed 동기화로 중복 방지
• iterable dataset: webdataset·streaming

4 Shuffle 전략

global shuffle은 많은 메모리 필요 → buffer approximation

5 저장 포맷 ★

6 GPU-side decoding ★

• NVJPEG·NVIMGCODEC: JPEG를 GPU에서 decode
• DALI pipeline: decode + augmentation 모두 GPU
• CPU preproc bound 모델에서 2~5× 처리량

7 Text pretrain loader 특수 LLM

• token-level sharding: fixed-length chunk
• index file: .bin + .idx (Megatron)
• seq boundary preserve 여부 선택
• packing 전제 (↗ §8)

8 Resumable sampler

• DistributedSampler는 set_epoch 필수
• streaming은 별도 offset tracking
• ↗ §15 checkpoint

9 진단 지표

10 흔한 실수

• num_workers=0: GPU 유휴
• pin_memory 미사용: H2D 대역폭 절반
• augmentation CPU fork 비용: 과한 worker 역효과

1 저장 대상 resume 정확성

2 저장 형태 ★

torch.distributed.checkpoint 2.2+

3 파일 레이아웃 예

ckpt-1000/
├ model/
│ ├ __0_0.distcp
│ ├ __1_0.distcp
│ └ ...
├ optim/
├ meta.json   (world topology)
└ sampler_state.pt

4 Sharded save 장점

• 각 rank가 병렬로 local shard만 dump
• write BW ∝ N (node 수)
• rank-0 bottleneck 없음
• load도 shard-aware로 수신

5 Consolidation 배포용

• FSDP: StateDictType.FULL_STATE_DICT
• rank-0에 모여 save
• 메모리 여유 필요 (full param)

6 Reshard on load ★

save: TP=8, PP=4, DP=16
load: TP=4, PP=4, DP=32   ← OK
load: TP=8, PP=4, DP=16   ← 동일
사용: resume시 node 수 변경

7 Async save CUDA stream

• D2H copy를 비동기로 시작 → 학습 지속
• CPU-side에서 disk write 병렬
• save latency 감춤 → 빈번 저장 가능
• Mosaic·DeepSpeed·Megatron 구현 존재

8 Save interval heuristic

interval ↑ → 손실 확률 ↑ · IO ↓

9 Resume 정확성 체크

1. loss curve 연속성 (점프 없음)
2. grad norm 분포 유사
3. data iteration index 일치
4. RNG 복원으로 dropout 재현

10 흔한 실수

• sampler state 미저장: resume 후 data 중복
• RNG state 누락: dropout 달라짐
• rank-0 save만: world 변경 불가

1 실패 모드 대규모

1000 GPU·30일 학습 시 수십건 통상

2 MTBF와 interval

3 Graceful detect

• NCCL async error → C10d exception
• timeout 설정: NCCL_TIMEOUT (default 30min)
• CUDA Xid log 파싱 (supervisor)
• straggler detect: step time quantile

4 torchrun elastic ★

• --max-restarts, --rdzv-backend=c10d
• memgroup·global_step이 rdzv metadata
• world size 변경 가능 (±node)

5 Elastic training 구성

[rdzv server]
     │
┌────┴────┬────┬────┐
worker  worker  ...
  │        │
 fail!
     ↓
rdzv re-bargain (N→N-1 or +spare)
     ↓
load last ckpt (reshard topology)
     ↓
resume

6 Hot spare 전략

• spare node 1~2대 대기
• failure 시 rendezvous에 join
• 대규모 scheduler (SLURM/k8s) 레벨 선택

7 Deterministic replay

• RNG + sampler state 복원 (↗ §15)
• NCCL non-determinism: NCCL_ALGO=Ring 고정
• CuDNN deterministic flag
• 단, FA·reduce-scatter는 non-associative

8 Save interval tuning

∝ 1/√MTBF · 실측이 최종

9 흔한 실수

• rdzv 단일 실패점: etcd/consul HA 필요
• NCCL_TIMEOUT 기본 30m: 대규모에 짧음
• sampler state 없음: resume 데이터 중복
• straggler 방치: throughput 전체 ↓

1 7B 권장 ★ 단일 node

2 70B 권장 ★ 중규모

3 400B 권장 ★ 초대형

4 Decision tree

start
 └ model ≤ 10B? → FSDP (FULL_SHARD) only
     │
     ▽ no
 └ intra-node NVLink? → TP=8
     │
     ▽ yes
 └ model ≤ 100B? → TP8 + PP4 + DP
     │
     ▽ no
 └ TP8 + PP≥8 + ZeRO-1 + CP/EP 조합

5 흔한 안티패턴

• TP cross-node: NVLink 없으면 금지
• PP + ZeRO-3: AG가 stage 간 얽힘 → ZeRO-1만
• small DP + huge PP: DP grad AR bubble

6 메모리 diagnosis ★

7 Throughput diagnosis

8 교차 참조 요약

• NCCL primitive·대역폭 ↗ V15
• KV cache·inference serving ↗ V16
• FP8·loss scaling 수치 ↗ V09
• FA varlen 상세 ↗ V07
• Profiling·stall ↗ V18

9 최종 체크리스트

1. model state 분산 전략 확정 (ZeRO/TP/PP)
2. activation 전략 (ckpt level·SP)
3. precision 경로 (BF16·FP8·loss scale)
4. comm-compute overlap 활성
5. checkpoint async·interval 설정
6. elastic rdzv·straggler 감시