MLflow 3 in Data Science di Fabric

Microsoft Fabric supporta MLflow fino alla versione 3.1, la piattaforma di rilevamento di Machine Learning open source. Con questo supporto, è possibile usare le funzionalità seguenti per tenere traccia e esaminare i carichi di lavoro di intelligenza artificiale generati e di Machine Learning in Fabric:

• LoggedModel, introdotto in MLflow 3, come entità di prima classe che collega ogni modello all'esecuzione di origine, al codice, alla configurazione, ai parametri, alle metriche e ai set di dati.
• Tracce che acquisisce richieste, risposte, chiamate agli strumenti, latenza e utilizzo dei token da applicazioni LLM (Large Language Model) e generative per intelligenza artificiale.

Questo articolo illustra le modifiche apportate a MLflow 3, come usare le nuove funzionalità in Fabric e come eseguire la migrazione da MLflow 2.x.

Prerequisiti

• Ottieni un abbonamento a Microsoft Fabric. Oppure, registrati per una versione di prova gratuita di Microsoft Fabric.

• Accedi a Microsoft Fabric.

• Passare a Fabric usando il selettore di esperienza nell'angolo in basso a sinistra della home page.

  

• Un'area di lavoro aggiornata all'esperienza di rilevamento di Machine Learning più recente. Per verificare l'idoneità e l'aggiornamento, vedere Aggiornare il sistema di rilevamento di Machine Learning.

• mlflow versione 3.0 o successiva. I notebook di Fabric vengono forniti con MLflow 2.x per impostazione predefinita, quindi è necessario eseguire l'aggiornamento a MLflow 3 eseguendo il comando seguente nel notebook:

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

  Lo stesso comando installa anche il pacchetto synapseml-mlflow aggiornato per scenari tra più aree di lavoro ed esterni a Fabric.

Cosa cambia in MLflow 3

MLflow 3 è retrocompatibile con i flussi di lavoro di MLflow 2.x. Esperimenti, esecuzioni e notebook esistenti che usano mlflow>=2 continuano a funzionare senza modifiche.

Scegliere un tipo di esperimento

Quando si crea un esperimento, la barra multifunzione comprende un selettore del tipo di esperimento:

• Esperimento ml : superficie di rilevamento classica per esecuzioni, parametri, metriche e LoggedModels. Usare questo tipo per i flussi di lavoro di Machine Learning tradizionali.
• Esperimento di IA — interfaccia incentrata sul tracciamento ottimizzata per i carichi di lavoro di IA generativa. La scheda Tracce è in primo piano e la vista dei dettagli dell’esecuzione mette in risalto i prompt, le chiamate agli strumenti e l’utilizzo dei token.

Gli esperimenti esistenti creati prima di MLflow 3 sono di tipo esperimento ML per impostazione predefinita. È possibile cambiare i tipi dalla barra multifunzione in qualsiasi momento.

Iniziare da un modello di notebook

Due template di notebook sono inclusi nella release per consentirti di iniziare con un solo clic. Quando si apre un esperimento che non ha ancora esecuzioni, la pagina dell'esperimento vuota presenta due schede di avvio:

• Nuovo template di modello — un esempio end-to-end di ElasticNet che illustra la nuova API LoggedModel, inclusi params=, get_logged_model() e le metriche collegate sia al LoggedModel sia a un dataset.
• Nuovo modello di traccia — copre @mlflow.trace decoratori, OpenAI autologging con credenziali Fabric, gli agenti LangChain e l’SDK di OpenAI Agents.

Selezionare una scheda per aprire un notebook preconfigurato con le versioni corrette del plug-in MLflow e l'autenticazione.

Registrare un modello con LoggedModel

In MLflow 3 ogni chiamata a log_model() crea un'entità LoggedModel collegata all'esecuzione di origine, ai relativi parametri, metriche e ai set di dati su cui è stato eseguito il training. L'esempio seguente esegue il training di un modello ElasticNet nel set di dati Iris, lo registra come LoggedModel e collega le metriche di valutazione a tale LoggedModel e al set di dati:

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

Al termine dell'esecuzione, il modello viene visualizzato come LoggedModel in due posizioni:

• Sezione Modelli registrati nella pagina dell'esperimento.
• La scheda Modelli registrati nella pagina dei dettagli dell'esecuzione.

Ispezionare un LoggedModel

Selezionare un oggetto LoggedModel dall'elenco per aprire la relativa pagina dei dettagli. La pagina dei dettagli mostra:

• Parametri e metriche acquisiti per il modello.
• Collegamento al run di origine che porta al run che ha prodotto il modello.
• Set di dati usati durante il training.
• Environment (versione Python, dipendenze, firma).

Confrontare LoggedModels

Nella sezione Modelli registrati selezionare più LoggedModels per confrontarli usando grafici a linee predefiniti, grafici a dispersione e coordinate parallele. È anche possibile cercare, filtrare, ordinare e raggruppare LoggedModels per metrica, parametro, tag o metadati.

Registrare un oggetto LoggedModel

Per alzare di livello LoggedModel a un elemento del modello di Machine Learning Fabric, aprire la pagina dei dettagli e selezionare Modello di registrazione. È possibile registrarlo come nuovo modello di Machine Learning o come nuova versione di un modello esistente. Dopo la registrazione, nella pagina dei dettagli LoggedModel viene visualizzato un collegamento all'elemento del modello registrato.

Cattura tracce di IA generativa

Le tracce catturano l'esecuzione di un'applicazione basata su LLM o di IA generativa come una gerarchia di span. Ogni traccia mostra input, output, latenza, utilizzo dei token e qualsiasi chiamata di strumento o funzione. Usa il tipo esperimento di IA per un'esperienza ottimale incentrata sulle tracce.

Monitorare una funzione con il decoratore @mlflow.trace

Aggiungere @mlflow.trace a qualsiasi funzione per registrare gli input, gli output e la durata. Usare mlflow.update_current_trace() per allegare tag dall'interno della funzione:

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 le funzioni decorate si chiamano tra loro, MLflow annida automaticamente gli intervalli in modo da poter visualizzare l'albero delle chiamate completo nella pagina dei dettagli della traccia.

Registrazione automatica dei completamenti della chat OpenAI

Abilita l'autologging di OpenAI in modo che ogni chiamata al client OpenAI venga tracciata automaticamente, senza aggiungere decoratori. L'esempio seguente usa AzureOpenAI con credenziali gestite da 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()}")

Per i framework per agenti, MLflow include anche il logging automatico per LangChain (mlflow.langchain.autolog()) e l'OpenAI Agents SDK. Il nuovo modello di traccia include esempi completi ed eseguibili per entrambi, comprese conversazioni multi-turno con invocazione di strumenti.

Visualizzare le tracce

Per visualizzare le tracce:

1. Aprire un esperimento che contiene esecuzioni generative di intelligenza artificiale.
2. Selezionare la scheda Tracce .
3. Selezionare una traccia per aprire la visualizzazione Dettagli traccia .

La visualizzazione dei dettagli di traccia mostra:

• Albero span con suddivisione gerarchica della richiesta.
• Input, output e attributi per ogni segmento.
• Coppie di richieste/risposte per intervalli LLM (sistema, utente, assistente).
• Latenza, utilizzo dei token e metadati del modello (nome, versione, parametri).
• Chiamate di strumenti e funzioni con i relativi input, output e ID dei documenti.
• Tracce non riuscite con tipo di eccezione, messaggio e traccia dello stack.

L'elenco di traccia mostra l'ID traccia, l'input, l'output, la durata, l'ora di inizio e lo stato (Completato, Non riuscito o In esecuzione). È possibile filtrare le tracce in base all'utente, allo stato o all'ora di inizio.

Le tracce generate da un'esecuzione vengono visualizzate anche nella pagina dei dettagli dell'esecuzione nella scheda Tracce .

Eseguire la migrazione da MLflow 2.x

È possibile adottare MLflow 3 in modo incrementale:

• I notebook esistenti continuano a funzionare senza modifiche. Il parametro legacy artifact_path in log_model() funziona ancora e produce un oggetto LoggedModel.
• I nuovi notebook devono usare il name parametro per maggiore chiarezza.
• Gli scenari tra aree di lavoro usano il pacchetto aggiornato synapseml-mlflow . Non è più necessario aggiungere mlflow-skinny alla versione 2.22.2. Per la procedura di installazione, vedere Gestire i modelli MLflow tra aree di lavoro e piattaforme.

Elementi non ancora supportati

La valutazione generativa dell'intelligenza artificiale (mlflow.genai.evaluate()) non è ancora abilitata in Fabric. È prevista per una versione futura.

Contenuti correlati

• Aggiornare il sistema di rilevamento di Machine Learning
• Esperimenti di apprendimento automatico in Microsoft Fabric
• Monitorare e gestire i modelli di apprendimento automatico
• Registrazione automatica in Data Science di Fabric
• Gestire i modelli MLflow tra aree di lavoro e piattaforme
• Guida alla migrazione di MLflow 3 (mlflow.org)
• Concetti di tracciamento (mlflow.org)