DVC (Datenversionskontrolle)

DVC (Data Version Control)

Installation

# Installiere DVC mit Cloud-Speicher-Unterstützung
pip install dvc[s3]    # Für AWS S3
pip install dvc[gs]    # Für Google Cloud Storage
pip install dvc[azure] # Für Azure Blob Storage
pip install dvc[all]   # Alle Remotes

# Initialisiere DVC in einem Git-Repository
cd mein-ml-projekt
git init
dvc init

Datendateien verfolgen

# track_data.sh — Füge große Dateien zur DVC-Verfolgung hinzu (anstatt zu Git)
# Füge einen großen Datensatz hinzu
dvc add data/trainingsbilder/
dvc add data/datensatz.csv

# DVC erstellt .dvc-Dateien (kleine Pointer) — committe diese zu Git
git add data/trainingsbilder.dvc data/datensatz.csv.dvc .gitignore
git commit -m "Trainingsdaten mit DVC verfolgen"

Remote-Speicher konfigurieren

# setup_remote.sh — Konfiguriere, wo DVC die eigentlichen Dateiinhalte speichert
# S3
dvc remote add -d meinremote s3://mein-bucket/dvc-storage

# Google Cloud Storage
dvc remote add -d meinremote gs://mein-bucket/dvc-storage

# Lokaler / Netzwerk-Pfad
dvc remote add -d meinremote /mnt/freigegeben/dvc-storage

# Daten zu Remote pushen
dvc push

# Daten von Remote pullen (auf einem anderen Rechner oder nach dem Klonen)
dvc pull

Reproduzierbare Pipelines erstellen

# dvc.yaml — Definiere ML-Pipeline-Stufen mit Abhängigkeiten und Ausgaben
stages:
  vorbereiten:
    cmd: python src/vorbereiten.py
    deps:
      - src/vorbereiten.py
      - data/roh/
    outs:
      - data/verarbeitet/

  trainieren:
    cmd: python src/trainieren.py
    deps:
      - src/trainieren.py
      - data/verarbeitet/
    params:
      - train.epochen
      - train.lernrate
      - train.batch_groesse
    outs:
      - models/model.pkl
    metrics:
      - metrics/train.json:
          cache: false

  evaluieren:
    cmd: python src/evaluieren.py
    deps:
      - src/evaluieren.py
      - models/model.pkl
      - data/verarbeitet/
    metrics:
      - metrics/eval.json:
          cache: false
    plots:
      - metrics/konfusionsmatrix.csv:
          x: vorhergesagt
          y: tatsaechlich

# params.yaml — Pipeline-Parameter (von DVC verfolgt)
train:
  epochen: 50
  lernrate: 0.001
  batch_groesse: 32

# Führe die gesamte Pipeline aus (führt nur geänderte Stufen neu aus)
dvc repro

# Führe eine bestimmte Stufe aus
dvc repro trainieren

Experimentverfolgung

# experiments.sh — ML-Experimente ausführen und vergleichen
# Führe ein Experiment mit geänderten Parametern aus
dvc exp run --set-param train.lernrate=0.01

# Führe mehrere Experimente parallel aus
dvc exp run --set-param train.lernrate=0.001 --queue
dvc exp run --set-param train.lernrate=0.01 --queue
dvc exp run --set-param train.lernrate=0.1 --queue
dvc queue start --jobs 3

# Vergleiche Experimente
dvc exp show
dvc exp diff

# Wende ein erfolgreiches Experiment im Arbeitsbereich an
dvc exp apply exp-abc123

# Pushe ein Experiment zu einem Git-Branch
dvc exp push origin exp-abc123

Metriken und Plots

# trainieren.py — Trainingsskript, das DVC-verfolgte Metriken ausgibt
import json
from sklearn.ensemble import RandomForestClassifier
from sklearn.datasets import load_iris
from sklearn.model_selection import train_test_split
from sklearn.metrics import accuracy_score, f1_score
import yaml
import pickle

# Lade Parameter
with open("params.yaml") as f:
    params = yaml.safe_load(f)["train"]

X, y = load_iris(return_X_y=True)
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)

model = RandomForestClassifier(n_estimators=params["epochen"])
model.fit(X_train, y_train)

preds = model.predict(X_test)
metrics = {
    "genauigkeit": accuracy_score(y_test, preds),
    "f1_wert": f1_score(y_test, preds, average="weighted"),
}

with open("metrics/train.json", "w") as f:
    json.dump(metrics, f, indent=2)

with open("models/model.pkl", "wb") as f:
    pickle.dump(model, f)

# Zeige Metriken über mehrere Experimente hinweg an
dvc metrics show
dvc metrics diff

# Generiere Plots
dvc plots show metrics/konfusionsmatrix.csv
dvc plots diff  # Vergleiche Plots zwischen Experimenten

Datenzugriff ohne Klonen

# Greife auf verfolgte Dateien aus einem beliebigen DVC-Repository zu, ohne es vollständig zu klonen
dvc get https://github.com/org/ml-repo data/verarbeitet/datensatz.csv
dvc import https://github.com/org/ml-repo models/model.pkl

# dvc_api.py — Greife programmatisch auf DVC-verfolgte Dateien zu
import dvc.api

# Lese eine Datei aus einem DVC-Repository
with dvc.api.open("data/datensatz.csv", repo="https://github.com/org/ml-repo") as f:
    import pandas as pd
    df = pd.read_csv(f)

# Erhalte die URL einer verfolgten Datei
url = dvc.api.get_url("models/model.pkl", repo="https://github.com/org/ml-repo")

Schlüsselkonzepte

• .dvc-Dateien: Kleine Pointer-Dateien, die zu Git committed werden und auf große Daten in einem Remote-Speicher verweisen.
• dvc repro: Reproduziert Pipelines — führt nur Stufen mit geänderten Abhängigkeiten neu aus.
• Experimente: Branch-freie Experimentverfolgung — ausführen, vergleichen und Ergebnisse anwenden.
• Parameter: Von DVC verfolgte YAML-Parameterdateien für reproduzierbare Konfigurationen.
• Metriken: JSON/YAML-Metrikdateien mit integrierten Vergleichswerkzeugen.
• Remote-Speicher: S3, GCS, Azure, SSH, HDFS — Daten bleiben dort, wo du sie haben möchtest.