MLflow 3 em Ciência de Dados Fabric

O Microsoft Fabric suporta o MLflow até à versão 3.1, a plataforma de rastreamento de aprendizagem automática de código aberto. Com este suporte, pode usar as seguintes capacidades para rastrear e inspecionar cargas de aprendizagem automática e IA generativa no Fabric:

• LoggedModel, introduzido no MLflow 3, como uma entidade de primeira classe que liga cada modelo à sua execução fonte, código, configuração, parâmetros, métricas e conjuntos de dados.
• Rastreios que capturam prompts, respostas, chamadas de ferramentas, latência e uso de tokens de grandes modelos de linguagem (LLM) e aplicações de IA generativa.

Este artigo explica as alterações no MLflow 3, como usar as novas funcionalidades do Fabric e como migrar do MLflow 2.x.

Pré-requisitos

• Obtenha uma assinatura do Microsoft Fabric. Ou inscreva-se para uma avaliação gratuita do Microsoft Fabric.

• Faça login no Microsoft Fabric.

• Mude para o Fabric usando o seletor de experiência no canto inferior esquerdo da sua página inicial.

  

• Um espaço de trabalho atualizado para a experiência de monitorização de aprendizagem automática mais recente. Para verificar a elegibilidade e a atualização, consulte Atualizar o seu sistema de rastreamento de machine learning.

• mlflow versão 3.0 ou posterior. Os notebooks Fabric vêm com MLflow 2.x por defeito, por isso precisas de atualizar para MLflow 3 executando o seguinte comando no teu portátil:

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

  O mesmo comando também instala o pacote atualizado synapseml-mlflow para cenários entre áreas de trabalho e fora do Fabric.

Que mudanças há no MLflow 3

O MLflow 3 é retrocompatível com os fluxos de trabalho do MLflow 2.x. As experiências, execuções e cadernos existentes que utilizam mlflow>=2 continuam a funcionar sem alterações.

Escolha um tipo de experiência

Quando cria um experimento, a fita inclui um interruptor do tipo experimento:

• Experimento de ML — interface clássica de rastreio para execuções, parâmetros, métricas e LoggedModels. Use este tipo para fluxos de trabalho tradicionais de aprendizagem automática.
• Experiência de IA — interface orientada para rastreio, otimizada para cargas de trabalho de IA generativa. O separador Rastreios está em primeiro plano, e a vista detalhada da execução enfatiza instruções, chamadas de ferramentas e a utilização de tokens.

As experiências existentes criadas antes do MLflow 3 são, por predefinição, do tipo experiência ML. Podes trocar de tipo a partir da fita a qualquer momento.

Comece a partir de um modelo de caderno

Dois modelos de blocos de notas são incluídos na versão para começar a trabalhar com um único clique. Quando abres um experimento que ainda não teve nenhuma execução, a página vazia do experimento mostra dois cartões iniciais:

• Novo modelo — um exemplo de ElasticNet de ponta a ponta que demonstra a nova API LoggedModel, incluindo params=, get_logged_model(), e métricas ligadas tanto ao LoggedModel como a um conjunto de dados.
• Novo modelo de rastreio — abrange decoradores @mlflow.trace, registo automático da OpenAI com credenciais do Fabric, agentes LangChain e o OpenAI Agents SDK.

Selecione um cartão para abrir um caderno pré-configurado com as versões corretas dos plugins MLflow e autenticação.

Registar um modelo com LlogedModel

No MLflow 3, cada chamada a log_model() cria uma entidade LoggedModel que está associada à execução de origem, aos respetivos parâmetros, métricas e aos conjuntos de dados com que foi treinada. O exemplo seguinte treina um modelo ElasticNet no conjunto de dados Iris, regista-o como um LoggedModel e associa as métricas de avaliação a esse LoggedModel e ao conjunto de dados:

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

Após a conclusão da execução, o modelo aparece como LoggedModel em dois locais:

• A secção Modelos Registados na página do experimento.
• O separador Modelos Registados na página de detalhes da corrida.

Inspecionar um Modelo Registado

Selecione um LoggedModel da lista para abrir a sua página de detalhes. A página de detalhes mostra:

• Parâmetros e métricas capturados para o modelo.
• Source run ligação que encaminha para a execução que produziu o modelo.
• Conjuntos de dados usados durante o treino.
• Ambiente (versão Python, dependências, assinatura).

Comparar modelos registados

Na secção Modelos Registados , selecione múltiplos LoggedModels para os comparar usando gráficos de linhas incorporados, gráficos de dispersão e coordenadas paralelas. Também pode pesquisar, filtrar, ordenar e agrupar LoggedModels por métrica, parâmetro, etiqueta ou metadados.

Registar LoggedModel

Para promover um LoggedModel para um item de modelo do Fabric ML, abra a sua página de detalhes e selecione Registar modelo. Pode registá-lo como um novo modelo de ML ou como uma nova versão de um modelo existente. Após o registo, a página de detalhes do LoggedModel mostra uma ligação para o item do modelo registado.

Capturar rastros de IA generativa

Os rastreios capturam a execução de um LLM ou de uma aplicação de IA generativa como uma hierarquia de intervalos. Cada traço mostra entradas, saídas, latência, utilização de tokens e quaisquer chamadas de ferramenta ou função. Utilize o tipo experiência de IA para a melhor experiência centrada nos rastreios.

Traça uma função com o @mlflow.trace decorador

Adicione @mlflow.trace a qualquer função para registar as suas entradas, saídas e duração. Use mlflow.update_current_trace() para anexar etiquetas a partir de dentro da função:

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

Quando funções decoradas se chamam entre si, o MLflow organiza automaticamente os spans de forma hierárquica, para que possa visualizar a árvore completa de chamadas na página de detalhes do trace.

Registo automático de conclusões de chat da OpenAI

Ative o registo automático da OpenAI para que todas as chamadas ao cliente da OpenAI sejam registadas automaticamente, sem necessidade de adicionar decoradores. O exemplo seguinte utiliza AzureOpenAI com credenciais geridas pelo 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 frameworks de agentes, o MLflow também disponibiliza autologging para LangChain (mlflow.langchain.autolog()) e o OpenAI Agents SDK. O novo modelo de rastreio inclui exemplos completos e executáveis de ambos, incluindo conversas com várias interações e invocação de ferramentas.

Visualizar traços

Para ver as pistas:

1. Abra um experimento que contenha execuções com IA generativa.
2. Selecione o separador Traces.
3. Selecione um rasto para abrir a vista Detalhe do rasto.

A vista detalhada do traço mostra:

• Uma árvore abrangente com decomposição hierárquica da solicitação.
• Entradas, saídas e atributos para cada intervalo.
• Pares de pedido/resposta para segmentos de LLM (sistema, utilizador, assistente).
• Latência, utilização de tokens e metadados do modelo (nome, versão, parâmetros).
• Chamadas de ferramentas e funções com as suas entradas, saídas e IDs de documentos.
• Rastreios com falha com tipo de exceção, mensagem e rastreio da pilha.

A lista de rastreios mostra o ID do traço, entrada, saída, duração, hora de início e estado (Concluído, Falhado ou Em Execução). Pode filtrar os vestígios por utilizador, estado ou hora de início.

Os traços produzidos por uma execução também aparecem na página de detalhes da execução, no separador Traços.

Migrar do MLflow 2.x

Pode adotar o MLflow 3 de forma incremental:

• Os cadernos existentes continuam a funcionar inalterados. O parâmetro legacy artifact_path em log_model() ainda funciona e produz um LoggedModel.
• Os cadernos novos devem usar o name parâmetro para maior clareza.
• Cenários entre áreas de trabalho utilizam o pacote atualizado synapseml-mlflow. Já não precisa de fixar mlflow-skinny na versão 2.22.2. Para as etapas de instalação, consulte Gerir modelos MLflow em espaços de trabalho e plataformas.

O que ainda não é suportado

A avaliação de IA generativa (mlflow.genai.evaluate()) ainda não está ativada no Fabric. Está planeado para um lançamento futuro.

Conteúdo relacionado

• Atualize o seu sistema de rastreamento de aprendizagem automática
• Experiências de aprendizagem automática em Microsoft Fabric
• Rastreie e gerencie modelos de aprendizado de máquina
• Registo automático no Fabric Data Science
• Gerir modelos MLflow em espaços de trabalho e plataformas
• Guia de migração do MLflow 3 (mlflow.org)
• Conceitos de rastreio (mlflow.org)