Utiliser le package d’interprétabilité pour expliquer les modèles ML et les prédictions dans Python (préversion)Use the interpretability package to explain ML models & predictions in Python (preview)

Dans ce guide pratique, vous allez apprendre à effectuer les tâches suivantes en utilisant le package d’interprétabilité du SDK Python Azure Machine Learning :In this how-to guide, you learn to use the interpretability package of the Azure Machine Learning Python SDK to perform the following tasks:

  • Expliquer la totalité du comportement du modèle ou des prédictions individuelles sur votre ordinateur personnel localementExplain the entire model behavior or individual predictions on your personal machine locally.

  • Activer les techniques d’interprétabilité pour les caractéristiques traitéesEnable interpretability techniques for engineered features.

  • Expliquer le comportement de la totalité du modèle et de prédictions individuelles dans AzureExplain the behavior for the entire model and individual predictions in Azure.

  • Utiliser un tableau de bord de visualisation pour interagir avec les explications de votre modèleUse a visualization dashboard to interact with your model explanations.

  • Déployer un explicatif de scoring à côté de votre modèle pour observer les explications au cours de l’inférenceDeploy a scoring explainer alongside your model to observe explanations during inferencing.

Pour plus d’informations sur les techniques d’interprétabilité et les modèles Machine Learning pris en charge, consultez Interprétabilité des modèles dans Azure Machine Learning et les exemples de notebooks.For more information on the supported interpretability techniques and machine learning models, see Model interpretability in Azure Machine Learning and sample notebooks.

Générer la valeur d’importance d’une caractéristique sur votre ordinateur personnelGenerate feature importance value on your personal machine

L’exemple suivant montre comment utiliser le package d’interprétabilité sur votre ordinateur personnel sans contacter les services Azure.The following example shows how to use the interpretability package on your personal machine without contacting Azure services.

  1. Installez le package azureml-interpret.Install the azureml-interpret package.

    pip install azureml-interpret
    
  2. Entraînez un exemple de modèle dans un notebook Jupyter local.Train a sample model in a local Jupyter Notebook.

    # load breast cancer dataset, a well-known small dataset that comes with scikit-learn
    from sklearn.datasets import load_breast_cancer
    from sklearn import svm
    from sklearn.model_selection import train_test_split
    breast_cancer_data = load_breast_cancer()
    classes = breast_cancer_data.target_names.tolist()
    
    # split data into train and test
    from sklearn.model_selection import train_test_split
    x_train, x_test, y_train, y_test = train_test_split(breast_cancer_data.data,            
                                                        breast_cancer_data.target,  
                                                        test_size=0.2,
                                                        random_state=0)
    clf = svm.SVC(gamma=0.001, C=100., probability=True)
    model = clf.fit(x_train, y_train)
    
  3. Appelez l’explicatif localement.Call the explainer locally.

    • Pour initialiser un objet d’explicatif, transmettez votre modèle et des données de formation au constructeur de l’explicatif.To initialize an explainer object, pass your model and some training data to the explainer's constructor.
    • Vous pouvez transmettre des noms de fonctionnalités et des noms de classes de sortie, en cas de classification, qui seront utilisés pour que vos descriptions et visualisations soient plus explicites encore.To make your explanations and visualizations more informative, you can choose to pass in feature names and output class names if doing classification.

    Les blocs de code suivants montrent comment instancier un objet explicatif avec TabularExplainer, MimicExplainer et PFIExplainer localement.The following code blocks show how to instantiate an explainer object with TabularExplainer, MimicExplainer, and PFIExplainer locally.

    • TabularExplainer appelle un des trois explicatifs SHAP sous-jacents (TreeExplainer, DeepExplainer ou KernelExplainer).TabularExplainer calls one of the three SHAP explainers underneath (TreeExplainer, DeepExplainer, or KernelExplainer).
    • TabularExplainer sélectionne automatiquement le plus approprié pour votre cas d’utilisation, mais vous pouvez appeler chacun des trois explicatifs sous-jacents directement.TabularExplainer automatically selects the most appropriate one for your use case, but you can call each of its three underlying explainers directly.
    from interpret.ext.blackbox import TabularExplainer
    
    # "features" and "classes" fields are optional
    explainer = TabularExplainer(model, 
                                 x_train, 
                                 features=breast_cancer_data.feature_names, 
                                 classes=classes)
    

    oror

    
    from interpret.ext.blackbox import MimicExplainer
    
    # you can use one of the following four interpretable models as a global surrogate to the black box model
    
    from interpret.ext.glassbox import LGBMExplainableModel
    from interpret.ext.glassbox import LinearExplainableModel
    from interpret.ext.glassbox import SGDExplainableModel
    from interpret.ext.glassbox import DecisionTreeExplainableModel
    
    # "features" and "classes" fields are optional
    # augment_data is optional and if true, oversamples the initialization examples to improve surrogate model accuracy to fit original model.  Useful for high-dimensional data where the number of rows is less than the number of columns.
    # max_num_of_augmentations is optional and defines max number of times we can increase the input data size.
    # LGBMExplainableModel can be replaced with LinearExplainableModel, SGDExplainableModel, or DecisionTreeExplainableModel
    explainer = MimicExplainer(model, 
                               x_train, 
                               LGBMExplainableModel, 
                               augment_data=True, 
                               max_num_of_augmentations=10, 
                               features=breast_cancer_data.feature_names, 
                               classes=classes)
    

    oror

    from interpret.ext.blackbox import PFIExplainer
    
    # "features" and "classes" fields are optional
    explainer = PFIExplainer(model,
                             features=breast_cancer_data.feature_names, 
                             classes=classes)
    

Expliquer le comportement de la totalité du modèle (explication globale)Explain the entire model behavior (global explanation)

Reportez-vous à l’exemple suivant pour vous aider à obtenir les valeurs d’importance de caractéristique d’agrégat (globale).Refer to the following example to help you get the aggregate (global) feature importance values.


# you can use the training data or the test data here, but test data would allow you to use Explanation Exploration
global_explanation = explainer.explain_global(x_test)

# if you used the PFIExplainer in the previous step, use the next line of code instead
# global_explanation = explainer.explain_global(x_train, true_labels=y_train)

# sorted feature importance values and feature names
sorted_global_importance_values = global_explanation.get_ranked_global_values()
sorted_global_importance_names = global_explanation.get_ranked_global_names()
dict(zip(sorted_global_importance_names, sorted_global_importance_values))

# alternatively, you can print out a dictionary that holds the top K feature names and values
global_explanation.get_feature_importance_dict()

Expliquer une prédiction individuelle (explication locale)Explain an individual prediction (local explanation)

Obtenez les valeurs d’importance de caractéristique individuelle de différents points de données en appelant des explicatifs pour une instance individuelle ou un groupe d’instances.Get the individual feature importance values of different datapoints by calling explanations for an individual instance or a group of instances.

Notes

PFIExplainer ne prend pas en charge les explicatifs locaux.PFIExplainer does not support local explanations.

# get explanation for the first data point in the test set
local_explanation = explainer.explain_local(x_test[0:5])

# sorted feature importance values and feature names
sorted_local_importance_names = local_explanation.get_ranked_local_names()
sorted_local_importance_values = local_explanation.get_ranked_local_values()

Transformations de fonctionnalité bruteRaw feature transformations

Vous pouvez choisir d’obtenir des explications en termes de fonctionnalités brutes, non transformées plutôt que de fonctionnalités conçues.You can opt to get explanations in terms of raw, untransformed features rather than engineered features. Pour cette option, vous transmettez votre pipeline de transformation de fonctionnalité à l’explicatif dans train_explain.py.For this option, you pass your feature transformation pipeline to the explainer in train_explain.py. Sinon, l’explicatif fournit des explications en termes de fonctionnalités conçues.Otherwise, the explainer provides explanations in terms of engineered features.

Le format de transformations prises en charge est le même que celui décrit dans sklearn-pandas.The format of supported transformations is the same as described in sklearn-pandas. En règle générale, toutes les transformations sont prises en charge tant qu’elles s’appliquent à une colonne unique et qu’elles constituent ainsi clairement des transformations un à plusieurs.In general, any transformations are supported as long as they operate on a single column so that it's clear they're one-to-many.

Pour obtenir une explication sur les fonctionnalités brutes, utilisez un sklearn.compose.ColumnTransformer ou une liste de tuples de transformateur adaptés.Get an explanation for raw features by using a sklearn.compose.ColumnTransformer or with a list of fitted transformer tuples. L’exemple suivant utilise sklearn.compose.ColumnTransformer.The following example uses sklearn.compose.ColumnTransformer.

from sklearn.compose import ColumnTransformer

numeric_transformer = Pipeline(steps=[
    ('imputer', SimpleImputer(strategy='median')),
    ('scaler', StandardScaler())])

categorical_transformer = Pipeline(steps=[
    ('imputer', SimpleImputer(strategy='constant', fill_value='missing')),
    ('onehot', OneHotEncoder(handle_unknown='ignore'))])

preprocessor = ColumnTransformer(
    transformers=[
        ('num', numeric_transformer, numeric_features),
        ('cat', categorical_transformer, categorical_features)])

# append classifier to preprocessing pipeline.
# now we have a full prediction pipeline.
clf = Pipeline(steps=[('preprocessor', preprocessor),
                      ('classifier', LogisticRegression(solver='lbfgs'))])


# clf.steps[-1][1] returns the trained classification model
# pass transformation as an input to create the explanation object
# "features" and "classes" fields are optional
tabular_explainer = TabularExplainer(clf.steps[-1][1],
                                     initialization_examples=x_train,
                                     features=dataset_feature_names,
                                     classes=dataset_classes,
                                     transformations=preprocessor)

Si vous souhaitez exécuter l’exemple avec la liste de tuples de transformateur adaptés, utilisez le code suivant :In case you want to run the example with the list of fitted transformer tuples, use the following code:

from sklearn.pipeline import Pipeline
from sklearn.impute import SimpleImputer
from sklearn.preprocessing import StandardScaler, OneHotEncoder
from sklearn.linear_model import LogisticRegression
from sklearn_pandas import DataFrameMapper

# assume that we have created two arrays, numerical and categorical, which holds the numerical and categorical feature names

numeric_transformations = [([f], Pipeline(steps=[('imputer', SimpleImputer(
    strategy='median')), ('scaler', StandardScaler())])) for f in numerical]

categorical_transformations = [([f], OneHotEncoder(
    handle_unknown='ignore', sparse=False)) for f in categorical]

transformations = numeric_transformations + categorical_transformations

# append model to preprocessing pipeline.
# now we have a full prediction pipeline.
clf = Pipeline(steps=[('preprocessor', DataFrameMapper(transformations)),
                      ('classifier', LogisticRegression(solver='lbfgs'))])

# clf.steps[-1][1] returns the trained classification model
# pass transformation as an input to create the explanation object
# "features" and "classes" fields are optional
tabular_explainer = TabularExplainer(clf.steps[-1][1],
                                     initialization_examples=x_train,
                                     features=dataset_feature_names,
                                     classes=dataset_classes,
                                     transformations=transformations)

Générer des valeurs d’importance d’une caractéristique par le biais d’exécutions distantesGenerate feature importance values via remote runs

L’exemple suivant montre comment vous pouvez utiliser la classe ExplanationClient pour activer l’interprétation du modèle pour les exécutions distantes.The following example shows how you can use the ExplanationClient class to enable model interpretability for remote runs. Son concept est similaire à celui du processus local, à l’exception des éléments suivants :It is conceptually similar to the local process, except you:

  • Utilisez ExplanationClient dans l’exécution à distance pour télécharger le contexte d’interprétation.Use the ExplanationClient in the remote run to upload the interpretability context.
  • Téléchargez le contexte ultérieurement dans un environnement local.Download the context later in a local environment.
  1. Installez le package azureml-interpret.Install the azureml-interpret package.

    pip install azureml-interpret
    
  2. Créez un script d’entraînement dans un notebook Jupyter local.Create a training script in a local Jupyter Notebook. Par exemple : train_explain.py.For example, train_explain.py.

    from azureml.interpret import ExplanationClient
    from azureml.core.run import Run
    from interpret.ext.blackbox import TabularExplainer
    
    run = Run.get_context()
    client = ExplanationClient.from_run(run)
    
    # write code to get and split your data into train and test sets here
    # write code to train your model here 
    
    # explain predictions on your local machine
    # "features" and "classes" fields are optional
    explainer = TabularExplainer(model, 
                                 x_train, 
                                 features=feature_names, 
                                 classes=classes)
    
    # explain overall model predictions (global explanation)
    global_explanation = explainer.explain_global(x_test)
    
    # uploading global model explanation data for storage or visualization in webUX
    # the explanation can then be downloaded on any compute
    # multiple explanations can be uploaded
    client.upload_model_explanation(global_explanation, comment='global explanation: all features')
    # or you can only upload the explanation object with the top k feature info
    #client.upload_model_explanation(global_explanation, top_k=2, comment='global explanation: Only top 2 features')
    
  3. Configurez une capacité de calcul Machine Learning comme cible de calcul et envoyez votre exécution d’apprentissage.Set up an Azure Machine Learning Compute as your compute target and submit your training run. Pour obtenir des instructions, consultez Créer et gérer des clusters de calcul Azure Machine Learning.See Create and manage Azure Machine Learning compute clusters for instructions. Vous pourriez également trouver les exemples de notebook utiles.You might also find the example notebooks helpful.

  4. Téléchargez l’explication dans votre notebook Jupyter local.Download the explanation in your local Jupyter Notebook.

    from azureml.interpret import ExplanationClient
    
    client = ExplanationClient.from_run(run)
    
    # get model explanation data
    explanation = client.download_model_explanation()
    # or only get the top k (e.g., 4) most important features with their importance values
    explanation = client.download_model_explanation(top_k=4)
    
    global_importance_values = explanation.get_ranked_global_values()
    global_importance_names = explanation.get_ranked_global_names()
    print('global importance values: {}'.format(global_importance_values))
    print('global importance names: {}'.format(global_importance_names))
    

VisualisationsVisualizations

Une fois que vous avez téléchargé les explications dans votre notebook Jupyter local, vous pouvez utiliser le tableau de bord de visualisation pour comprendre et interpréter votre modèle.After you download the explanations in your local Jupyter Notebook, you can use the visualization dashboard to understand and interpret your model. Pour charger le widget de tableau de bord de visualisation dans votre notebook Jupyter, utilisez le code suivant :To load the visualization dashboard widget in your Jupyter Notebook, use the following code:

from interpret_community.widget import ExplanationDashboard

ExplanationDashboard(global_explanation, model, datasetX=x_test)

La visualisation prend en charge les explications sur les caractéristiques de conception et brutes.The visualization supports explanations on both engineered and raw features. Les explications brutes sont basées sur les caractéristiques issues du jeu de données d’origine et les explications de conception sont basées sur les caractéristiques issues du jeu de données auquel s’applique l’ingénierie des caractéristiques.Raw explanations are based on the features from the original dataset and engineered explanations are based on the features from the dataset with feature engineering applied.

Lorsque vous tentez d’interpréter un modèle par rapport au jeu de données d’origine, il est recommandé d’utiliser des explications brutes, car l’importance de chaque caractéristique correspond à une colonne du jeu de données d’origine.When attempting to interpret a model with respect to the original dataset it is recommended to use raw explanations as each feature importance will correspond to a column from the original dataset. L’examen de l’impact des catégories individuelles à partir d’une caractéristique catégorielle est un scénario dans lequel les explications de conception peuvent être utiles.One scenario where engineered explanations might be useful is when examining the impact of individual categories from a categorical feature. Si un encodage à chaud est appliqué à une caractéristique catégorielle, les explications de conception qui en résultent comportent une valeur d’importance différente par catégorie, une par caractéristique de conception à chaud.If a one-hot encoding is applied to a categorical feature, then the resulting engineered explanations will include a different importance value per category, one per one-hot engineered feature. Cela peut être utile lorsque vous vous concentrez sur la partie du jeu de données qui fournit le plus d’informations au modèle.This can be useful when narrowing down which part of the dataset is most informative to the model.

Notes

Les explications de conception et brutes sont calculées séquentiellement.Engineered and raw explanations are computed sequentially. En premier lieu, une explication de conception est créée sur la base du modèle et du pipeline de caractérisation.First an engineered explanation is created based on the model and featurization pipeline. Ensuite, l’explication brute est créée sur la base de cette explication de conception, en agrégeant l’importance des caractéristiques de conception issues de la même caractéristique brute.Then the raw explanation is created based on that engineered explanation by aggregating the importance of engineered features that came from the same raw feature.

Créer, modifier et afficher des cohortes de jeu de donnéesCreate, edit and view dataset cohorts

Le ruban supérieur affiche des statistiques globales sur votre modèle et vos données.The top ribbon shows the overall statistics on your model and data. Vous pouvez segmenter et découper vos données en cohortes de jeu de données, ou sous-groupes, pour examiner ou comparer les performances et les explications de votre modèle dans ces sous-groupes définis.You can slice and dice your data into dataset cohorts, or subgroups, to investigate or compare your model’s performance and explanations across these defined subgroups. En comparant les statistiques et les explications de votre jeu de données entre ces sous-groupes, vous pouvez vous faire une idée de la raison pour laquelle des erreurs peuvent se produire dans un groupe plutôt qu’un autre.By comparing your dataset statistics and explanations across those subgroups, you can get a sense of why possible errors are happening in one group versus another.

Création, modification et affichage de cohortes de jeu de donnéesCreating, editing, and viewing dataset cohorts

Comprendre le comportement de la totalité du modèle (explication globale)Understand entire model behavior (global explanation)

Les trois premiers onglets du tableau de bord d’explication fournissent une analyse globale du modèle entraîné, avec ses prédictions et explications.The first three tabs of the explanation dashboard provide an overall analysis of the trained model along with its predictions and explanations.

Performances du modèleModel performance

Évaluez les performances de votre modèle en explorant la distribution de vos valeurs de prédiction et les valeurs des métriques de performances de votre modèle.Evaluate the performance of your model by exploring the distribution of your prediction values and the values of your model performance metrics. Vous pouvez approfondir l’étude de votre modèle en examinant une analyse comparative de ses performances entre différentes cohortes ou sous-groupes de votre jeu de données.You can further investigate your model by looking at a comparative analysis of its performance across different cohorts or subgroups of your dataset. Sélectionnez des filtres le long de la valeur y et de la valeur x pour couper différentes dimensions.Select filters along y-value and x-value to cut across different dimensions. Affichez les métriques telles que la justesse, la précision, le rappel, le taux de faux positifs (FPR) et le taux de faux négatif (FNR).View metrics such as accuracy, precision, recall, false positive rate (FPR) and false negative rate (FNR).

Onglet des performances du modèle dans la visualisation des explicationsModel performance tab in the explanation visualization

Explorateur de jeu de donnéesDataset explorer

Explorez les statistiques de votre jeu de données en sélectionnant différents filtres le long des axes X, Y et des couleurs pour découper vos données selon différentes dimensions.Explore your dataset statistics by selecting different filters along the X, Y, and color axes to slice your data along different dimensions. Créez les cohortes de jeu de données ci-dessus pour analyser les statistiques du jeu de données à l’aide de filtres, tels que le résultat prédit, les caractéristiques du jeu de données et les groupes d’erreurs.Create dataset cohorts above to analyze dataset statistics with filters such as predicted outcome, dataset features and error groups. Utilisez l’icône d’engrenage en haut à droite du graphique pour changer les types de graphique.Use the gear icon in the upper right-hand corner of the graph to change graph types.

Onglet de l’explorateur de jeu de données dans la visualisation des explicationsDataset explorer tab in the explanation visualization

Agréger l’importance des caractéristiquesAggregate feature importance

Explorez les k caractéristiques les plus importantes qui ont un impact sur vos prédictions de modèle globales (également appelées explication globale).Explore the top-k important features that impact your overall model predictions (also known as global explanation). Utilisez le curseur pour afficher les valeurs d’importance des caractéristiques décroissantes.Use the slider to show descending feature importance values. Sélectionnez jusqu’à trois cohortes pour voir leurs valeurs d’importance de caractéristiques côte à côte.Select up to three cohorts to see their feature importance values side by side. Cliquez sur l’une des barres de caractéristiques du graphique pour voir comment les valeurs de la caractéristique sélectionnée influencent la prédiction de modèle dans le tracé des dépendances ci-dessous.Click on any of the feature bars in the graph to see how values of the selected feature impact model prediction in the dependence plot below.

Onglet Agréger l’importance des caractéristiques dans la visualisation des explicationsAggregate feature importance tab in the explanation visualization

Comprendre les prédictions individuelles (explication locale)Understand individual predictions (local explanation)

Le quatrième onglet des explications vous permet d’explorer un point de données individuel et l’importance de ses caractéristiques individuelles.The fourth tab of the explanation tab lets you drill into an individual datapoint and their individual feature importances. Vous pouvez charger le tracé de l’importance des caractéristiques individuelles pour n’importe quel point de données en cliquant sur l’un des points de données individuels dans le nuage de points principal ou en sélectionnant un point de données spécifique dans le volet d’Assistant de droite.You can load the individual feature importance plot for any data point by clicking on any of the individual data points in the main scatter plot or selecting a specific datapoint in the panel wizard on the right.

TracéPlot DescriptionDescription
Importance des caractéristiques individuellesIndividual feature importance Montre les k caractéristiques les plus importantes pour une prédiction individuelle.Shows the top-k important features for an individual prediction. Permet d’illustrer le comportement local du modèle sous-jacent sur un point de données spécifique.Helps illustrate the local behavior of the underlying model on a specific data point.
Analyse de simulationWhat-If analysis Autorise les modifications des valeurs de caractéristiques du point de données réel sélectionné et observe les modifications résultantes de la valeur de prédiction en générant un point de données hypothétique avec les nouvelles valeurs de caractéristiques.Allows changes to feature values of the selected real data point and observe resulting changes to prediction value by generating a hypothetical datapoint with the new feature values.
Attente conditionnelle individuelle (ICE)Individual Conditional Expectation (ICE) Autorise les modifications de valeur de fonctionnalité d’une valeur minimale à une valeur maximale.Allows feature value changes from a minimum value to a maximum value. Permet d’illustrer la façon dont la prédiction du point de données change en cas de modification d’une fonctionnalité.Helps illustrate how the data point's prediction changes when a feature changes.

Importance des caractéristiques individuelles et onglet Simulation dans le tableau de bord d’explicationIndividual feature importance and What-if tab in explanation dashboard

Notes

Il s’agit d’explications basées sur de nombreuses approximations et non pas de la « cause » des prédictions.These are explanations based on many approximations and are not the "cause" of predictions. Sans une robustesse mathématique stricte de l’inférence de causalité, nous ne conseillons pas aux utilisateurs de prendre des décisions concrètes en fonction des perturbations des caractéristiques de l’outil de simulation.Without strict mathematical robustness of causal inference, we do not advise users to make real-life decisions based on the feature perturbations of the What-If tool. Cet outil est principalement destiné à la compréhension de votre modèle et au débogage.This tool is primarily for understanding your model and debugging.

Visualisation dans Azure Machine Learning StudioVisualization in Azure Machine Learning studio

Si vous effectuez les étapes décrites dans l’interprétabilité à distance (chargement de l’explication générée sur l’historique des exécutions d’Azure Machine Learning), vous pouvez voir le tableau de bord de visualisation dans Azure Machine Learning Studio.If you complete the remote interpretability steps (uploading generated explanation to Azure Machine Learning Run History), you can view the visualization dashboard in Azure Machine Learning studio. Ce tableau de bord est une version plus simple du tableau de bord de visualisation décrit ci-dessus.This dashboard is a simpler version of the visualization dashboard explained above. Les tracés ICE et de génération de point de données de simulation sont désactivés, car il n’existe aucun calcul actif dans Azure Machine Learning Studio à même d’effectuer leurs calculs en temps réel.What-If datapoint generation and ICE plots are disabled as there is no active compute in Azure Machine Learning studio that can perform their real time computations.

Si les explications de jeu de données, globales et locales sont disponibles, les données remplissent tous les onglets.If the dataset, global, and local explanations are available, data populates all of the tabs. Si seule une explication globale est disponible, l’onglet Importance des caractéristiques individuelles est désactivé.If only a global explanation is available, the Individual feature importance tab will be disabled.

Suivez un de ces parcours pour accéder au tableau de bord de visualisation dans Azure Machine Learning Studio :Follow one of these paths to access the visualization dashboard in Azure Machine Learning studio:

  • Volet des Expériences (préversion)Experiments pane (Preview)

    1. Sélectionnez Expériences dans le volet gauche pour afficher la liste des expériences que vous avez exécutées sur Azure Machine Learning.Select Experiments in the left pane to see a list of experiments that you've run on Azure Machine Learning.
    2. Sélectionnez une expérience particulière pour afficher toutes les exécutions de cette expérience.Select a particular experiment to view all the runs in that experiment.
    3. Sélectionnez une exécution, puis l'onglet Explications pour voir le tableau de bord de visualisation des explications.Select a run, and then the Explanations tab to the explanation visualization dashboard.

    Tableau de bord de visualisation avec Agréger l’importance des caractéristiques dans AzureML Studio dans les expériencesVisualization Dashboard with Aggregate Feature Importance in AzureML studio in experiments

  • Volet ModèlesModels pane

    1. Si vous avez enregistré votre modèle d’origine en suivant les étapes décrites dans Déployer des modèles avec Azure Machine Learning, vous pouvez sélectionner Modèles dans le volet gauche pour l’afficher.If you registered your original model by following the steps in Deploy models with Azure Machine Learning, you can select Models in the left pane to view it.
    2. Sélectionnez un modèle, puis l'onglet Explications pour voir le tableau de bord de visualisation des explications.Select a model, and then the Explanations tab to view the explanation visualization dashboard.

Interprétabilité au moment de l’inférenceInterpretability at inference time

Vous pouvez déployer l’explicatif avec le modèle d’origine et l’utiliser au moment de l’inférence pour fournir les valeurs d’importance des caractéristiques individuelles (explication locale) pour tout nouveau point de donnée.You can deploy the explainer along with the original model and use it at inference time to provide the individual feature importance values (local explanation) for any new datapoint. Nous proposons également des explicatifs de scoring plus légers pour améliorer les performances d’interprétabilité au moment de l’inférence, qui sont actuellement pris en charge uniquement dans le kit SDK Azure Machine Learning.We also offer lighter-weight scoring explainers to improve interpretability performance at inference time, which is currently supported only in Azure Machine Learning SDK. Le processus de déploiement d’un explicatif de scoring plus léger est similaire au déploiement d’un modèle et comprend les étapes suivantes :The process of deploying a lighter-weight scoring explainer is similar to deploying a model and includes the following steps:

  1. Créez un objet d’explication.Create an explanation object. Par exemple, vous pouvez utiliser TabularExplainer :For example, you can use TabularExplainer:

     from interpret.ext.blackbox import TabularExplainer
    
    
    explainer = TabularExplainer(model, 
                                 initialization_examples=x_train, 
                                 features=dataset_feature_names, 
                                 classes=dataset_classes, 
                                 transformations=transformations)
    
  2. Créer un explicatif de scoring avec l’objet d’explication.Create a scoring explainer with the explanation object.

    from azureml.interpret.scoring.scoring_explainer import KernelScoringExplainer, save
    
    # create a lightweight explainer at scoring time
    scoring_explainer = KernelScoringExplainer(explainer)
    
    # pickle scoring explainer
    # pickle scoring explainer locally
    OUTPUT_DIR = 'my_directory'
    save(scoring_explainer, directory=OUTPUT_DIR, exist_ok=True)
    
  3. Configurez et inscrivez une image qui utilise le modèle d’explicatif de scoring.Configure and register an image that uses the scoring explainer model.

    # register explainer model using the path from ScoringExplainer.save - could be done on remote compute
    # scoring_explainer.pkl is the filename on disk, while my_scoring_explainer.pkl will be the filename in cloud storage
    run.upload_file('my_scoring_explainer.pkl', os.path.join(OUTPUT_DIR, 'scoring_explainer.pkl'))
    
    scoring_explainer_model = run.register_model(model_name='my_scoring_explainer', 
                                                 model_path='my_scoring_explainer.pkl')
    print(scoring_explainer_model.name, scoring_explainer_model.id, scoring_explainer_model.version, sep = '\t')
    
  4. Vous pouvez éventuellement récupérer l’explicatif de scoring sur le cloud et tester les explications.As an optional step, you can retrieve the scoring explainer from cloud and test the explanations.

    from azureml.interpret.scoring.scoring_explainer import load
    
    # retrieve the scoring explainer model from cloud"
    scoring_explainer_model = Model(ws, 'my_scoring_explainer')
    scoring_explainer_model_path = scoring_explainer_model.download(target_dir=os.getcwd(), exist_ok=True)
    
    # load scoring explainer from disk
    scoring_explainer = load(scoring_explainer_model_path)
    
    # test scoring explainer locally
    preds = scoring_explainer.explain(x_test)
    print(preds)
    
  5. Déployez l’image sur une cible de calcul en procédant comme suit :Deploy the image to a compute target, by following these steps:

    1. Si nécessaire, enregistrez votre modèle de prédiction d’origine en suivant les étapes décrites dans Déployer des modèles avec Azure Machine Learning.If needed, register your original prediction model by following the steps in Deploy models with Azure Machine Learning.

    2. Créez un fichier de scoring.Create a scoring file.

      %%writefile score.py
      import json
      import numpy as np
      import pandas as pd
      import os
      import pickle
      from sklearn.externals import joblib
      from sklearn.linear_model import LogisticRegression
      from azureml.core.model import Model
      
      def init():
      
         global original_model
         global scoring_model
      
         # retrieve the path to the model file using the model name
         # assume original model is named original_prediction_model
         original_model_path = Model.get_model_path('original_prediction_model')
         scoring_explainer_path = Model.get_model_path('my_scoring_explainer')
      
         original_model = joblib.load(original_model_path)
         scoring_explainer = joblib.load(scoring_explainer_path)
      
      def run(raw_data):
         # get predictions and explanations for each data point
         data = pd.read_json(raw_data)
         # make prediction
         predictions = original_model.predict(data)
         # retrieve model explanations
         local_importance_values = scoring_explainer.explain(data)
         # you can return any data type as long as it is JSON-serializable
         return {'predictions': predictions.tolist(), 'local_importance_values': local_importance_values}
      
    3. Définissez la configuration du déploiement.Define the deployment configuration.

      Cette configuration dépend des exigences de votre modèle.This configuration depends on the requirements of your model. L’exemple suivant définit une configuration qui utilise un seul cœur d’UC et 1 Go de mémoire.The following example defines a configuration that uses one CPU core and one GB of memory.

      from azureml.core.webservice import AciWebservice
      
       aciconfig = AciWebservice.deploy_configuration(cpu_cores=1,
                                                 memory_gb=1,
                                                 tags={"data": "NAME_OF_THE_DATASET",
                                                       "method" : "local_explanation"},
                                                 description='Get local explanations for NAME_OF_THE_PROBLEM')
      
    4. Créer un fichier avec des dépendances d’environnement.Create a file with environment dependencies.

      from azureml.core.conda_dependencies import CondaDependencies
      
      # WARNING: to install this, g++ needs to be available on the Docker image and is not by default (look at the next cell)
      
      azureml_pip_packages = ['azureml-defaults', 'azureml-core', 'azureml-telemetry', 'azureml-interpret']
      
      
      # specify CondaDependencies obj
      myenv = CondaDependencies.create(conda_packages=['scikit-learn', 'pandas'],
                                       pip_packages=['sklearn-pandas'] + azureml_pip_packages,
                                       pin_sdk_version=False)
      
      
      with open("myenv.yml","w") as f:
         f.write(myenv.serialize_to_string())
      
      with open("myenv.yml","r") as f:
         print(f.read())
      
    5. Créer un fichier dockerfile personnalisé avec g++ installé.Create a custom dockerfile with g++ installed.

      %%writefile dockerfile
      RUN apt-get update && apt-get install -y g++
      
    6. Déployez l’image créée.Deploy the created image.

      Ce processus prend environ cinq minutes.This process takes approximately five minutes.

      from azureml.core.webservice import Webservice
      from azureml.core.image import ContainerImage
      
      # use the custom scoring, docker, and conda files we created above
      image_config = ContainerImage.image_configuration(execution_script="score.py",
                                                      docker_file="dockerfile",
                                                      runtime="python",
                                                      conda_file="myenv.yml")
      
      # use configs and models generated above
      service = Webservice.deploy_from_model(workspace=ws,
                                          name='model-scoring-service',
                                          deployment_config=aciconfig,
                                          models=[scoring_explainer_model, original_model],
                                          image_config=image_config)
      
      service.wait_for_deployment(show_output=True)
      
  6. Testez le déploiement.Test the deployment.

    import requests
    
    # create data to test service with
    examples = x_list[:4]
    input_data = examples.to_json()
    
    headers = {'Content-Type':'application/json'}
    
    # send request to service
    resp = requests.post(service.scoring_uri, input_data, headers=headers)
    
    print("POST to url", service.scoring_uri)
    # can covert back to Python objects from json string if desired
    print("prediction:", resp.text)
    
  7. Nettoyer.Clean up.

    Pour supprimer un service web déployé, utilisez service.delete().To delete a deployed web service, use service.delete().

Résolution des problèmesTroubleshooting

  • Données éparses non prises en charge : Le tableau de bord d’explication de modèle s’interrompt/ralentit considérablement avec un grand nombre de caractéristiques. Par conséquent, nous ne prenons actuellement pas en charge le format de données éparses.Sparse data not supported: The model explanation dashboard breaks/slows down substantially with a large number of features, therefore we currently do not support sparse data format. En outre, des problèmes de mémoire générale surviendront avec les jeux de données volumineux et un grand nombre de caractéristiques.Additionally, general memory issues will arise with large datasets and large number of features.

  • Modèles de prévision non pris en charge avec les explications de modèle : L’interprétabilité, la meilleure explication du modèle, n’est pas disponible pour les expériences de prévision AutoML, qui recommandent les algorithmes suivants comme modèle optimal : TCNForecaster, AutoArima, Prophet, ExponentialSmoothing, Moyenne, Naïf, Moyenne saisonnière et Naïf saisonnier.Forecasting models not supported with model explanations: Interpretability, best model explanation, is not available for AutoML forecasting experiments that recommend the following algorithms as the best model: TCNForecaster, AutoArima, Prophet, ExponentialSmoothing, Average, Naive, Seasonal Average, and Seasonal Naive. La prévision AutoML a des modèles de régression qui prennent en charge les explications.AutoML Forecasting has regression models which support explanations. Toutefois, dans le tableau de bord d’explication, l’onglet « Importance des caractéristiques individuelles » n’est simplement pas pris en charge pour la prévision en raison de la complexité des pipelines de données.However, in the explanation dashboard, the "Individual feature importance" tab is just not supported for forecasting because of complexity in their data pipelines.

  • Explication locale d’index de données : Le tableau de bord d’explication ne prend pas en charge l’association des valeurs d’importance locale à un identificateur de ligne issu du jeu de données de validation d’origine si ce jeu de données dépasse les 5 000 points de données, car le tableau de bord sous-échantillonne les données de manière aléatoire.Local explanation for data index: The explanation dashboard does not support relating local importance values to a row identifier from the original validation dataset if that dataset is greater than 5000 datapoints as the dashboard randomly downsamples the data. Toutefois, le tableau de bord affiche les valeurs de caractéristiques de jeu de données brutes pour chaque point de données transmis dans le tableau de bord sous l’onglet Importance des caractéristiques individuelles. Les utilisateurs peuvent mapper les importantes locales en retour sur le jeu de données d’origine en faisant correspondre les valeurs de caractéristiques de jeu de données brutes.However, the dashboard shows raw dataset feature values for each datapoint passed into the dashboard under the Individual feature importance tab. Users can map local importances back to the original dataset through matching the raw dataset feature values. Si la taille du jeu de données de validation est inférieure à 5 000 échantillons, la caractéristique index dans AzureML Studio correspond à l’index dans le jeu de données de validation.If the validation dataset size is less than 5000 samples, the index feature in AzureML studio will correspond to the index in the validation dataset.

  • Tracés de simulation/ICE non pris en charge dans Studio : Les tracés de simulation et d’attente conditionnelle individuelle (ICE) ne sont pas pris en charge dans Azure Machine Learning Studio sous l’onglet Explications puisque l’explication chargée a besoin d’un calcul actif pour recalculer les prédictions et les probabilités des caractéristiques perturbées.What-if/ICE plots not supported in studio: What-If and Individual Conditional Expectation (ICE) plots are not supported in Azure Machine Learning studio under the Explanations tab since the uploaded explanation needs an active compute to recalculate predictions and probabilities of perturbed features. Ils sont actuellement pris en charge dans les notebooks Jupyter lorsqu’ils sont exécutés en tant que widget à l’aide du kit SDK.It is currently supported in Jupyter notebooks when run as a widget using the SDK.

Étapes suivantesNext steps

En savoir plus sur l’interprétation des modèlesLearn more about model interpretability

Consultez les exemples de notebooks sur l’interprétabilité d’Azure Machine LearningCheck out Azure Machine Learning Interpretability sample notebooks