MLflow 3 in Fabric Data Science

Microsoft Fabric unterstützt MLflow bis einschließlich Version 3.1, die Open-Source-Plattform zur Nachverfolgung von Machine-Learning-Experimenten. Mit dieser Unterstützung können Sie die folgenden Funktionen verwenden, um maschinelles Lernen und generative KI-Workloads in Fabric nachzuverfolgen und zu prüfen:

• LoggedModel, eingeführt in MLflow 3, als erstklassige Entität, die jedes Modell mit seiner Quellausführung, Code, Konfiguration, Parameter, Metriken und Datasets verknüpft.
• Ablaufverfolgungen , die Eingabeaufforderungen, Antworten, Toolaufrufe, Latenz und Tokenverwendung aus großen Sprachmodellen (LLM) und generativen KI-Anwendungen erfassen.

In diesem Artikel werden die Änderungen in MLflow 3, die Verwendung der neuen Features in Fabric und die Migration von MLflow 2.x erläutert.

Voraussetzungen

• Erwerben Sie ein Microsoft Fabric-Abonnement. Oder registrieren Sie sich für eine kostenlose Microsoft Fabric-Testversion.

• Melden Sie sich bei Microsoft Fabric an.

• Wechseln Sie zu Fabric, indem Sie den Benutzeroberflächenschalter auf der unteren linken Seite Ihrer Startseite verwenden.

  

• Ein Arbeitsbereich, der auf die neueste Machine Learning-Tracking-Erfahrung aktualisiert wurde. Informationen zum Überprüfen der Berechtigung und des Upgrades finden Sie unter Upgrade Ihres Machine Learning-Tracking-Systems.

• mlflow Version 3.0 oder höher. Fabric-Notizbücher werden standardmäßig mit MLflow 2.x ausgeliefert, daher müssen Sie durch Ausführen des folgenden Befehls in Ihrem Notebook auf MLflow 3 aktualisieren:

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

  Derselbe Befehl installiert auch das aktualisierte synapseml-mlflow-Paket für arbeitsbereichübergreifende und externe Fabric Szenarien.

Was ändert sich in MLflow 3?

MLflow 3 ist abwärtskompatibel mit MLflow 2.x-Workflows. Vorhandene Experimente, Ausführungen und Notizbücher, die mlflow>=2 verwenden, funktionieren weiterhin ohne Änderungen.

Auswählen eines Experimenttyps

Wenn Sie ein Experiment erstellen, enthält das Menüband einen Experimenttypschalter:

• ML-Experiment – klassische Nachverfolgungsoberfläche für Ausführungen, Parameter, Metriken und LoggedModels. Verwenden Sie diesen Typ für herkömmliche maschinelle Lernworkflows.
• KI-Experiment – Oberfläche mit Fokus auf Tracing, optimiert für generative KI-Workloads. Die Registerkarte Traces steht im Mittelpunkt, und die Ausführungsdetailansicht hebt Prompts, Tool-Aufrufe und die Token-Nutzung hervor.

Vorhandene Experimente, die vor MLflow 3 erstellt wurden, werden standardmäßig auf den ML-Experimenttyp festgelegt . Sie können die Typen jederzeit über das Menüband wechseln.

Beginnen mit einer Notizbuchvorlage

Zwei Notebook-Vorlagen werden mit der Release mitgeliefert, damit Sie mit nur einem Klick loslegen können. Wenn Sie ein Experiment öffnen, das noch keine Ausführung hat, zeigt die leere Experimentseite zwei Startkarten an:

• Neue Modellvorlage – ein End-to-End-ElasticNet-Beispiel, das die neue LoggedModel-API veranschaulicht, einschließlich params=, get_logged_model()und Metriken, die sowohl mit dem LoggedModel als auch mit einem Dataset verknüpft sind.
• Neue Nachverfolgungsvorlage — umfasst @mlflow.trace Dekoratoren, die automatische Protokollierung von OpenAI mit Fabric-Anmeldeinformationen, LangChain-Agenten und das OpenAI Agents SDK.

Wählen Sie eine Karte aus, um ein vorkonfiguriertes Notizbuch mit den richtigen MLflow-Plug-In-Versionen und Authentifizierung zu öffnen.

Protokollieren eines Modells mit "LoggedModel"

In MLflow 3 erstellt jeder Aufruf von log_model() eine LoggedModel-Entität, die mit dem Quelllauf, seinen Parametern, Metriken und den Datensätzen verknüpft ist, mit denen es trainiert wurde. Im folgenden Beispiel wird ein ElasticNet-Modell für das Iris-Dataset trainiert, es als "LoggedModel" protokolliert und die Auswertungsmetriken wieder mit dem Protokollierten Modell und Dataset verknüpft:

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

Nach Abschluss des Laufs erscheint das Modell an zwei Stellen als „LoggedModel“:

• Der Abschnitt "Protokollierte Modelle " auf der Experimentseite.
• Die Registerkarte Protokollierte Modelle auf der Run-Detailseite.

Untersuchen eines LoggedModel

Wählen Sie ein "LoggedModel" aus der Liste aus, um die Detailseite zu öffnen. Die Detailseite zeigt:

• Für das Modell erfasste Parameter und Metriken .
• Link zur Quellausführung, der zu der Ausführung führt, die das Modell erzeugt hat.
• Datasets, die während der Schulung verwendet werden.
• Environment (Python Version, Abhängigkeiten, Signatur).

LoggedModels vergleichen

Wählen Sie im Abschnitt "Protokollierte Modelle" mehrere Protokollierte Modelle aus, um sie mit integrierten Liniendiagrammen, Punktdiagrammen und parallelen Koordinaten zu vergleichen. Sie können protokollierte Modelle auch nach Metrik, Parameter, Tag oder Metadaten durchsuchen, filtern, sortieren und gruppieren.

Registrieren eines "LoggedModel"

Um ein LoggedModel zu einem Fabric ML-Modellelement heraufzustufen, öffnen Sie die Detailseite, und wählen Sie Register model aus. Sie können es als neues ML-Modell oder als neue Version eines vorhandenen Modells registrieren. Nach der Registrierung zeigt die Detailseite "LoggedModel" einen Link zum registrierten Modellelement an.

Erfassen von generativen KI-Ablaufverfolgungen

Traces erfassen die Ausführung einer LLM- oder generativen KI-Anwendung in Form einer Hierarchie von Spans. Jeder Trace zeigt Eingaben, Ausgaben, Latenz, Token-Nutzung und etwaige Tool- oder Funktionsaufrufe an. Verwenden Sie den Typ KI-Experiment für eine optimale, auf Ablaufverfolgung ausgerichtete Nutzung.

Verfolge eine Funktion mit dem @mlflow.trace Decorator

Fügen Sie @mlflow.trace einer beliebigen Funktion hinzu, um ihre Eingaben, Ausgaben und Dauer aufzuzeichnen. Verwenden Sie mlflow.update_current_trace(), um innerhalb der Funktion Tags anzuhängen:

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

Wenn dekorierte Funktionen sich gegenseitig aufrufen, verschachtelt MLflow die Spans automatisch, sodass Sie den vollständigen Aufrufbaum auf der Trace-Detailseite anzeigen können.

Abschluss des Autolog OpenAI-Chats

Aktivieren Sie die automatische Protokollierung von OpenAI, sodass jeder Aufruf des OpenAI-Clients automatisch nachverfolgt wird, ohne Dekorateure hinzuzufügen. Im folgenden Beispiel werden AzureOpenAI mit Fabric-verwalteten Anmeldeinformationen verwendet:

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 Agent-Frameworks liefert MLflow auch autologging für LangChain (mlflow.langchain.autolog()) und das OpenAI Agents SDK. Die neue Trace-Vorlage enthält vollständige, ausführbare Beispiele für beides, einschließlich mehrstufiger Tool-Calling-Konversationen.

Ablaufverfolgungen anzeigen

So zeigen Sie Traces an:

1. Öffnen Sie ein Experiment, das generative KI-Läufe enthält.
2. Wählen Sie die Registerkarte Traces aus.
3. Wählen Sie einen Trace aus, um die Ansicht „Trace-Details“ zu öffnen.

Die Detailansicht der Ablaufverfolgung zeigt Folgendes:

• Eine Spannstruktur mit hierarchischer Aufschlüsselung der Anforderung.
• Eingaben, Ausgaben und Attribute für jeden Bereich.
• Prompt-/Antwort-Paare für LLM-Bereiche (System, Benutzer, Assistent).
• Latenz, Tokenverwendung und Modellmetadaten (Name, Version, Parameter).
• Tool- und Funktionsaufrufe mit ihren Eingaben, Ausgaben und Dokument-IDs.
• Fehlgeschlagene Ablaufverfolgungen mit Ausnahmetyp, Nachricht und Stapelablaufverfolgung.

Die Trace-Liste zeigt die Trace-ID, Eingabe, Ausgabe, Dauer, Startzeit und den Status (Abgeschlossen, Fehlgeschlagen oder Wird ausgeführt). Sie können Ablaufverfolgungen nach Benutzer, Status oder Startzeit filtern.

Die bei einer Ausführung erzeugten Traces werden auch auf der Detailseite der Ausführung unter der Registerkarte Traces angezeigt.

Migrieren von MLflow 2.x

Sie können MLflow 3 inkrementell übernehmen:

• Vorhandene Notizbücher werden weiterhin unverändert ausgeführt. Der veraltete Parameter artifact_path in log_model() funktioniert weiterhin und erzeugt ein LoggedModel.
• Neue Notizbücher sollten den name Parameter zur Übersichtlichkeit verwenden.
• Arbeitsbereichsübergreifende Szenarien verwenden das aktualisierte synapseml-mlflow Paket. Sie müssen mlflow-skinny nicht mehr auf 2.22.2 festlegen. Installationsschritte finden Sie unter Verwalten von MLflow-Modellen für Arbeitsbereiche und Plattformen.

Was noch nicht unterstützt wird

Die generative KI-Auswertung (mlflow.genai.evaluate()) ist in Fabric noch nicht aktiviert. Es ist für eine zukünftige Version geplant.

Verwandte Inhalte

• Aktualisieren Ihres Machine Learning-Tracking-Systems
• Experimente mit Maschinellem Lernen in Microsoft Fabric
• Nachverfolgen und Verwalten von Machine Learning-Modellen
• Autologging in Fabric Data Science
• Verwalten von MLflow-Modellen über Arbeitsbereiche und Plattformen hinweg
• MLflow 3-Migrationshandbuch (mlflow.org)
• Ablaufverfolgungskonzepte (mlflow.org)