Versionsverfolgung und LoggedModel

Mit der MLflow-Versionsnachverfolgung können Sie versionsierte Darstellungen Ihrer GenAI-Anwendungen erstellen. Die Versionsverwaltung bietet die folgenden Vorteile:

• Reproduzierbarkeit und Prüfbarkeit. Jede App oder Modellversion verknüpft ihren spezifischen Code, z. B. den Git-Commit-Hash und seine Konfiguration.
• Hilfe beim Debuggen. Vergleichen Sie Code, Konfigurationen, Auswertungsergebnisse und Ablaufverfolgungen zwischen Modellversionen.
• Systematische Auswertung. Verwenden Sie mlflow.genai.evaluate(), um Metriken wie Qualitätsbewertungen, Kosten und Latenz nebeneinander zu vergleichen.

Zum Erstellen einer App- oder Modellversion verwenden Sie eine LoggedModel. In MLflow stellt eine LoggedModel bestimmte Version Ihrer GenAI-Anwendung dar. Jeder unterschiedliche Zustand Ihrer Anwendung, den Sie evaluieren, bereitstellen oder auf den Sie verweisen möchten, kann als ein neues LoggedModel erfasst werden.

Diese Seite ist eine Einführung in die MLflow-Versionsnachverfolgung. Eine schrittweise Anleitung finden Sie unter Nachverfolgen von Versionen von Git-basierten Anwendungen mit MLflow.

Methoden für die Versionsnachverfolgung

MLflow bietet zwei Methoden für die Versionsnachverfolgung:

• mlflow.set_active_model(): Einfache Versionsnachverfolgung. Erstellt bei Bedarf automatisch eine LoggedModel Ablaufverfolgung und verknüpft nachfolgende Ablaufverfolgungen.
• mlflow.create_external_model(): Vollkontrolle über die Versionserstellung. Sie können umfangreiche Metadaten, Parameter und Tags bereitstellen.

set_active_model

Verknüpft Ablaufverfolgungen mit einer bestimmten LoggedModel Version. Wenn ein Modell mit dem angegebenen Namen nicht vorhanden ist, wird automatisch ein Modell erstellt.

def set_active_model(
    name: Optional[str] = None,
    model_id: Optional[str] = None
) -> ActiveModel:

Die Parameter

*Entweder name oder model_id muss bereitgestellt werden.

Rückgabewert

Gibt ein ActiveModel Objekt (Unterklasse von LoggedModel) zurück, das als Kontext-Manager verwendet werden kann.

Anwendungsbeispiel

import mlflow

# Simple usage - creates model if it doesn't exist
mlflow.set_active_model(name="my-agent-v1.0")

# Use as context manager
with mlflow.set_active_model(name="my-agent-v2.0") as model:
    print(f"Model ID: {model.model_id}")
    # Traces within this context are linked to this model

# Use with existing model ID
mlflow.set_active_model(model_id="existing-model-id")

create_external_model

Erstellt eine neue LoggedModel Für Anwendungen, deren Code und Artefakte außerhalb von MLflow gespeichert werden (z. B. in Git).

def create_external_model(
    name: Optional[str] = None,
    source_run_id: Optional[str] = None,
    tags: Optional[dict[str, str]] = None,
    params: Optional[dict[str, str]] = None,
    model_type: Optional[str] = None,
    experiment_id: Optional[str] = None,
) -> LoggedModel:

Die Parameter

Rückgabewert

Gibt ein LoggedModel Objekt mit:

• model_id: Eindeutiger Bezeichner für das Modell
• name: Der Name des zugewiesenen Modells
• experiment_id: Zugeordnete Experiment-ID
• creation_timestamp: Beim Erstellen des Modells
• status: Modellstatus (immer "READY" für externe Modelle)
• tags: Wörterbuch mit Tags
• params: Parameterwörterbuch

Anwendungsbeispiel

import mlflow

# Basic usage
model = mlflow.create_external_model(
    name="customer-support-agent-v1.0"
)

# With full metadata
model = mlflow.create_external_model(
    name="recommendation-engine-v2.1",
    model_type="rag-agent",
    params={
        "llm_model": "gpt-4",
        "temperature": "0.7",
        "max_tokens": "1000",
        "retrieval_k": "5"
    },
    tags={
        "team": "ml-platform",
        "environment": "staging",
        "git_commit": "abc123def"
    }
)

# Within a run context
with mlflow.start_run() as run:
    model = mlflow.create_external_model(
        name="my-agent-v3.0",
        source_run_id=run.info.run_id
    )

LoggedModel-Klasse

Die LoggedModel Klasse stellt ein versionsiertes Modell in MLflow dar.

Eigenschaften

Allgemeine Muster

Versionsverfolgung mit Git-Integration

import mlflow
import subprocess

# Get current git commit
git_commit = subprocess.check_output(["git", "rev-parse", "HEAD"]).decode().strip()[:8]

# Create versioned model name
model_name = f"my-app-git-{git_commit}"

# Track the version
model = mlflow.create_external_model(
    name=model_name,
    tags={"git_commit": git_commit}
)

Verknüpfen von Spuren mit Versionen

import mlflow

# Set active model - all subsequent traces will be linked
mlflow.set_active_model(name="my-agent-v1.0")

# Your application code with tracing
@mlflow.trace
def process_request(query: str):
    # This trace will be automatically linked to my-agent-v1.0
    return f"Processing: {query}"

# Run the application
result = process_request("Hello world")

Produktivbetrieb

Verwenden Sie in der Produktion Umgebungsvariablen, anstatt Folgendes aufzurufen set_active_model():

# Set the model ID that traces should be linked to
export MLFLOW_ACTIVE_MODEL_ID="my-agent-v1.0"

Bewährte Methoden

1. Verwenden der semantischen Versionsverwaltung in Modellnamen (z. B. "app-v1.2.3")
2. Einschließen von Git-Commits in Tags zur Rückverfolgbarkeit
3. Parameter müssen Zeichenfolgen sein – Zahlen und Booleane konvertieren
4. Verwenden von model_type zum Kategorisieren ähnlicher Anwendungen
5. Legen Sie das aktive Modell vor der Ablaufverfolgung fest, um eine ordnungsgemäße Verknüpfung sicherzustellen

Häufige Probleme

Ungültige Parametertypen:

# Error: Parameters must be strings
# Wrong:
params = {"temperature": 0.7, "max_tokens": 1000}

# Correct:
params = {"temperature": "0.7", "max_tokens": "1000"}

Nächste Schritte

• Nachverfolgen von Anwendungsversionen – Schritt-für-Schritt-Anleitung zur Version Ihrer GenAI-App
• Verknüpfen von Produktionsablaufverfolgungen – Verbinden von Produktionsdaten mit App-Versionen
• Paket für die Bereitstellung – Bereitstellen von versionsgesteuerten Apps im Model Serving