Scoring de modèle avec PREDICT dans Microsoft Fabric

Article
05/23/2023

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 bloc-notes Microsoft Fabric ou de la page d’élément d’un modèle donné.

Important

Microsoft Fabric est actuellement en préversion. Certaines informations portent sur un produit en préversion susceptible d’être substantiellement modifié avant sa publication. Microsoft ne donne aucune garantie, expresse ou implicite, concernant les informations fournies ici.

Dans cet article, vous allez apprendre à appliquer PREDICT de deux façons, 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

Un abonnement Power BI Premium. Si vous n’en avez pas, consultez Comment acheter des Power BI Premium.
Un espace de travail Power BI avec une capacité Premium affectée. Si vous n’avez pas d’espace de travail, suivez les étapes décrites dans Créer un espace de travail pour en créer un et l’affecter à une capacité Premium.
Connectez-vous à Microsoft Fabric.

Limites

La fonction PREDICT est actuellement prise en charge pour un ensemble limité de versions de modèle, notamment PyTorch, Sklearn, Spark, TensorFlow, ONNX, XGBoost, LightGBM, CatBoost et Statsmodels.
PREDICT exige que les modèles soient enregistrés au format MLflow avec leurs signatures renseignées.
PREDICT ne prend pas en charge les modèles 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. Si vous avez déjà entraîné et inscrit un modèle 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.

Entraîner un modèle 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 entraîner des modèles avec scikit-learn pour en savoir plus sur les modèles d’entraînement 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"
    )

Charger des données de test en tant que DataFrame Spark. Pour générer des prédictions par lots à l’aide du modèle 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 test variable 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))
```
Créez un MLFlowTransformer objet pour charger le modèle pour l’inférence. Pour créer un MLFlowTransformer objet permettant de générer des prédictions par lots, vous devez effectuer les opérations suivantes :
- spécifier les colonnes du test DataFrame dont vous avez besoin comme 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, 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
)
```
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 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 avez utilisé votre propre modèle, remplacez les valeurs par le modèle et les 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, 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.

Notes

L’utilisation de l’API Spark SQL pour générer des prédictions nécessite toujours la création d’un MLFlowTransformer objet (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 utilisez votre propre modèle, remplacez les valeurs par le modèle et les 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

À partir de la page d’élément de n’importe quel modèle, 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 pour vous
Copier un modèle de code dans un notebook et personnaliser les paramètres vous-même

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

L’expérience d’interface utilisateur guidée vous guide tout au long des étapes permettant de sélectionner les données sources pour le scoring, de mapper correctement les données aux entrées de votre modèle, de spécifier la destination des sorties de votre modèle et de 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,

Accédez à la page d’élément d’une version de modèle donnée.
Sélectionnez Appliquer ce modèle dans l’Assistant dans la liste déroulante Appliquer le modèle .

La sélection ouvre la fenêtre « Appliquer les prédictions de modèle » à l’étape « Sélectionner la table d’entrée ».
Sélectionnez une table d’entrée dans l’un des Lakehouses de votre espace de travail actuel.
Sélectionnez Suivant pour accéder à l’étape « Mapper les colonnes d’entrée ».
Mappez les noms de colonnes de la table source aux champs d’entrée du modèle, qui ont été 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.
Sélectionnez Suivant pour accéder à l’étape « Créer une table de sortie ».
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 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 la destination Lakehouse est également disponible.
Sélectionnez Suivant pour accéder à l’étape « Mapper les colonnes de sortie ».
Utilisez le ou les champs de texte fournis pour nommer la ou les colonnes de la table de sortie qui stockeront les prédictions du modèle.
Sélectionnez Suivant pour accéder à l’étape « Configurer le notebook ».
Fournissez un nom pour un nouveau notebook 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 le Presse-papiers et le coller dans un bloc-notes existant si vous préférez.
Sélectionnez Suivant pour accéder à l’étape « Vérifier et terminer ».
Passez en revue les détails de la page de résumé et sélectionnez Créer un bloc-notes pour ajouter le nouveau bloc-notes 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.

Utiliser un modèle de code personnalisable

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

Accédez à la page d’élément d’une version de modèle donnée.
Sélectionnez Copier le code à appliquer dans la liste déroulante Appliquer le modèle . 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. 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 fournira des entrées au modèle
<INPUT_COLS>: tableau de noms de colonnes de la table d’entrée à alimenter dans le modèle
<OUTPUT_COLS>: nom d’une nouvelle colonne dans la table de sortie qui stocke les prédictions
<MODEL_NAME>: nom du modèle à utiliser pour générer des prédictions
<MODEL_VERSION>: version du modèle à utiliser pour générer des prédictions
<OUTPUT_TABLE>: chemin d’accès au fichier de la table qui stockera les prédictions

import mlflow 
from synapse.ml.predict import MLFlowTransformer 
 
df = spark.read.format("delta").load( 
    <INPUT_TABLE> 
) 
 
model = MLFlowTransformer( 
    inputCols=<INPUT_COLS>, 
    outputCol=<OUTPUT_COLS>, 
    modelName=<MODEL_NAME>, 
    modelVersion=<MODEL_VERSION> 
) 
df = model.transform(df) 
 
df.write.format('delta').mode("overwrite").save( 
    <OUTPUT_TABLE> 
)