MLflow 3 w Fabric Data Science

Microsoft Fabric obsługuje MLflow do wersji 3.1, platformę open source do śledzenia uczenia maszynowego. Dzięki tej obsłudze można użyć następujących funkcji do śledzenia i sprawdzania obciążeń uczenia maszynowego i generowania sztucznej inteligencji w Fabric:

• LoggedModel, wprowadzony w usłudze MLflow 3, jako jednostka pierwszej klasy, która łączy każdy model z jego uruchomieniem źródłowym, kodem, konfiguracją, parametrami, metrykami i zestawami danych.
• Ślady, które rejestrują prompty, odpowiedzi, wywołania narzędzi, opóźnienia i wykorzystanie tokenów w aplikacjach opartych na dużych modelach językowych (LLM) i generatywnej sztucznej inteligencji.

W tym artykule wyjaśniono, jakie zmiany w środowisku MLflow 3, jak używać nowych funkcji w Fabric oraz jak przeprowadzić migrację z platformy MLflow 2.x.

Prerequisites

• Uzyskaj subskrypcję usługi Microsoft Fabric. Możesz też utworzyć konto bezpłatnej wersji próbnej usługi Microsoft Fabric.

• Zaloguj się do Microsoft Fabric.

• Przełącz na Fabric, używając przełącznika doświadczenia w dolnym lewym rogu twojej strony głównej.

  

• Obszar roboczy uaktualniony do najnowszego środowiska śledzenia uczenia maszynowego. Aby sprawdzić, czy się kwalifikujesz, i przeprowadzić aktualizację, zobacz Zaktualizuj system śledzenia uczenia maszynowego.

• mlflow wersja 3.0 lub nowsza. Notesy Fabric domyślnie zawierają bibliotekę MLflow 2.x, dlatego należy zaktualizować MLflow do wersji 3, uruchamiając w swoim notesie następujące polecenie:

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

  To samo polecenie instaluje również zaktualizowany pakiet synapseml-mlflow dla scenariuszy obejmujących wiele obszarów roboczych i poza środowiskiem Fabric.

Jakie zmiany w środowisku MLflow 3

MLflow 3 jest wstecznie zgodny z przepływami pracy MLflow 2.x. Istniejące eksperymenty, przebiegi i notatniki korzystające z mlflow>=2 nadal będą działać bez zmian.

Wybieranie typu eksperymentu

Podczas tworzenia eksperymentu wstążka zawiera przełącznik typu eksperymentu:

• Eksperyment uczenia maszynowego — klasyczna powierzchnia śledzenia przebiegów, parametrów, metryk i zarejestrowanych modeli. Tego typu należy używać w przypadku tradycyjnych przepływów pracy uczenia maszynowego.
• Eksperyment AI — interfejs zorientowany przede wszystkim na śledzenie, dostosowany do obciążeń generatywnej AI. Karta Ślady znajduje się na pierwszym planie, a widok szczegółów przebiegu eksponuje prompty, wywołania narzędzi i wykorzystanie tokenów.

Istniejące eksperymenty utworzone przed MLflow 3 są domyślnie typu eksperyment ML. Możesz w dowolnym momencie zmienić typ na wstążce.

Rozpoczynanie od szablonu notesu

Dwa szablony notatników są dołączone do tej wersji, aby umożliwić szybkie rozpoczęcie pracy jednym kliknięciem. Po otwarciu eksperymentu, który nie ma jeszcze żadnych uruchomień, pusta strona eksperymentu wyświetla dwie karty startowe:

• Nowy szablon modelu — kompleksowa aplikacja ElasticNet, która demonstruje nowy interfejs API LoggedModel, w tym params=get_logged_model(), i metryki połączone zarówno z modelem LoggedModel, jak i zestawem danych.
• Nowy szablon śledzenia — obejmuje @mlflow.trace dekoratory, automatyczne logowanie OpenAI z poświadczeniami Fabric, agentów LangChain oraz pakiet SDK OpenAI Agents.

Wybierz kartę, aby otworzyć wstępnie skonfigurowany notebook z odpowiednimi wersjami wtyczek MLflow i skonfigurowanym uwierzytelnianiem.

Rejestrowanie modelu przy użyciu usługi LoggedModel

W MLflow 3 każde wywołanie log_model() tworzy encję LoggedModel, która jest połączona z uruchomieniem źródłowym, jego parametrami, metrykami i zbiorami danych, na których model został wytrenowany. W poniższym przykładzie model ElasticNet jest trenowany w zestawie danych Iris, rejestruje go jako element LoggedModel i łączy metryki oceny z powrotem z tym elementem LoggedModel i zestawem danych:

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

Po zakończeniu uruchomienia model pojawia się jako LoggedModel w dwóch miejscach:

• Sekcja Zarejestrowane modele na stronie eksperymentu.
• Zakładka Zarejestrowane modele na stronie szczegółów uruchomienia.

Inspekcja modelu LoggedModel

Wybierz model LoggedModel z listy, aby otworzyć stronę szczegółów. Na stronie szczegółów widoczne są:

• Parametry i metryki przechwycone dla modelu.
• Łącze do przebiegu źródłowego, prowadzące do przebiegu, w ramach którego utworzono model.
• Zestawy danych używane podczas trenowania.
• Environment (wersja Python, zależności, podpis).

Porównaj LoggedModels

W sekcji Zarejestrowane modele wybierz wiele zarejestrowanych modeli , aby porównać je przy użyciu wbudowanych wykresów liniowych, wykresów punktowych i współrzędnych równoległych. Można również wyszukiwać, filtrować, sortować i grupować zarejestrowanemodely według metryk, parametru, tagu lub metadanych.

Zarejestruj LoggedModel

Aby przekształcić model LoggedModel w element modelu ML w usłudze Fabric, otwórz stronę szczegółów i wybierz opcję Register model. Możesz zarejestrować go jako nowy model uczenia maszynowego lub nową wersję istniejącego modelu. Po rejestracji na stronie szczegółów LoggedModel zostanie wyświetlony link do zarejestrowanego elementu modelu.

Przechwytywanie śledzenia generowania sztucznej inteligencji

Ślady przechwytują wykonywanie aplikacji LLM lub generującej sztuczną inteligencję jako hierarchię zakresów. Każdy ślad pokazuje dane wejściowe, dane wyjściowe, opóźnienie, użycie tokenu oraz dowolne wywołania narzędzia lub funkcji. Użyj typu Eksperyment AI, aby uzyskać najlepszą obsługę z podejściem traces-first.

Śledź funkcję przy użyciu dekoratora @mlflow.trace

Dodaj @mlflow.trace do dowolnej funkcji, aby zarejestrować swoje dane wejściowe, dane wyjściowe i czas trwania. Użyj polecenia mlflow.update_current_trace() , aby dołączyć tagi z poziomu funkcji:

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

Po wywołaniu funkcji dekorowanych narzędzie MLflow automatycznie zagnieżdża zakresy, dzięki czemu można wizualizować pełne drzewo wywołań na stronie szczegółów śledzenia.

Automatyczne rejestrowanie uzupełnień czatu OpenAI

Włącz automatyczne rejestrowanie openAI, aby każde wywołanie klienta OpenAI było śledzone automatycznie bez dodawania dekoratorów. W poniższym przykładzie użyto AzureOpenAI z poświadczeniami zarządzanymi Fabric:

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

W przypadku frameworków agentowych MLflow oferuje także automatyczne rejestrowanie dla LangChain (mlflow.langchain.autolog()) i SDK agentów OpenAI. Szablon Nowy ślad zawiera kompletne, możliwe do uruchomienia przykłady dla obu tych elementów, w tym konwersacje z wieloma narzędziami.

Wyświetlanie śladów

Aby wyświetlić ślady:

1. Otwórz eksperyment zawierający uruchomienia generatywnej AI.
2. Wybierz kartę Ślady .
3. Wybierz ślad, aby otworzyć widok Szczegóły śladu.

Widok szczegółów śladu pokazuje:

• Drzewo rozpiętości z hierarchicznym podziałem żądania.
• Dane wejściowe, dane wyjściowe i atrybuty dla każdego zakresu.
• Pary promptów i odpowiedzi dla segmentów LLM (system, użytkownik, asystent).
• Opóźnienie, użycie tokenu i metadane modelu (nazwa, wersja, parametry).
• Wywołania narzędzi i funkcji z ich danymi wejściowymi, wyjściowymi i identyfikatorami dokumentów.
• Nieudane ślady z typem wyjątku, komunikatem i śladem stosu.

Lista śledzenia zawiera identyfikator śledzenia, dane wejściowe, dane wyjściowe, czas trwania, czas rozpoczęcia i stan (Ukończono, Niepowodzenie lub Uruchomione). Możesz filtrować ślady według użytkownika, stanu lub godziny rozpoczęcia.

Ślady generowane przez przebieg są również wyświetlane na stronie szczegółów przebiegu na karcie Ślady .

Migracja z MLflow 2.x

Aplikację MLflow 3 można wdrożyć przyrostowo:

• Istniejące notatniki nadal działają bez zmian. Dotychczasowy parametr artifact_path w log_model() nadal działa i zwraca obiekt LoggedModel.
• Nowe notatniki powinny używać parametru name dla zachowania przejrzystości.
• Scenariusze między obszarami roboczymi używają uaktualnionego synapseml-mlflow pakietu. Nie trzeba już przypinać mlflow-skinny do wersji 2.22.2. Aby uzyskać instrukcje instalacji, zobacz Zarządzanie modelami MLflow w obszarach roboczych i platformach.

Co nie jest jeszcze obsługiwane

Ocena generatywnej sztucznej inteligencji (mlflow.genai.evaluate()) nie jest jeszcze włączona w Fabric. Planowane jest wydanie w przyszłości.

Treści powiązane

• Uaktualnianie systemu śledzenia uczenia maszynowego
• Eksperymenty uczenia maszynowego w Microsoft Fabric
• śledzenie modeli uczenia maszynowego i zarządzanie nimi
• Automatyczne rejestrowanie w usłudze Fabric Data Science
• Zarządzanie modelami MLflow w obszarach roboczych i platformach
• Przewodnik migracji platformy MLflow 3 (mlflow.org)
• Pojęcia związane ze śledzeniem (mlflow.org)