Reproducibility

Reproducibility im Überblick

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?

Technisch betrachtet

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)