Reproducibility Stack: Seeds, cuDNN Flags, and Deterministic CUDA — End the 'Works on My Machine' Problem

# === Full deterministic init bloku (cookbook'un her Lab'ında bulunur) ===
import os, random, hashlib
import numpy as np
import torch
 
def set_full_seed(seed: int = 42):
    """Tüm RNG katmanlarını + cuDNN/cuBLAS deterministic'i set eder."""
    # Python-level
    random.seed(seed)
    os.environ["PYTHONHASHSEED"] = str(seed)
 
    # NumPy
    np.random.seed(seed)
 
    # PyTorch
    torch.manual_seed(seed)
    torch.cuda.manual_seed(seed)
    torch.cuda.manual_seed_all(seed)
 
    # cuBLAS workspace — ":4096:8" deterministic GEMM gerektirir
    # PyTorch >= 1.11: CUBLAS_WORKSPACE_CONFIG set edilmezse use_deterministic_algorithms hata atar
    os.environ["CUBLAS_WORKSPACE_CONFIG"] = ":4096:8"
 
    # cuDNN
    torch.backends.cudnn.deterministic = True
    torch.backends.cudnn.benchmark = False        # benchmark seçim non-deterministic
 
    # ATen-level deterministic enforcement
    torch.use_deterministic_algorithms(True, warn_only=True)
    # warn_only=False yaparsan tek bir non-det op tüm run'ı patlatır — gerçek "strict mode"
 
    return seed
 
def seed_worker(worker_id: int):
    """DataLoader worker'ları için seed_fn — her worker farklı ama deterministic."""
    worker_seed = torch.initial_seed() % 2**32
    np.random.seed(worker_seed)
    random.seed(worker_seed)
 
# Kullanım
seed = set_full_seed(42)
gen = torch.Generator(); gen.manual_seed(seed)  # DataLoader'a verilecek
 
from torch.utils.data import DataLoader
loader = DataLoader(
    dataset,
    batch_size=8,
    shuffle=True,
    num_workers=4,
    worker_init_fn=seed_worker,
    generator=gen,                                # shuffle'ın seed'i
    persistent_workers=True,
)

# === Repro CI testi (cookbook için zorunlu) ===
# Aynı kodu 2 kez çalıştır, son loss'lar bit-exact olmalı.
 
import subprocess, json, hashlib
 
def run_once(seed: int = 42) -> dict:
    """Eğitim script'ini bir kez çalıştırır, son loss + bazı tensor hash'leri döner."""
    result = subprocess.run(
        ["python", "train.py", "--seed", str(seed), "--max_steps", "50", "--out", "ci.json"],
        capture_output=True, text=True, check=True,
    )
    with open("ci.json") as f:
        return json.load(f)
 
run_a = run_once(seed=42)
run_b = run_once(seed=42)
 
assert run_a["final_loss"] == run_b["final_loss"], (
    f"Loss not bit-exact: {run_a['final_loss']} vs {run_b['final_loss']}\n"
    f"Diff: {abs(run_a['final_loss'] - run_b['final_loss']):.2e}"
)
 
# Tensor hash karşılaştırma — daha sıkı
assert run_a["weight_sha256"] == run_b["weight_sha256"], (
    "Weights diverged at step 50 — possible non-deterministic op slipped in"
)
 
print("✅ Repro CI passed: 2 run, bit-exact final state")