Śledzenie wersji i LoggedModel

Śledzenie wersji platformy MLflow umożliwia tworzenie reprezentacji wersji aplikacji GenAI. Przechowywanie wersji zapewnia następujące korzyści:

• Powtarzalność i możliwość inspekcji. Każda aplikacja lub wersja modelu łączy się z określonym kodem, takim jak skrót zatwierdzenia usługi Git i jego konfiguracja.
• Pomoc dotycząca debugowania. Porównaj kod, konfiguracje, wyniki oceny i ślady między wersjami modelu.
• Systematyczne ocenianie. Użyj mlflow.genai.evaluate() do porównywania metryk, takich jak oceny jakości, koszty i opóźnienia w porównaniu bezpośrednim.

Aby utworzyć wersję aplikacji lub modelu, użyj polecenia LoggedModel. W środowisku MLflow reprezentuje LoggedModel określoną wersję aplikacji GenAI. Każdy odrębny stan aplikacji, który chcesz ocenić, wdrożyć lub odwołać się do niego, może zostać przechwycony jako nowy LoggedModelelement.

Ta strona stanowi wprowadzenie do śledzenia wersji MLflow. Aby zapoznać się z samouczkiem krok po kroku, zobacz Śledzenie wersji aplikacji opartych na Git za pomocą MLflow.

Metody śledzenia wersji

Rozwiązanie MLflow udostępnia dwie metody śledzenia wersji:

• mlflow.set_active_model(): proste śledzenie wersji. Automatycznie tworzy LoggedModel w razie potrzeby i łączy kolejne ślady.
• mlflow.create_external_model(): Pełna kontrola nad tworzeniem wersji. Możesz podać obszerne metadane, parametry i tagi.

set_active_model

Łączy ślady z określoną LoggedModel wersją. Jeśli model o podanej nazwie nie istnieje, automatycznie go tworzy.

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

Parametry

*Albo name, albo model_id muszą być podane.

Wartość zwracana

Zwraca obiekt (podklasę ActiveModelLoggedModel), który może być używany jako menedżer kontekstu.

Przykładowe użycie

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

Tworzy nowy LoggedModel element dla aplikacji, których kod i artefakty są przechowywane poza platformą MLflow (np. w usłudze 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:

Parametry

Wartość zwracana

Zwraca obiekt LoggedModel z:

• model_id: unikatowy identyfikator modelu
• name: Przypisana nazwa modelu
• experiment_id: Skojarzony identyfikator eksperymentu
• creation_timestamp: Po utworzeniu modelu
• status: Stan modelu (zawsze "GOTOWY" dla modeli zewnętrznych)
• tags: Słownik tagów
• params: Słownik parametrów

Przykładowe użycie

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
    )

Klasa LoggedModel

Klasa LoggedModel reprezentuje model wersjonowany w narzędziu MLflow.

Właściwości

Typowe wzorce

Śledzenie wersji za pomocą integracji z usługą Git

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}
)

Łączenie śladów z wersjami

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")

Wdrożenie produkcyjne

W środowisku produkcyjnym należy użyć zmiennych środowiskowych zamiast wywoływać set_active_model():

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

Najlepsze praktyki

1. Używaj wersjonowania semantycznego w nazwach modeli (np. "app-v1.2.3")
2. Uwzględnianie zatwierdzeń git w tagach w celu śledzenia
3. Parametry muszą być ciągami — konwertowanie liczb i wartości logicznych
4. Używanie model_type do kategoryzowania podobnych aplikacji
5. Ustaw aktywny model przed śledzeniem w celu zapewnienia prawidłowego połączenia

Typowe problemy

Nieprawidłowe typy parametrów:

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

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

Dalsze kroki

• Śledzenie wersji aplikacji — przewodnik krok po kroku dotyczący wersji aplikacji GenAI
• Łączenie śladów produkcyjnych — łączenie danych produkcyjnych z wersjami aplikacji
• Pakiet do wdrożenia — wdrażanie wersji aplikacji w usłudze modelowania