MLflow

MLflow ist eine Open-Source-Plattform zur Verwaltung des gesamten Lebenszyklus des maschinellen Lernens — vom Experiment-Tracking und der Modellversionierung bis hin zu Bereitstellung und Überwachung. MLflow wird von Tausenden Organisationen weltweit genutzt und bringt Struktur und Reproduzierbarkeit in ML-Workflows. Führen Sie es in der GPU-Cloud von Clore.ai aus, um neben Ihren Trainingsjobs einen zentralen Tracking-Server zu erhalten.

---

Was ist MLflow?

MLflow bietet vier Kernkomponenten:

Komponente	Beschreibung
Tracking	Protokollieren von Parametern, Metriken, Artefakten und Code aus ML-Läufen
Projekte	Code für reproduzierbare Läufe paketieren
Modelle	Standardisiertes Modellformat für die Bereitstellung über Frameworks hinweg
Model Registry	Zentraler Modellspeicher mit Versionierung und Lebenszyklus

Unterstützte Frameworks (integriertes Autologging):

• PyTorch, TensorFlow/Keras

• Scikit-learn, XGBoost, LightGBM

• HuggingFace Transformers

• Spark MLlib, statsmodels, Prophet

---

Voraussetzungen

Anforderung	Wert
GPU-VRAM	Beliebig (der MLflow-Server selbst ist CPU-gebunden)
Speicher	20 GB+ (für Artefakte)
RAM	Mindestens 4 GB für den Server
Ports	22 (SSH), 5000 (MLflow-UI)

Der MLflow-Tracking-Server ist leichtgewichtig. Sie können ihn auf einer kleinen CPU-Instanz ausführen und Ihre GPU-Trainingsjobs darauf verweisen lassen. Alternativ können Sie ihn zusammen mit Ihrer GPU-Trainingsinstanz betreiben.

---

Schritt 1 — Einen Server auf Clore.ai mieten

1. Melde dich an bei clore.ai.

2. Klicken Sie auf Marktplatz.

3. Für einen dedizierten Tracking-Server: nach RAM ≥ 8 GB filtern (GPU optional).

4. Für die gemeinsame Nutzung: verwenden Sie Ihre vorhandene Trainingsinstanz.

5. Docker-Image festlegen: ghcr.io/mlflow/mlflow:latest

6. Offene Ports festlegen: 22 (SSH) und 5000 (MLflow-UI).

7. Klicken Sie auf Mieten.

---

Schritt 2 — Den MLflow-Tracking-Server starten

Das offizielle ghcr.io/mlflow/mlflow Image erfordert eine Überschreibung des Startbefehls.

In der Clore.ai-Docker-Konfiguration

Setzen Sie den Befehl (oder die Entrypoint-Überschreibung) auf:

bash -c "apt-get update -q && apt-get install -y -q openssh-server && \
    mkdir /var/run/sshd && \
    echo 'root:clore123' | chpasswd && \
    sed -i 's/#PermitRootLogin prohibit-password/PermitRootLogin yes/' /etc/ssh/sshd_config && \\
    service ssh start && \
    mlflow server \
        --host 0.0.0.0 \
        --port 5000 \
        --default-artifact-root /mlflow/artifacts \
        --backend-store-uri sqlite:////mlflow/mlflow.db"

Alternative: Benutzerdefiniertes Dockerfile

FROM ghcr.io/mlflow/mlflow:latest

RUN apt-get update && apt-get install -y \
    openssh-server \
    && rm -rf /var/lib/apt/lists/*

# SSH konfigurieren
RUN mkdir /var/run/sshd && \
    echo 'root:clore123' | chpasswd && \
    sed -i 's/#PermitRootLogin prohibit-password/PermitRootLogin yes/' /etc/ssh/sshd_config

# Zusätzliche Python-Pakete
RUN pip install boto3 psycopg2-binary

RUN mkdir -p /mlflow/artifacts

EXPOSE 22 5000

CMD service ssh start && \\
    mlflow server \
        --host 0.0.0.0 \
        --port 5000 \
        --default-artifact-root /mlflow/artifacts \
        --backend-store-uri sqlite:////mlflow/mlflow.db

---

Schritt 3 — Auf die MLflow-UI zugreifen

Öffnen Sie Ihren Browser:

http://<clore-host>:<public-port-5000>

Sie sollten das MLflow-Experiments-Dashboard sehen.

Das Standard-SQLite-Backend (mlflow.db) speichert alle Laufmetadaten lokal. Für den produktiven Einsatz oder die Teamnutzung wechseln Sie zu PostgreSQL — siehe erweiterte Konfiguration unten.

---

Schritt 4 — Ihr erstes Experiment protokollieren

Von einem entfernten Trainingsjob verbinden

Auf Ihrer Trainingsmaschine (oder einer anderen Clore.ai-Instanz) legen Sie die Tracking-URI fest:

export MLFLOW_TRACKING_URI=http://<clore-host>:<public-port-5000>

Einfaches PyTorch-Experiment-Logging

import mlflow
import mlflow.pytorch
import torch
import torch.nn as nn
import torch.optim as optim

# Mit dem MLflow-Server verbinden
mlflow.set_tracking_uri("http://<clore-host>:<public-port-5000>")
mlflow.set_experiment("my-first-experiment")

# Ein einfaches Modell definieren
class SimpleNet(nn.Module):
    def __init__(self, input_size, hidden_size, output_size):
        super().__init__()
        self.fc1 = nn.Linear(input_size, hidden_size)
        self.relu = nn.ReLU()
        self.fc2 = nn.Linear(hidden_size, output_size)
    
    def forward(self, x):
        return self.fc2(self.relu(self.fc1(x)))

# Training mit MLflow-Tracking
with mlflow.start_run(run_name="training-run-001"):
    # Hyperparameter protokollieren
    params = {
        "learning_rate": 0.001,
        "batch_size": 64,
        "epochs": 100,
        "hidden_size": 256,
        "optimizer": "adam"
    }
    mlflow.log_params(params)
    
    # Modell initialisieren
    model = SimpleNet(784, 256, 10).cuda()
    optimizer = optim.Adam(model.parameters(), lr=params["learning_rate"])

    criterion = nn.CrossEntropyLoss()
    
    # Trainingsschleife
    for epoch in range(params["epochs"]):
        loss = torch.tensor(0.5 / (epoch + 1))  # Simuliert
        accuracy = 0.7 + epoch * 0.003
        
        # Metriken in jeder Epoche protokollieren
        mlflow.log_metrics({
            "train_loss": loss.item(),
            "train_accuracy": accuracy,
        }, step=epoch)
    
    # Das finale Modell protokollieren
    mlflow.pytorch.log_model(model, "model")
    
    # Endgültige Metriken protokollieren
    mlflow.log_metric("final_accuracy", accuracy)
    
    print(f"Lauf in MLflow protokolliert. ID: {mlflow.active_run().info.run_id}")

Autologging für HuggingFace Transformers

import mlflow
from transformers import TrainingArguments, Trainer

mlflow.set_tracking_uri("http://<clore-host>:<public-port-5000>")
mlflow.set_experiment("llm-finetuning")

# Autologging aktivieren — protokolliert automatisch Parameter, Metriken und Modell
mlflow.transformers.autolog()

training_args = TrainingArguments(
    output_dir="./results",
    num_train_epochs=3,
    per_device_train_batch_size=16,
    per_device_eval_batch_size=64,
    learning_rate=2e-5,
    warmup_steps=500,
    weight_decay=0.01,
    logging_dir="./logs",
    logging_steps=10,
    evaluation_strategy="epoch",
)

trainer = Trainer(
    model=model,
    args=training_args,
    train_dataset=train_dataset,
    eval_dataset=eval_dataset,
)

with mlflow.start_run():
    trainer.train()

---

Schritt 5 — Scikit-learn mit Autologging

import mlflow
import mlflow.sklearn
from sklearn.ensemble import RandomForestClassifier
from sklearn.model_selection import train_test_split
from sklearn.datasets import load_digits

mlflow.set_tracking_uri("http://<clore-host>:<public-port-5000>")
mlflow.set_experiment("sklearn-experiments")

# Alles automatisch protokollieren
mlflow.sklearn.autolog()

X, y = load_digits(return_X_y=True)
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2)

with mlflow.start_run(run_name="random-forest-v1"):
    rf = RandomForestClassifier(n_estimators=100, max_depth=10, random_state=42)
    rf.fit(X_train, y_train)
    
    score = rf.score(X_test, y_test)
    print(f"Testgenauigkeit: {score:.4f}")
    # Alle Parameter, Metriken und das Modell werden automatisch protokolliert!

---

Schritt 6 — Model Registry

Modellversionen über die UI oder API registrieren und verwalten:

import mlflow

client = mlflow.MlflowClient("http://<clore-host>:<public-port-5000>")

# Ein Modell aus einem Lauf registrieren
run_id = "your-run-id-here"
model_uri = f"runs:/{run_id}/model"

registered = mlflow.register_model(
    model_uri=model_uri,
    name="production-classifier"
)

print(f"Version: {registered.version}")

# Modellphase wechseln
client.transition_model_version_stage(
    name="production-classifier",
    version=registered.version,
    stage="Production"
)

# Ein Produktionsmodell überall laden
model = mlflow.pyfunc.load_model(
    model_uri="models:/production-classifier/Production"
)

---

Schritt 7 — Ein Modell bereitstellen

MLflow kann jedes protokollierte Modell als REST-API bereitstellen:

# Auf der MLflow-Serverinstanz
export MLFLOW_TRACKING_URI=http://localhost:5000

mlflow models serve \
    --model-uri "models:/production-classifier/Production" \
    --host 0.0.0.0 \
    --port 5001 \
    --no-conda

Das bereitgestellte Modell testen:

curl -X POST http://<clore-host>:5001/invocations \
    -H "Content-Type: application/json" \\
    -d '{"inputs": [[1.0, 2.0, 3.0, ...]]}'

---

Erweiterte Konfiguration

PostgreSQL-Backend (Produktion)

# Mit PostgreSQL starten
mlflow server \
    --host 0.0.0.0 \
    --port 5000 \
    --backend-store-uri postgresql://user:password@db-host/mlflow \
    --default-artifact-root s3://my-bucket/mlflow-artifacts

S3-Artefaktspeicher

pip install boto3

export AWS_ACCESS_KEY_ID=your_key
export AWS_SECRET_ACCESS_KEY=your_secret

mlflow server \
    --host 0.0.0.0 \
    --port 5000 \
    --default-artifact-root s3://my-mlflow-bucket/artifacts \
    --backend-store-uri sqlite:////mlflow/mlflow.db

Authentifizierung (Enterprise)

pip install mlflow[auth]

mlflow server \
    --host 0.0.0.0 \
    --port 5000 \
    --app-name basic-auth \
    --backend-store-uri sqlite:////mlflow/mlflow.db \
    --default-artifact-root /mlflow/artifacts

---

Läufe in der UI vergleichen

1. Öffnen Sie die MLflow-UI unter http://<clore-host>:<port>

2. Wählen Sie im linken Bereich ein Experiment aus

3. Aktivieren Sie die Kontrollkästchen neben mehreren Läufen

4. Klicken Sie auf Vergleichen um Metriken und Parameter nebeneinander zu sehen

5. Nutzen Sie den Diagramme Registerkarte für den visuellen Vergleich

---

Fehlerbehebung

Kann keine Verbindung zum Tracking-Server herstellen

mlflow.exceptions.MlflowException: API-Anfrage mit Statuscode 503 fehlgeschlagen

Lösungen:

• Stellen Sie sicher, dass Port 5000 in Clore.ai geöffnet und weitergeleitet ist

• Überprüfen Sie, ob der Server läuft: ps aux | grep mlflow

• Konnektivität testen: curl http://<clore-host>:<port>/health

Artefakt-Upload schlägt fehl

Lösung: Stellen Sie sicher, dass das Artefaktverzeichnis beschreibbar ist:

chmod 777 /mlflow/artifacts

SQLite-gesperrt-Fehler (gleichzeitige Schreibzugriffe)

Lösung: Wechseln Sie für Mehrbenutzer-Setups zu PostgreSQL:

pip install psycopg2-binary

Model Registry wird nicht angezeigt

Lösung: Stellen Sie sicher, dass Sie eine --backend-store-uri verwenden, die die Registry unterstützt (SQLite oder PostgreSQL — nicht nur ein lokaler Pfad).

---

Kostenschätzung

Instanz	Anwendungsfall	Geschätzter Preis	Hinweise
CPU 4-Kerne	Nur Tracking-Server	~$0,05/Std.	Sehr leichtgewichtig
RTX 3080	Co-lokales Training	$0,05–0,19/Std.	Training + MLflow
RTX 4090	Schweres Training + Tracking	ca. 0,14–0,42 $/h	Am häufigsten verwendetes Setup

Führen Sie MLflow auf einer günstigen CPU-Instanz aus und verweisen Sie alle Ihre GPU-Trainingsjobs darauf. Auf diese Weise läuft der Tracking-Server kontinuierlich, ohne teure GPU-Kredite zu verbrauchen.

---

Nützliche Ressourcen

• Offizielle MLflow-Dokumentation

• MLflow GitHub

• MLflow Docker Hub

• Anleitung zur MLflow Model Registry

• MLflow Tracking API-Referenz

---

GPU-Empfehlungen für Clore.ai

Anwendungsfall	Empfohlene GPU	Geschätzte Kosten bei Clore.ai
Entwicklung/Testen	RTX 3090 (24 GB)	0,07–0,21 $/GPU/Stunde
Produktionstraining	RTX 4090 (24 GB)	0,14–0,42 $/GPU/Stunde
Experimente im großen Maßstab	A100 80GB	Bare Metal

💡 Alle Beispiele in diesem Leitfaden können bereitgestellt werden auf Clore.ai GPU-Servern. Durchsuchen Sie verfügbare GPUs und mieten Sie stundenweise — keine Verpflichtungen, voller Root-Zugriff.