Mixed Precision & 수치 안정성

1 표현식 sign · exp · mantissa (-1)^S · 2^E · 1.M

• Normalized: E ∈ [1, 2^e−2], leading 1 implicit
• Subnormal: E = 0, leading 0, gap 균등 채움 → underflow 완화
• Zero: E = 0, M = 0 (±0 존재)
• Inf/NaN: E = 2^e−1

2 Bias exponent 정규화

3 Subnormal gradual underflow

• FP32 min normal 2⁻¹²⁶ ≈ 1.18e−38 · min subnormal 2⁻¹⁴⁹ ≈ 1.40e−45
• FTZ (flush-to-zero): GPU에서 subnormal을 0으로 — 성능↑ 정밀↓

4 Special values Inf · NaN E=all-1

• NaN 전파: op(x, NaN) = NaN (quiet) → 중독 (poison)
• NaN ≠ NaN — IEEE 비교 규칙
• ±0: 부호 있음, 비교는 같음 (+0 == −0)

5 FP32 bit layout ★

31 30        23 22                    0
 ┌─┬──────────┬───────────────────────┐
 │S│  E (8)   │      M (23)           │
 └─┴──────────┴───────────────────────┘
  sign  exp       mantissa (fraction)
  bias = 127
  normalized: x = (-1)^S · 2^(E-127) · 1.M

6 FP64 bit layout

63 62          52 51                    0
 ┌─┬─────────────┬───────────────────────┐
 │S│   E (11)    │       M (52)          │
 └─┴─────────────┴───────────────────────┘
  bias = 1023
  precision ≈ 15~17 decimal digit

ε_mach(FP64) = 2⁻⁵² ≈ 2.22e−16 · ↗ V09 §8 Error

7 Machine epsilon 정밀도 한계

8 FP32 · FP64 dynamic range

IEEE 754-2008 · dd = decimal digit

1 FP16 layout 1/5/10 exp=5 narrow

15 14   10 9               0
 ┌─┬──────┬───────────────┐
 │S│E (5) │   M (10)      │
 └─┴──────┴───────────────┘
 bias=15  range ~[6e-8, 6.5e+4]
 ε_mach = 2^-10 ≈ 9.77e-4

• IEEE 754-2008 binary16 표준
• range 좁음 → gradient underflow ∴ loss scaling 필요
• precision 10 bit → BF16보다 정밀

2 BF16 layout 1/8/7 FP32 exp 유지

15 14         7 6             0
 ┌─┬────────────┬─────────────┐
 │S│  E (8)     │   M (7)     │
 └─┴────────────┴─────────────┘
 bias=127  range ≈ FP32
 ε_mach = 2^-7 ≈ 7.81e-3

• FP32 상위 16 bit 그대로 = FP32 ↔ BF16 변환 단순 truncate
• range 넓음 → loss scaling 불필요
• precision 낮음 — 7 mantissa bit

3 TF32 layout 1/8/10 TC input only

18 17          10 9             0
 ┌─┬─────────────┬───────────────┐
 │S│   E (8)     │    M (10)     │
 └─┴─────────────┴───────────────┘
 19-bit internal · storage 32-bit
 bias=127  range = FP32

• A100+ Tensor Core 전용 → FP32 입력을 silently TF32로 변환
• FP32 range + FP16 precision
• accumulation은 FP32 (TF32로 누적 아님)
• 주의: 비결정적 — reproducibility 필요시 off

4 3-format 비교 ★

5 Range × Precision trade 정성 2D

precision (mantissa)
  ↑
10│ FP16  TF32        FP32
  │                    │
 7│      BF16
  │
 3│ FP8-E4M3
 2│ FP8-E5M2 FP6-E3M2
 1│ FP4-E2M1
  └─────────────────────→ range (exp)
    e=4  e=5  e=8(FP32·BF16·TF32)  e=11(FP64)

세로축 mantissa bit = precision · 가로축 exp bit = range · 정성 배치

6 Tensor Core 지원 매트릭스 A100/H100

NVIDIA A100/H100 whitepaper · sparsity 미포함 · TC=Tensor Core

1 FP8 두 variant ★ inf·grad

OCP FP8 spec · H100 whitepaper · E4M3 NaN만 (Inf 없음, range↑)

2 FP8 E4M3 bit layout

 7 6     3 2   0
 ┌─┬─────┬─────┐
 │S│E (4)│M (3)│
 └─┴─────┴─────┘
 bias=7  max=448  NaN: S.1111.111
 Inf 없음 → max 표현 확장 (240 vs 224)

3 FP8 E5M2 bit layout

 7 6       2 1 0
 ┌─┬─────────┬───┐
 │S│ E (5)   │M 2│
 └─┴─────────┴───┘
 bias=15  max=57344  IEEE 표준 (Inf/NaN)
 → FP16과 exp 공유, mantissa만 다름

4 왜 2가지? range vs precision

• weight: 분포 좁음 → E4M3
• activation (forward): 정규화 후 좁은 분포 → E4M3
• gradient: 극단값 (outlier) 많음 → E5M2
• optimizer state (moment): FP32 유지 (너무 민감)

5 Per-tensor scaling 공식 ★

• 1 scale per tensor — metadata 최소
• outlier 1개가 전체 tensor 정밀도 파괴 가능

6 Scaling 세분도 비교

구체 알고리즘 선택은 ↗ V10 §1~§4

7 E4M3 값 분포 예시

E=0001 (2^-6)
  0.015625, 0.017578, 0.019531, ... 0.029296
E=0010 (2^-5)
  0.03125, 0.03515, 0.0390, ...
E=1111 (2^8, 특수)
  MSB ≠ 111: normal (up to 448)
  M = 111: NaN only

→ 지수 간 가격차 2배 · 지수 내 8 레벨 (3 mant)

8 Accumulator 선택 acc dtype

C[m,n] = Σ_k A[m,k] · B[k,n]
  A,B : FP8
  product : FP16 중간
  acc     : FP32  ← 필수
  output  : BF16/FP16/FP8 dequant

1 왜 FP4/FP6? 동기

• 모델 크기 → HBM capacity·BW bottleneck
• FP8 → FP4 → 2× 용량, 2× BW, 2× TC throughput
• precision 격차는 block scaling으로 복구
• Blackwell TC에 FP4/FP6 natively 지원 (5세대 TE)

2 FP4 variants ★ E2M1

E2M1:  0b SEEM
  values: 0, ±0.5, ±1, ±1.5, ±2, ±3, ±4, ±6
  → 16 lattice point (sign + magnitude)

3 FP4 E2M1 값 전체 표 16 레벨

E∈{0,1,2,3}·M∈{0,1} · *subnorm/norm 경계 · MX spec

4 FP6 variants

• FP8와 FP4 사이의 중간 bit-width
• Blackwell TC MXFP6 지원
• storage: 6 bit · 4 원소 = 24 bit (packing 비효율)

5 MX (OCP Microscaling) block-scale family

OCP MX spec v1.0 · 2023

6 NVFP4 NVIDIA 확장 G=16

NVFP4 whitepaper · 같은 FP4 element지만 quantization 오차 ↓

7 E8M0 scale format

• 8 bit unsigned exponent only · mantissa 0 bit
• 표현값: 2^k, k ∈ [−127, +127] · NaN = 0xFF
• scale 자체가 정확한 power-of-2 → multiply = exponent add
• HW 단순 · scale 곱셈이 bit shift 수준

1 Block-scale 원리 ★

• per-tensor 대비 outlier 흡수
• per-element (=FP32) 대비 메모리 효율
• metadata overhead = sizeof(scale) / G

2 MXFP8 (G=32) layout ★ 32-pack

block (G=32 elements, MXFP8):
 ┌─────────────────────────────────────┐
 │ s₀ (E8M0, 1B) │ e₀ e₁ ... e₃₁ (32B) │
 └─────────────────────────────────────┘
   scale            32 FP8 elements
   → total 33 B per block
   → overhead 8b / 32 elem = 0.25 b/elem

tensor [N elements] =
 ┌────────┬────────┬────────┬─── ...
 │block 0 │block 1 │block 2 │
 │s₀│data │s₁│data │s₂│data │
 └────────┴────────┴────────┴─── ...
   각 block 독립 scale · 순차 배치

3 NVFP4 (G=16) layout ★

block (G=16 elements, NVFP4):
 ┌──────────────────────────────────────┐
 │ s₀ (FP8 E4M3, 1B) │ e₀..e₁₅ (packed) │
 └──────────────────────────────────────┘
   scale                16 FP4 = 8 B
   → total 9 B per block
   → overhead 8b / 16 elem = 0.5 b/elem

FP4 packing (2 elem / byte):
 byte: [ e₂ᵢ₊₁ | e₂ᵢ ]  ← nibble
         high     low
 16 elements = 8 bytes

scale precision:
 MXFP4 UE8M0: s ∈ {2^-127, ..., 2^127}  (pow-2 만)
 NVFP4 FP8:   s = (-1)^S · 2^(E-7) · 1.M (full FP8)

4 Microscaling matmul 수식

• group 내부 dot 결과는 FP32로 확장 후 scale 곱
• TC 명령이 group dot + scale을 단일 op로 fuse
• acc는 FP32 (≥ N=수백에서 필수)

5 Format 효과 bit-rate 비교 ★

6 Block axis 선택

• weight: output channel 축 block — dequant이 matmul와 정렬
• activation: token 축 (per-token group) — 분포 token별 상이
• KV cache: head 또는 token (↗ V10 §8)
• 축 선택 실패 → matmul에서 scale broadcast 불일치

1 왜 rounding? exact 불가능

• rounding 선택은 error 분포를 결정
• IEEE 754는 4개 기본 모드 정의
• additional: stochastic, round-to-odd

2 IEEE 754 4 modes ★

• RN = IEEE 754 기본 (banker's rounding)
• RZ = C cast behavior, GPU HW 일부

3 RN-even (banker's) tie-break

decimal 예 (소수 1자리 → 정수):
  2.5 → 2  (even)
  3.5 → 4  (even)
  4.5 → 4  (even)
  5.5 → 6  (even)
→ 긴 합산에서 bias 0 (상·하 round 확률 동일)

4 Rounding error bound 공식

• 상대 오차 bound = 1/2 ULP (unit in last place) for RN
• ULP = 2^E−m · 현재 x의 last bit 단위

5 Stochastic Rounding (SR) ★ 랜덤 tie

• unbiased → 작은 gradient가 weight에 확률적으로 누적
• low-bit training (FP16 master 없이) 핵심 기법
• HW 지원: Hopper/Blackwell FP8 TC 옵션

6 RN vs SR 비교 작은 업데이트

7 GPU rounding 기본값

• CUDA FMA (fma.rn.f32): RN 기본
• type cast __float2half: RN 기본, __float2half_rn/_rz/_rd/_ru variant
• Tensor Core accumulator: 내부 RN
• PTX: cvt.{rn|rz|rm|rp|rni|rzi|rmi|rpi} suffix

PTX ISA · cvt instruction · ↗ V03 §5

1 FP 덧셈 non-associative ★

2 이유 정렬·shift 손실

• 큰 수 + 작은 수: 작은 수의 mantissa가 shift되어 일부 bit 유실
• 유실된 bit는 되돌아오지 않음
• subsequent 연산 순서가 어떤 bit를 살리는지 결정

큰 수: 1.00 × 2^20
작은 수: 1.00 × 2^0
정렬:  1.00 × 2^20
     + 0.00...01 × 2^20  (20 bit shift)
     ─────────────────
     → mantissa 비트수 넘으면 소실

3 Reduction tree 순서 결과 변동

serial (left-to-right):
  (((a₀ + a₁) + a₂) + a₃)
  → O(N) step, O(log N) 오차 누적 낮음 if ordered

tree (pairwise):
   a₀ a₁ a₂ a₃
    \ /    \ /
     s₁     s₂
       \   /
        S
  → O(log N) step, 오차 O(√log N)

warp-shuffle:
  stride 16, 8, 4, 2, 1
  → HW에 결정된 순서, 일관성 yes

Higham "Accuracy and Stability" Ch4 · pairwise가 일반적으로 더 정확

4 결정론 문제 ★

• atomicAdd: block 도착 순서는 run-by-run 다름 (warp scheduling)
• cuBLAS: 일부 split-K 내부 atomic 사용 → bit-varying
• 해결책: deterministic 옵션 (cuDNN/cuBLAS), split-K 대신 Stream-K (↗ V05 §8)
• 테스트 재현성·debugging에서 중요

5 Reduction 오차 경계

• serial O(N) → 큰 N에서 위험
• pairwise O(log N) → GPU tree reduce 자연스러움
• Kahan O(1) → 4× FLOP 비용 (↗ §8)

6 Mixed-dtype 누적 원칙

원칙: 누적 dtype ≥ 입력 dtype · 짧으면 catastrophic

1 Relative error 모델 ★ x·(1+δ)

• 한 연산당 상대 오차 최대 ε
• 연산 N개 연쇄: (1+δ)^N ≈ 1 + Nε (first-order)
• 일반적 bound: cond · N · ε (condition number 곱)

2 Condition number 입력 민감도

• well-conditioned: cond ~ 1
• ill-conditioned: cond ≫ 1 (이 경우 어떤 알고리즘도 정확 불가)
• 입력 오차 · cond = 출력 오차 하한

3 Forward vs backward error

stable 알고리즘 + ill-conditioned 문제 = 여전히 부정확

4 Catastrophic cancellation ★ 비슷한 값 뺄셈

5 Cancellation 회피 패턴

• libm에 전용 함수 제공 (log1p / expm1)
• GPU: __log1pf, __expm1f

6 Kahan summation ★ compensated

s = 0; c = 0   // s: sum, c: lost bit carry
for x in xs:
  y = x - c          // undo prev loss
  t = s + y          // add, may lose LSB
  c = (t - s) - y    // recover lost bit
  s = t
return s

• 4× FLOP · extra register 1개
• GPU 병렬 합산에서는 pairwise tree가 대개 충분
• long-sequence accumulator (e.g. FP8 training)에서 유용

7 Neumaier 개선

• Kahan의 변형 — |s| < |x|일 때 역할 교체
• 더 안정적, 비용 동일
• C++ std::reduce의 일부 impl 채용

1 Naive softmax 문제 ★

• FP16 exp 범위: x ∈ [−17, +11]
• FP32 exp 범위: x ∈ [−87, +88]
• Transformer logits는 수십~수백 도달 → overflow 불가피

2 Stable softmax ★ subtract max

3 3-pass → 2-pass → 1-pass

online softmax: (m, l) pair를 streaming update · FlashAttention 핵심 · ↗ V07 §2~§3

4 Log-sum-exp (LSE)

• cross-entropy: loss = −log p_y = LSE(x) − x_y
• softmax를 실제로 계산하지 않고도 loss 얻음 → 수치 안정
• PyTorch F.cross_entropy 내부 LSE 사용

5 Online softmax 결합 공식 증명

6 Low-precision softmax

• attention logits 저장: BF16 okay, FP16 위험 (범위)
• exp 내부 누적: FP32 필수
• P = softmax(S) 출력: FP16/BF16 okay (∈[0,1])
• FP8 attention: P를 [0, 1]로 clamp 후 E4M3 (FA3 incoherent, ↗ V07 §10)

1 동기 왜 mixed?

• TC throughput: FP16/BF16이 FP32 대비 8×+
• HBM 용량/BW: 16 bit가 32 bit 대비 2×
• 그러나 weight update · optimizer state는 정밀도 민감
• forward/backward는 low, master weight·update는 FP32

2 Master weight 개념 ★ FP32 master

master W (FP32) ──┐
                  ▼ cast
              W_fp16 ── forward ──► loss
                                    │
              ◄── backward ── grad_fp16
              │
              ▼ cast to FP32 + scale down
         Δ (FP32) ──► update master W

3 Micikevicius 2017 AMP 공식 ★

1. Master W: FP32
2. Forward: W → FP16, activation FP16
3. Loss: FP32 (또는 FP16 + scale)
4. Backward: gradient FP16
5. Unscale gradient → FP32
6. Optimizer step: FP32 master update

Micikevicius et al. "Mixed Precision Training" ICLR 2018

4 BF16 vs FP16 training

5 Optimizer state precision

• Adam m, v: FP32 권장 (second moment가 작은 값 축적)
• BF16 optimizer: 실험적 (일부 방식 수렴 저하)
• 8-bit optimizer (bitsandbytes): block-wise quant

6 Dtype 할당 template ★

7 AMP API 구성

• PyTorch: torch.amp.autocast + GradScaler
• JAX: bfloat16 dtype 직접 / jmp
• Megatron/NeMo: FP32 master + FP16/BF16 compute 수동 관리
• TE: FP8 mixed precision 전담 (↗ §12)

1 Gradient underflow 문제 ★

• 특히 초반 layer의 gradient는 깊이만큼 축소
• subnormal 허용해도 정밀도 낮음
• BF16은 range가 FP32와 같아 이 문제 없음

2 Loss scaling 원리 scale up · unscale down

• loss에 단일 상수 곱 = gradient 모두에 동일 배율
• optimizer step 직전 동일 배율로 나누면 원래 update

3 Static vs Dynamic

4 Dynamic loss scaling 알고리즘 ★

init: s = 2^15
for step:
  scaled_loss = loss * s
  scaled_loss.backward()
  # gradient = grad * s
  if any(isinf(g) or isnan(g)):   # overflow
    s = s / 2                      # shrink
    skip optimizer step
    reset counter
  else:
    unscale grad: g = g / s
    optimizer.step()
    counter += 1
    if counter >= N:              # stable window
      s = s * 2                   # try larger
      counter = 0

PyTorch GradScaler 기본 동작 · N=2000 step default

5 Inf/NaN 탐지

• NaN 전파: op(NaN, ·) = NaN · 한 번 발생하면 전체 tensor 감염
• torch.isinf(g).any() / torch.isnan(g).any()
• GPU: __isnanf, __isinff intrinsic
• batch-level 집계 (AllReduce bool)가 분산 훈련 필수

6 분산 환경 scaling sync

각 rank가 독립 scale 사용 시 weight divergence
→ scale은 global synchronize
→ overflow rank 있으면 모든 rank skip

protocol:
  1. each rank: check Inf/NaN local
  2. allreduce OR bool
  3. if any rank overflow: shrink s, skip
  4. else: proceed optimizer

7 Gradient clipping 관계

• clipping은 unscale 이후 수행
• clip 전 norm 계산도 FP32
• overflow detect → clip 무의미 (이미 Inf)

1 FP8 training 차이점 ★

• scale이 tensor마다 필요 (range 극단적으로 좁음)
• forward/backward/gradient 각각 다른 variant
• scale 결정이 수렴에 직접 영향
• master weight는 여전히 FP32 (optimizer precision 유지)

2 Transformer Engine 개요

• te.Linear, te.TransformerLayer drop-in
• 내부: amax history + delayed scaling 자동
• attention forward/backward FP8

3 Per-tensor amax history ★ window

history[N] (ring buffer):
  step t    : amax_t
  step t-1  : amax_{t-1}
  ...
  step t-N+1: amax_{t-N+1}

amax_used = max(history)
s = amax_used / FP8_max

4 Delayed scaling ★ 1-step 지연

step t:
  x_t 계산
  amax_t 계산 (현재 tensor)
  quant(x_t) with s_{t-1}   ← 직전 step scale
  push amax_t to history

step t+1:
  s_t = max(history) / FP8_max
  quant with s_t

cost: scale이 1 step lag · 수렴에는 무해 (history size N ≥ 16)

5 Dtype transition 규칙

6 Forward/Backward FP8 variant 배치

forward:
  W (E4M3) × X (E4M3) → Y (FP32 acc → BF16)

backward (grad output gY):
  dgrad: gY (E5M2) × W^T (E4M3) → gX
  wgrad: X^T (E4M3) × gY (E5M2) → gW

이유:
  W, X는 정규화된 좁은 분포 → E4M3
  gY는 outlier 가능 (loss gradient) → E5M2

7 Scale factor safety margin

• amax 그대로 사용: outlier에 정확히 맞춤 → 노이즈 1개에 0이 되는 risk
• safety margin: s = amax · m / FP8_max, m > 1
• TE default: m ≈ 1.0 (amax history가 smoothing 역할)

8 Block-scale FP8 training Blackwell

• Blackwell TC: MXFP8 block=32 native
• per-tensor amax 불필요 (block마다 local amax)
• outlier 자동 흡수 → TE 구조 단순화
• 구체 알고리즘·양자화 선택은 ↗ V10 §11

1 전체 포맷 bit layout 표 ★

IEEE 754 · OCP FP8/MX · NVFP4 whitepaper

2 Dtype × use-case 결정 표 ★

3 수치 안정성 체크리스트

1. softmax: subtract max 포함 여부
2. log: log1p / logsumexp 사용
3. sqrt·rsqrt ε 가드 (∇sqrt(0) = Inf)
4. NaN 감지 hook (dev mode)
5. accumulator dtype ≥ input dtype
6. reduction tree deterministic 여부

4 Training recipe 요약

5 흔한 함정 10선

1. FP16 accumulator 사용 → 수백 원소에서 붕괴
2. softmax subtract max 생략
3. BF16에 loss scaling 적용
4. Kahan의 compensated term이 -O3로 제거
5. RZ와 RD 혼동 (부호에서 차이)
6. gradient E4M3 사용 (range 부족)
7. weight E5M2 사용 (precision 부족)
8. 비결정 reduction 으로 bit-exact 테스트
9. subnormal FTZ on 상태에서 underflow 무시
10. scale을 매 step runtime 갱신 → 비결정