Seguimiento de versiones y LoggedModel

El seguimiento de versiones de MLflow permite crear representaciones versionadas de las aplicaciones de GenAI. El control de versiones proporciona las siguientes ventajas:

• Reproducibilidad y auditabilidad. Cada aplicación o versión del modelo vincula a su código específico, como el hash de confirmación de Git y su configuración.
• Ayuda con la depuración. Compare el código, las configuraciones, los resultados de la evaluación y los seguimientos entre las versiones del modelo.
• Evaluación sistemática. Use mlflow.genai.evaluate() para comparar métricas como puntuaciones de calidad, costo y latencia en paralelo.

Para crear una aplicación o una versión de modelo, use un LoggedModel. En MLflow, un LoggedModel representa una versión específica de tu aplicación GenAI. Cada estado distinto de la aplicación a la que desea evaluar, implementar o hacer referencia se puede capturar como un nuevo LoggedModel.

Esta página es una introducción al seguimiento de versiones de MLflow. Para ver un tutorial paso a paso, consulte Seguimiento de versiones de aplicaciones basadas en Git con MLflow.

Métodos para el seguimiento de versiones

MLflow proporciona dos métodos para el seguimiento de versiones:

• mlflow.set_active_model(): simple seguimiento de versiones. Crea automáticamente un LoggedModel si es necesario y vincula las trazas posteriores.
• mlflow.create_external_model(): control total sobre la creación de versiones. Puede proporcionar metadatos, parámetros y etiquetas extensos.

set_active_model

Vincula trazas a una versión específica LoggedModel. Si no existe un modelo con el nombre especificado, se crea automáticamente uno.

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

Parámetros

*Se debe proporcionar name o model_id.

Valor devuelto

Devuelve un ActiveModel objeto (subclase de LoggedModel) que se puede usar como administrador de contexto.

Ejemplo de uso

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

Crea un nuevo LoggedModel para las aplicaciones cuyo código y artefactos se almacenan fuera de MLflow (por ejemplo, en 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:

Parámetros

Valor devuelto

Devuelve un objeto LoggedModel con:

• model_id: identificador único para el modelo
• name: el nombre del modelo asignado.
• experiment_id: id. de experimento asociado
• creation_timestamp: cuando se creó el modelo
• status: estado del modelo (siempre "LISTO" para modelos externos)
• tags: diccionario de etiquetas
• params: diccionario de parámetros

Ejemplo de uso

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
    )

Clase LoggedModel

La LoggedModel clase representa un modelo con versiones en MLflow.

Propiedades

Patrones comunes

Seguimiento de versiones con integración de 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}
)

Vinculación de trazas a versiones

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

Despliegue de producción

En producción, use variables de entorno en lugar de llamar a set_active_model():

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

Procedimientos recomendados

1. Utiliza el versionado semántico en nombres de modelo (por ejemplo, "app-v1.2.3")
2. Incluir confirmaciones de Git en etiquetas para la rastreabilidad
3. Los parámetros deben ser cadenas : convertir números y booleanos
4. Uso de model_type para clasificar aplicaciones similares
5. Establecimiento del modelo activo antes del seguimiento para garantizar una vinculación adecuada

Problemas comunes

Tipos de parámetros no válidos:

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

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

Pasos siguientes

• Seguimiento de las versiones de la aplicación : guía paso a paso para la versión de la aplicación de GenAI
• Vinculación de seguimientos de producción : conexión de datos de producción a versiones de la aplicación
• Paquete para la implementación : implementación de aplicaciones con versiones en Model Serving