수학

MATH / 중급 70번

부동소수점은 어디서 새는가: 반올림, 상쇄, 더하는 순서

0.1 + 0.2가 0.3이 아닌 이유부터 시작해 머신 엡실론을 유도하고, 같은 16비트인데 fp16과 bf16이 서로 다른 지점에서 터지는 이유, 비슷한 수를 뺄 때 유효자리가 사라지는 파괴적 상쇄, 그리고 1,000만 개를 순서만 바꿔 더했을 때 오차가 백만 배 갈리는 실험까지 직접 재 봤습니다.

PALDYN Team44 MIN READ

같은 스크립트를 두 번 돌렸는데 학습 손실이 소수 넷째 자리에서 갈립니다. 시드도 같고 데이터도 같고 순서도 같은데 GPU 개수만 둘에서 넷으로 바꿨습니다. 「부동소수점 오차겠지」로 넘기고 나면, 몇 주 뒤 fp16으로 추론을 내리다가 어텐션 출력이 통째로 nan이 되는 것을 보고 다시 같은 자리로 돌아옵니다.

두 현상은 같은 뿌리에서 나옵니다. 컴퓨터가 담는 실수는 실수가 아니라 유한한 개수의 눈금이고, 그 눈금이 어디에 얼마 간격으로 서 있는지를 알면 두 가지 모두 예측 가능한 사건이 됩니다.

초급 47번 「자릿수와 오차」에서 유효숫자와 상대오차를 손계산으로 다뤘는데, 밑이 2인 진법을 세우지 않아 「0.1 + 0.2가 왜 0.3이 아닌가」와 머신 엡실론을 이 글로 넘겼습니다. 여기서 받습니다.

비트 배치와 머신 엡실론

눈금이 어떻게 놓이는지부터 봅니다. 출발점은 누구나 한 번은 밟는 0.1입니다.

0.1의 이진 표현

>>> f"{0.1:.20f}"
'0.10000000000000000555'
>>> f"{0.1 + 0.2:.20f}"
'0.30000000000000004441'
>>> f"{0.3:.20f}"
'0.29999999999999998890'

덧셈이 틀린 것이 아닙니다. 입력이 이미 0.1과 0.2가 아니었습니다.

이유는 진법입니다. 십진법에서 1/31/3 이 0.333…0.333\ldots 로 안 끝나듯, 이진법에서는 1/101/10 이 안 끝납니다. 분모가 밑의 소인수만으로 이뤄져야 유한 소수가 되는데, 10의 소인수는 2와 5이고 이진법의 밑은 2뿐이라 5를 처리할 방법이 없습니다. 그래서

0.1=0.00011001100110011‾…(2)0.1 = 0.0001100110011\overline{0011}\ldots_{(2)}

이고, 유한한 비트에 담으려면 어딘가에서 잘라야 합니다. 파이썬이 실제로 담고 있는 값은 정확히

360287970189639736028797018963968=0.1000000000000000055511151231257827…\frac{3602879701896397}{36028797018963968} = 0.1000000000000000055511151231257827\ldots

입니다. 0.2도 마찬가지로 조금 크고, 둘을 더한 값이 0.3에 가장 가까운 눈금보다 한 칸 위에 떨어집니다. 여기서 첫 번째 규칙이 나옵니다. 부동소수점 값은 == 로 비교하지 않습니다. 두 계산 경로가 수학적으로 같아도 눈금 하나만큼 갈릴 수 있습니다. 무엇으로 대신 비교하는지는 마지막 절에서 다룹니다.

머신 엡실론

IEEE 754는 실수 하나를 세 조각으로 담습니다.

x=(−1)s×1.f×2ex = (-1)^{s} \times 1.f \times 2^{e}

ss 는 부호 1비트, ee 는 지수, 1.f1.f 는 가수입니다. 맨 앞의 1은 항상 1이라 저장하지 않고, 소수점 아래 pp 비트만 담습니다. 이 pp 가 정밀도를 정합니다.

fp32 · bf16 · fp16의 비트 배치 비교

지수 비트는 범위를, 가수 비트는 정밀도를 정합니다. 지수 비트를 하나 늘리면 표현 가능한 범위가 제곱으로 넓어지고, 가수 비트를 하나 늘리면 눈금 간격이 절반이 됩니다.

가수가 pp 비트라는 말은 [1,2)[1, 2) 구간을 2p2^p 등분한다는 뜻입니다. 그 구간의 눈금 간격이 2−p2^{-p} 이고, 이 값을 머신 엡실론이라고 부릅니다 — 1과 그 바로 다음 눈금 사이의 거리입니다. fp32에서 확인하면 이렇습니다.

>>> np.float32(1.0) + np.float32(2.0 ** -23) == np.float32(1.0)
False
>>> np.float32(1.0) + np.float32(2.0 ** -24) == np.float32(1.0)
True

2−23≈1.19×10−72^{-23} \approx 1.19\times10^{-7} 이 fp32의 머신 엡실론입니다. 그 절반 이하를 1에 더하면 결과가 다시 1로 반올림돼 아무 일도 안 일어납니다.

지수가 1 오르면 같은 개수의 눈금이 두 배 넓은 구간을 나눠 맡으므로 간격도 두 배가 됩니다.

지수 구간마다 눈금 간격이 두 배가 되는 수직선

그래서 부동소수점의 절대오차는 값에 비례해 커지고, 일정한 것은 상대오차뿐입니다. 반올림은 가장 가까운 눈금으로 가므로 오차가 간격의 절반을 넘지 않고, 따라서

∣x^−x∣∣x∣≤ε2=2−(p+1)\frac{|\hat{x} - x|}{|x|} \le \frac{\varepsilon}{2} = 2^{-(p+1)}

입니다. x^\hat{x} 는 저장된 값, xx 는 참값입니다. 이 부등식이 이 글에 나오는 모든 사고의 출발점입니다.

형식 지수 비트 가수 비트 pp 머신 엡실론 2−p2^{-p} 상대오차 상한 표현 범위 유효 십진자리
fp64 11 52 2.22 × 10⁻¹⁶ 1.11 × 10⁻¹⁶ ±1.8 × 10³⁰⁸ 약 16
fp32 8 23 1.19 × 10⁻⁷ 5.96 × 10⁻⁸ ±3.4 × 10³⁸ 약 7
bf16 8 7 7.81 × 10⁻³ 3.91 × 10⁻³ ±3.4 × 10³⁸ 약 2
fp16 5 10 9.77 × 10⁻⁴ 4.88 × 10⁻⁴ ±6.6 × 10⁴ 약 3

ULP와 반올림

머신 엡실론은 1에서의 눈금 간격 하나입니다. 이것을 아무 값에서나 재도록 넓힌 것, 곧 지금 그 값이 서 있는 자리의 눈금 간격 하나를 ULP(unit in the last place)라고 부릅니다. 가수의 마지막 비트 하나가 나타내는 크기라는 뜻입니다. fp32에서 1의 ULP는 머신 엡실론과 같은 1.2×10−71.2\times10^{-7} 이고, 500만 근처에서는 0.5, 10810^8 근처에서는 8입니다. 이름을 세워 두면 오차를 값의 크기와 상관없이 「몇 ULP 틀렸다」로 말할 수 있습니다. 반올림 한 번의 오차는 0.5 ULP를 넘지 않고, 라이브러리 문서가 exp나 sin의 정확도를 「1 ULP 이내」로 적는 것도 이 단위입니다.

남은 질문은 참값이 두 눈금의 정확히 가운데에 떨어질 때입니다. 언제나 위로 올리면 가운데 경우마다 오차가 같은 방향으로 쌓입니다. 그래서 IEEE 754의 기본 규칙은 가운데면 가수의 마지막 비트가 0인 쪽, 곧 짝수 눈금으로 가는 것이고, 이것을 짝수 반올림(round half to even)이라고 합니다. 가운데 경우의 절반은 올라가고 절반은 내려가므로 오차가 한쪽으로 쏠리지 않습니다. 위에서 1+2−241 + 2^{-24} 가 1로 돌아온 것이 바로 이 규칙입니다 — 1+2−241 + 2^{-24} 는 1과 1+2−231 + 2^{-23} 의 정확히 가운데이고, 마지막 비트가 0인 쪽이 1입니다.

정확한 정수 범위

같은 간격 이야기를 정수에 적용하면 실무에서 자주 밟는 함정이 하나 나옵니다. fp32의 ULP는 223=8,388,6082^{23} = 8{,}388{,}608 부터 2242^{24} 사이에서 0.5에서 1로 넘어가고, 224=16,777,2162^{24} = 16{,}777{,}216 을 넘으면 2가 됩니다. 그 위에서는 홀수가 눈금에 없습니다.

>>> int(np.float32(16_777_216)), int(np.float32(16_777_217))
(16777216, 16777216)

16,777,217은 16,777,216과 16,777,218의 가운데라 짝수 반올림을 따라 아래로 갑니다. 그래서 fp32가 모든 정수를 빠짐없이 담는 것은 16,777,216까지입니다. bf16은 가수가 7비트라 같은 경계가 28=2562^8 = 256 에 옵니다 — 257을 넣으면 256이 나옵니다.

토큰 id, 스텝 카운터, 누적 샘플 수를 실수형 텐서에 담으면 이 경계를 넘는 순간 조용히 뭉개집니다. 어휘가 25만인 모델의 토큰 id를 bf16에 넣으면 대부분이 다른 id로 바뀌고, 오류는 하나도 안 납니다. 정수는 정수형에 둡니다.

fp16과 bf16

bf16과 fp16은 둘 다 16비트인데 나누는 방식이 정반대입니다. bf16은 fp32의 지수 8비트를 그대로 두고 가수만 잘랐고, fp16은 지수를 5비트로 줄이는 대신 가수를 10비트 남겼습니다. 그래서 서로 다른 지점에서 터집니다.

범위와 정밀도

값이 형식의 가장 큰 눈금을 넘어 inf가 되는 것을 오버플로, 0이 아닌 가장 작은 눈금보다 작아져 0이 되는 것을 언더플로라고 합니다. 두 형식에 같은 값을 넣어 보면 이렇습니다.

값 fp16 bf16
1 × 10⁻⁸ 0 (언더플로) 1.0012 × 10⁻⁸
1.00391 1.00391 1.0 (가수 부족)
30,000 30,000 29,952
70,000 inf (오버플로) 70,144
1 × 10¹⁰ inf 9.9992 × 10⁹

fp16은 범위에서 터집니다. 최대값이 65,504라 그 위는 전부 inf입니다. 어텐션이 실제로 이 벽을 만납니다 — softmax를 계산하면서 eze^{z} 를 구하는데, z=12z = 12 만 돼도 e12≈162,755e^{12} \approx 162{,}755 로 fp16의 상한을 넘습니다. bf16에서는 162,816으로 무사합니다. 로짓 자체도 시퀀스가 길어지고 스케일이 커지면 −155,219-155{,}219 같은 값이 나오는데, fp16에서는 이 값이 이미 -inf입니다.

bf16은 정밀도에서 터집니다. 가수가 7비트뿐이라 1+2−81 + 2^{-8} 은 그냥 1이 됩니다. 유효 십진자리가 두 자리 남짓이라, 큰 누적합에 작은 갱신을 더하는 일이 통째로 무시됩니다. 학습률 10−410^{-4} 로 크기 1짜리 가중치를 갱신하면 bf16에서는 아무 일도 안 일어납니다.

그래서 실무의 정답은 「무엇을 쓰나」가 아니라 「무엇을 어디에 두나」입니다. 행렬 곱은 bf16으로 하고(범위가 넓어 오버플로 걱정이 없음) 누산과 가중치 갱신은 fp32로 하는 것이 혼합정밀도의 기본형입니다. 어디에 무엇을 두는지는 다음 글 「수치적으로 안정한 계산 패턴 모음」이 목록으로 맡습니다.

비정규수

위 표에서 fp16이 10−810^{-8} 을 0으로 만든 자리를 더 들여다봅니다. 맨 앞에 1이 있는 보통의 수, 곧 지금까지 다룬 1.f×2e1.f \times 2^{e} 꼴을 정규수라고 합니다. fp16의 지수는 −14-14 아래로 못 내려가므로 가장 작은 정규수는 2−14≈6.10×10−52^{-14} \approx 6.10\times10^{-5} 입니다. 여기서 바로 0으로 떨어지면 0과 그 사이에 큰 구멍이 생깁니다.

그 구멍을 메우는 것이 비정규수입니다. 지수를 가장 작은 값에 묶어 둔 채 맨 앞의 1을 0으로 바꿔서, 0.f×2−140.f \times 2^{-14} 꼴로 눈금을 0까지 같은 간격으로 이어 깝니다. fp16에서 그 간격이자 가장 작은 비정규수가 2−24≈5.96×10−82^{-24} \approx 5.96\times10^{-8} 입니다. 10−810^{-8} 은 이 간격의 절반보다 작아 0이 됐고, 10−510^{-5} 는 비정규수로 살아남습니다.

fp16의 0 근처 눈금: 비정규수 구간과 정규수 구간

대가가 있습니다. 비정규수는 맨 앞의 1을 잃었으므로 값이 작아질수록 쓸 수 있는 가수 비트가 줄어 상대오차가 커집니다. 그리고 많은 하드웨어에서 비정규수 연산이 느려서, 비정규수를 통째로 0으로 미는 설정이 따로 있습니다. 결과를 0으로 미는 것을 flush-to-zero라고 하고, CUDA 컴파일 옵션이나 CPU 플래그로 켭니다. 켜 두면 fp16에서는 6.10×10−56.10\times10^{-5} 아래가 전부 0이 되어 언더플로 경계가 천 배 위로 올라옵니다.

손실 스케일링

fp16 학습에서 이 경계를 가장 먼저 밟는 것은 기울기입니다. 역전파의 기울기는 10−810^{-8} 근처까지 작아지기 일쑤인데, fp16에서는 그 값이 0이 되어 해당 가중치가 갱신을 못 받습니다.

해법은 범위를 옮기는 것입니다. 역전파 전에 손실에 큰 수 SS 를 곱하면 연쇄법칙을 따라 모든 기울기가 SS 배가 되어 표현 가능한 구간으로 올라오고, 갱신 직전에 fp32에서 SS 로 되나눕니다. 이것이 손실 스케일링입니다. S=216S = 2^{16} 이면 10−810^{-8} 이 6.55×10−46.55\times10^{-4} 가 되어 정규수 구간에 들어가고, 되나누면 1.0×10−81.0\times10^{-8} 이 돌아옵니다. 2의 거듭제곱을 쓰는 것은 곱하고 나누는 일이 지수만 바꾸고 가수를 안 건드려 오차를 하나도 더하지 않기 때문입니다.

손실 스케일링의 한 스텝

SS 가 너무 크면 이번에는 큰 기울기가 65,504를 넘습니다. 그래서 실제 구현은 기울기에 inf나 nan이 섞였는지 검사해, 섞였으면 그 스텝을 건너뛰고 SS 를 절반으로 줄이고, 한동안 무사하면 다시 키웁니다. bf16 학습에는 이 장치가 필요 없습니다. 지수가 fp32와 같은 8비트라 10−810^{-8} 이 처음부터 담기기 때문입니다.

FP8

8비트까지 내려가면 같은 가르기가 한 단계 더 되풀이됩니다. 널리 쓰는 두 형식이 지수 4비트·가수 3비트인 E4M3과 지수 5비트·가수 2비트인 E5M2입니다.

형식 머신 엡실론 최대값
E4M3 0.125 448
E5M2 0.25 57,344

E4M3은 정밀도를 조금 더 남기고 범위를 448에서 끊었고, E5M2는 fp16과 같은 지수 폭으로 범위를 지키고 정밀도를 더 버렸습니다. 그래서 흔히 순전파의 가중치와 활성값에는 E4M3을, 크기가 들쭉날쭉한 기울기에는 E5M2를 씁니다. 범위가 이렇게 좁으면 전역 SS 하나로는 모자라서, 텐서마다 따로 스케일 값을 들고 다니며 담기 전에 곱하고 꺼낸 뒤에 나눕니다. 손실 스케일링을 텐서 단위로 잘게 쪼갠 것입니다. E4M3에는 inf가 없어 범위를 넘으면 nan이 된다는 점도 스케일을 꼼꼼히 관리하는 이유입니다.

파괴적 상쇄

반올림 오차는 상대오차로 보면 10−710^{-7} 수준이라 대개 무시할 만합니다. 그런데 그 오차가 결과의 맨 앞자리로 올라오는 연산이 하나 있습니다.

유효자리의 소실

비슷한 크기의 두 수를 뺄 때입니다.

비슷한 두 수를 뺄 때 유효자리가 사라지는 그림

aa 와 bb 는 각각 일곱 자리를 믿을 수 있었습니다. 그런데 앞의 여섯 자리가 서로 같아서 빼는 순간 0으로 사라지고, 남는 것은 마지막 한 자리뿐입니다. 원래 그 자리 아래에 있던 반올림 오차가 이제 결과의 두 번째 자리가 됩니다. 이것을 파괴적 상쇄(catastrophic cancellation)라고 합니다.

>>> a, b = np.float32(1.2345678), np.float32(1.2345670)
>>> float(a - b)
7.152557373046875e-07        # 참값은 8.0e-07

상대오차가 11%입니다. 뺄셈 자체는 완벽하게 정확했습니다 — 두 저장값의 차이를 정확히 계산했습니다. 새어 나간 것은 입력이 이미 갖고 있던 오차이고, 상쇄가 그것을 확대했을 뿐입니다. ULP로 말하면 aa 와 bb 는 각각 0.5 ULP 이내로 정확했는데, 차이가 겨우 여섯 ULP 남짓이라 그 0.5가 결과에서는 열 퍼센트가 됩니다.

이차방정식의 근

교과서적인 예가 이차방정식의 근입니다. ax2+bx+c=0ax^2+bx+c=0 의 근을

x=−b±b2−4ac2ax = \frac{-b \pm \sqrt{b^2-4ac}}{2a}

로 구하는데, b2≫4acb^2 \gg 4ac 이면 b2−4ac≈∣b∣\sqrt{b^2-4ac} \approx |b| 라서 두 근 중 하나에서 −b-b 와 ⋅\sqrt{\cdot} 가 거의 같은 크기로 서로 뺍니다. a=1a=1, b=108b=10^8, c=1c=1 로 fp64에서 계산하면

작은 근 큰 근
공식 그대로 −7.4506 × 10⁻⁹ −1.0 × 10⁸
참값 −1.0 × 10⁻⁸ −1.0 × 10⁸

작은 근이 25%나 틀렸습니다. fp64인데도 그렇습니다.

고치는 방법은 상쇄가 일어나는 뺄셈을 아예 없애는 것입니다. 근과 계수의 관계 x1x2=c/ax_1x_2 = c/a 를 쓰면 됩니다.

def roots_stable(a, b, c):
    d = math.sqrt(b * b - 4 * a * c)
    q = -0.5 * (b + math.copysign(d, b))   # 부호를 맞춰 '더하기'로 만든다
    return q / a, c / q                    # 작은 근은 나눗셈으로 얻는다

copysign으로 bb 와 같은 부호를 붙였기 때문에 b+sign⁡(b)⋅b + \operatorname{sign}(b)\sqrt{\cdot} 는 같은 부호끼리의 덧셈이라 상쇄가 없습니다. 그렇게 안전하게 구한 큰 근에서 작은 근을 나눗셈으로 끌어냅니다. 이 방법으로 계산하면 작은 근이 정확히 −1.0×10−8-1.0\times10^{-8} 입니다.

여기서 나오는 규칙입니다. 상쇄를 만나면 정밀도를 올리지 말고 식을 바꿉니다. fp32를 fp64로 바꾸는 것은 자릿수를 몇 개 더 벌어 줄 뿐 구조를 안 고칩니다. 위 예가 fp64에서도 25% 틀린 것이 그 증거입니다.

곱셈과 나눗셈

그렇다면 곱셈과 나눗셈은 왜 이 문제를 안 일으킬까요. 두 입력이 각각 상대오차 δ1\delta_1, δ2\delta_2 를 안고 있으면 곱은

x(1+δ1)⋅y(1+δ2)=xy (1+δ1+δ2+δ1δ2)x(1+\delta_1)\cdot y(1+\delta_2) = xy\,(1 + \delta_1 + \delta_2 + \delta_1\delta_2)

이라 상대오차가 대략 δ1+δ2\delta_1 + \delta_2 로 더해질 뿐입니다. 나눗셈도 δ1−δ2\delta_1 - \delta_2 로 같은 크기입니다. 결과의 크기가 아무리 작거나 커도 상대오차는 입력의 몇 배 수준에 머뭅니다. 뺄셈만 다른 것은 결과의 크기 ∣x−y∣|x - y| 가 입력의 크기보다 훨씬 작아질 수 있어서, 같은 절대오차가 상대오차로는 ∣x∣/∣x−y∣|x|/|x-y| 배로 부풀기 때문입니다. 자릿수를 통째로 날리는 산술은 부호가 다른 덧셈을 포함해 뺄셈 하나뿐입니다. 그래서 수치 오류를 추적할 때는 곱셈 사슬보다 뺄셈이 끼는 자리를 먼저 봅니다.

합산 순서

실수 덧셈에는 결합법칙이 있습니다. (a+b)+c=a+(b+c)(a+b)+c = a+(b+c) 입니다. 부동소수점 덧셈에는 없습니다. 각 단계마다 눈금으로 반올림이 들어가는데 그 눈금이 중간합의 크기에 따라 달라지기 때문입니다.

흡수

가장 뚜렷한 예입니다. fp32에서 10810^8 에 1을 백만 번 더해 봅니다.

f32 = np.float32
big, n = f32(1e8), 1_000_000

s = big
for _ in range(n):
    s = f32(s + f32(1.0))
print(float(s))            # 100000000.0  — 아무것도 안 더해졌다

s = f32(0.0)
for _ in range(n):
    s = f32(s + f32(1.0))
print(float(s + big))      # 101000000.0  — 참값

이유는 눈금 간격입니다. fp32에서 10810^8 의 ULP는 8입니다. 거기에 1을 더하면 가장 가까운 눈금은 여전히 자기 자신이라 반올림이 원래 값을 돌려줍니다. 백만 번을 반복해도 마찬가지입니다. 반면 작은 것부터 더하면 중간합이 10610^6 근처에 있는 동안 간격이 0.0625라 1이 제대로 쌓입니다. 이렇게 더할 값이 중간합의 눈금 간격보다 작아 통째로 버려지는 것을 흡수(absorption)라고 합니다.

정렬의 역효과

무작위 데이터에서는 어떨까요. [0,1)[0,1) 균등 난수 1,000만 개를 여섯 가지 방법으로 fp32에서 더하고 fp64 참값과 비교했습니다.

여섯 가지 합산 방법의 상대오차 막대그래프

방법 결과 상대오차
작은 것부터 (오름차순 정렬) 5,057,480.5 1.15 × 10⁻²
뒤에서부터 5,000,322.0 1.08 × 10⁻⁴
앞에서부터 4,999,722.5 1.14 × 10⁻⁵
numpy 기본 (쌍대 합산) 4,999,779.5 2.41 × 10⁻⁸
카한 합산 4,999,779.5 2.41 × 10⁻⁸
fp32 입력 → fp64 누산 4,999,779.62 2.24 × 10⁻¹⁵

참값은 4,999,779.6205입니다. 같은 수 1,000만 개를 순서만 바꿔 더했는데 오차가 백만 배 갈립니다.

「작은 것부터 더하면 낫다」는 통념이 여기서는 가장 나빴습니다. 시드를 세 번 바꿔도 1.151.16%로 재현됐고, 방향도 항상 과대평가였습니다. 원인은 정렬이 반올림을 한쪽으로 몰았기 때문입니다. 마지막 백만 개는 값이 0.91.0 사이인데 그때 중간합은 500만 근처라 ULP가 0.5입니다. 0.91.0을 0.5 눈금에 맞추면 나머지가 항상 0.40.5 구간에 떨어지고, 그 구간은 언제나 위쪽 눈금이 더 가깝습니다. 반올림이 매번 같은 방향으로 일어나 오차가 상쇄되지 않고 쌓입니다.

이것은 오차가 쌓이는 속도의 두 얼굴입니다. 항이 nn 개이면 반올림도 nn 번 일어나고, 매번 같은 방향이면 상대오차가 최악으로 n⋅ε/2n \cdot \varepsilon/2 에 비례해 자랍니다. 반올림이 위아래로 고르게 흩어지면 서로 상당 부분 지워져서, 동전 던지기의 누적처럼 n⋅ε/2\sqrt{n} \cdot \varepsilon/2 쯤에 머뭅니다. fp32로 n=107n = 10^7 이면 앞쪽이 0.6, 뒤쪽이 1.9×10−41.9\times10^{-4} 이고, 정렬하지 않은 두 줄이 뒤쪽 근처에 섰습니다. 반올림이 오차를 지우는 것은 남는 자리가 고르게 흩어질 때뿐이고, 정렬은 그 고름을 깨서 최악 쪽으로 미는 조작입니다.

쌍대 합산과 카한 합산

numpy의 기본 합산이 소박한 반복문보다 천 배 정확합니다. np.sum은 배열을 반으로 쪼개 각각 더한 뒤 합치는 쌍대 합산(pairwise summation)을 씁니다. 중간합이 언제나 원소 개수에 비례하는 크기에 머물러 흡수가 덜 일어나고, 오차가 O(n)O(n) 이 아니라 O(log⁡n)O(\log n) 으로 쌓입니다. 손으로 for 루프를 써서 더하는 것이 라이브러리보다 나쁜 이유가 이것입니다.

카한 합산은 버려진 부분을 다음 항에 되돌립니다.

def kahan(a):
    s = f32(0.0)
    c = f32(0.0)                    # 지난번에 흡수돼 사라진 몫
    for v in a:
        y = f32(v - c)              # 잃었던 만큼 미리 보태 둔다
        t = f32(s + y)              # 여기서 다시 일부가 흡수된다
        c = f32(f32(t - s) - y)     # 실제로 들어간 양과의 차이가 이번에 잃은 몫
        s = t
    return float(s)

핵심은 세 번째 줄입니다. t - s는 「이번에 실제로 반영된 양」이고, 거기서 y(넣으려던 양)를 빼면 흡수돼 사라진 몫이 나옵니다. 그것을 c에 담아 두었다가 다음 항에서 되돌립니다. 이 트릭 덕분에 오차가 nn 과 무관한 상수로 묶이지만, 덧셈이 네 번으로 늘고 순차적이라 벡터화가 안 됩니다.

그리고 가장 싼 방법은 표의 맨 아래 줄입니다. 입력은 fp32로 두고 누산기만 fp64로 두면 오차가 10−1510^{-15} 로 떨어집니다. np.sum(x, dtype=np.float64) 한 줄이고, GPU의 텐서 코어가 bf16 입력을 fp32 누산기로 처리하는 것도 정확히 이 발상입니다. 정밀도는 저장하는 곳이 아니라 쌓이는 곳에 필요합니다.

노름 계산

합산의 고장은 벡터의 길이를 잴 때도 그대로 나옵니다. 성분 제곱의 합에 제곱근을 씌운 값, 곧 벡터의 유클리드 길이를 노름이라고 하고, 그래디언트 클리핑과 정규화 층이 매 스텝 이것을 계산합니다. 문제는 중간의 제곱입니다. fp16에서 65,504≈255.9\sqrt{65{,}504} \approx 255.9 이므로 성분 하나가 256만 돼도 그 제곱이 inf가 되고, 최종 노름은 그보다 훨씬 작은 값이어야 하는데도 결과가 inf입니다. 반대로 성분이 10−410^{-4} 정도면 제곱이 10−810^{-8} 로 언더플로해 노름이 0으로 나옵니다.

그래서 표준 구현은 가장 큰 성분의 절댓값 mm 으로 먼저 나눕니다.

∥x∥=m∑i(xim)2\|x\| = m \sqrt{\sum_i \left(\frac{x_i}{m}\right)^2}

나눈 뒤의 성분은 전부 1 이하라 제곱이 넘치지 않고, 가장 큰 항이 1이라 합 전체가 언더플로하지도 않습니다. 수학적으로는 같은 식을 범위가 안전한 자리로 옮겨 계산한 것이고, 손실 스케일링과 같은 발상입니다.

두 고장의 진단

서두의 두 현상으로 돌아갑니다. 앞에서 세운 낱말로 하나씩 짚을 수 있습니다.

손실의 갈림

손실이 소수 넷째 자리에서 갈린 것은 GPU 개수가 부분합의 묶음을 바꿨기 때문입니다. GPU 두 대는 배치를 둘로 쪼개 각각 더한 뒤 합치고, 네 대는 넷으로 쪼갭니다. 수학적으로는 같은 합이지만 부동소수점에서는 결합법칙이 없으므로 다른 값이 나옵니다. 위 표에서 같은 데이터가 묶는 방법에 따라 4,999,722부터 5,057,480까지 갈렸던 것과 같은 일입니다. 이것은 버그가 아니고, 없앨 수도 없습니다. 재현성이 꼭 필요하면 누산 순서를 고정하는 결정론적 커널을 켜야 하고 그만큼 느려집니다.

허용치 비교

그렇다면 두 실행의 손실이 「같다」는 것은 무엇으로 판정할까요. ==를 쓰면 위 이유로 늘 다르다고 나옵니다. 대신 차이가 기준의 몇 배 이내인지를 봅니다. 차이를 값의 크기에 견주는 기준이 상대 허용치이고, 크기와 무관하게 고정된 기준이 절대 허용치입니다. numpy의 isclose는 둘을 더해

∣a−b∣≤atol+rtol⋅∣b∣|a - b| \le \text{atol} + \text{rtol} \cdot |b|

로 판정합니다. 상대 허용치만으로는 0 근처에서 판정이 안 됩니다. b=0b = 0 이면 오른쪽이 0이 되어 아무리 작은 차이도 실패로 나오기 때문입니다. 파이썬 표준 math.isclose는 절대 허용치의 기본값이 0이라 math.isclose(1e-10, 0)이 False입니다. 기울기나 잔차처럼 0으로 가야 하는 값을 비교할 때는 절대 허용치를 직접 정해 넣습니다. 상대 허용치는 형식의 머신 엡실론보다 넉넉하게 잡습니다 — fp32끼리 견주면서 10−910^{-9} 을 요구하면 같은 계산도 통과를 못 합니다.

nan 추적

fp16 어텐션이 nan이 된 것은 범위 문제입니다. 지수 5비트짜리 형식의 상한 65,504를 eze^{z} 가 넘었습니다. 이쪽은 고칠 수 있고 고치는 방법이 이미 표준입니다 — softmax를 계산하기 전에 최댓값을 빼면 지수가 절대 양수가 되지 않아 오버플로가 원천적으로 사라집니다.

다만 nan은 생긴 자리에서 끝나지 않습니다. nan이 섞인 연산의 결과는 다시 nan이라 한 원소에서 시작해 몇 층 뒤 출력 전체를 덮으므로, 마지막에 보이는 자리는 원인이 아닙니다. 짚는 순서가 있습니다. 먼저 층마다 출력에 nan이 처음 나타나는 자리를 찾습니다. nan은 자기 자신과도 같지 않아서 x != x가 참인 원소가 정확히 nan이고, torch.isnan이 이 성질을 씁니다. 자리를 찾으면 그 연산의 입력에서 nan을 만드는 두 조합을 봅니다. 하나는 inf - inf입니다. 마스크로 한 행을 통째로 −∞-\infty 로 채운 어텐션에서 최댓값을 빼면 −∞−(−∞)-\infty - (-\infty) 가 됩니다. 다른 하나는 0 * inf, 그리고 같은 뿌리의 inf / inf입니다. 오버플로한 지수를 오버플로한 합으로 나누는 softmax가 이 자리입니다. 두 조합 모두 바로 앞 단계에 이미 inf가 있었다는 뜻이므로, 결국 범위를 넘은 첫 연산을 찾는 일이 됩니다.

정리하면 이 글의 세 고장은 성격이 다릅니다. 반올림은 피할 수 없고 상대오차 상한으로 관리합니다. 상쇄는 식을 바꿔 피합니다. 흡수와 순서 의존은 누산기를 어디에 두느냐로 관리합니다. 셋을 구별하는 것이 「정밀도를 올려 보자」와 「구조를 고치자」를 가르는 일입니다.

연습 문제

답은 문항을 눌러 펼칩니다. 계산이 필요한 문항은 numpy로 직접 확인해 봐도 좋습니다.

눈금 간격

  1. fp32에서 이웃한 두 눈금 사이가 처음으로 1이 되는 값은 얼마인가요?
    가수가 23비트이므로 [2k,2k+1)[2^k, 2^{k+1}) 구간의 간격은 2k−232^{k-23} 입니다. 이것이 1이 되는 것은 k=23k = 23 일 때라 223=8,388,6082^{23} = 8{,}388{,}608 부터입니다. 그 바로 아래 구간의 간격은 0.5입니다.
  2. fp32에서 1,024의 ULP를 구하세요.
    1,024=2101{,}024 = 2^{10} 이므로 ULP는 210×2−23=2−13≈1.22×10−42^{10} \times 2^{-23} = 2^{-13} \approx 1.22\times10^{-4} 입니다. np.spacing(np.float32(1024))가 같은 값을 냅니다.
  3. fp32에서 1+x1 + x 가 1로 돌아오는 양수 xx 의 가장 큰 값은 얼마이고, 그 경계값에서 결과를 정하는 규칙은 무엇인가요?
    2−24≈5.96×10−82^{-24} \approx 5.96\times10^{-8} 입니다. 1+2−241 + 2^{-24} 는 1과 1+2−231 + 2^{-23} 의 정확히 가운데라 짝수 반올림이 마지막 비트가 0인 1로 보냅니다. 이보다 조금이라도 크면 위쪽 눈금이 더 가까워 1+2−231 + 2^{-23} 이 됩니다.
  4. fp32에 정수 16,777,219를 담으면 어떤 값이 되나요?
    16,777,220입니다. 2242^{24} 위에서는 간격이 2라 16,777,219는 16,777,218과 16,777,220의 가운데이고, 짝수 반올림은 가수의 마지막 비트가 0인 쪽을 고릅니다. 16,777,218=224+2⋅116{,}777{,}218 = 2^{24} + 2\cdot1, 16,777,220=224+2⋅216{,}777{,}220 = 2^{24} + 2\cdot2 이므로 마지막 비트가 0인 것은 뒤쪽입니다.

범위와 순서

  1. fp16에서 eze^{z} 가 오버플로하기 시작하는 zz 의 경계를 소수 둘째 자리까지 구하세요. 로짓이 (5, 9, 12)(5,\ 9,\ 12) 일 때 최댓값 빼기를 하면 지수 함수에 들어가는 값은 무엇이 되나요?
    상한이 65,504이므로 z>ln⁡65,504≈11.09z > \ln 65{,}504 \approx 11.09 면 넘칩니다. 그래서 세 로짓 중 12가 그대로는 inf입니다. 최댓값 12를 빼면 지수 함수에 (−7, −3, 0)(-7,\ -3,\ 0) 이 들어가 e−7≈9.1×10−4e^{-7} \approx 9.1\times10^{-4}, e−3≈0.050e^{-3} \approx 0.050, e0=1e^{0} = 1 로 전부 1 이하가 되고, softmax 값은 분자와 분모에서 같은 e12e^{12} 가 약분돼 그대로입니다.
  2. fp16에서 2,048 하나와 1 백 개를 두 순서로 더하세요 — 2,048에서 시작해 1을 하나씩 더하는 순서와, 1 백 개를 먼저 더한 뒤 2,048을 더하는 순서입니다. 어느 쪽이 맞는지 fp64 결과로 판정하세요.
    2,048 근처에서 fp16의 간격은 2라 2,048+12{,}048 + 1 은 가운데이고 짝수 반올림으로 2,048에 돌아옵니다. 그래서 앞 순서는 백 번을 더해도 2,048입니다. 뒤 순서는 중간합이 100까지 정확히 쌓인 뒤 2,148이 되고, 2,148은 짝수라 fp16 눈금 위에 있습니다. fp64로 더하면 2,148이므로 뒤 순서가 맞고, 앞 순서는 흡수입니다.

정리

  • 0.1은 이진법에서 유한 소수가 아니다. 분모 10의 소인수에 5가 있어서다. 0.1 + 0.2 != 0.3은 덧셈이 아니라 입력이 이미 틀려서 생긴다. 부동소수점을 ==로 비교하지 않는다.
  • 실수는 (−1)s×1.f×2e(-1)^s \times 1.f \times 2^e 로 저장된다. 지수 비트가 범위를, 가수 비트가 정밀도를 정한다.
  • 가수 pp 비트는 [1,2)[1,2) 를 2p2^p 등분한다. 그 간격이 머신 엡실론 2−p2^{-p} 이고, 반올림 상대오차는 그 절반을 넘지 않는다. fp32는 2−23≈1.19×10−72^{-23} \approx 1.19\times10^{-7} 이다.
  • 지수가 1 오르면 눈금 간격이 두 배가 된다. 그 자리의 간격 하나가 ULP이고, 절대오차는 값에 비례해 커지며 상대오차만 일정하다. fp32에서 1의 ULP는 1.2×10−71.2\times10^{-7} 인데 10810^8 의 ULP는 8이다.
  • 정확히 가운데면 가수의 마지막 비트가 0인 쪽으로 간다(짝수 반올림). 그래서 fp32는 16,777,216까지, bf16은 256까지만 모든 정수를 담는다. 토큰 id와 카운터는 정수형에 둔다.
  • bf16은 fp32의 지수를 그대로 두고 가수를 잘랐고, fp16은 반대다. fp16은 65,504에서 오버플로로 터지고(e12e^{12} 가 이미 넘는다), bf16은 1+2−81+2^{-8} 이 그냥 1이 되는 정밀도로 터진다.
  • fp16의 가장 작은 정규수는 6.10×10−56.10\times10^{-5} 이고, 그 아래 5.96×10−85.96\times10^{-8} 까지 비정규수가 버틴다. flush-to-zero를 켜면 그 구간이 통째로 0이 된다.
  • fp16 학습은 손실에 2162^{16} 같은 수를 곱해 기울기를 표현 가능한 구간으로 올리고 갱신 직전에 되나눈다. 지수가 넓은 bf16에는 필요 없다. FP8은 E4M3(최대 448)과 E5M2(최대 57,344)로 같은 가르기를 한 번 더 하고, 텐서마다 스케일을 둔다.
  • 파괴적 상쇄는 비슷한 두 수를 뺄 때 겹치던 앞자리가 사라지고 반올림 오차가 맨 앞자리로 올라오는 것이다. 곱셈과 나눗셈은 상대오차를 더할 뿐이라 상쇄를 만들지 않는다.
  • 상쇄를 만나면 정밀도를 올리지 말고 식을 바꾼다. 이차방정식 근의 공식은 fp64에서도 작은 근이 25% 틀렸고, copysign으로 덧셈으로 바꾸면 정확해진다.
  • 부동소수점 덧셈에는 결합법칙이 없다. fp32에서 10810^8 에 1을 백만 번 더하면 ULP가 8이라 하나도 안 쌓인다(흡수).
  • 1,000만 개를 순서만 바꿔 더하니 오차가 1.15×10−21.15\times10^{-2} 부터 2.24×10−152.24\times10^{-15} 까지 갈렸다. 오름차순 정렬이 가장 나빴다 — 반올림이 같은 방향으로 몰리면 오차가 n\sqrt{n} 이 아니라 nn 쪽으로 자란다.
  • np.sum의 쌍대 합산은 소박한 반복문보다 천 배 정확하고, 카한 합산은 흡수된 몫을 다음 항에 되돌린다. 가장 싼 방법은 누산기만 fp64로 두는 것이다. 노름은 가장 큰 성분으로 나눈 뒤 재야 fp16에서 넘치지 않는다.
  • GPU 개수를 바꾸면 손실이 달라지는 것은 부분합의 묶음이 달라져서다. 버그가 아니고 없앨 수도 없으며, 비교는 상대 허용치와 절대 허용치를 함께 둔 isclose로 한다.
  • nan은 x != x로 처음 나타난 자리를 찾고, 그 입력에서 inf - inf와 0 * inf를 본다. 둘 다 바로 앞에서 범위를 넘은 연산이 있었다는 뜻이다.

읽어주셔서 감사합니다. 😊

LATEST

수학의 최신 글

수학2026.11.17

다양체 위의 최적화: 직교 제약과 Muon의 직교화가 하는 일

차트·접공간·리만 계량·측지선·후퇴로 다양체를 세우고, 스티펠·그라스만·양정치 행렬·확률 단체의 접공간과 사영을 계산한 뒤, 리만 그래디언트가 유클리드 그래디언트의 접공간 사영임을 증명하고 극분해 후퇴와 뉴턴–슐츠 반복의 수렴 조건을 다룹니다.

고급46 MIN
수학2026.11.17

프리컨디셔닝의 이론: Adam에서 K-FAC·Shampoo·Muon까지 한 줄로

갱신 −ηP⁻¹∇를 노름의 최급강하로 읽고 헤세·가우스–뉴턴·피셔·경험적 피셔의 관계를 정리한 뒤, 준뉴턴과 3차 정규화, K-FAC의 크로네커 인수분해와 그 독립 가정, Shampoo의 −1/4 지수, Muon의 스펙트럴 노름 유도를 차례로 세워 이들이 어디서 일치하는지 보입니다.

고급41 MIN
수학2026.11.17

확률적 근사와 SGD의 연속 극한: 수렴한다는 말의 정확한 뜻

로빈스–먼로 조건과 마팅게일 잡음으로 SGD의 수렴을 정확히 정의하고, 볼록·강볼록·PL·비볼록에서의 수렴률과 오라클 하한을 계산한 뒤, SGD를 확률미분방정식으로 읽어 학습률/배치가 온도가 되는 관점과 안정성의 가장자리를 다룹니다.

고급48 MIN