MLflow 3 en Ciencia de datos de Fabric

Microsoft Fabric admite MLflow hasta la versión 3.1, la plataforma de seguimiento de aprendizaje automático de código abierto. Con esta compatibilidad, puede usar las siguientes funcionalidades para realizar un seguimiento e inspeccionar las cargas de trabajo de inteligencia artificial generativa y aprendizaje automático en Fabric:

• LoggedModel, introducido en MLflow 3, como una entidad de primera clase que vincula cada modelo a su ejecución de origen, código, configuración, parámetros, métricas y conjuntos de datos.
• Trazas que capturan instrucciones, respuestas, llamadas a herramientas, latencia y uso de tokens de aplicaciones de modelos de lenguaje de gran tamaño (LLM) y de IA generativa.

En este artículo se explican los cambios en MLflow 3, cómo usar las nuevas características de Fabric y cómo migrar desde MLflow 2.x.

Prerequisites

• Obtenga una suscripción a Microsoft Fabric. O bien, regístrese para obtener una evaluación gratuita de Microsoft Fabric.

• Inicie sesión en Microsoft Fabric.

• Cambie a Fabric mediante el conmutador de experiencia en el lado inferior izquierdo de la página principal.

  

• Un espacio de trabajo actualizado con la experiencia más reciente de seguimiento de aprendizaje automático. Para comprobar la idoneidad y la actualización, consulte Actualización del sistema de seguimiento de aprendizaje automático.

• mlflow versión 3.0 o posterior. Los cuadernos de Fabric incluyen MLflow 2.x de forma predeterminada, por lo que debe actualizar a MLflow 3 ejecutando el siguiente comando en su cuaderno:

  %pip install "synapseml-mlflow[online-notebook]>=2.0.3" "mlflow-skinny==3.1.0" "opentelemetry-api<=1.40.0"
  

  El mismo comando también instala el paquete synapseml-mlflow actualizado para escenarios entre espacios de trabajo y fuera de Fabric.

Cambios en MLflow 3

MLflow 3 es retrocompatible con los flujos de trabajo de MLflow 2.x. Los experimentos, ejecuciones y cuadernos existentes que usan mlflow>=2 siguen funcionando sin cambios.

Elegir un tipo de experimento

Al crear un experimento, la cinta de opciones incluye un selector de tipo de experimento:

• Experimento de ML : superficie de seguimiento clásica para ejecuciones, parámetros, métricas y LoggedModels. Use este tipo para flujos de trabajo de aprendizaje automático tradicionales.
• Experimento de IA : la superficie de seguimiento primero se ajusta para cargas de trabajo de IA generativas. La pestaña Traces ocupa un lugar central, y la vista de detalles de la ejecución destaca los prompts, las llamadas a herramientas y el uso de tokens.

Los experimentos existentes creados antes de MLflow 3 se asignan por defecto al tipo ML experiment. Puede cambiar de tipo desde la cinta de opciones en cualquier momento.

Inicio desde una plantilla de cuaderno

Dos plantillas de cuaderno se incluyen con la versión para que se ejecute en un solo clic. Al abrir un experimento que aún no tiene ninguna ejecución, la página de experimento vacía muestra dos tarjetas de inicio:

• Nueva plantilla de modelo — un ejemplo integral de ElasticNet que muestra la nueva API de LoggedModel, incluidos params=, get_logged_model() y métricas vinculadas tanto a LoggedModel como a un conjunto de datos.
• Nueva plantilla de seguimiento — cubre @mlflow.trace decoradores, registro automático de OpenAI con credenciales de Fabric, agentes de LangChain y el SDK de agentes de OpenAI.

Seleccione una tarjeta para abrir un cuaderno preconfigurado con las versiones y la autenticación adecuadas del complemento MLflow.

Registro de un modelo con LoggedModel

En MLflow 3, cada llamada a log_model() crea una entidad LoggedModel vinculada a la ejecución de origen, sus parámetros, métricas y los conjuntos de datos en los que se entrenó. En el ejemplo siguiente, se entrena un modelo ElasticNet con el conjunto de datos Iris, se registra como un LoggedModel y se vinculan las métricas de evaluación a ese LoggedModel y al conjunto de datos:

import pandas as pd
from sklearn.linear_model import ElasticNet
from sklearn.metrics import mean_squared_error, mean_absolute_error, r2_score
from sklearn.datasets import load_iris
from sklearn.model_selection import train_test_split

import mlflow
import mlflow.sklearn
from mlflow.entities import Dataset

mlflow.set_experiment("mlflow3-logged-model-demo")

def compute_metrics(actual, predicted):
    rmse = mean_squared_error(actual, predicted)
    mae = mean_absolute_error(actual, predicted)
    r2 = r2_score(actual, predicted)
    return rmse, mae, r2

iris = load_iris()
iris_df = pd.DataFrame(data=iris.data, columns=iris.feature_names)
iris_df["quality"] = (iris.target == 2).astype(int)
train_df, test_df = train_test_split(iris_df, test_size=0.2, random_state=42)

with mlflow.start_run() as training_run:
    # Wrap the training data as an MLflow Dataset so metrics can be linked to it.
    train_dataset: Dataset = mlflow.data.from_pandas(train_df, name="train")
    train_x = train_dataset.df.drop(["quality"], axis=1)
    train_y = train_dataset.df[["quality"]]

    lr = ElasticNet(alpha=0.5, l1_ratio=0.5, random_state=42)
    lr.fit(train_x, train_y)

    # Log the model. `params=` attaches hyperparameters directly to the LoggedModel.
    model_info = mlflow.sklearn.log_model(
        sk_model=lr,
        name="elasticnet",
        params={"alpha": 0.5, "l1_ratio": 0.5},
        input_example=train_x,
    )

    # Retrieve the LoggedModel to inspect its identifier and parameters.
    logged_model = mlflow.get_logged_model(model_info.model_id)
    print(logged_model.model_id, logged_model.params)

    # Compute metrics and link them to both the LoggedModel and the training dataset.
    predictions = lr.predict(train_x)
    rmse, mae, r2 = compute_metrics(train_y, predictions)
    mlflow.log_metrics(
        metrics={"rmse": rmse, "r2": r2, "mae": mae},
        model_id=logged_model.model_id,
        dataset=train_dataset,
    )

Una vez completada la ejecución, el modelo aparece como LoggedModel en dos lugares:

• La sección Modelos registrados en la página del experimento.
• La pestaña Modelos registrados de la página de detalles de la ejecución.

Inspección de un modelo registrado

Seleccione un Modelo registrado en la lista para abrir su página de detalles. En la página de detalles se muestra lo siguiente:

• Parámetros y métricas capturados para el modelo.
• Enlace a la ejecución de origen que lleva a la ejecución que generó el modelo.
• Conjuntos de datos usados durante el entrenamiento.
• Environment (versión de Python, dependencias, firma).

Comparación de Modelos registrados

En la sección Modelos registrados , seleccione varios Modelos registrados para compararlos mediante gráficos de líneas integrados, gráficos de dispersión y coordenadas paralelas. También puede buscar, filtrar, ordenar y agrupar LoggedModels por métrica, parámetro, etiqueta o metadatos.

Registro de un modelo registrado

Para promover un LoggedModel a un elemento de modelo de ML de Fabric, abra su página de detalles y seleccione Register model. Puede registrarlo como un nuevo modelo de ML o como una nueva versión de un modelo existente. Después del registro, la página de detalles de LoggedModel muestra un vínculo al elemento de modelo registrado.

Captura de trazas de IA generativa

Las trazas capturan la ejecución de una aplicación LLM o de IA generativa como una jerarquía de segmentos. Cada seguimiento muestra entradas, salidas, latencia, uso de tokens y cualquier llamada de herramienta o función. Use el tipo de experimento de IA para obtener la mejor experiencia de seguimiento.

Rastrea una función con el decorador @mlflow.trace

Agregue @mlflow.trace a cualquier función para registrar sus entradas, salidas y duración. Use mlflow.update_current_trace() para adjuntar etiquetas desde dentro de la función:

import mlflow
import time

mlflow.set_experiment("mlflow3-trace-demo")

@mlflow.trace
def process_user(user_id, action):
    mlflow.update_current_trace(tags={
        "user_id": user_id,
        "action": action,
        "environment": "production",
    })
    time.sleep(1)
    return f"Processed action {action} for user {user_id}"

with mlflow.start_run(run_name="function_call"):
    process_user(user_id=123, action="login")

Cuando las funciones decoradas se llaman unas a otras, MLflow anida automáticamente los tramos para visualizar el árbol de llamadas completo en la página de detalles de la traza.

Autolog de finalizaciones de chat de OpenAI

Habilitar el registro automático de OpenAI para que todas las llamadas al cliente de OpenAI se rastreen automáticamente, sin añadir decoradores. En el ejemplo siguiente se usa AzureOpenAI con credenciales administradas por Fabric:

import mlflow
from openai import AzureOpenAI
from synapse.ml.fabric.credentials import get_openai_httpx_sync_client

mlflow.openai.autolog()

client = AzureOpenAI(
    api_version="2025-04-01-preview",
    http_client=get_openai_httpx_sync_client(),
)

with mlflow.start_run(run_name="simple_openai_chat") as run:
    response = client.chat.completions.create(
        model="gpt-4.1",
        messages=[
            {"role": "system", "content": "You are a helpful assistant."},
            {"role": "user", "content": "What are the main components of MLflow?"},
        ],
        temperature=0.7,
    )
    print(response.choices[0].message.content)
    print(f"Trace ID: {mlflow.get_last_active_trace_id()}")

Para los frameworks de agentes, MLflow también incluye autologging para LangChain (mlflow.langchain.autolog()) y el SDK de agentes de OpenAI. La plantilla «Nuevo rastreo» incluye ejemplos completos y ejecutables para ambos, incluidas conversaciones multiturno con uso de herramientas.

Ver trazas

Para ver trazas:

1. Abra un experimento que contenga ejecuciones de IA generativas.
2. Seleccione la pestaña Seguimientos .
3. Seleccione una traza para abrir la vista Detalle de la traza.

La vista detallada de la traza muestra:

• Árbol de spans con el desglose jerárquico de la solicitud.
• Entradas, salidas y atributos para cada intervalo.
• Pares de prompt/respuesta para segmentos de LLM (sistema, usuario, asistente).
• Latencia, uso de tokens y metadatos del modelo (nombre, versión, parámetros).
• Llamadas a herramientas y funciones con sus entradas, salidas e identificadores de documento.
• Trazas fallidas con el tipo de excepción, el mensaje y la traza de pila.

La lista de seguimiento muestra el identificador de seguimiento, la entrada, la salida, la duración, la hora de inicio y el estado (Completado, Erróneo o En ejecución). Puede filtrar los seguimientos por usuario, estado o hora de inicio.

Los seguimientos generados por una ejecución también aparecen en la página de detalles de ejecución en la pestaña Seguimientos .

Migración desde MLflow 2.x

Puede adoptar MLflow 3 de forma incremental:

• Los cuadernos existentes siguen ejecutándose sin cambios. El parámetro heredado artifact_path de log_model() todavía funciona y genera un objeto LoggedModel.
• Los nuevos cuadernos de notas deben usar el parámetro name para mayor claridad.
• Los escenarios entre áreas de trabajo usan el paquete actualizado synapseml-mlflow . Ya no es necesario anclar mlflow-skinny a 2.22.2. Para conocer los pasos de instalación, consulte Administración de modelos de MLflow en áreas de trabajo y plataformas.

Lo que aún no se admite

La evaluación de IA generativa (mlflow.genai.evaluate()) aún no está habilitada en Fabric. Está previsto para una versión futura.

Contenido relacionado

• Actualización del sistema de seguimiento del aprendizaje automático
• Experimentos de aprendizaje automático en Microsoft Fabric
• Seguimiento y administración de modelos de Machine Learning
• Registro automático en Ciencia de datos de Fabric
• Administración de modelos de MLflow en áreas de trabajo y plataformas
• Guía de migración de MLflow 3 (mlflow.org)
• Conceptos de seguimiento (mlflow.org)