MLflow 3 i Fabric Data Science

Microsoft Fabric stöder MLflow upp till version 3.1, plattformen för maskininlärning med öppen källkod. Med det här stödet kan du använda följande funktioner för att spåra och inspektera maskininlärning och generativa AI-arbetsbelastningar i Fabric:

• LoggedModel, som introducerades i MLflow 3, som en förstklassig entitet som länkar varje modell till dess källkodskörning, kod, konfiguration, parametrar, mått och datauppsättningar.
• Spårningar som samlar in frågor, svar, verktygsanrop, svarstid och tokenanvändning från llm-program (large language model) och generativa AI-program.

Den här artikeln förklarar vilka ändringar i MLflow 3, hur du använder de nya funktionerna i Fabric och hur du migrerar från MLflow 2.x.

Förutsättningar

• Skaffa en Microsoft Fabric-prenumeration. Eller registrera dig för en kostnadsfri utvärderingsversion av Microsoft Fabric.

• Logga in på Microsoft Fabric.

• Växla till Fabric med hjälp av upplevelseväxlaren längst ned till vänster på startsidan.

  

• En arbetsyta som har uppgraderats till den senaste upplevelsen för spårning av maskininlärning. Information om hur du kontrollerar berättigande och uppgradering finns i Uppgradera systemet för maskininlärningsspårning.

• mlflow version 3.0 eller senare. Fabric notebook-filer levereras med MLflow 2.x som standard, så du måste uppgradera till MLflow 3 genom att köra följande kommando i notebook-filen:

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

  Samma kommando installerar också det uppgraderade synapseml-mlflow paketet för scenarier mellan arbetsytor och utanför Fabric.

Vad är nytt i MLflow 3

MLflow 3 är bakåtkompatibel med MLflow 2.x-arbetsflöden. Befintliga experiment, körningar och notebook-filer som används mlflow>=2 fortsätter att fungera utan ändringar.

Välj en experimenttyp

När du skapar ett experiment har menyfliksområdet en växlingsknapp för experimenttyp:

• ML-experiment – klassisk spårningsyta för körningar, parametrar, mått och LoggedModels. Använd den här typen för traditionella arbetsflöden för maskininlärning.
• AI-experiment – ett gränssnitt med fokus på spårning, optimerat för generativa AI-arbetsbelastningar. Fliken Spårningar finns i mitten och körningsinformationsvyn framhäver uppmaningar, verktygsanrop och tokenanvändning.

Befintliga experiment som skapats före MLflow 3 är som standard ml-experimenttypen . Du kan när som helst byta typ i menyfliksområdet.

Börja från en notebook-mall

Två notebook-mallar levereras med versionen för att få igång dig med ett klick. När du öppnar ett experiment som inte har några körningar än visas två startkort på den tomma experimentsidan:

• Ny modellmall – ett ElasticNet-exempel från slutpunkt till slutpunkt som visar det nya LoggedModel-API:et, inklusive params=, get_logged_model()och mått som är länkade till både LoggedModel och en datauppsättning.
• Ny spårningsmall – omfattar @mlflow.trace dekoratörer, OpenAI-automatisk loggning med Fabric autentiseringsuppgifter, LangChain-agenter och OpenAI Agents SDK.

Välj ett kort för att öppna en förkonfigurerad anteckningsbok med rätt versioner av MLflow-insticksprogram och autentisering.

Logga en modell med LoggedModel

I MLflow 3 skapar varje anrop till log_model() en LoggedModel-entitet som är länkad till källkörningen, dess parametrar, mått och de datamängder som den tränades på. I följande exempel tränar du en ElasticNet-modell på Iris-datamängden, registrerar den som en LoggedModel och kopplar utvärderingsmåtten tillbaka till den LoggedModel och datamängd som används:

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

När körningen har slutförts visas modellen som en LoggedModel på två ställen:

• Avsnittet Loggade modeller på experimentsidan.
• Fliken Loggade modeller på sidan med körningsdetaljer.

Granska en LoggedModel

Välj en LoggedModel i listan för att öppna dess informationssida. Informationssidan visar:

• Parametrar och mått som samlats in för modellen.
• Källkörningslänk som navigerar till körningen som skapade modellen.
• Datauppsättningar som används under träning.
• Miljö (Python-version, beroenden, signatur).

Jämför LoggedModels

I avsnittet Loggade modeller väljer du flera LoggedModels för att jämföra dem med hjälp av inbyggda linjediagram, punktdiagram och parallella koordinater. Du kan också söka, filtrera, sortera och gruppera LoggedModels efter mått, parameter, tagg eller metadata.

Registrera en LoggedModel

Om du vill höja upp en LoggedModel till ett Fabric ML-modellobjekt öppnar du dess informationssida och väljer Registrera modell. Du kan registrera den som en ny ML-modell eller som en ny version av en befintlig modell. Efter registreringen visar informationssidan LoggedModel en länk till det registrerade modellobjektet.

Samla in generativa AI-spårningar

Spår fångar exekveringen av en LLM- eller generativ AI-applikation som en hierarki av spann. Varje spårning visar indata, utdata, svarstid, tokenanvändning och alla verktyg eller funktionsanrop. Använd typen AI experiment för en så bra spårningsfokuserad upplevelse som möjligt.

Spåra en funktion med dekoratören @mlflow.trace

Lägg till @mlflow.trace i alla funktioner för att registrera dess indata, utdata och varaktighet. Använd mlflow.update_current_trace() för att koppla taggar inifrån 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 dekorerade funktioner anropar varandra kapslar MLflow automatiskt intervallen så att du kan visualisera hela anropsträdet på spårningsinformationssidan.

Automatisk loggning av OpenAI-chattkompletteringar

Aktivera Automatisk loggning av OpenAI så att varje anrop till OpenAI-klienten spåras automatiskt, utan att dekoratörer läggs till. I följande exempel används AzureOpenAI med Fabric hanterade autentiseringsuppgifter:

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

För agentramverk skickar MLflow även automatisk loggning för LangChain (mlflow.langchain.autolog()) och OpenAI Agents SDK. Den nya spårningsmallen innehåller fullständiga, körbara exempel för dem båda, inklusive flerstegskonversationer med verktygsanrop.

Visa spårningar

Så här visar du spårningar:

1. Öppna ett experiment som innehåller generativa AI-körningar.
2. Välj fliken Spårningar .
3. Välj en spårning för att öppna vyn Spårningsinformation .

Vyn för spårningsdetaljer visar:

• Ett span-träd med hierarkisk uppdelning av begäran.
• Indata, utdata och attribut för varje spann.
• Prompt-/svarspar för LLM-spann (system, användare, assistenten).
• Svarstid, tokenanvändning och modellmetadata (namn, version, parametrar).
• Verktygs- och funktionsanrop med indata, utdata och dokument-ID:n.
• Misslyckade spårningar med undantagstyp, meddelande och stackspår.

Spårningslistan visar spårnings-ID, indata, utdata, varaktighet, starttid och status (Slutförd, Misslyckades eller Körs). Du kan filtrera spårningar efter användare, status eller starttid.

Spårningar som genereras av en körning visas också på sidan med körningsinformation under fliken Spårningar.

Migrera från MLflow 2.x

Du kan införa MLflow 3 stegvis:

• Befintliga notebook-filer fortsätter att köras oförändrade. Den äldre artifact_path parametern på log_model() fungerar fortfarande och skapar en LoggedModel.
• Nya anteckningsböcker bör använda nameparametern för tydlighetens skull.
• Scenarier mellan arbetsytor använder det uppgraderade synapseml-mlflow paketet. Du behöver inte längre fästa mlflow-skinny på 2.22.2. Installationssteg finns i Hantera MLflow-modeller över arbetsytor och plattformar.

Vad som ännu inte stöds

Generativ AI-utvärdering (mlflow.genai.evaluate()) har ännu inte aktiverats i Fabric. Det är planerat för en framtida version.

Relaterat innehåll

• Uppgradera ditt system för maskininlärningsspårning
• Maskininlärningsexperiment i Microsoft Fabric
• Spåra och hantera maskininlärningsmodeller
• Automatisk loggning i Fabric Data Science
• Hantera MLflow-modeller mellan arbetsytor och plattformar
• Migreringsguide för MLflow 3 (mlflow.org)
• Begrepp inom spårning (mlflow.org)