MLflow 3 dans Data Science de Fabric

Microsoft Fabric prend en charge MLflow jusqu’à la version 3.1, la plateforme de suivi machine learning open source. Avec cette prise en charge, vous pouvez utiliser les fonctionnalités suivantes pour effectuer le suivi et l’inspection des charges de travail machine learning et d’IA génératives dans Fabric :

LoggedModel, introduit dans MLflow 3, en tant qu’entité de première classe qui lie chaque modèle à son exécution source, code, configuration, paramètres, métriques et jeux de données.
Traces qui capturent les invites, les réponses, les appels d’outils, la latence et l’utilisation des jetons à partir de grands modèles de langage (LLM) et d’applications IA génératives.

Cet article explique les modifications apportées à MLflow 3, comment utiliser les nouvelles fonctionnalités de Fabric et comment migrer à partir de MLflow 2.x.

Prerequisites

Obtenez un abonnement Microsoft Fabric. Ou, inscrivez-vous pour un essai gratuit de Microsoft Fabric.
Connectez-vous à Microsoft Fabric.
Basculez vers Fabric à l’aide du sélecteur d’expérience situé en bas à gauche de votre page d’accueil.

Un espace de travail mis à niveau vers la plus récente expérience de suivi de l’apprentissage automatique. Pour vérifier l’éligibilité et la mise à niveau, consultez Mettre à niveau votre système de suivi machine learning.
mlflow version 3.0 ou ultérieure. Fabric notebooks sont fournis avec MLflow 2.x par défaut. Vous devez donc effectuer une mise à niveau vers MLflow 3 en exécutant la commande suivante dans votre bloc-notes :
```
%pip install "synapseml-mlflow[online-notebook]>=2.0.3" "mlflow-skinny==3.1.0" "opentelemetry-api<=1.40.0"
```
La même commande installe également le package mis à niveau synapseml-mlflow pour les scénarios inter-espaces de travail et en dehors de Fabric.

Modifications apportées à MLflow 3

Area	MLflow 2.x	MLflow 3
API de journalisation des modèles	`log_model(model, artifact_path="model")`	`log_model(model, name="my_model", params={...})` (l’héritage `artifact_path` fonctionne toujours)
Représentation du modèle	Artefact joint à une exécution	Entité LoggedModel de première classe liée à une exécution
Interface utilisateur d’expérimentation	Vue d’expérience unique	Expérience ML et types d’expériences IA, ainsi qu’une section Modèles consignés et un onglet Traces
Observabilité de l’IA générative	Non disponible	Traces des prompts, réponses, appels d’outils, latence et jetons

MLflow 3 est rétrocompatible avec les workflows MLflow 2.x. Les expériences existantes, les exécutions et les notebooks qui utilisent mlflow>=2 continuent de fonctionner sans modification.

Choisir un type d’expérience

Lorsque vous créez une expérience, le ruban inclut un commutateur de type expérience :

Expérience ML : surface de suivi classique pour les exécutions, les paramètres, les métriques et les LoggedModels. Utilisez ce type pour les flux de travail machine learning traditionnels.
Expérience IA : surface de traçage d’abord paramétrée pour les charges de travail IA génératives. L’onglet Traces est mis en avant, et la vue détaillée de l’exécution met l’accent sur les prompts, les appels aux outils et l’utilisation des tokens.

Les expériences existantes créées avant MLflow 3 sont, par défaut, du type expérience ML. Vous pouvez changer de type à partir du ruban à tout moment.

Démarrer à partir d’un modèle de notebook

Deux modèles de notebooks sont inclus avec cette version pour vous permettre de démarrer en un clic. Lorsque vous ouvrez une expérience qui n’a pas encore d’exécution, la page d’expérience vide affiche deux cartes de démarrage :

Nouveau modèle de modèle : exemple ElasticNet de bout en bout qui illustre la nouvelle API LoggedModel, y compris params=, get_logged_model()et les métriques liées à LoggedModel et à un jeu de données.
Nouveau modèle de trace — couvre les décorateurs @mlflow.trace, la journalisation automatique OpenAI avec des identifiants Fabric, les agents LangChain et le SDK OpenAI Agents.

Sélectionnez une carte pour ouvrir un notebook préconfiguré avec les versions de plug-in MLflow appropriées et l’authentification.

Journaliser un modèle avec LoggedModel

Dans MLflow 3, chaque appel à log_model() crée une entité LoggedModel qui est liée à l’exécution source, à ses paramètres, à ses métriques et aux jeux de données sur lesquels il a été entraîné. L’exemple suivant entraîne un modèle ElasticNet sur le jeu de données Iris, le journalise en tant que LoggedModel et lie les métriques d’évaluation à ce LoggedModel et à ce jeu de données :

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

Une fois l’exécution terminée, le modèle apparaît en tant que LoggedModel à deux emplacements :

Section Modèles consignés sur la page d’expérience.
Onglet Modèles consignés sur la page de détails de l’exécution.

Inspecter un LoggedModel

Sélectionnez un LoggedModel dans la liste pour ouvrir sa page de détails. La page de détails montre :

Paramètres et métriques capturés pour le modèle.
Lien d’exécution source qui accède à l’exécution qui a produit le modèle.
Jeux de données utilisés pendant l’entraînement.
Environnement (Python version, dépendances, signature).

Comparer les modèles journalisés

Dans la section Modèles journalisés , sélectionnez plusieurs LoggedModels pour les comparer à l’aide de graphiques en courbes intégrés, de nuages de points et de coordonnées parallèles. Vous pouvez également rechercher, filtrer, trier et regrouper LoggedModels par métrique, paramètre, balise ou métadonnées.

$Capture d’écran de l’onglet Modèles avec plusieurs modèles journalisés sélectionnés et le panneau de comparaison des métriques montrant les graphiques en courbes pour RMSE, bagging_fraction et bagging_freq.$

Enregistrer un LoggedModel

Pour promouvoir un LoggedModel vers un élément de modèle ML Fabric, ouvrez sa page de détails et sélectionnez Inscrire le modèle. Vous pouvez l’inscrire en tant que nouveau modèle ML ou en tant que nouvelle version d’un modèle existant. Après l’inscription, la page de détails LoggedModel affiche un lien vers l’élément de modèle inscrit.

Capturer des traces d’IA générative

Les traces permettent de suivre l’exécution d’une application fondée sur un LLM ou sur l’IA générative sous la forme d’une hiérarchie de spans. Chaque trace affiche les entrées, les sorties, la latence, l’utilisation des jetons et tous les appels d’outil ou de fonction. Utilisez le type d’expérience d’IA pour une expérience « traces first » optimale.

Tracer une fonction avec le `@mlflow.trace` décorateur

Ajoutez @mlflow.trace à n’importe quelle fonction pour enregistrer ses entrées, sorties et durée. Permet mlflow.update_current_trace() d’attacher des balises à partir de l’intérieur de la fonction :

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

Lorsque des fonctions décorées s’appellent entre elles, MLflow imbrique automatiquement les spans afin que vous puissiez visualiser l’arborescence complète des appels sur la page de détails de la trace.

Journalisation automatique des complétions de chat OpenAI

Activez l’autologging OpenAI pour que chaque appel au client OpenAI soit suivi automatiquement, sans ajouter de décorateurs. L’exemple suivant utilise AzureOpenAI des informations d’identification gérées par 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()}")

Pour les frameworks d’agents, MLflow fournit également la journalisation automatique pour LangChain (mlflow.langchain.autolog()) et le SDK OpenAI Agents. Le nouveau modèle de trace inclut des exemples complets et exécutables pour les deux, y compris les conversations d’appel d’outils à plusieurs tours.

Afficher les traces

Pour afficher les traces :

Ouvrez une expérience qui contient des exécutions d’IA générative.
Sélectionnez l’onglet Traces .
Sélectionnez une trace pour ouvrir l’affichage des détails de la trace.

L’affichage des détails de la trace affiche les éléments suivants :

Arborescence de spans montrant la décomposition hiérarchique de la requête.
Entrées, sorties et attributs pour chaque étendue.
Paires prompt/réponse pour les spans LLM (système, utilisateur, assistant).
Latence, utilisation des jetons et métadonnées de modèle (nom, version, paramètres).
Appels d’outils et de fonctions avec leurs entrées, sorties et ID de document.
Traces ayant échoué avec le type d’exception, le message et la trace de pile.

La liste de trace affiche l’ID de trace, l’entrée, la sortie, la durée, l’heure de début et l’état (Terminé, Échec ou Exécution). Vous pouvez filtrer les traces par utilisateur, état ou heure de début.

Les traces produites par une exécution apparaissent également sur la page détails de l’exécution sous l’onglet Traces .

Migrer à partir de MLflow 2.x

Vous pouvez adopter MLflow 3 de manière incrémentielle :

Les blocs-notes existants continuent de s’exécuter sans modification. Le paramètre hérité artifact_path sur log_model() fonctionne toujours et produit un LoggedModel.
Les nouveaux blocs-notes doivent utiliser le name paramètre pour plus de clarté.
Les scénarios inter-espaces de travail utilisent le package mis à niveau synapseml-mlflow . Vous n’avez plus besoin d’épingler mlflow-skinny à 2.22.2. Pour connaître les étapes d’installation, consultez Gérer les modèles MLflow entre les espaces de travail et les plateformes.

Ce qui n’est pas encore pris en charge

L’évaluation de l’IA générative (mlflow.genai.evaluate()) n’est pas encore activée dans Fabric. C’est prévu pour une version ultérieure.

Commentaires

Cette page a-t-elle été utile ?

Last updated on 2026-06-23