Partager via


Scoring de modèle Machine Learning avec PREDICT dans Microsoft Fabric

Microsoft Fabric permet aux utilisateurs d’opérationnaliser des modèles Machine Learning avec une fonction évolutive appelée PREDICT, qui prend en charge le scoring par lots dans n’importe quel moteur de calcul. Les utilisateurs peuvent générer des prédictions par lots directement à partir d’un notebook Microsoft Fabric ou de la page d’élément d’un modèle Machine Learning donné.

Dans cet article, vous allez apprendre à appliquer PREDICT dans les deux sens, que vous soyez plus à l’aise pour écrire du code vous-même ou utiliser une expérience d’interface utilisateur guidée pour gérer le scoring par lots pour vous.

Prérequis

Limites

  • La fonction PREDICT est actuellement prise en charge pour un ensemble limité de saveurs de modèle Machine Learning, notamment :
    • PyTorch
    • SKLearn
    • Spark
    • TensorFlow
    • ONNX
    • XGBoost
    • LightGBM
    • CatBoost
    • Statsmodels
    • Prophet
    • Keras
  • PREDICT exige que les modèles Machine Learning soient enregistrés au format MLflow avec leurs signatures remplies.
  • PREDICT ne prend pas en charge les modèles Machine Learning avec des entrées ou sorties multi-tenseurs.

Appeler PREDICT à partir d’un notebook

PREDICT prend en charge les modèles empaquetés MLflow dans le Registre Microsoft Fabric. S’il existe déjà un modèle Machine Learning entraîné et inscrit dans votre espace de travail, vous pouvez passer à l’étape 2 ci-dessous. Si ce n’est pas le cas, l’étape 1 fournit un exemple de code pour vous guider dans l’apprentissage d’un exemple de modèle de régression logistique. Vous pouvez utiliser ce modèle pour générer des prédictions par lots à la fin de la procédure.

  1. Effectuer l'apprentissage d’un modèle Machine Learning et l’inscrire auprès de MLflow. L’exemple de code suivant utilise l’API MLflow pour créer une expérience machine learning et démarrer une exécution MLflow pour un modèle de régression logistique scikit-learn. La version du modèle est ensuite stockée et inscrite dans le Registre Microsoft Fabric. Découvrez comment effectuer l'apprentissage des modèles Machine Learning avec scikit-learn pour en savoir plus sur les modèles de formation et les expériences de suivi de vos propres.

    import mlflow
    import numpy as np 
    from sklearn.linear_model import LogisticRegression 
    from sklearn.datasets import load_diabetes
    from mlflow.models.signature import infer_signature 
    
    mlflow.set_experiment("diabetes-demo")
    with mlflow.start_run() as run:
        lr = LogisticRegression()
        data = load_diabetes(as_frame=True)
        lr.fit(data.data, data.target) 
        signature = infer_signature(data.data, data.target) 
    
        mlflow.sklearn.log_model(
            lr,
            "diabetes-model",
            signature=signature,
            registered_model_name="diabetes-model"
        ) 
    
  2. Charger des données de test sous forme de DataFrame Spark. Pour générer des prédictions par lots à l’aide du modèle Machine Learning entraîné à l’étape précédente, vous avez besoin de données de test sous la forme d’un DataFrame Spark. Vous pouvez remplacer la valeur de la variable test dans le code suivant par vos propres données.

    # You can substitute "test" below with your own data
    test = spark.createDataFrame(data.frame.drop(['target'], axis=1))
    
  3. Créez un objet MLFlowTransformer pour charger le modèle Machine Learning pour l’inférence. Pour créer un objet MLFlowTransformer permettant de générer des prédictions par lots, vous devez effectuer les actions suivantes :

    • spécifiez les colonnes du test DataFrame dont vous avez besoin en tant qu’entrées de modèle (dans ce cas, toutes),
    • choisissez un nom pour la nouvelle colonne de sortie (dans ce cas, predictions), et
    • fournissez le nom de modèle et la version de modèle appropriés pour générer ces prédictions.

    Si vous utilisez votre propre modèle Machine Learning, remplacez les valeurs par les colonnes d’entrée, le nom de la colonne de sortie, le nom du modèle et la version du modèle.

    from synapse.ml.predict import MLFlowTransformer
    
    # You can substitute values below for your own input columns,
    # output column name, model name, and model version
    model = MLFlowTransformer(
        inputCols=test.columns,
        outputCol='predictions',
        modelName='diabetes-model',
        modelVersion=1
    )
    
  4. Générez des prédictions à l’aide de la fonction PREDICT. Pour appeler la fonction PREDICT, vous pouvez utiliser l’API Transformer, l’API Spark SQL ou une fonction définie par l’utilisateur (UDF) PySpark. Les sections suivantes montrent comment générer des prédictions par lots avec les données de test et le modèle Machine Learning définis dans les étapes précédentes, à l’aide des différentes méthodes d’appel de PREDICT.

PREDICT avec l’API Transformer

Le code suivant appelle la fonction PREDICT avec l’API Transformer. Si vous utilisez votre propre modèle Machine Learning, remplacez les valeurs du modèle et des données de test.

# You can substitute "model" and "test" below with values  
# for your own model and test data 
model.transform(test).show()

PREDICT avec l’API SPARK SQL

Le code suivant appelle la fonction PREDICT avec l’API SPARK SQL. Si vous avez utilisé votre propre modèle Machine Learning, remplacez les valeurs par model_name, model_versionet features par le nom de votre modèle, la version du modèle et les colonnes de caractéristiques.

Remarque

L’utilisation de l’API Spark SQL pour générer des prédictions nécessite toujours la création d’un objet MLFlowTransformer (comme à l’étape 3).

from pyspark.ml.feature import SQLTransformer 

# You can substitute "model_name," "model_version," and "features" 
# with values for your own model name, model version, and feature columns
model_name = 'diabetes-model'
model_version = 1
features = test.columns

sqlt = SQLTransformer().setStatement( 
    f"SELECT PREDICT('{model_name}/{model_version}', {','.join(features)}) as predictions FROM __THIS__")

# You can substitute "test" below with your own test data
sqlt.transform(test).show()

PREDICT avec une fonction définie par l’utilisateur

Le code suivant appelle la fonction PREDICT avec une fonction UDF PySpark. Si vous avez utilisé votre propre modèle Machine Learning, remplacez les valeurs du modèle et des fonctionnalités.

from pyspark.sql.functions import col, pandas_udf, udf, lit

# You can substitute "model" and "features" below with your own values
my_udf = model.to_udf()
features = test.columns

test.withColumn("PREDICT", my_udf(*[col(f) for f in features])).show()

Générer du code PREDICT à partir de la page d’élément d’un modèle Machine Learning

À partir de la page d’élément de n’importe quel modèle Machine Learning, vous pouvez choisir l’une des options suivantes pour commencer à générer des prédictions par lots pour une version de modèle spécifique avec PREDICT.

  • Utiliser une expérience d’interface utilisateur guidée pour générer du code PREDICT
  • Copier un modèle de code dans un bloc-notes et personnaliser les paramètres vous-même

Utiliser une expérience d’interface utilisateur guidée

L’expérience guidée de l’interface utilisateur vous guide tout au long des étapes pour :

  • Sélectionner les données sources pour le scoring
  • Mapper correctement les données aux entrées de votre modèle Machine Learning
  • Spécifier la destination des sorties de votre modèle
  • Créer un notebook qui utilise PREDICT pour générer et stocker les résultats de prédiction

Pour utiliser l’expérience guidée,

  1. Accédez à la page d’élément d’une version de modèle Machine Learning donnée.

  2. Sélectionnez Appliquer ce modèle dans l’Assistant dans la liste déroulante Appliquer cette version.

    Screenshot of the prompt to apply an ML model from its item page.

    La sélection ouvre la fenêtre « Appliquer les prédictions de modèle Machine Learning » à l’étape « Sélectionner une table d’entrée ».

  3. Sélectionnez une table d’entrée dans l’un des lakehouses de votre espace de travail actuel.

    Screenshot of the step to select an input table for ML model predictions.

  4. Sélectionnez Suivant pour accéder à l’étape « Colonnes d’entrée de carte ».

  5. Mapper les noms de colonnes de la table source aux champs d’entrée du modèle Machine Learning, qui sont extraits de la signature du modèle. Vous devez fournir une colonne d’entrée pour tous les champs obligatoires du modèle. En outre, les types de données des colonnes sources doivent correspondre aux types de données attendus du modèle.

    Conseil

    L’Assistant préremplira ce mappage si les noms des colonnes de la table d’entrée correspondent aux noms de colonnes enregistrés dans la signature du modèle Machine Learning.

    Screenshot of the step to map input columns for ML model predictions.

  6. Sélectionnez Suivant pour passer à l’étape « Créer une table de sortie ».

  7. Fournissez un nom pour une nouvelle table dans le lakehouse sélectionné de votre espace de travail actuel. Cette table de sortie stocke les valeurs d’entrée de votre modèle Machine Learning avec les valeurs de prédiction ajoutées. Par défaut, la table de sortie est créée dans le même lakehouse que la table d’entrée, mais l’option permettant de modifier le lakehouse de destination est également disponible.

    Screenshot of the step to create an output table for ML model predictions.

  8. Sélectionnez Suivant pour accéder à l’étape « Colonnes d’entrée de carte ».

  9. Utilisez les champs de texte fournis pour nommer les colonnes de la table de sortie qui stockent les prédictions du modèle Machine Learning.

    Screenshot of the step to map output columns for ML model predictions.

  10. Sélectionnez Suivant pour accéder à l’étape « Configurer le notebook ».

  11. Fournissez un nom pour un nouveau bloc-notes qui exécutera le code PREDICT généré. L’Assistant affiche un aperçu du code généré à cette étape. Vous pouvez copier le code dans votre Presse-papiers et le coller dans un notebook existant si vous préférez.

    Screenshot of the step to configure a notebook for ML model predictions.

  12. Sélectionnez Suivant pour passer à l’étape « Vérifier et terminer ».

  13. Passez en revue les détails de la page récapitulative et sélectionnez Créer un notebook pour ajouter le nouveau notebook avec son code généré à votre espace de travail. Vous êtes dirigé directement vers ce notebook, où vous pouvez exécuter le code pour générer et stocker des prédictions.

    Screenshot of the review-and-finish step for ML model predictions.

Utiliser un modèle de code personnalisable

Pour utiliser un modèle de code pour générer des prédictions par lots :

  1. Accédez à la page d’élément d’une version de modèle Machine Learning donnée.
  2. Sélectionnez Copier le code à appliquer dans la liste déroulante Appliquer cette version. La sélection vous permet de copier un modèle de code personnalisable.

Vous pouvez coller ce modèle de code dans un notebook pour générer des prédictions par lots avec votre modèle Machine Learning. Pour exécuter correctement le modèle de code, vous devez remplacer manuellement les valeurs suivantes :

  • <INPUT_TABLE> : chemin d’accès au fichier de la table qui fournit des entrées au modèle Machine Learning
  • <INPUT_COLS> : tableau de noms de colonnes de la table d’entrée à alimenter dans le modèle Machine Learning
  • <OUTPUT_COLS> : nom d’une nouvelle colonne dans la table de sortie qui stocke les prédictions
  • <MODEL_NAME> : nom du modèle Machine Learning à utiliser pour générer des prédictions
  • <MODEL_VERSION> : version du modèle Machine Learning à utiliser pour générer des prédictions
  • <OUTPUT_TABLE> : chemin d’accès au fichier de la table qui stocke les prédictions

Screenshot of the copy-code template for ML model predictions.

import mlflow 
from synapse.ml.predict import MLFlowTransformer 
 
df = spark.read.format("delta").load( 
    <INPUT_TABLE> # Your input table filepath here
) 
 
model = MLFlowTransformer( 
    inputCols=<INPUT_COLS>, # Your input columns here
    outputCol=<OUTPUT_COLS>, # Your new column name here
    modelName=<MODEL_NAME>, # Your ML model name here
    modelVersion=<MODEL_VERSION> # Your ML model version here
) 
df = model.transform(df) 
 
df.write.format('delta').mode("overwrite").save( 
    <OUTPUT_TABLE> # Your output table filepath here
)