Reproducibility

Einfach erklärt

Reproducibility bedeutet: Wenn du ein ML-Experiment wiederholst, bekommst du exakt dieselben Ergebnisse. Das klingt selbstverständlich, ist aber in der Praxis überraschend schwer.

Warum ist das schwer?

Experiment am Montag:
- Daten: train.csv (Version?)
- Code: model.py (welcher Commit?)
- Libraries: torch (welche Version?)
- Random Seed: (gesetzt?)
- GPU: (deterministisch?)
→ Accuracy: 94.5%

Experiment am Freitag:
- "Dieselben" Inputs
→ Accuracy: 93.8%  ← Warum anders?!

Was muss versioniert werden?

Komponente	Beispiel	Tool
Code	model.py, train.py	Git
Daten	train.csv, test.csv	DVC, Git LFS
Config	hyperparameters.yaml	Git
Environment	Python 3.11, torch 2.2	Docker, pip freeze
Random State	seed=42	Im Code setzen

Technischer Deep Dive

Random Seeds setzen

import random
import numpy as np
import torch

def set_seed(seed: int = 42):
    random.seed(seed)
    np.random.seed(seed)
    torch.manual_seed(seed)
    torch.cuda.manual_seed_all(seed)
    
    # Für volle Determinismus (langsamer)
    torch.backends.cudnn.deterministic = True
    torch.backends.cudnn.benchmark = False
    torch.use_deterministic_algorithms(True)

set_seed(42)

Dependencies pinnen

# requirements.txt mit exakten Versionen
pip freeze > requirements.txt

# Oder mit pip-tools
pip-compile requirements.in --generate-hashes

# requirements.txt
torch==2.2.0
transformers==4.38.0
numpy==1.26.4
scikit-learn==1.4.0

Docker für Umgebung

FROM python:3.11-slim

WORKDIR /app

COPY requirements.txt .
RUN pip install --no-cache-dir -r requirements.txt

COPY . .

# Reproduzierbar: Gleicher Container = Gleiche Umgebung
CMD ["python", "train.py"]

DVC Pipeline

# dvc.yaml
stages:
  preprocess:
    cmd: python preprocess.py
    deps:
      - data/raw/
      - preprocess.py
    outs:
      - data/processed/
  
  train:
    cmd: python train.py
    deps:
      - data/processed/
      - train.py
      - config.yaml
    params:
      - config.yaml:
    outs:
      - models/model.pkl
    metrics:
      - metrics.json:
        cache: false

# Pipeline reproduzieren
dvc repro

# Zu alter Version zurück
git checkout v1.0
dvc checkout
dvc repro

Experiment Logging

import mlflow

mlflow.set_experiment("fraud_detection")

with mlflow.start_run():
    # Config loggen
    mlflow.log_params({
        "learning_rate": 0.001,
        "epochs": 10,
        "batch_size": 32,
        "seed": 42
    })
    
    # Code-Version
    mlflow.log_param("git_commit", get_git_commit())
    
    # Daten-Hash
    mlflow.log_param("data_hash", hash_file("train.csv"))
    
    # Training
    model = train(...)
    
    # Metriken
    mlflow.log_metrics({"accuracy": 0.95, "f1": 0.93})
    
    # Modell
    mlflow.sklearn.log_model(model, "model")

Checkliste

• Random Seeds gesetzt
• Dependencies gepinnt
• Daten versioniert
• Code in Git
• Config geloggt
• Umgebung dokumentiert (Docker)
• GPU-Determinismus aktiviert (wenn nötig)