Gérer les modèles MLflow entre les espaces de travail et les plateformes

Le Machine Learning de production nécessite plus que l’entraînement d’un bon modèle. Vous avez besoin de flux de travail fiables pour déplacer des modèles du développement à travers la validation jusqu'à la production. La journalisation entre espaces de travail dans Microsoft Fabric active deux scénarios clés :

• Créez des flux de travail MLOps de bout en bout. Entraîner et expérimenter dans un espace de travail de développement, valider dans un espace de travail de test et déployer sur un espace de travail de service de production à l’aide d’API MLflow standard. Cette séparation des environnements aide les équipes à appliquer des portes de qualité et à maintenir des pistes d’audit claires de l’expérimentation à la production.

• Intégrez les ressources de machine learning existantes dans Fabric. Si vous avez déjà entraîné des modèles dans Azure Databricks, Azure Machine Learning, un environnement local ou toute autre plateforme prenant en charge MLflow, vous pouvez enregistrer ces expériences et modèles directement dans un espace de travail Fabric. Vous pouvez facilement consolider vos artefacts d'apprentissage automatique en un seul endroit sans reconstruire vos pipelines d’entraînement.

La journalisation inter-espaces de travail fonctionne via le package synapseml-mlflow, qui fournit un plug-in de suivi MLflow compatible Fabric. Vous vous authentifiez auprès de votre espace de travail cible, définissez l’URI de suivi et utilisez des commandes MLflow standard.

Prerequisites

• Un abonnement Microsoft Fabric ou un essai gratuit Microsoft Fabric.
• Autorisation d’écriture sur l’espace de travail Fabric cible.
• Système de suivi machine learning mis à niveau pour les espaces de travail source et cible.

Pour les scénarios de notebook Fabric, créez un nouveau bloc-notes et attachez un lakehouse, avant d’exécuter du code.

Installer le plug-in MLflow

Le package synapseml-mlflow active la journalisation inter-espaces de travail en fournissant le plug-in de suivi MLflow Fabric. Choisissez la commande d’installation en fonction de votre environnement.

%pip install -U "synapseml-mlflow[online-notebook]" "mlflow-skinny<=2.22.2"

pip install -U "synapseml-mlflow" "mlflow-skinny<=2.22.2"

Après l’installation, redémarrez le noyau avant d’exécuter le code restant.

Journaliser des objets MLflow vers un autre espace de travail Fabric

Dans ce scénario, vous exécutez un bloc-notes dans un espace de travail Fabric (source) tout en enregistrant des expériences et des modèles dans un autre espace de travail Fabric (cible).

Définir l’espace de travail cible

Pointez sur votre espace de travail cible en définissant la variable d’environnement MLFLOW_TRACKING_URI :

import os

target_workspace_id = "<your-target-workspace-id>"
target_uri = f"sds://api.fabric.microsoft.com/v1/workspaces/{target_workspace_id}/mlflow"
os.environ["MLFLOW_TRACKING_URI"] = target_uri

Consigner les expériences et les modèles

Créez une expérience et journalisez une exécution avec des paramètres, des métriques et un modèle :

import mlflow
import mlflow.sklearn
import numpy as np
from sklearn.linear_model import LogisticRegression
from mlflow.models.signature import infer_signature

# Create or set the experiment in the target workspace
EXP_NAME = "my-cross-workspace-experiment"
MODEL_NAME = "my-cross-workspace-model"
mlflow.set_experiment(EXP_NAME)

with mlflow.start_run() as run:
    lr = LogisticRegression()
    X = np.array([-2, -1, 0, 1, 2, 1]).reshape(-1, 1)
    y = np.array([0, 0, 1, 1, 1, 0])
    lr.fit(X, y)

    score = lr.score(X, y)
    signature = infer_signature(X, y)

    mlflow.log_params({
        "objective": "classification",
        "learning_rate": 0.05,
    })
    mlflow.log_metric("score", score)

    mlflow.sklearn.log_model(lr, "model", signature=signature)

    mlflow.register_model(
        f"runs:/{run.info.run_id}/model",
        MODEL_NAME
    )

Une fois l’exécution terminée, l’expérience et le modèle inscrit apparaissent dans l’espace de travail cible.

Déplacer des objets MLflow entre des espaces de travail Fabric

Dans ce scénario, vous journalisez d’abord les objets dans l’espace de travail source, puis téléchargez les artefacts et reconnectez-les à l’espace de travail cible. Cette méthode est utile lorsque vous devez promouvoir un modèle entraîné d’un espace de travail de développement vers un espace de travail de production.

Étape 1 : Journaliser les objets dans l’espace de travail source

import mlflow
import mlflow.sklearn
import numpy as np
from sklearn.linear_model import LogisticRegression
from mlflow.models.signature import infer_signature

# Log to the current (source) workspace
EXP_NAME = "source-experiment"
mlflow.set_experiment(EXP_NAME)

with mlflow.start_run() as run:
    lr = LogisticRegression()
    X = np.array([-2, -1, 0, 1, 2, 1]).reshape(-1, 1)
    y = np.array([0, 0, 1, 1, 1, 0])
    lr.fit(X, y)

    signature = infer_signature(X, y)
    mlflow.sklearn.log_model(lr, "model", signature=signature)

    source_run_id = run.info.run_id

Étape 2 : Télécharger des artefacts à partir de l’exécution source

import mlflow.artifacts

# Download the model artifacts locally
local_artifact_path = mlflow.artifacts.download_artifacts(
    run_id=source_run_id,
    artifact_path="model"
)

Étape 3 : reconnecter les artefacts à l’espace de travail cible

import os

target_workspace_id = "<your-target-workspace-id>"
target_uri = f"sds://api.fabric.microsoft.com/v1/workspaces/{target_workspace_id}/mlflow"
os.environ["MLFLOW_TRACKING_URI"] = target_uri

TARGET_EXP_NAME = "promoted-experiment"
TARGET_MODEL_NAME = "promoted-model"
mlflow.set_experiment(TARGET_EXP_NAME)

with mlflow.start_run() as run:
    mlflow.log_artifacts(local_artifact_path, "model")
    mlflow.register_model(
        f"runs:/{run.info.run_id}/model",
        TARGET_MODEL_NAME
    )

Enregistrer les objets MLflow à partir de l'extérieur de Fabric

Vous pouvez consigner des expériences et des modèles MLflow dans un espace de travail Fabric à partir de n’importe quel environnement où vous générez vos modèles, notamment :

• Ordinateurs locaux. VS Code, notebooks Jupyter ou tout environnement de Python local.
• Azure Databricks. Azure Databricks notebooks et tâches.
• Azure Machine Learning. Azure Machine Learning instances de calcul et pipelines.
• Toute autre plateforme. Tout environnement prenant en charge Python et MLflow.

Étape 1 : Installer le package

Installez le synapseml-mlflow package dans votre environnement :

pip install -U "synapseml-mlflow" "mlflow-skinny<=2.22.2"

Étape 2 : S’authentifier avec Fabric

Choisissez une méthode d’authentification basée sur votre environnement :

from fabric.analytics.environment.credentials import SetFabricAnalyticsDefaultTokenCredentialsGlobally
from azure.identity import DefaultAzureCredential

SetFabricAnalyticsDefaultTokenCredentialsGlobally(
    credential=DefaultAzureCredential(exclude_interactive_browser_credential=False)
)

from fabric.analytics.environment.credentials import SetFabricAnalyticsDefaultTokenCredentialsGlobally
from azure.identity import DeviceCodeCredential

device_code_credential = DeviceCodeCredential()
SetFabricAnalyticsDefaultTokenCredentialsGlobally(
    credential=device_code_credential
)

Étape 3 : Définir l’espace de travail cible et journaliser les objets MLflow

Après l'authentification, définissez l'URI de suivi pour qu'il pointe vers votre espace de travail Fabric cible et utilisez les API standard MLflow pour consigner les expériences et les modèles.

import os
import mlflow
import mlflow.sklearn
import numpy as np
from sklearn.linear_model import LogisticRegression
from mlflow.models.signature import infer_signature

target_workspace_id = "<your-target-workspace-id>"
target_uri = f"sds://api.fabric.microsoft.com/v1/workspaces/{target_workspace_id}/mlflow"
os.environ["MLFLOW_TRACKING_URI"] = target_uri

EXP_NAME = "external-experiment"
MODEL_NAME = "external-model"
mlflow.set_experiment(EXP_NAME)

with mlflow.start_run() as run:
    lr = LogisticRegression()
    X = np.array([-2, -1, 0, 1, 2, 1]).reshape(-1, 1)
    y = np.array([0, 0, 1, 1, 1, 0])
    lr.fit(X, y)

    signature = infer_signature(X, y)
    mlflow.log_metric("score", lr.score(X, y))
    mlflow.sklearn.log_model(lr, "model", signature=signature)

    mlflow.register_model(
        f"runs:/{run.info.run_id}/model",
        MODEL_NAME
    )

Utiliser la journalisation inter-espaces de travail avec la protection de l'accès sortant

Si votre espace de travail dispose d’une protection d’accès sortant activée , la journalisation inter-espaces de travail nécessite un point de terminaison privé managé entre espaces de travail à partir de l’espace de travail source vers l’espace de travail cible.

La journalisation dans le même espace de travail et la journalisation depuis l’extérieur Fabric (ordinateurs locaux, Azure Databricks, Azure Machine Learning) fonctionnent sans configuration supplémentaire.

Pour plus d'informations sur les scénarios pris en charge et la configuration requise, consultez protection d'accès sortant de l'espace de travail pour Fabric Science des données.

Installer le package dans un espace de travail compatible OAP

La commande standard %pip install nécessite un accès Internet sortant, qui est bloqué dans les espaces de travail avec la protection d’accès sortant (OAP) activée. Pour installer le synapseml-mlflow package, commencez par le télécharger à partir d’un environnement non-OAP, puis chargez-le dans le lakehouse.

1. Téléchargez le synapseml-mlflow package à partir d’un ordinateur disposant d’un accès à Internet.

   pip download synapseml-mlflow[online-notebook]
   

2. Chargez les fichiers téléchargés dans lakehouse dans votre espace de travail compatible OAP. Chargez tous les .whl fichiers dans la section Fichiers de la lakehouse (par exemple, /lakehouse/default/Files).

3. Installez à partir du chemin du Lakehouse dans votre notebook Fabric :

   %pip install --no-index --find-links=/lakehouse/default/Files "synapseml-mlflow[online-notebook]>2.0.0" "mlflow-skinny<=2.22.2" --pre
   

4. Définissez l’URI de suivi pour utiliser le point de terminaison privé managé. Si votre espace de travail actuel a OAP activé, vous devez configurer un point de terminaison privé géré entre espaces de travail de l'espace de travail source vers l'espace de travail cible. Ensuite, routez l’URI de suivi via le point de terminaison privé.

   import os
   from fabric.analytics.environment.context import FabricContext, InternalContext
   
   context = FabricContext(workspace_id=target_workspace_id, internal_context=InternalContext(is_wspl_enabled=True))
   print(context.pbi_shared_host)
   # You need to set up and use this private endpoint if your current workspace has OAP enabled
   
   os.environ["MLFLOW_TRACKING_URI"] = f"sds://{context.pbi_shared_host}/v1/workspaces/{target_workspace_id}/mlflow"
   

Limitations connues

• L’autorisation d’écriture est requise. Vous devez disposer d’une autorisation d’écriture sur l’espace de travail cible.
• La traçabilité entre espaces de travail n’est pas prise en charge. Vous ne pouvez pas afficher les relations entre les blocs-notes, les expériences et les modèles lorsque ces objets sont enregistrés à partir de différents espaces de travail.
• Le bloc-notes source n’est pas visible dans l’espace de travail cible. Le bloc-notes source n’apparaît pas dans l’espace de travail cible. Sur les détails de l’artefact et les pages de liste, le lien vers le bloc-notes source est vide.
• Les instantanés d’élément ne sont pas pris en charge. Les expériences ou modèles Machine Learning enregistrés dans un autre espace de travail n’apparaissent pas dans l’instantané de l’élément de notebook d’exécution source.
• Les modèles de langage volumineux ne sont pas pris en charge. La journalisation inter-espaces de travail ne prend pas en charge les modèles de langage volumineux (LLMs).

Contenu connexe

• Expériences de machine learning dans Microsoft Fabric
• Suivre et gérer des modèles Machine Learning
• Mettre à niveau votre système de suivi machine learning
• Autolog dans Microsoft Fabric
• Pipelines d’intégration et de déploiement Git pour les expériences et modèles Machine Learning
• Protection de l’accès sortant de l’espace de travail pour la science des données