MLflow 3 i Fabric Data Science

Microsoft Fabric støtter MLflow opp til versjon 3.1, den åpne kildekodeplattformen for maskinlæringssporing. Med denne støtten kan du bruke følgende funksjoner for å spore og inspisere maskinlæring og generative AI-arbeidsbelastninger i Fabric:

  • LoggedModel, introdusert i MLflow 3, som en førsteklasses enhet som kobler hver modell til kildekjøring, kode, konfigurasjon, parametere, metrikker og datasett.
  • Spor som fanger opp prompts, svar, verktøykall, forsinkelse og tokenbruk fra store språkmodeller (LLM) og generative AI-applikasjoner.

Denne artikkelen forklarer hvilke endringer som skjer i MLflow 3, hvordan du bruker de nye funksjonene i Fabric, og hvordan du migrerer fra MLflow 2.x.

Animert GIF av et MLflow 3-eksperiment i Fabric, som viser fanene Runs, Models, and Traces sammen med kortene Save logged model og Compare logged models.

Forutsetninger

  • Et arbeidsområde oppgradert til den nyeste opplevelsen innen maskinlæringssporing. For å sjekke kvalifikasjon og oppgradering, se Oppgrader ditt maskinlæringssporingssystem.

  • mlflow versjon 3.0 eller nyere. Fabric-notatbøker leveres med MLflow 2.x som standard, så du må oppgradere til MLflow 3 ved å kjøre følgende kommando i notatboken din:

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

    Den samme kommandoen installerer også den oppgraderte synapseml-mlflow-pakken for scenarier på tvers av arbeidsområder og utenfor Fabric.

Hva endrer seg i MLflow 3

Område MLflow 2.x MLflow 3
Modellloggings-API log_model(model, artifact_path="model") log_model(model, name="my_model", params={...}) (arven artifact_path fungerer fortsatt)
Modellrepresentasjon Artefakt festet til en rekke Førsteklasses LoggedModel-enhet knyttet til en kjøring
Eksperimentets brukergrensesnitt Enkelt-eksperiment-visning ML-eksperiment vs AI-eksperimenttyper, pluss en seksjon for loggede modeller og en fane Traces.
Generativ AI-observabilitet Ikke tilgjengelig Spor for prompts, svar, verktøykall, forsinkelse og tokens

MLflow 3 er bakoverkompatibel med MLflow 2.x-arbeidsflyter. Eksisterende eksperimenter, kjøringer og notatbøker som brukes mlflow>=2 fortsetter å fungere uten endringer.

Velg en eksperimenttype

Når du lager et eksperiment, inkluderer båndet en eksperiment-type bryter:

  • ML-eksperiment — klassisk sporingsflate for kjøringer, parametere, metrikker og LoggedModels. Bruk denne typen for tradisjonelle maskinlæringsarbeidsflyter.
  • AI-eksperiment — sporing-først-overflate tilpasset generative AI-arbeidsbelastninger. Traces-fanen er i sentrum, og kjøredetaljvisningen legger vekt på prompts, verktøykall og tokenbruk.

Eksisterende eksperimenter laget før MLflow 3 bruker som standard ML-eksperimenttypen . Du kan bytte type fra båndet når som helst.

Skjermbilde av nedtrekksmenyen for eksperimentbånd som lar deg bytte mellom maskinlæringseksperimenter og AI-eksperimenttyper.

Start med en notatbokmal

To notatbokmaler følger med utgivelsen for å få deg til å kjøre med ett klikk. Når du åpner et eksperiment som ennå ikke har noen kjøringer, viser den tomme eksperimentsiden to startkort:

  • Ny modellmal — et ende-til-ende ElasticNet-eksempel som demonstrerer det nye LoggedModel API-et, inkludert params=, get_logged_model(), og måleparametere knyttet til både LoggedModel og et datasett.
  • Ny sporingsmal — dekker @mlflow.trace dekoratorer, OpenAI autologging med Fabric legitimasjon, LangChain-agenter og OpenAI Agents SDK.

Velg et kort for å åpne en forhåndskonfigurert notatbok med riktige MLflow-plugin-versjoner og autentisering.

Skjermbilde av den tomme eksperimentsiden med startkortene for ny modell og ny sporingsmal markert.

Logg en modell med LoggedModel

I MLflow 3 oppretter hvert kall en log_model()LoggedModel-enhet som er koblet til kildekjøringen, dens parametere, måleparametere og datasettene den ble trent på. Følgende eksempel trener en ElasticNet-modell på Iris-datasettet, logger det som en LoggedModel, og kobler evalueringsmetrikkene tilbake til den LoggedModel og datasettet:

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

Etter at kjøringen er fullført, vises modellen som en logget modell på to steder:

  • Loggede modeller-seksjonen på eksperimentsiden.
  • Fanen Loggede modeller på detaljsiden for kjøring.

Skjermbilde av en kjøredetaljside med Modeller og spor markert, som viser den lenkede LoggedModel.

Inspeksjoner en logget modell

Velg en LoggedModel fra listen for å åpne detaljsiden. Detaljsiden viser:

  • Parametere og måleparametere fanget opp for modellen.
  • Kildekjøringslenke som navigerer til kjøringen som produserte modellen.
  • Datasett brukt under opplæring.
  • Environment (Python versjon, avhengigheter, signatur).

Skjermbilde av fanen Modeller på eksperimentsiden med listen over loggede modeller markert.

Sammenlign loggedModels

I delen Loggede Modeller velger du flere LoggedModels for å sammenligne dem ved hjelp av innebygde linjediagrammer, spredningsdiagrammer og parallelle koordinater. Du kan også søke, filtrere, sortere og gruppere LoggedModels etter metrikk, parameter, tagg eller metadata.

Skjermbilde av fanen Modeller med flere loggførte modeller valgt og panelet for sammenligning av metrikk som viser linjediagrammer for RMSE, bagging_fraction og bagging_freq.

Registrer en logget modell

For å promotere en LoggedModel til et Fabric ML-modellelement, åpne detaljsiden og velg Register model. Du kan registrere den som en ny ML-modell eller som en ny versjon av en eksisterende modell. Etter registrering viser detaljsiden LoggedModel en lenke til den registrerte modellen.

Fang generative AI-spor

Traces fanger kjøringen av en LLM eller generativ AI-applikasjon som et hierarki av spenn. Hvert spor viser innganger, utganger, forsinkelse, tokenbruk og eventuelle verktøy- eller funksjonskall. Bruk AI-eksperimenttypen for best mulig traces-first opplevelse.

Spor en funksjon med dekoratøren @mlflow.trace

Legg til @mlflow.trace en hvilken som helst funksjon for å registrere innganger, utganger og varighet. Bruk mlflow.update_current_trace() for å legge til tagger fra innsiden av funksjonen:

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

Når dekorerte funksjoner kaller hverandre, nester MLflow automatisk spennene slik at du kan visualisere hele kalltreet på trace-detaljsiden.

Autolog OpenAI-chatfullføringer

Aktivere OpenAI-autologging slik at hvert kall til OpenAI-klienten spores automatisk, uten å legge til dekoratører. Følgende eksempel bruker AzureOpenAI med Fabric-administrerte legitimasjoner:

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

For agentrammeverk leverer MLflow også autologging for LangChain (mlflow.langchain.autolog()) og OpenAI Agents SDK. Den nye sporingsmalen inkluderer komplette, kjørbare eksempler for begge, inkludert fler-runders verktøyanropssamtaler.

Se spor

For å se spor:

  1. Åpne et eksperiment som inneholder generative AI-kjøringer.
  2. Velg fanen Traces .
  3. Velg et spor for å åpne Trace-detaljvisningen .

Skjermbilde av et åpnet spor som viser utførelsesdetaljer, egenskaper og sporingsdetaljer med input og output.

Visningen av sporingsdetaljene viser:

  • Et spenntre med hierarkisk oppdeling av forespørselen.
  • Innganger, utganger og attributter for hvert spenn.
  • Prompt/response-par for LLM-spenn (system, bruker, assistent).
  • Latens, tokenbruk og modellmetadata (navn, versjon, parametere).
  • Verktøy- og funksjonskall med sine input, output og dokument-ID-er.
  • Mislykkede spor med unntakstype, melding og stakkspor.

Sporingslisten viser sporings-ID, inndata, utdata, varighet, starttid og status (fullført, mislyktes eller kjører). Du kan filtrere spor etter bruker, status eller starttidspunkt.

Skjermbilde av en åpnet sporingsliste som viser sporings-ID, input, output, varighet, starttid og status.

Spor produsert av en kjøring vises også på detaljsiden under fanen Spor.

Migrer fra MLflow 2.x

Du kan ta i bruk MLflow 3 gradvis:

  • Eksisterende notatbøker fortsetter å kjøre uendret. Legacy-parameteren artifact_path på log_model() fungerer fortsatt og produserer en LoggedModel.
  • Nye notatbøker bør bruke parameteren name for klarhet.
  • Cross-workspace-scenarier bruker den oppgraderte synapseml-mlflow pakken. Du trenger ikke lenger å feste mlflow-skinny til 2.22.2. For installasjonstrinn, se Administrer MLflow-modeller på tvers av arbeidsområder og plattformer.

Hva som ennå ikke er støttet

Generativ AI-evaluering (mlflow.genai.evaluate()) er ennå ikke aktivert i Fabric. Den er planlagt for en fremtidig utgivelse.

Relatert innhold

  • Last updated on