Notes
L’accès à cette page nécessite une autorisation. Vous pouvez essayer de vous connecter ou de modifier des répertoires.
L’accès à cette page nécessite une autorisation. Vous pouvez essayer de modifier des répertoires.
Dans cet article, vous apprendrez comment entraîner des modèles de régression à l'aide de machines de boosting explicables (EBM) dans Microsoft Fabric. Un EBM est une technique d’apprentissage automatique qui combine la puissance de l’amélioration du dégradé avec une accentuation sur l’interprétabilité du modèle. Il crée un ensemble d’arbres de décision, semblable au boosting de gradient, mais avec un focus unique sur la génération de modèles lisibles par l’homme. Les ebMs fournissent non seulement des prédictions précises, mais offrent également des explications claires et intuitives pour ces prédictions. Ils conviennent parfaitement aux applications où la compréhension des facteurs sous-jacents qui pilotent les décisions de modèle est essentielle, comme les soins de santé, les finances et la conformité réglementaire.
Dans SynapseML, vous pouvez utiliser une implémentation évolutive de machines d’amélioration explicables, optimisées par Apache Spark, pour entraîner de nouveaux modèles. Ce tutoriel vous guide tout au long du processus d’application de l’extensibilité et de l’interprétabilité des machines d’amélioration expliquées au sein de Microsoft Fabric en utilisant Apache Spark. L’utilisation de machines de boosting explicables avec Microsoft Fabric est actuellement en préversion.
Avantages des machines de boosting explicables
Les EBM offrent un mélange unique d’interprétabilité et de puissance prédictive, ce qui en fait un choix idéal lorsque la transparence et la compréhension des modèles Machine Learning sont cruciales. Avec les ebMs, les utilisateurs peuvent obtenir des insights précieux sur les facteurs sous-jacents qui pilotent les prédictions, ce qui leur permet de comprendre pourquoi un modèle prend des décisions ou des prédictions spécifiques, ce qui est essentiel pour la création d’une confiance dans les systèmes IA.
Leur capacité à découvrir des relations complexes dans les données tout en fournissant des résultats clairs et interprétables les rend inestimables dans des domaines tels que la finance, la santé et la détection des fraudes. Dans ces champs, l’explication du modèle n’est pas seulement souhaitable, mais souvent une exigence réglementaire. Finalement, l’utilisation d’EBMs peut trouver un équilibre entre les performances du modèle et la transparence, ce qui garantit que les solutions IA sont précises, facilement compréhensibles et responsables.
Conditions préalables
Souscrire à un abonnement Microsoft Fabric . Vous pouvez également vous inscrire à une version d’évaluation gratuite de Microsoft Fabric .
Connectez-vous à Microsoft Fabric.
Utilisez le sélecteur d’expérience en bas à gauche de votre page d’accueil pour basculer vers Fabric.
- Créez un bloc-notes dans votre espace de travail en sélectionnant +, puis notebook.
Importer MLflow
MLflow vous permet de suivre les paramètres et les résultats du modèle. L’extrait de code suivant montre comment utiliser MLflow à des fins d’expérimentation et de suivi. La valeur ebm-wine-quality est le nom de l’expérience dans laquelle les informations sont enregistrées.
# Import MLflow
import mlflow
# Create a new experiment for EBM Wine Quality
mlflow.set_experiment("ebm-wine-quality")
Charger des données
L’extrait de code suivant charge et prépare le jeu de données Wine Quality standard, qui sert de jeu de données compact et précieux pour les tâches de régression. Il est important de souligner que le processus de conversion implique la conversion d’un dataframe Pandas (retourné par Sklearn lors de l’utilisation de l’argument as_frame) en trame de données Spark, comme requis par les formateurs de style Spark ML :
import sklearn
# Load the Wine Quality Data Set using the as_frame argument for Pandas compatibility.
bunch = sklearn.datasets.load_wine(as_frame=True)
# Extract the data into a Pandas dataframe.
pandas_df = bunch['data']
# Add the target variable to the Pandas dataframe.
pandas_df['target'] = bunch['target']
# Convert the Pandas dataframe to a Spark dataframe.
df = spark.createDataFrame(pandas_df)
# Display the resulting Spark dataframe.
display(df)
Cet extrait de code montre comment charger, manipuler et convertir le jeu de données à utiliser avec des tâches De Machine Learning basées sur Spark.
Préparer des données
Comme il est habituel avec les apprenants de style Spark ML, il est essentiel d’organiser les fonctionnalités dans une colonne à valeur vectorielle. Dans ce cas, reportez-vous à cette colonne en tant que « caractéristiques », qui englobe toutes les colonnes du dataframe chargé, à l’exception de la variable cible :
from pyspark.ml.feature import VectorAssembler
# Define the name of the target variable column.
labelColumnName = 'target'
# Create a VectorAssembler to consolidate features.
assembler = VectorAssembler(outputCol='features')
# Specify the input columns, excluding the target column.
assembler.setInputCols([c for c in df.columns if c != labelColumnName])
# Transform the dataframe to include the 'features' column.
df_with_features = assembler.transform(df)
Cet extrait de code montre comment utiliser VectorAssembler pour structurer correctement les fonctionnalités pour la modélisation basée sur Spark ML ultérieure.
Entraîner le modèle
Le code suivant lance le processus de création d’un modèle de régression EBM à l’aide de la bibliothèque Synapse ML. Tout d’abord, initialisez l’estimateur de régression EBM, en spécifiant qu’il est destiné à une tâche de régression. Ensuite, définissez le nom de la colonne d’étiquette pour vous assurer que le modèle connaît la colonne à prédire. Enfin, ajustez le modèle au jeu de données prétraité :
# Import the EBMRegression estimator from Synapse ML.
from synapse.ml.ebm import EbmRegression
# Create an instance of the EBMRegression estimator.
estimator = EbmRegression()
# Set the label column for the regression task.
estimator.setLabelCol(labelColumnName)
# Fit the EBM regression model to the prepared dataset.
model = estimator.fit(df_with_features)
Afficher les explications globales
Pour visualiser l’explication globale du modèle, vous pouvez obtenir le wrapper de visualisation et utiliser la méthode de la interpretbibliothèqueshow. L'enveloppe de visualisation agit comme un pont pour faciliter la visualisation du modèle. Voici comment procéder :
# Get the visualization wrapper for the model.
wrap = model.getVizWrapper()
# Generate the global explanation.
explanation = wrap.explain_global()
Ensuite, importez la bibliothèque interpret et utilisez la méthode show pour afficher l’explication :
import interpret
interpret.show(explanation)
Le terme « importances » représente la contribution absolue moyenne (score) de chaque terme (caractéristique ou interaction) vers les prédictions. Ces contributions sont calculées en moyenne dans le jeu de données d’entraînement, en tenant compte du nombre d’échantillons dans chaque bac et poids des échantillons (le cas échéant). Les 15 premiers termes les plus importants sont affichés dans l’explication.
Afficher les explications locales
Les explications fournies sont à un niveau global, mais il existe des scénarios où les sorties par fonctionnalité sont également précieuses. Le formateur et le modèle offrent la possibilité de définir FeaturesScoresCol, qui, lorsqu’il est rempli, introduit une autre colonne vectorielle. Chaque vecteur de cette colonne correspond à la longueur de la colonne de caractéristiques, avec chaque valeur correspondant à la fonctionnalité au même index. Ces valeurs représentent la contribution de la valeur de chaque fonctionnalité à la sortie finale du modèle.
Contrairement aux explications globales, il n’existe actuellement aucune intégration directe avec la visualisation interpret pour les sorties par fonctionnalité. Cela est dû au fait que les visualisations globales sont mises à l’échelle principalement avec le nombre de fonctionnalités (généralement petites), tandis que les explications locales sont mises à l’échelle avec le nombre de lignes (qui, si une trame de données Spark, peut être importante).
Voici comment configurer et utiliser le FeaturesScoresCol:
# Set the FeaturesScoresCol to include per-feature outputs.
prediction = model.setFeatureScoresCol("featurescores").transform(df_with_features)
# For small datasets, you can collect the results to a single machine without issues.
# However, for larger datasets, caution should be exercised when collecting all rows locally.
# In this example, we convert to Pandas for easy local inspection.
predictions_pandas = prediction.toPandas()
predictions_list = prediction.collect()
À des fins d’illustration, nous allons imprimer les détails du premier exemple :
# Extract the first example from the collected predictions.
first = predictions_list[0]
# Print the lengths of the features and feature scores.
print('Length of the features is', len(first['features']), 'while the feature scores have length', len(first['featurescores']))
# Print the values of the features and feature scores.
print('Features are', first['features'])
print('Feature scores are', first['featurescores'])
Cet extrait de code montre comment accéder aux valeurs de fonctionnalité et imprimer les scores de fonctionnalités correspondants pour le premier exemple dans les prédictions. Ce code produit la sortie suivante :
Length of the features is 13 while the feature scores have length 13
Features are [14.23, 1.71, 2.43, 15.6, 127.0, 2.8, 3.06, 0.28, 2.29, 5.64, 1.04, 3.92, 1065.0]
Feature scores are [-0.06610139373422304, -0.06386890875478829, 0.006784629513340544, -0.27503132406909486, -0.017971992178296585, 0.027848245358365248, 0.08691003021839885, -0.09550122309042419, -0.0068259112648438175, -0.04053278237133137, 0.07148173894260551, 0.07739120309898403, -0.0867647572984993]