Tutoriel Partie 4 : Effectuer un scoring par lots et enregistrer les prédictions dans un lakehouse

Ce tutoriel montre comment importer le modèle LightGBMClassifier inscrit que vous avez créé dans la partie 3. Ce tutoriel a utilisé le registre de modèles MLflow Microsoft Fabric pour entraîner le modèle, puis effectuer des prédictions par lots sur un jeu de données de test chargé à partir d’un lakehouse.

Avec Microsoft Fabric, vous pouvez opérationnaliser des modèles Machine Learning avec la fonction PREDICT évolutive. Cette fonction prend en charge le scoring par lots dans n’importe quel moteur de calcul. Vous pouvez générer des prédictions par lots directement à partir d’un bloc-notes Microsoft Fabric ou à partir de la page d’élément d’un modèle donné. Pour plus d’informations sur la fonction PREDICT, visitez cette ressource.

Pour générer des prédictions par lots sur le jeu de données de test, utilisez la version 1 du modèle LightGBM entraîné. Cette version a montré les meilleures performances parmi tous les modèles Machine Learning entraînés. Vous chargez le jeu de données de test dans un DataFrame Spark et créez un objet MLFlowTransformer pour générer des prédictions par lots. Vous pouvez ensuite appeler la fonction PREDICT à l’aide de l’une des techniques suivantes :

Conditions préalables

• Obtenez un abonnement Microsoft Fabric . Vous pouvez également vous inscrire à une version d’évaluation gratuite 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.

  

Il s’agit de la partie 4 d’une série de cinq tutoriels. Pour suivre ce didacticiel, commencez par effectuer les travaux suivants :

• Partie 1 : ingérer des données dans un lac Microsoft Fabric à l’aide d’Apache Spark.
• partie 2 : Explorer et visualiser des données à l’aide de notebooks Microsoft Fabric pour en savoir plus sur les données.
• Partie 3 : Entraîner et inscrire des modèles Machine Learning.

Suivez dans le notebook

4-predict.ipynb est le notebook qui accompagne ce tutoriel.

• Pour ouvrir le bloc-notes associé pour ce didacticiel, suivez les instructions de Préparer votre système pour les didacticiels de science des données pour importer le bloc-notes dans votre espace de travail.

• Si vous préférez copier et coller le code à partir de cette page, vous pouvez créer un bloc-notes.

• Assurez-vous d'attacher un lakehouse au notebook avant de commencer à exécuter du code.

Charger les données de test

Dans l’extrait de code suivant, chargez les données de test que vous avez enregistrées dans la partie 3 :

df_test = spark.read.format("delta").load("Tables/df_test")
display(df_test)

PREDICT avec l’API Transformer

Pour utiliser l’API Transformer à partir de SynapseML, vous devez d’abord créer un objet MLFlowTransformer.

Instancier l’objet MLFlowTransformer

L’objet MLFlowTransformer sert de wrapper autour du modèle MLFlow que vous avez inscrit dans la partie 3. Il vous permet de générer des prédictions par lots sur un DataFrame donné. Pour instancier l’objet MLFlowTransformer, vous devez fournir les paramètres suivants :

• Colonnes dataFrame de test dont le modèle a besoin en tant qu’entrée (dans ce cas, le modèle a besoin de tous ces éléments)
• Nom de la nouvelle colonne de sortie (dans ce cas, prédictions)
• Nom de modèle correct et version pour générer les prédictions (dans ce cas, lgbm_sm et version 1)

L’extrait de code suivant gère les étapes suivantes :

from synapse.ml.predict import MLFlowTransformer

model = MLFlowTransformer(
    inputCols=list(df_test.columns),
    outputCol='predictions',
    modelName='lgbm_sm',
    modelVersion=1
)

Maintenant que vous disposez de l’objet MLFlowTransformer, vous pouvez l’utiliser pour générer des prédictions par lots, comme illustré dans l’extrait de code suivant :

import pandas

predictions = model.transform(df_test)
display(predictions)

PREDICT avec l’API SPARK SQL

L’extrait de code suivant utilise l’API SQL Spark pour appeler la fonction PREDICT :

from pyspark.ml.feature import SQLTransformer 

# Substitute "model_name", "model_version", and "features" below with values for your own model name, model version, and feature columns
model_name = 'lgbm_sm'
model_version = 1
features = df_test.columns

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

# Substitute "X_test" below with your own test dataset
display(sqlt.transform(df_test))

PREDICT avec une fonction définie par l’utilisateur (UDF)

L’extrait de code suivant utilise une fonction UDF PySpark pour appeler la fonction PREDICT :

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

# Substitute "model" and "features" below with values for your own model name and feature columns
my_udf = model.to_udf()
features = df_test.columns

display(df_test.withColumn("predictions", my_udf(*[col(f) for f in features])))

Vous pouvez également générer du code PREDICT à partir de la page d’élément d’un modèle. Pour plus d’informations sur la fonction PREDICT, visitez cette ressource.

Écrire des résultats de prédiction de modèle dans le lakehouse

Après avoir généré des prédictions par lots, réécrivez les résultats de prédiction du modèle dans la lakehouse, comme indiqué dans l’extrait de code suivant :

# Save predictions to lakehouse to be used for generating a Power BI report
table_name = "customer_churn_test_predictions"
predictions.write.format('delta').mode("overwrite").save(f"Tables/{table_name}")
print(f"Spark DataFrame saved to delta table: {table_name}")

Étape suivante

Passez à :