MLflow 3 in Fabric Data Science

Microsoft Fabric ondersteunt MLflow tot versie 3.1, het opensource-platform voor machine learning-tracering. Met deze ondersteuning kunt u de volgende mogelijkheden gebruiken om machine learning- en generatieve AI-workloads in Fabric bij te houden en te inspecteren:

• LoggedModel, geïntroduceerd in MLflow 3, als een eersteklas entiteit die elk model koppelt aan de bronuitvoering, code, configuratie, parameters, metrische gegevens en gegevenssets.
• Traceringen die prompts, antwoorden, hulpprogramma-aanroepen, latentie en tokengebruik van LLM-toepassingen (Large Language Model) en generatieve AI-toepassingen vastleggen.

In dit artikel wordt uitgelegd welke wijzigingen in MLflow 3, hoe u de nieuwe functies in Fabric gebruikt en hoe u migreert van MLflow 2.x.

Prerequisites

• Haal een Microsoft Fabric-abonnement op. Of meld u aan voor een gratis proefversie van Microsoft Fabric.

• Meld u aan bij Microsoft Fabric.

• Schakel over naar Fabric met behulp van de ervaringsschakelaar aan de linkerkant van de startpagina.

  

• Een werkruimte die is bijgewerkt naar de nieuwste machine learning-traceringservaring. Zie Uw machine learning-volgsysteem upgraden om te controleren of u in aanmerking komt en kunt upgraden.

• mlflow versie 3.0 of hoger. Fabric notebooks standaard worden verzonden met MLflow 2.x, dus u moet een upgrade uitvoeren naar MLflow 3 door de volgende opdracht uit te voeren in uw notebook:

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

  Met dezelfde opdracht installeert u ook het bijgewerkte synapseml-mlflow-pakket voor werkruimteoverschrijdende scenario's en scenario's buiten Fabric.

Welke wijzigingen in MLflow 3

MLflow 3 is achterwaarts compatibel met MLflow 2.x-werkstromen. Bestaande experimenten, runs en notebooks die mlflow>=2 gebruiken, blijven zonder wijzigingen werken.

Een experimenttype kiezen

Wanneer u een experiment maakt, bevat het lint een schakeloptie voor het experimenttype:

• ML-experiment — klassiek oppervlak voor het bijhouden van runs, parameters, metrische gegevens en LoggedModels. Gebruik dit type voor traditionele machine learning-werkstromen.
• AI experiment — platform met tracing als uitgangspunt, afgestemd op generatieve AI-werklasten. Het tabblad Traces staat centraal en de detailweergave van de run benadrukt prompts, toolaanroepen en tokengebruik.

Bestaande experimenten die zijn gemaakt voordat MLflow 3 standaard het ML-experimenttype heeft . U kunt op elk moment via het lint tussen typen wisselen.

Beginnen met een notitiebloksjabloon

Twee notebooksjablonen worden met de release meegeleverd, zodat u met één klik aan de slag kunt. Wanneer u een experiment opent dat nog geen uitvoeringen heeft, worden op de lege experimentpagina twee starterskaarten weergegeven:

• Nieuwe modelsjabloon : een end-to-end ElasticNet-voorbeeld dat de nieuwe LoggedModel-API demonstreert, inclusief params=, get_logged_model()en metrische gegevens die zijn gekoppeld aan zowel het LoggedModel als een gegevensset.
• Nieuwe traceringssjabloon — behandelt @mlflow.trace decorators, OpenAI-autologging met Fabric-referenties, LangChain-agents en de OpenAI Agents SDK.

Selecteer een kaart om een vooraf geconfigureerd notebook te openen met de juiste versies en verificatie van de MLflow-invoegtoepassing.

Een model registreren met LoggedModel

In MLflow 3 maakt elke aanroep van log_model() een LoggedModel-entiteit aan die gekoppeld is aan de bronrun, de parameters, metingen en de datasets waarop deze is getraind. In het volgende voorbeeld wordt een ElasticNet-model getraind op de Iris-gegevensset, vastgelegd als een LoggedModel en worden de metrische evaluatiegegevens gekoppeld aan dat LoggedModel en de gegevensset:

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

Nadat de uitvoering is voltooid, wordt het model weergegeven als een LoggedModel op twee plaatsen:

• De sectie Geregistreerde modellen op de experimentpagina.
• Het tabblad Geregistreerde modellen op de detailpagina van de run.

Een LoggedModel inspecteren

Selecteer een LoggedModel in de lijst om de detailpagina te openen. Op de detailpagina ziet u:

• Parameters en metrische gegevens die zijn vastgelegd voor het model.
• Link naar bronrun die naar de run gaat waarmee het model is geproduceerd.
• Gegevenssets die tijdens de training worden gebruikt.
• Omgeving (Python versie, afhankelijkheden, handtekening).

LoggedModels vergelijken

Selecteer in de sectie Vastgelegde modellen meerdere LoggedModels om ze te vergelijken met behulp van ingebouwde lijndiagrammen, spreidingsdiagrammen en parallelle coördinaten. U kunt ook zoeken, filteren, sorteren en LoggedModels groeperen op metrische waarde, parameter, tag of metagegevens.

Een LoggedModel registreren

Als u een LoggedModel wilt promoveren naar een Fabric ML-modelitem, opent u de detailpagina en selecteert u Model registreren. U kunt het registreren als een nieuw ML-model of als een nieuwe versie van een bestaand model. Na de registratie toont de detailpagina van LoggedModel een koppeling naar het geregistreerde modelitem.

Generatieve AI-sporen vastleggen

Traceringen leggen vast hoe een LLM- of generatieve AI-toepassing wordt uitgevoerd, in de vorm van een hiërarchie van segmenten. Elke trace toont invoer, uitvoer, latentie, tokengebruik en elk hulpprogramma of functie-aanroepen. Gebruik het AI-experiment-type voor de beste traces-first ervaring.

Een functie traceren met de @mlflow.trace decorator

Voeg @mlflow.trace toe aan een functie om de invoer, uitvoer en duur vast te leggen. Gebruik mlflow.update_current_trace() om tags toe te voegen vanuit de functie:

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

Wanneer gedecoreerde functies elkaar aanroepen, nestelt MLflow automatisch de spans, zodat u de volledige aanroepstructuur kunt visualiseren op de detailpagina van de trace.

Automatisch loggen van OpenAI-chataanvullingen

Schakel automatische logging van OpenAI in, zodat elke aanroep aan de OpenAI-client automatisch wordt getraceerd, zonder decorators toe te voegen. In het volgende voorbeeld wordt AzureOpenAI gebruikt met door Fabric beheerde aanmeldingsgegevens:

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

Voor agentframeworks biedt MLflow ook autologging voor LangChain (mlflow.langchain.autolog()) en de OpenAI Agents SDK. De sjabloon 'Nieuwe trace' bevat volledige, uitvoerbare voorbeelden voor beide, inclusief gesprekken met meerdere beurten waarin tools worden aangeroepen.

Traceringen weergeven

Traceringen weergeven:

1. Open een experiment dat generatieve AI-runs bevat.
2. Selecteer het tabblad Traces.
3. Selecteer een trace om de weergave Tracedetails te openen.

In de detailweergave van de trace ziet u:

• Een spanstructuur met hiërarchische uitsplitsing van de aanvraag.
• Invoer, uitvoer en kenmerken voor elke periode.
• Prompt-antwoordparen voor LLM-segmenten (systeem, gebruiker, assistent).
• Latentie, tokengebruik en modelmetagegevens (naam, versie, parameters).
• Hulpprogramma- en functie-aanroepen met hun invoer, uitvoer en document-id's.
• Mislukte traceringen met uitzonderingstype, bericht en stacktracering.

De traceringslijst bevat tracerings-id, invoer, uitvoer, duur, begintijd en status (Voltooid, Mislukt of Actief). U kunt traceringen filteren op gebruiker, status of begintijd.

Traces die door een run worden gegenereerd, worden ook weergegeven op de detailpagina van de run onder het tabblad Traces.

Migreren van MLflow 2.x

U kunt MLflow 3 incrementeel gebruiken:

• Bestaande notebooks blijven ongewijzigd werken. De verouderde parameter artifact_path op log_model() werkt nog steeds en levert een LoggedModel op.
• Nieuwe notebooks moeten de name parameter voor duidelijkheid gebruiken.
• Scenario's voor meerdere werkruimten maken gebruik van het bijgewerkte synapseml-mlflow pakket. U hoeft mlflow-skinny niet meer vast te zetten op 2.22.2. Zie MLflow-modellen beheren in werkruimten en platforms voor installatiestappen.

Wat nog niet wordt ondersteund

Generatieve AI-evaluatie (mlflow.genai.evaluate()) is nog niet ingeschakeld in Fabric. Het is gepland voor een toekomstige release.

Verwante inhoud

• Uw machine learning-traceringssysteem upgraden
• Machine learning-experimenten in Microsoft Fabric
• Machine Learning-modellen bijhouden en beheren
• Autologging in Fabric Data Science
• MLflow-modellen beheren in werkruimten en platforms
• Migratiehandleiding voor MLflow 3 (mlflow.org)
• Concepten van traceren (mlflow.org)