MLflow 3 i Fabric Data Science

Microsoft Fabric understøtter MLflow op til version 3.1, den open source platform til maskinlæringssporing. Med denne support kan du bruge følgende funktioner til at spore og inspicere maskinlæring og generative AI-arbejdsbelastninger i Fabric:

  • LoggedModel, introduceret i MLflow 3, som en førsteklasses enhed, der forbinder hver model med dens kildekørsel, kode, konfiguration, parametre, metrikker og datasæt.
  • Spor, der opfanger prompts, svar, værktøjskald, latenstid og tokenbrug fra store sprogmodeller (LLM) og generative AI-applikationer.

Denne artikel forklarer, hvilke ændringer der sker i MLflow 3, hvordan man bruger de nye funktioner i Fabric, og hvordan man migrerer fra MLflow 2.x.

Animeret GIF af et MLflow 3-eksperiment i Fabric, der viser fanerne Runs, Models og Traces sammen med kortene Save logged model og Compare logged models.

Forudsætninger

  • Et arbejdsområde opgraderet til den nyeste maskinlærings-tracking-oplevelse. For at tjekke berettigelse og opgradering, se Opgrader dit maskinlæringssporingssystem.

  • mlflow version 3.0 eller nyere. Fabric-notebooks leveres som standard med MLflow 2.x, så du skal opgradere til MLflow 3 ved at køre følgende kommando i din notebook:

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

    Den samme kommando installerer også den opgraderede synapseml-mlflow-pakke til scenarier på tværs af arbejdsområder og udenfor Fabric.

Hvad ændrer sig i MLflow 3

Område MLflow 2.x MLflow 3
Model logging API log_model(model, artifact_path="model") log_model(model, name="my_model", params={...}) (arven artifact_path virker stadig)
Modelrepræsentation Artefaktet fastgjort til en række Førsteklasses LoggedModel-enhed knyttet til en kørsel
Eksperimentets brugerflade Enkelt eksperiment-visning ML-eksperiment vs. AI-eksperimenttyper, plus en sektion Loggede Modeller og en Traces-fane
Generativ AI-observabilitet Ikke tilgængelig Spor for prompts, svar, værktøjskald, latenstid og tokens

MLflow 3 er bagudkompatibelt med MLflow 2.x workflows. Eksisterende eksperimenter, kørsler og notesbøger, der bruges mlflow>=2 , fortsætter med at fungere uden ændringer.

Vælg en eksperimenttype

Når du opretter et eksperiment, indeholder båndet en eksperimenttype-kontakt:

  • ML-eksperiment — klassisk sporingsoverflade for runs, parametre, metrikker og LoggedModels. Brug denne type til traditionelle maskinlæringsarbejdsgange.
  • AI-eksperiment — spor-først overflade tunet til generative AI-arbejdsbelastninger. Traces-fanen er i centrum, og run detail-visningen lægger vægt på prompts, værktøjskald og tokenbrug.

Eksisterende eksperimenter oprettet før MLflow 3 bruger som standard ML-eksperimenttypen . Du kan skifte type fra båndet når som helst.

Skærmbillede af eksperimentbåndsdropdown-menuen, hvor du kan skifte mellem maskinlæringseksperimenter og AI-eksperimenttyper.

Start med en notesbogsskabelon

To notesbogsskabeloner følger med udgivelsen, så du kan køre med ét klik. Når du åbner et eksperiment, der endnu ikke har nogen kørsler, dukker den tomme eksperimentside to startkort op:

  • Ny modelskabelon — et end-to-end ElasticNet-eksempel, der demonstrerer det nye LoggedModel API, inklusive params=, get_logged_model(), og metrikker knyttet til både LoggedModel og et datasæt.
  • Ny sporingsskabelon dækker @mlflow.trace dekoratorer, OpenAI autolog med Fabric legitimationsoplysninger, LangChain-agenter og OpenAI Agents SDK.

Vælg et kort for at åbne en forudkonfigureret notesbog med de rigtige MLflow-plugin-versioner og autentificering.

Skærmbillede af den tomme eksperimentside med startkortene for ny model og ny trace-skabelon markeret.

Log en model med LoggedModel

I MLflow 3 opretter hvert kald til log_model() en LoggedModel-enhed , der er knyttet til kildekørslen, dens parametre, metrikker og de datasæt, den er trænet på. Følgende eksempel træner en ElasticNet-model på Iris-datasættet, logger det som en LoggedModel og kobler evalueringsmetrikkerne tilbage til den LoggedModel og datasættet:

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

Efter kørslen er fuldført, vises modellen som en LoggedModel to steder:

  • Sektionen Loggede Modeller på eksperimentsiden.
  • Fanen Loggede modeller på siden med kørselsdetaljer.

Skærmbillede af en run-detaljeside med sektionen Modeller og spor markeret, som viser den tilknyttede LoggedModel.

Inspicer en logget model

Vælg en LoggedModel fra listen for at åbne dens detaljeside. Detaljesiden viser:

  • Parametre og metrikker indfanget for modellen.
  • Kildekørselslink , der navigerer til det run, der producerede modellen.
  • Datasæt brugt under træning.
  • Environment (Python version, afhængigheder, signatur).

Skærmbillede af fanen Modeller på eksperimentsiden med listen over loggede modeller markeret.

Sammenlign LoggedModels

I afsnittet Loggede Modeller skal du vælge flere LoggedModels for at sammenligne dem ved hjælp af indbyggede linjediagrammer, spredningsdiagrammer og parallelle koordinater. Du kan også søge, filtrere, sortere og gruppere LoggedModels efter metrik, parameter, tag eller metadata.

Skærmbillede af fanen Modeller med flere loggede modeller valgt og panelet Metriksammenligning, der viser linjediagrammer for RMSE, bagging_fraction og bagging_freq.

Registrer en logget model

For at promovere en LoggedModel til et Fabric ML-modelelement, åbn dens detaljeside og vælg Register model. Du kan registrere den som en ny ML-model eller som en ny version af en eksisterende model. Efter registrering viser detaljesiden LoggedModel et link til det registrerede modelelement.

Indfang generative AI-spor

Traces fanger udførelsen af en LLM- eller generativ AI-applikation som et hierarki af spænd. Hver trace viser input, output, latenstid, tokenbrug og ethvert værktøj eller funktionskald. Brug AI-eksperimenttypen for den bedste traces-first oplevelse.

Spor en funktion med dekoratøren @mlflow.trace

Tilføj @mlflow.trace til enhver funktion for at registrere dens inputs, output og varighed. Brug mlflow.update_current_trace() til at vedhæfte tags indefra funktionen:

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 dekorerede funktioner kalder hinanden, indlejrer MLflow automatisk spændene, så du kan visualisere hele kaldstræet på trace-detaljesiden.

Autolog OpenAI chatfuldførelser

Aktivér OpenAI-autologning, så hvert kald til OpenAI-klienten spores automatisk, uden at tilføje dekoratorer. Følgende eksempel bruger AzureOpenAI med Fabric-managed credentials:

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 agent-frameworks leverer MLflow også autologning for LangChain (mlflow.langchain.autolog()) og OpenAI Agents SDK. Den nye trace-skabelon indeholder komplette, kørbare eksempler for begge, inklusive multi-turn tool-call-samtaler.

Se spor

For at se spor:

  1. Åbn et eksperiment, der indeholder generative AI-kørsler.
  2. Vælg fanen Traces .
  3. Vælg en trace for at åbne Trace-detaljevisningen .

Skærmbillede af et åbnet spor, der viser eksekveringsdetaljer, egenskaber og trace-detaljer med input og output.

Trace-detaljevisningen viser:

  • Et spantræ med hierarkisk opdeling af anmodningen.
  • Input, output og attributter for hvert spænd.
  • Prompt/respons-par for LLM spænder over (system, bruger, assistent).
  • Latenstid, tokenbrug og modelmetadata (navn, version, parametre).
  • Værktøjs- og funktionskald med deres input, output og dokument-ID'er.
  • Fejlede spor med undtagelsestype, besked og stakspor.

Sporingslisten viser trace-ID, input, output, varighed, starttid og status (Fuldført, Fejlet eller Kørende). Du kan filtrere spor efter bruger, status eller starttidspunkt.

Skærmbillede af en åbnet sporingsliste, der viser trace-ID, input, output, varighed, starttid og status.

Spor produceret af en kørsel vises også på sekvensdetaljesiden under fanen Spor.

Migrer fra MLflow 2.x

Du kan tage MLflow 3 i brug gradvist:

  • Eksisterende notebooks kører fortsat uændret. Den ældre artifact_path parameter på log_model() virker stadig og producerer en LoggedModel.
  • Nye notesbøger bør bruge parameteren name for klarhed.
  • Tværarbejdsområde-scenarier bruger den opgraderede synapseml-mlflow pakke. Du behøver ikke længere at fastgøre mlflow-skinny til 2.22.2. For installationstrin, se Administrer MLflow-modeller på tværs af arbejdsområder og platforme.

Hvad der endnu ikke er understøttet

Generativ AI-evaluering (mlflow.genai.evaluate()) er endnu ikke aktiveret i Fabric. Den er planlagt til en fremtidig udgivelse.

Relateret indhold

  • Last updated on