Suivi des versions et LoggedModel

Le suivi des versions MLflow vous permet de créer des représentations avec version de vos applications GenAI. Le contrôle de version offre les avantages suivants :

• Reproductibilité et auditabilité. Chaque application ou version de modèle est liée à son code spécifique, tel que le hachage de validation Git et sa configuration.
• Aide au débogage. Comparez le code, les configurations, les résultats d’évaluation et les traces entre les versions du modèle.
• Évaluation systématique. Permet mlflow.genai.evaluate() de comparer les métriques telles que les scores de qualité, le coût et la latence côte à côte.

Pour créer une application ou une version de modèle, vous utilisez un LoggedModel. Dans MLflow, un LoggedModel représente une version spécifique de votre application GenAI. Chaque état distinct de votre application à évaluer, déployer ou faire référence peut être capturé en tant que nouveau LoggedModel.

Cette page présente le suivi des versions de MLflow. Pour obtenir un didacticiel pas à pas, consultez Suivre les versions d’applications git avec MLflow.

Méthodes pour le suivi des versions

MLflow fournit deux méthodes pour le suivi des versions :

• mlflow.set_active_model(): suivi de version simple. Crée automatiquement un LoggedModel si nécessaire et lie les traces qui suivent.
• mlflow.create_external_model(): Contrôle total sur la création de version. Vous pouvez fournir des métadonnées, des paramètres et des balises étendus.

set_active_model

Lie les traces à une version spécifique LoggedModel . Si un modèle portant le nom donné n’existe pas, il en crée automatiquement un.

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

Paramètres

Soit name, soit model_id doit être fourni.

Valeur de retour

Retourne un ActiveModel objet (sous-classe de LoggedModel) qui peut être utilisé comme gestionnaire de contexte.

Exemple d’utilisation

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

Crée une nouvelle LoggedModel application pour les applications dont le code et les artefacts sont stockés en dehors de MLflow (par exemple, dans 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:

Paramètres

Valeur de retour

Retourne un objet LoggedModel avec :

• model_id: identificateur unique pour le modèle
• name: Nom du modèle affecté
• experiment_id: ID d’expérience associé
• creation_timestamp: lors de la création du modèle
• status: État du modèle (toujours « READY » pour les modèles externes)
• tags: Dictionnaire de balises
• params: Dictionnaire de paramètres

Exemple d’utilisation

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, classe

La LoggedModel classe représente un modèle versionné dans MLflow.

Propriétés

Modèles courants

Suivi des versions avec l’intégration 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}
)

Liaison de traces avec des versions

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

Déploiement de production

En production, utilisez des variables d’environnement au lieu d’appeler set_active_model():

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

Meilleures pratiques

1. Utiliser le contrôle de version sémantique dans les noms de modèles (par exemple, « app-v1.2.3 »)
2. Inclure les commits Git dans les balises pour la traçabilité
3. Les paramètres doivent être des chaînes : convertir des nombres et des booléens
4. Utiliser model_type pour catégoriser des applications similaires
5. Définir un modèle actif avant le suivi pour garantir une liaison appropriée

Problèmes courants

Types de paramètres non valides :

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

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

Étapes suivantes

• Suivre les versions d’application - Guide pas à pas pour la version de votre application GenAI
• Lier des traces de production - Connecter des données de production aux versions d’application
• Package pour le déploiement - Déployer des applications avec version sur Model Service