☕ 들어가며 : "분명히 똑같이 돌렸는데요?"

자, 커피 한 잔 들고 편하게 앉아봐. 오늘 우리가 풀 미스터리는 이거야.

"동일한 데이터셋, 동일한 코드, 동일한 하이퍼파라미터로 학습시켰는데 왜 매번 다른 모델이 나올까?"

이거 진짜 흔한 일이야. 논문 재현하려고 GitHub 코드 그대로 클론해서 돌렸는데, 논문에 적힌 94.3%가 안 나오고 92.1%가 나와. 그래서 "아 내가 뭘 잘못했나?" 하고 밤새 코드를 뜯어봐. 근데 사실은... 너는 아무것도 잘못하지 않았을 수도 있어.

딥러닝 학습은 본질적으로 확률적(stochastic) 프로세스야. 그리고 그 위에 하드웨어와 병렬 연산의 물리적 제약이 얹혀 있지. 이 둘이 합쳐지면, "동일한 입력 → 동일한 출력"이라는 우리가 컴퓨터에 대해 갖고 있던 상식이 슬쩍 무너져.

이 글에서는 정보지능공학 관점에서 이 현상을 하나하나 해부해볼 거야. 수식은 최소한으로, 대신 "아 그래서 그런 거였구나!" 하는 순간을 최대한 많이 만들어볼게.

🗺️ 전체 지도 먼저 보기

복잡한 얘기 하기 전에 큰 그림부터. 모델 하나가 만들어지기까지 무작위성이 끼어드는 지점이 이렇게 많아.

봤지? 무려 7개의 문. 이 중에 하나만 삐끗해도 결과는 달라져. 이제 하나씩 열어보자.

🎰 1장. 일부러 넣은 랜덤 — "확률적"이라는 이름의 설계

1-1. 가중치 초기화 : 출발점이 다르면 도착점도 다르다

신경망을 만들면 제일 먼저 하는 게 가중치를 채우는 거야. 그런데 전부 0으로 채우면? 망해. 같은 층의 모든 뉴런이 완전히 동일한 그래디언트를 받아서 영원히 똑같은 값을 유지하거든. 이걸 대칭성 문제(symmetry breaking failure)라고 해.

그래서 우리는 일부러 난수로 초기화해. Xavier(Glorot) 초기화, He 초기화 같은 게 다 그거야. 분산을 적절히 맞춘 난수를 뿌려서 각 뉴런이 서로 다른 특징을 학습하게 만드는 거지.

여기서 중요한 건, 초기화는 손실 지형(loss landscape)에서의 출발 지점을 정한다는 거야. 깊은 신경망의 손실 지형은 말도 안 되게 울퉁불퉁한 고차원 공간이거든. 파라미터가 1억 개면 1억 차원 공간이야. 상상도 안 되지?

그 공간에서 출발점이 다르면, 경사하강법이 굴러떨어지는 계곡도 달라져. 그리고 딥러닝의 신기한 점은, 서로 다른 계곡들이 대부분 비슷한 수준의 성능을 낸다는 거야. 하지만 "비슷한"이지 "같은"은 아니지. 그래서 92.1%와 93.4% 같은 차이가 생겨.

1-2. 데이터 셔플링 : 순서가 만드는 나비효과

SGD(Stochastic Gradient Descent)의 S, 즉 "Stochastic(확률적)"이 바로 여기서 나와. 전체 데이터로 한 번에 그래디언트를 계산하는 게 아니라, 무작위로 뽑은 미니배치로 근사하는 거야.

매 epoch마다 데이터를 섞으면 배치 구성이 달라지고, 배치가 달라지면 그래디언트의 방향도 조금씩 달라져. 이 "노이즈"는 사실 버그가 아니라 기능이야. 적당한 노이즈는 얕은 극소점(sharp minima)을 탈출하게 도와주고, 일반화 성능을 높여주거든.

1-3. 데이터 증강 : 매번 다른 이미지를 보는 모델

RandomCrop, RandomHorizontalFlip, ColorJitter, Mixup, CutMix, RandAugment... 요즘 비전 모델 학습에 증강은 필수야. 그런데 이건 말 그대로 매 스텝 다른 데이터를 만들어내는 것이거든.

"동일한 데이터로 훈련했다"고 말하지만, 증강이 들어간 순간 모델이 실제로 본 픽셀은 매번 달라. 원본 5만 장이 사실상 무한대의 변형으로 확장되는 거고, 그 변형의 시퀀스가 시드에 따라 완전히 달라지지.

NLP에서도 마찬가지야. 토큰 마스킹(BERT의 MLM), 드롭 토큰, 백트랜슬레이션, 그리고 요즘은 데이터 패킹 순서까지 무작위 요소가 가득해.

1-4. 드롭아웃과 확률적 레이어

드롭아웃은 학습 중 뉴런을 확률 p로 꺼버려. 즉 매 forward pass마다 다른 서브네트워크가 학습되는 거야. Stochastic Depth, DropPath, DropBlock 같은 것도 같은 철학이고.

이건 앙상블 효과를 내주는 훌륭한 정규화 기법이지만, 당연히 재현성 측면에선 또 하나의 난수 소스야.

1-5. 그 외 숨은 랜덤들

여기까지는 "시드를 고정하면 해결되는" 영역이야. torch.manual_seed(42), np.random.seed(42), random.seed(42) 3종 세트 딱 박으면 상당 부분 잡혀.

그런데 말이야... 시드를 다 고정했는데도 결과가 다르면? 여기서부터 진짜 재밌어져. 🍿

🔬 2장. 시드로도 안 잡히는 랜덤 — 부동소수점의 배신

2-1. 컴퓨터의 덧셈은 결합법칙을 지키지 않는다

초등학교에서 배웠지. (a + b) + c = a + (b + c). 결합법칙. 수학에선 당연해.

그런데 컴퓨터의 부동소수점 연산에서는 이게 성립하지 않아.

>>> (0.1 + 0.2) + 0.3
0.6000000000000001
>>> 0.1 + (0.2 + 0.3)
0.6

>>> (1e16 + 1.0) - 1e16
0.0          # 1.0이 증발했다
>>> 1e16 + (1.0 - 1e16)
1.0          # 순서만 바꿨는데 살아남았다

왜 이럴까? IEEE 754 부동소수점은 유한한 비트로 실수를 근사하거든. float32는 부호 1비트, 지수 8비트, 가수 23비트. 즉 유효 숫자가 대략 7자리 정도야.

큰 수와 아주 작은 수를 더하면, 작은 수가 가수 비트 밖으로 밀려나서 그냥 사라져. 이걸 흡수 오차(absorption) 또는 소실(swamping)이라고 해. 그러니 어떤 순서로 더하느냐에 따라 결과가 달라지는 거지.

2-2. GPU는 왜 순서를 보장하지 않을까?

CPU에서 for문으로 배열을 더하면 순서가 딱 정해져 있어. 0번, 1번, 2번... 항상 같아. 그래서 결과도 항상 같지.

그런데 GPU는 수천~수만 개의 스레드가 동시에 일해. 예를 들어 100만 개 원소를 더할 때, GPU는 이걸 잘게 쪼개서 병렬로 부분합을 구하고, 그 부분합들을 다시 합쳐(reduction). 이때 어떤 블록이 먼저 끝나느냐는 그때그때 달라.

특히 atomicAdd 같은 연산은 "여러 스레드가 같은 메모리 주소에 안전하게 더하기"를 보장하지만, 더하는 순서는 보장하지 않아. 이게 비결정성의 대표적 원흉이야.

2-3. cuDNN의 "알아서 빠른 거 골라줄게"

합성곱(Convolution) 연산 하나를 구현하는 방법은 여러 가지야. 직접 계산(direct), im2col+GEMM, FFT 기반, Winograd 알고리즘... 각각 속도와 수치 특성이 달라.

NVIDIA cuDNN은 benchmark=True로 설정하면 실행 시점에 여러 알고리즘을 실제로 돌려보고 제일 빠른 걸 선택해. 이게 autotuning이야. 속도는 확실히 빨라지는데... 문제는 그 순간 GPU 상태(온도, 다른 프로세스, 메모리 단편화)에 따라 선택되는 알고리즘이 달라질 수 있다는 거야.

Winograd 알고리즘은 곱셈 횟수를 줄이는 대신 수치 오차가 조금 더 커. FFT 기반은 또 다른 오차 특성이 있고. 그러니 알고리즘이 바뀌면 소수점 6~7자리에서 다른 값이 나오고, 그게 학습 전체로 증폭돼.

# 재현성 vs 속도의 트레이드오프
torch.backends.cudnn.benchmark = False      # 자동 튜닝 끄기 (재현성 ↑, 속도 ↓)
torch.backends.cudnn.deterministic = True   # 결정적 커널만 사용

2-4. TF32, FP16, BF16 — 정밀도를 깎으면 생기는 일

요즘 GPU(Ampere 이후)는 기본적으로 TF32라는 포맷을 써. 이건 float32처럼 보이지만 실제 행렬곱 내부에서는 가수를 10비트로 깎아서 계산해. 텐서 코어를 활용해 훨씬 빠르지만, 정밀도는 낮아지지.

혼합 정밀도(AMP, Automatic Mixed Precision)를 쓰면 여기에 동적 손실 스케일링(dynamic loss scaling)이 붙어. 그래디언트가 FP16 범위에서 언더플로 나지 않게 손실에 큰 수를 곱했다가 나중에 나누는 기법인데, 스케일 값이 overflow 발생 여부에 따라 실행 중에 자동으로 조정돼.

즉, 아주 미세한 수치 차이 하나가 "이번엔 overflow 발생 / 안 발생"을 가르고, 그게 스케일 값을 바꾸고, 그게 또 학습 궤적을 바꿔. 완벽한 나비효과지.

2-5. 멀티스레드 DataLoader의 함정

PyTorch의 DataLoader(num_workers=4)는 4개 프로세스가 병렬로 데이터를 준비해. 그런데 각 워커는 자기만의 난수 상태를 갖고 있어. 워커가 데이터를 반환하는 순서, 그리고 각 워커에서 실행되는 증강의 난수 소비 순서가 실행마다 미묘하게 달라질 수 있지.

def seed_worker(worker_id):
    worker_seed = torch.initial_seed() % 2**32
    np.random.seed(worker_seed)
    random.seed(worker_seed)

g = torch.Generator()
g.manual_seed(42)

loader = DataLoader(dataset, batch_size=32, shuffle=True,
                    num_workers=4, worker_init_fn=seed_worker,
                    generator=g, persistent_workers=True)

이렇게 worker_init_fn과 generator를 명시해야 워커별 시드가 결정적으로 관리돼. 이거 안 하면 num_workers를 4에서 8로만 바꿔도 결과가 달라질 수 있어. 진짜야.

2-6. 분산 학습 : 노드가 늘면 랜덤도 늘어난다

DDP(DistributedDataParallel)로 GPU 8장에서 학습한다고 해보자. 각 GPU가 그래디언트를 계산하고, all-reduce로 합쳐. 이 all-reduce도 ring 방식이냐 tree 방식이냐에 따라 덧셈 순서가 달라져. NCCL은 네트워크 토폴로지와 텐서 크기에 따라 알고리즘을 자동 선택하고.

거기에 gradient bucketing(그래디언트를 묶어서 통신하는 최적화)의 경계가 바뀌면 또 합산 순서가 바뀌고... 비동기 통신 완료 순서도 매번 다르고... 뭐, 카오스지.

그래서 "GPU 4장에서 학습한 결과와 8장에서 학습한 결과는 하이퍼파라미터가 같아도 다르다"는 게 거의 상식이야. 유효 배치 크기까지 달라지면 말할 것도 없고.

🦋 3장. 왜 작은 차이가 큰 차이로 증폭될까?

3-1. 카오스 시스템으로서의 신경망 학습

1e-7. 소수점 아래 7번째 자리의 차이. "에이 그게 뭐 대수야?" 싶지?

그런데 딥러닝 학습은 수만~수십만 번의 반복 업데이트로 이루어져. 각 스텝에서 파라미터는 이전 스텝의 결과에 의존하고, 그래디언트는 현재 파라미터에 비선형적으로 의존해. 이건 전형적인 반복 동역학계(iterated dynamical system)고, 이런 시스템은 종종 초기 조건에 민감해.

3-2. 결정적 분기점 : ReLU, argmax, 그리고 if문

증폭을 가속하는 특별한 범인들이 있어. 불연속적인 결정을 내리는 연산들이야.

특히 Mixture-of-Experts(MoE) 구조는 이 문제가 심각해. 토큰마다 어떤 전문가(expert)로 보낼지 라우팅하는데, 라우팅 확률이 비슷한 두 전문가 사이에서 선택이 뒤바뀌면 완전히 다른 파라미터가 업데이트되거든. 게다가 용량 제한(capacity factor) 때문에 같은 배치 안의 다른 토큰들에게도 연쇄적으로 영향을 줘.

3-3. 손실 지형에는 '정답'이 하나가 아니다

깊은 신경망의 손실 함수는 볼록(convex)하지 않아. 극소점이 아주 많지. 그런데 재밌는 건, 고차원에서는 "나쁜 극소점"보다 안장점(saddle point)이 훨씬 흔하고, 도달 가능한 극소점들은 대체로 비슷한 손실 값을 갖는다는 실증적·이론적 관찰들이 있어.

더 놀라운 건 모드 연결성(mode connectivity) 연구야. Garipov 등(2018)은 서로 다른 시드로 학습한 두 모델 사이에, 손실이 거의 증가하지 않는 곡선 경로가 존재한다는 걸 보였어. 즉 이 해들은 완전히 고립된 섬이 아니라, 저지대 능선으로 연결되어 있다는 거지.

그리고 순열 대칭성(permutation symmetry). 은닉층 뉴런의 순서를 바꿔도 함수적으로는 완전히 동일한 네트워크야. n개 뉴런이면 n! 가지 표현이 존재하는 거지. Entezari 등(2022)의 "순열 불변성을 고려하면 SGD 해들이 사실상 하나의 볼록 분지에 있을 수 있다"는 가설도 여기서 나와.

📊 4장. 그럼 차이가 얼마나 나는데? — 숫자로 보는 편차

4-1. 관찰되는 편차의 규모

여러 실증 연구와 실무 경험을 종합하면 대략 이런 양상이야. (데이터셋·모델·설정에 따라 편차 자체가 달라지니 참고용으로 봐줘.)

특히 BERT 계열 소규모 파인튜닝의 시드 민감성은 유명해. Dodge 등(2020)의 연구는 GLUE의 작은 태스크(RTE, MRPC 등)에서 시드만 바꿔도 성능이 크게 요동치고, 심지어 일부 시드에서는 학습이 완전히 실패(degenerate run)한다는 걸 보고했어.

4-2. 그럼 성능 차이가 없으면 모델도 같은 건가?

절대 아니야. 이게 진짜 중요한 포인트인데.

두 모델이 똑같이 92.5%를 기록했다고 해도, 틀리는 샘플이 다를 수 있어. 이걸 예측 불일치(prediction churn / disagreement)라고 해.

실제로 동일 설정·다른 시드 모델 쌍의 테스트 예측을 비교하면, 정확도는 거의 같은데 예측이 엇갈리는 샘플이 수 %에 달하는 경우가 흔해. 정확도라는 단일 스칼라 지표는 모델의 행동을 요약하기엔 너무 거칠다는 뜻이지.

4-3. 편차를 재는 방법

제대로 실험하려면 이렇게 해:

Dodge 등이 제안한 expected max performance 개념도 유용해. "시도 횟수 n에 따른 기대 최대 성능"을 곡선으로 그려서, 계산 예산 대비 공정한 비교를 하자는 아이디어야.

🛠️ 5장. 실전 재현성 확보 가이드 — 완전 결정론에 도전하기

5-1. PyTorch 완전 결정론 세팅

import os, random, numpy as np, torch

def make_deterministic(seed: int = 42):
    # 1) CUBLAS 워크스페이스 고정 (CUDA 10.2+ 필수)
    os.environ["CUBLAS_WORKSPACE_CONFIG"] = ":4096:8"
    os.environ["PYTHONHASHSEED"] = str(seed)

    # 2) 모든 난수 생성기 시드 고정
    random.seed(seed)
    np.random.seed(seed)
    torch.manual_seed(seed)
    torch.cuda.manual_seed_all(seed)

    # 3) cuDNN 결정론 모드
    torch.backends.cudnn.deterministic = True
    torch.backends.cudnn.benchmark = False

    # 4) 비결정적 연산 만나면 에러 발생시키기
    torch.use_deterministic_algorithms(True, warn_only=False)

    # 5) TF32 끄기 (정밀도 일관성)
    torch.backends.cuda.matmul.allow_tf32 = False
    torch.backends.cudnn.allow_tf32 = False

make_deterministic(42)

use_deterministic_algorithms(True)가 핵심이야. 이걸 켜면 비결정적 CUDA 커널을 사용하려 할 때 런타임 에러를 던져줘. "너 지금 재현 안 되는 연산 쓰고 있어!"라고 알려주는 거지.

5-2. TensorFlow / JAX의 경우

# TensorFlow
import os, tensorflow as tf
os.environ["TF_DETERMINISTIC_OPS"] = "1"
os.environ["TF_CUDNN_DETERMINISTIC"] = "1"
tf.keras.utils.set_random_seed(42)
tf.config.experimental.enable_op_determinism()   # TF 2.8+

JAX는 접근법 자체가 달라. 암묵적 전역 난수 상태가 아예 없어. 모든 난수 함수가 명시적으로 key를 받아야 해.

# JAX - 함수형 난수 관리
import jax
key = jax.random.PRNGKey(42)
key, subkey = jax.random.split(key)
noise = jax.random.normal(subkey, (128, 256))
# key를 안 쪼개고 재사용하면? 같은 난수가 또 나옴 (의도적 설계)

처음엔 귀찮은데, 써보면 "아 이게 맞는 설계구나" 싶어져. 난수의 흐름이 코드에 명시적으로 드러나니까 병렬화해도 재현성이 유지되거든.

5-3. 환경 자체를 고정하기

코드만 같다고 되는 게 아니야. 진짜 재현을 원하면 환경까지 박제해야 해.

5-4. 결정론의 대가 — 얼마나 느려지나?

공짜는 없어. 결정론 모드를 켜면 대략 이런 비용을 치러.

그래서 현실적인 전략은 이거야:

🧩 6장. 비결정성을 '문제'가 아니라 '자원'으로 쓰기

여기까지 읽으면 "비결정성 = 나쁜 것"처럼 느껴지지? 근데 반전이 있어. 이 무작위성 덕분에 딥러닝이 잘 되는 측면도 있고, 심지어 이걸 적극 활용하는 기법들도 많아.

6-1. 딥 앙상블 : 랜덤이 곧 다양성

Lakshminarayanan 등(2017)이 제안한 Deep Ensembles는 놀랍도록 단순해. "시드만 다르게 해서 여러 모델을 학습시키고 예측을 평균내라."

이게 왜 잘 될까? 서로 다른 시드의 모델들은 다른 극소점에 수렴하고, 서로 다른 종류의 실수를 하거든. 평균을 내면 개별 오류가 상쇄되고, 동시에 예측의 분산이 자연스러운 불확실성 추정치가 돼.

실제로 딥 앙상블은 복잡한 베이지안 신경망 기법들보다도 불확실성 추정과 분포 외 데이터(OOD) 탐지에서 강력한 성능을 보이는 경우가 많아. 단순한데 강력한, 딥러닝다운 해법이지.

6-2. 랜덤을 아예 알고리즘으로 쓰는 경우

6-3. LLM의 비결정성 : 요즘 가장 뜨거운 주제

"ChatGPT에 temperature=0으로 설정했는데 왜 답이 매번 다르지?" 이 질문 한 번쯤 해봤지?

이건 위에서 다룬 내용의 종합판이야. 원인이 여러 겹으로 쌓여 있어.

그래서 "batch-invariant kernel"(배치 크기와 무관하게 동일한 연산 순서를 보장하는 커널)을 만드는 연구가 최근 주목받고 있어. 속도를 조금 희생하더라도 추론 결과의 완전한 재현을 보장하려는 시도지. LLM 평가·A/B 테스트·규제 대응에서 이건 점점 중요해지고 있어.

🔧 7장. 디버깅 실전 — "내 결과가 안 맞을 때" 체크리스트

자, 실제로 문제가 터졌을 때 어떻게 추적할까? 순서대로 따라가보자.

7-1. 유용한 진단 코드

import torch, platform, subprocess

def env_fingerprint():
    info = {
        "python": platform.python_version(),
        "torch": torch.__version__,
        "cuda": torch.version.cuda,
        "cudnn": torch.backends.cudnn.version(),
        "gpu": torch.cuda.get_device_name(0) if torch.cuda.is_available() else "cpu",
        "gpu_count": torch.cuda.device_count(),
        "tf32_matmul": torch.backends.cuda.matmul.allow_tf32,
        "cudnn_benchmark": torch.backends.cudnn.benchmark,
        "cudnn_det": torch.backends.cudnn.deterministic,
    }
    for k, v in info.items():
        print(f"{k:16s}: {v}")
    return info

# 학습 루프에 체크섬 심기
def param_checksum(model):
    s = 0.0
    for p in model.parameters():
        s += float(p.detach().double().sum())
    return s

# 매 스텝 출력하면 어디서 갈라지는지 바로 보임
# print(f"step {i} loss={loss.item():.10f} ck={param_checksum(model):.10f}")

이 param_checksum 트릭 은근히 강력해. 두 실행의 로그를 diff로 비교하면 정확히 몇 번째 스텝에서 갈라졌는지 딱 나와.

🌐 8장. 더 넓은 시선 — 재현성은 과학의 문제다

8-1. 재현성의 세 가지 층위

연구 커뮤니티에서는 재현성을 이렇게 구분해:

사실 과학적으로 진짜 중요한 건 세 번째야. 비트 단위로 동일한 결과가 아니라, "결론이 재현되는가"가 핵심이거든.

그러니까 "정확도가 92.4가 아니라 92.1이 나왔다"는 건 문제가 아닐 수 있어. 하지만 "논문에서는 기존 방법보다 좋다고 했는데 내가 돌리니 더 나쁘다"면 그건 진짜 문제야.

8-2. 재현성 위기와 커뮤니티의 대응

2018년 NeurIPS에서 Joelle Pineau가 제안한 Reproducibility Checklist는 큰 전환점이었어. 지금은 주요 학회들이 논문 제출 시 체크리스트를 요구하지.

ML Reproducibility Challenge 같은 커뮤니티 이벤트도 활발해. 참가자들이 논문을 독립적으로 재현해보고 보고서를 내는 건데, 결과가 꽤 흥미로워. "완전히 재현됨"보다 "부분적으로 재현됨"이 훨씬 많다는 게 반복적으로 관찰되고 있어.

8-3. 벤치마크 과적합이라는 함정

여기서 좀 불편한 얘기를 해볼게.

같은 테스트셋을 수천 번 반복해서 사용하면 어떻게 될까? 연구자들이 "테스트셋 성능을 보고 방법을 수정"하는 과정을 반복하면, 결국 테스트셋에 대한 간접적 과적합이 일어나.

Recht 등(2019)은 CIFAR-10과 ImageNet의 새로운 테스트셋을 원래 수집 절차대로 만들어서 기존 모델들을 평가했어. 결과? 모든 모델의 성능이 하락했어. 다만 모델 간 순위는 대체로 유지됐지. 즉 "절대 수치는 부풀려져 있지만 상대 비교는 어느 정도 유효하다"는 결론.

이 얘기를 왜 하냐면, "0.2%p 차이"에 목매는 게 얼마나 의미 없는지를 보여주기 때문이야. 시드 편차가 ±0.5%p인데 0.2%p 개선을 주장하는 건... 음, 통계적으로 좀 곤란하지.

8-4. 그래서 좋은 실험이란?

🧪 9장. 직접 해보는 실험 — 백문이 불여일견

말로만 들으면 감이 안 오지? 직접 확인해볼 수 있는 간단한 실험들을 준비했어.

실험 1 : 부동소수점 결합법칙 깨기

import numpy as np

# 큰 수와 작은 수가 섞인 배열
arr = np.array([1e8, 1.0, -1e8, 1.0, 1e8, -1e8], dtype=np.float32)

print("순서대로 :", np.float32(0) + arr[0] + arr[1] + arr[2] + arr[3] + arr[4] + arr[5])
print("역순     :", np.float32(0) + arr[5] + arr[4] + arr[3] + arr[2] + arr[1] + arr[0])
print("numpy sum:", arr.sum())          # pairwise summation 사용
print("정확한 값 :", 2.0)

# 무작위 순서로 100번 더해보기
results = set()
for _ in range(100):
    perm = np.random.permutation(arr)
    s = np.float32(0)
    for x in perm:
        s = np.float32(s + x)
    results.add(float(s))
print("나온 서로 다른 결과들:", sorted(results))

실행해보면 0.0, 1.0, 2.0 같은 서로 다른 값들이 나와. 같은 숫자를 더했는데도!

실험 2 : GPU 누적 합의 비결정성

import torch

x = torch.randn(10_000_000, device='cuda', dtype=torch.float32)
sums = {float(x.sum()) for _ in range(20)}
print(f"20번 합산 → 서로 다른 값 {len(sums)}개")
# 환경에 따라 1개일 수도, 여러 개일 수도 있음

# scatter_add는 훨씬 잘 드러남
idx = torch.randint(0, 100, (5_000_000,), device='cuda')
src = torch.randn(5_000_000, device='cuda')
outs = []
for _ in range(10):
    out = torch.zeros(100, device='cuda')
    out.scatter_add_(0, idx, src)
    outs.append(out.clone())
diff = max(float((outs[0] - o).abs().max()) for o in outs)
print(f"scatter_add 최대 편차: {diff:.3e}")

실험 3 : 시드만 바꿔서 성능 분포 보기

import numpy as np

accs = []
for seed in range(10):
    make_deterministic(seed)
    model = build_model()
    acc = train_and_eval(model)
    accs.append(acc)
    print(f"seed {seed}: {acc:.4f}")

accs = np.array(accs)
print(f"\n평균   : {accs.mean():.4f}")
print(f"표준편차: {accs.std():.4f}")
print(f"범위   : {accs.min():.4f} ~ {accs.max():.4f}")
print(f"최대-최소 차이: {accs.max()-accs.min():.4f}")

작은 데이터셋으로 해보면 깜짝 놀랄 거야. 최대-최소 차이가 논문들이 자랑하는 "개선폭"보다 큰 경우가 흔하거든.

실험 4 : 두 모델의 예측 불일치 측정

import numpy as np

pred_a = model_a.predict(X_test).argmax(1)
pred_b = model_b.predict(X_test).argmax(1)
y = y_test

acc_a = (pred_a == y).mean()
acc_b = (pred_b == y).mean()
disagree = (pred_a != pred_b).mean()

both_right = ((pred_a == y) & (pred_b == y)).mean()
only_a     = ((pred_a == y) & (pred_b != y)).mean()
only_b     = ((pred_a != y) & (pred_b == y)).mean()
both_wrong = ((pred_a != y) & (pred_b != y)).mean()

print(f"정확도 A/B : {acc_a:.4f} / {acc_b:.4f}")
print(f"예측 불일치 : {disagree:.4f}")
print(f"둘 다 맞음 {both_right:.3f} | A만 {only_a:.3f} | "
      f"B만 {only_b:.3f} | 둘 다 틀림 {both_wrong:.3f}")

정확도는 비슷한데 불일치율이 3~8%씩 나오는 걸 보면, "모델이 같다"는 게 얼마나 성립하기 어려운 말인지 실감할 수 있어.

📖 10장. 자주 묻는 질문 모음

torch.save({
    'epoch': epoch, 'step': global_step,
    'model': model.state_dict(),
    'optimizer': optimizer.state_dict(),
    'scheduler': scheduler.state_dict(),
    'scaler': scaler.state_dict(),          # AMP 사용 시
    'torch_rng': torch.get_rng_state(),
    'cuda_rng': torch.cuda.get_rng_state_all(),
    'numpy_rng': np.random.get_state(),
    'python_rng': random.getstate(),
    'sampler_epoch': epoch,                  # DistributedSampler
}, path)

🎁 마무리 — 우리가 배운 것들

핵심 요약

마지막으로

처음 이 문제를 만났을 때 대부분의 개발자는 좌절해. "컴퓨터는 결정적이어야 하는 거 아니야?" 하면서.

근데 조금 익숙해지면 관점이 바뀌어. 이건 버그가 아니라 딥러닝이라는 시스템의 본질적 성질이야. 고차원 비볼록 최적화를 확률적 방법으로 푸는 이상, 그리고 유한 정밀도 하드웨어에서 수천 개 코어를 병렬로 돌리는 이상, 어느 정도의 비결정성은 피할 수 없어.

중요한 건 이 성질을 이해하고, 통제할 수 있는 건 통제하고, 통제할 수 없는 건 측정해서 정직하게 보고하는 것이야. 그게 진짜 엔지니어링이고 진짜 과학이지.

다음에 누가 "내 결과가 안 나와요" 하고 물어보면, 이제 당신은 체계적으로 답해줄 수 있을 거야. 시드는 고정했는지, cudnn benchmark는 껐는지, DataLoader worker 시드는 잡았는지, GPU 모델은 같은지, 몇 번이나 돌려봤는지...

그 질문들 하나하나가, 사실은 정보지능공학이 "공학"인 이유야. 불확실성 속에서도 신뢰할 수 있는 시스템을 만드는 것. 그게 우리 일이니까. 🚀