Używanie pakietu możliwości interpretowania do wyjaśniania modeli uczenia maszynowego & w języku Python (wersja zapoznawcza)Use the interpretability package to explain ML models & predictions in Python (preview)

Z tego przewodnika dowiesz się, jak używać pakietu możliwości interpretowania zestawu SDK języka Python Azure Machine Learning do wykonywania następujących zadań:In this how-to guide, you learn to use the interpretability package of the Azure Machine Learning Python SDK to perform the following tasks:

  • Wyjaśnienie całego zachowania modelu lub poszczególnych przewidywań na komputerze osobistym lokalnie.Explain the entire model behavior or individual predictions on your personal machine locally.

  • Włączanie technik interpretacji dla funkcji inżynierowanych.Enable interpretability techniques for engineered features.

  • Wyjaśnienie zachowania dla całego modelu i poszczególnych przewidywań na platformie Azure.Explain the behavior for the entire model and individual predictions in Azure.

  • Użyj pulpitu nawigacyjnego wizualizacji, aby korzystać z wyjaśnień modelu.Use a visualization dashboard to interact with your model explanations.

  • Wdobyj objaśnienie oceniania obok modelu, aby obserwować wyjaśnienia podczas wnioskowania.Deploy a scoring explainer alongside your model to observe explanations during inferencing.

Aby uzyskać więcej informacji na temat obsługiwanych technik interpretacji i modeli uczenia maszynowego, zobacz Możliwości interpretowania modelu w Azure Machine Learning notesach i przykładach.For more information on the supported interpretability techniques and machine learning models, see Model interpretability in Azure Machine Learning and sample notebooks.

Aby uzyskać wskazówki dotyczące włączania możliwości interpretowania modeli wytrenowany za pomocą zautomatyzowanego uczenia maszynowego, zobacz Interpretability: model explanations for automated machine learning models (preview) (Możliwości interpretowania: wyjaśnieniamodeli zautomatyzowanego uczenia maszynowego (wersja zapoznawcza) ).For guidance on how to enable interpretability for models trained with automated machine learning see, Interpretability: model explanations for automated machine learning models (preview).

Generowanie wartości ważności funkcji na komputerze osobistymGenerate feature importance value on your personal machine

W poniższym przykładzie pokazano, jak używać pakietu możliwości interpretowania na komputerze osobistym bez kontaktowania się z usługami platformy Azure.The following example shows how to use the interpretability package on your personal machine without contacting Azure services.

  1. Zainstaluj pakiet azureml-interpret.Install the azureml-interpret package.

    pip install azureml-interpret
    
  2. Trenowanie przykładowego modelu w lokalnym Jupyter Notebook.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. Wywołaj objaśnienia lokalnie.Call the explainer locally.

    • Aby zainicjować obiekt objaśnienia, przekaż model i niektóre dane szkoleniowe do konstruktora objaśniacza.To initialize an explainer object, pass your model and some training data to the explainer's constructor.
    • Aby wyjaśnienia i wizualizacje zawierały więcej informacji, można przekazać nazwy funkcji i wyjściowe nazwy klas w przypadku klasyfikacji.To make your explanations and visualizations more informative, you can choose to pass in feature names and output class names if doing classification.

    Poniższe bloki kodu pokazują, jak utworzyć wystąpienia obiektu objaśnienia za pomocą TabularExplainer obiektów MimicExplainer , i PFIExplainer lokalnie.The following code blocks show how to instantiate an explainer object with TabularExplainer, MimicExplainer, and PFIExplainer locally.

    • TabularExplainer Wywołuje jeden z trzech objaśnienia SHAP poniżej ( TreeExplainer DeepExplainer , , lub KernelExplainer ).TabularExplainer calls one of the three SHAP explainers underneath (TreeExplainer, DeepExplainer, or KernelExplainer).
    • TabularExplainer Automatycznie wybiera najbardziej odpowiedni dla Twojego przypadku użycia, ale możesz bezpośrednio wywołać każdego z trzech podstawowych objaśnień.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)
    

    lubor

    
    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)
    

    lubor

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

Wyjaśnienie całego zachowania modelu (wyjaśnienie globalne)Explain the entire model behavior (global explanation)

Zapoznaj się z poniższym przykładem, aby uzyskać zagregowane (globalne) wartości ważności funkcji.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()

Wyjaśnienie poszczególnych przewidywań (wyjaśnienie lokalne)Explain an individual prediction (local explanation)

Pobierz wartości ważności poszczególnych cech dla różnych punktów danych, wywołując wyjaśnienia dla poszczególnych wystąpień lub grup wystąpień.Get the individual feature importance values of different datapoints by calling explanations for an individual instance or a group of instances.

Uwaga

PFIExplainer Nie obsługuje lokalnych wyjaśnień.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()

Nieprzetworzone przekształcenia funkcjiRaw feature transformations

Zamiast tworzonych funkcji można uzyskać wyjaśnienia dotyczące nieprzetworzonych, nieprzetworzonych funkcji.You can opt to get explanations in terms of raw, untransformed features rather than engineered features. W przypadku tej opcji potok przekształcania funkcji jest przekazywać do objaśnienia w programie train_explain.py .For this option, you pass your feature transformation pipeline to the explainer in train_explain.py. W przeciwnym razie objaśnienie zawiera wyjaśnienia dotyczące funkcji inżynierowanych.Otherwise, the explainer provides explanations in terms of engineered features.

Format obsługiwanych przekształceń jest taki sam, jak opisano w pliku sklearn-pandas.The format of supported transformations is the same as described in sklearn-pandas. Ogólnie rzecz biorąc, wszystkie przekształcenia są obsługiwane, o ile działają na jednej kolumnie, dzięki czemu jest jasne, że są one typu "jeden do wielu".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.

Uzyskaj wyjaśnienie cech pierwotnych przy użyciu funkcji lub z listą dopasowanych sklearn.compose.ColumnTransformer krotek transformatora.Get an explanation for raw features by using a sklearn.compose.ColumnTransformer or with a list of fitted transformer tuples. W poniższym przykładzie sklearn.compose.ColumnTransformer użyto .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)

Jeśli chcesz uruchomić przykład z listą dopasowanych krotek transformatora, użyj następującego kodu: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)

Generowanie wartości ważności funkcji za pośrednictwem przebiegów zdalnychGenerate feature importance values via remote runs

W poniższym przykładzie pokazano, jak można użyć klasy , aby włączyć możliwość interpretacji ExplanationClient modelu dla zdalnych przebiegów.The following example shows how you can use the ExplanationClient class to enable model interpretability for remote runs. Jest on koncepcyjnie podobny do procesu lokalnego, z tą różnicą, że:It is conceptually similar to the local process, except you:

  • Użyj w ExplanationClient zdalnym uruchomieniu, aby przekazać kontekst możliwości interpretacji.Use the ExplanationClient in the remote run to upload the interpretability context.
  • Pobierz kontekst później w środowisku lokalnym.Download the context later in a local environment.
  1. Zainstaluj pakiet azureml-interpret.Install the azureml-interpret package.

    pip install azureml-interpret
    
  2. Utwórz skrypt trenowania w lokalnym Jupyter Notebook.Create a training script in a local Jupyter Notebook. Na przykład 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. Skonfiguruj usługę obliczeniową Azure Machine Learning compute jako docelowy obiekt obliczeniowy i prześlij przebieg trenowania.Set up an Azure Machine Learning Compute as your compute target and submit your training run. Aby uzyskać instrukcje, Azure Machine Learning tworzenie klastrów obliczeniowych i zarządzanie nimi.See Create and manage Azure Machine Learning compute clusters for instructions. Przydatne mogą być również przykładowe notesy.You might also find the example notebooks helpful.

  4. Pobierz wyjaśnienie w pliku Jupyter Notebook.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))
    

WizualizacjeVisualizations

Po pobraniu wyjaśnień w lokalnym Jupyter Notebook możesz użyć wizualizacji na pulpicie nawigacyjnym z wyjaśnieniami, aby zrozumieć i zinterpretować model.After you download the explanations in your local Jupyter Notebook, you can use the visualizations in the explanations dashboard to understand and interpret your model. Aby załadować widżet pulpitu nawigacyjnego objaśnień w Jupyter Notebook, użyj następującego kodu:To load the explanations dashboard widget in your Jupyter Notebook, use the following code:

from interpret_community.widget import ExplanationDashboard

ExplanationDashboard(global_explanation, model, datasetX=x_test)

Wizualizacje obsługują wyjaśnienia dotyczące zarówno funkcji inżynierowanych, jak i nieprzetworzonych.The visualizations support explanations on both engineered and raw features. Nieprzetworzone wyjaśnienia są oparte na funkcjach z oryginalnego zestawu danych, a inżynieryjne wyjaśnienia są oparte na funkcjach z zestawu danych z zastosowaną inżynierią cech.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.

Podczas próby interpretacji modelu względem oryginalnego zestawu danych zaleca się użycie pierwotnych wyjaśnień, ponieważ każda ważność funkcji będzie odpowiadać kolumnie z oryginalnego zestawu danych.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. Jednym ze scenariuszy, w którym inżynierowie mogą być przydatni, jest badanie wpływu poszczególnych kategorii z funkcji podzielonej na kategorie.One scenario where engineered explanations might be useful is when examining the impact of individual categories from a categorical feature. Jeśli kodowanie "gorąca" zostanie zastosowane do funkcji kategoriacznej, wynikowe wyjaśnienia inżynierów będą zawierać inną wartość ważności dla każdej kategorii, jedną na jedną funkcję inżynieryjną z gorącą gorącą.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. Może to być przydatne podczas zawężania, która część zestawu danych jest najbardziej wartościowa dla modelu.This can be useful when narrowing down which part of the dataset is most informative to the model.

Uwaga

Inżynierowie i nieprzetworzone wyjaśnienia są obliczane sekwencyjnie.Engineered and raw explanations are computed sequentially. Najpierw zostanie utworzone inżynierowane wyjaśnienie na podstawie modelu i potoku cechowania.First an engineered explanation is created based on the model and featurization pipeline. Następnie nieprzetworzone wyjaśnienie jest tworzone na podstawie tego zaprojektowanego wyjaśnienia przez agregowanie znaczenia cech inżynierowanych, które pochodziły z tej samej funkcji pierwotnej.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.

Tworzenie, edytowanie i wyświetlanie kohort zestawu danychCreate, edit and view dataset cohorts

Górna wstążka przedstawia ogólne statystyki dotyczące modelu i danych.The top ribbon shows the overall statistics on your model and data. Dane można ująć w kohorty zestawów danych lub podgrupy, aby zbadać lub porównać wydajność i wyjaśnienia modelu w tych zdefiniowanych podgrupach.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. Porównując statystyki zestawu danych i wyjaśnienia w tych podgrupach, można określić, dlaczego możliwe błędy występują w jednej grupie, a dlaczego w innej.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.

Tworzenie, edytowanie i wyświetlanie kohort zestawu danychCreating, editing, and viewing dataset cohorts

Opis całego zachowania modelu (wyjaśnienie globalne)Understand entire model behavior (global explanation)

Pierwsze trzy karty pulpitu nawigacyjnego wyjaśnienia zawierają ogólną analizę wytrenowany model wraz z jego przewidywaniami i wyjaśnieniami.The first three tabs of the explanation dashboard provide an overall analysis of the trained model along with its predictions and explanations.

Wydajność modeluModel performance

Oceń wydajność modelu, eksplorując rozkład wartości przewidywania i wartości metryk wydajności modelu.Evaluate the performance of your model by exploring the distribution of your prediction values and the values of your model performance metrics. Możesz dokładniej zbadać model, analizą porównawczą jego wydajności w różnych kohorcie lub podgrupach zestawu danych.You can further investigate your model by looking at a comparative analysis of its performance across different cohorts or subgroups of your dataset. Wybierz filtry wzdłuż wartości y i x,aby wycinać różne wymiary.Select filters along y-value and x-value to cut across different dimensions. Wyświetl metryki, takie jak dokładność, precyzja, przywołanie, wskaźnik wyników fałszywie dodatnich (FPR) i wskaźnik wyników fałszywie ujemnych (FNR).View metrics such as accuracy, precision, recall, false positive rate (FPR) and false negative rate (FNR).

Karta Wydajności modelu w wizualizacji wyjaśnieniaModel performance tab in the explanation visualization

Eksplorator zestawów danychDataset explorer

Eksploruj statystyki zestawu danych, wybierając różne filtry wzdłuż osi X, Y i kolorów, aby fragmentować dane na różne wymiary.Explore your dataset statistics by selecting different filters along the X, Y, and color axes to slice your data along different dimensions. Utwórz kohorty zestawów danych powyżej, aby analizować statystyki zestawu danych za pomocą filtrów, takich jak przewidywany wynik, funkcje zestawu danych i grupy błędów.Create dataset cohorts above to analyze dataset statistics with filters such as predicted outcome, dataset features and error groups. Użyj ikony koła zębatego w prawym górnym rogu wykresu, aby zmienić typy wykresów.Use the gear icon in the upper right-hand corner of the graph to change graph types.

Karta Eksploratora zestawów danych w wizualizacji wyjaśnieniaDataset explorer tab in the explanation visualization

Agregowanie ważności funkcjiAggregate feature importance

Zapoznaj się z najważniejszymi funkcjami, które mają wpływ na ogólne przewidywania modelu (tzw. wyjaśnienie globalne).Explore the top-k important features that impact your overall model predictions (also known as global explanation). Użyj suwaka, aby wyświetlić malejące wartości ważności cech.Use the slider to show descending feature importance values. Wybierz maksymalnie trzy kohorty, aby wyświetlić obok siebie wartości ważności funkcji.Select up to three cohorts to see their feature importance values side by side. Kliknij dowolny z pasków funkcji na wykresie, aby zobaczyć, jak wartości wybranej funkcji wpływają na przewidywanie modelu na poniższym wykresie zależności.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.

Karta Agregowanie ważności funkcji w wizualizacji wyjaśnieniaAggregate feature importance tab in the explanation visualization

Opis poszczególnych przewidywań (wyjaśnienie lokalne)Understand individual predictions (local explanation)

Czwarta karta wyjaśnienia umożliwia przechodzenie do szczegółów poszczególnych punktów danych i ich poszczególnych ważności funkcji.The fourth tab of the explanation tab lets you drill into an individual datapoint and their individual feature importances. Wykres ważności poszczególnych cech można załadować dla dowolnego punktu danych, klikając dowolny punkt danych na głównym wykresie punktowym lub wybierając konkretny punkt danych w kreatorze panelu po prawej stronie.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.

DziałkaPlot OpisDescription
Ważność poszczególnych funkcjiIndividual feature importance Przedstawia najważniejsze ważne funkcje dla poszczególnych przewidywań.Shows the top-k important features for an individual prediction. Pomaga zilustrować lokalne zachowanie podstawowego modelu w określonym punkcie danych.Helps illustrate the local behavior of the underlying model on a specific data point.
What-If analizyWhat-If analysis Umożliwia zmiany wartości cech wybranego rzeczywistego punktu danych i obserwowanie wynikowych zmian wartości przewidywania przez wygenerowanie hipotetycznego punktu danych z nowymi wartościami cech.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.
Indywidualne oczekiwanie warunkowe (ICE)Individual Conditional Expectation (ICE) Umożliwia zmianę wartości funkcji z wartości minimalnej na wartość maksymalną.Allows feature value changes from a minimum value to a maximum value. Pomaga zilustrować, jak zmienia się przewidywanie punktu danych po zmianie funkcji.Helps illustrate how the data point's prediction changes when a feature changes.

Ważność poszczególnych funkcji i karta What-if na pulpicie nawigacyjnym wyjaśnieniaIndividual feature importance and What-if tab in explanation dashboard

Uwaga

Są to wyjaśnienia oparte na wielu przybliżeniach i nie są "przyczyną" przewidywań.These are explanations based on many approximations and are not the "cause" of predictions. Bez ścisłej odporności matematycznej wnioskowania przyczynowego nie zalecamy użytkownikom podejmowania rzeczywistych decyzji na podstawie perturbacji funkcji What-If narzędzia.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. To narzędzie jest przeznaczone głównie do zrozumienia modelu i debugowania.This tool is primarily for understanding your model and debugging.

Wizualizacja w Azure Machine Learning studioVisualization in Azure Machine Learning studio

Jeśli ukończysz kroki zdalnej interpretacji (przekazywanie wygenerowanych wyjaśnień do historii uruchamiania usługi Azure Machine Learning), możesz wyświetlić wizualizacje na pulpicie nawigacyjnym objaśnień w Azure Machine Learning studio .If you complete the remote interpretability steps (uploading generated explanations to Azure Machine Learning Run History), you can view the visualizations on the explanations dashboard in Azure Machine Learning studio. Ten pulpit nawigacyjny jest prostszą wersją widżetu pulpitu nawigacyjnego wygenerowanego w notesie Jupyter.This dashboard is a simpler version of the dashboard widget thats generated within your Jupyter notebook. What-If generowania punktów danych i wykresów ICE są wyłączone, ponieważ nie ma aktywnych obliczeń w Azure Machine Learning studio, które mogą wykonywać obliczenia w czasie rzeczywistym.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.

Jeśli zestaw danych, objaśnienia globalne i lokalne są dostępne, dane wypełniają wszystkie karty.If the dataset, global, and local explanations are available, data populates all of the tabs. Jeśli dostępne jest tylko globalne wyjaśnienie, karta Ważność poszczególnych funkcji zostanie wyłączona.If only a global explanation is available, the Individual feature importance tab will be disabled.

Postępuj zgodnie z jedną z tych ścieżek, aby uzyskać dostęp do pulpitu nawigacyjnego z wyjaśnieniami w Azure Machine Learning studio:Follow one of these paths to access the explanations dashboard in Azure Machine Learning studio:

  • Okienko Eksperymenty (wersja zapoznawcza)Experiments pane (Preview)

    1. Wybierz pozycję Experiments (Eksperymenty) w okienku po lewej stronie, aby wyświetlić listę eksperymentów uruchomionych w Azure Machine Learning.Select Experiments in the left pane to see a list of experiments that you've run on Azure Machine Learning.
    2. Wybierz określony eksperyment, aby wyświetlić wszystkie przebiegi w tym eksperymencie.Select a particular experiment to view all the runs in that experiment.
    3. Wybierz przebieg, a następnie kartę Wyjaśnienia na pulpicie nawigacyjnym wizualizacji wyjaśnienia.Select a run, and then the Explanations tab to the explanation visualization dashboard.

    Pulpit nawigacyjny wizualizacji z zagregowaną ważnością funkcji w programie AzureML Studio w eksperymentachVisualization Dashboard with Aggregate Feature Importance in AzureML studio in experiments

  • Okienko ModeleModels pane

    1. Jeśli oryginalny model został zarejestrowany, zgodnie z instrukcjami z tematu Deploy models with Azure Machine Learning (Wdrażanie modeli za pomocą usługi Azure Machine Learning),możesz wybrać pozycję Modele w okienku po lewej stronie, aby go wyświetlić.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. Wybierz model, a następnie kartę Wyjaśnienia, aby wyświetlić pulpit nawigacyjny z wyjaśnieniami.Select a model, and then the Explanations tab to view the explanations dashboard.

Możliwości interpretowania w czasie wnioskowaniaInterpretability at inference time

Możesz wdrożyć objaśnienie wraz z oryginalnym modelem i użyć go podczas wnioskowania, aby podać poszczególne wartości ważności funkcji (wyjaśnienie lokalne) dla każdego nowego punktu danych.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. Oferujemy również lżejsze objaśnienia oceniania, aby poprawić wydajność interpretacji w czasie wnioskowania, która jest obecnie obsługiwana tylko w Azure Machine Learning SDK.We also offer lighter-weight scoring explainers to improve interpretability performance at inference time, which is currently supported only in Azure Machine Learning SDK. Proces wdrażania objaśnienia oceny lżejszej wagi jest podobny do wdrażania modelu i obejmuje następujące kroki:The process of deploying a lighter-weight scoring explainer is similar to deploying a model and includes the following steps:

  1. Utwórz obiekt wyjaśnienia.Create an explanation object. Możesz na przykład użyć funkcji 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. Utwórz objaśnienie oceniania z obiektem wyjaśnienia.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. Skonfiguruj i zarejestruj obraz, który używa modelu objaśnienia oceniania.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. Opcjonalnie możesz pobrać objaśnienie oceniania z chmury i przetestować wyjaśnienia.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. Wdzyskaj obraz do docelowego obiektu obliczeniowego, korzystając z następujących kroków:Deploy the image to a compute target, by following these steps:

    1. W razie potrzeby zarejestruj oryginalny model przewidywania, korzystając z procedury opisanej w tece Wdrażanie modeli za pomocą Azure Machine Learning.If needed, register your original prediction model by following the steps in Deploy models with Azure Machine Learning.

    2. Utwórz plik oceniania.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. Zdefiniowanie konfiguracji wdrożenia.Define the deployment configuration.

      Ta konfiguracja zależy od wymagań modelu.This configuration depends on the requirements of your model. W poniższym przykładzie zdefiniowano konfigurację, która używa jednego rdzenia procesora CPU i jednego GB pamięci.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. Utwórz plik z zależnościami środowiska.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. Utwórz niestandardowy plik dockerfile z zainstalowanym g++.Create a custom dockerfile with g++ installed.

      %%writefile dockerfile
      RUN apt-get update && apt-get install -y g++
      
    6. Wdrażanie utworzonego obrazu.Deploy the created image.

      Ten proces trwa około pięciu minut.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. Przetestuj wdrożenie.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. Czyszczenie.Clean up.

    Aby usunąć wdrożoną usługę internetową, użyj programu service.delete() .To delete a deployed web service, use service.delete().

Rozwiązywanie problemówTroubleshooting

  • Rozrzedne dane nie są obsługiwane: pulpit nawigacyjny wyjaśnienia modelu znacznie się łamie/spowalnia przy dużej liczbie funkcji, dlatego obecnie nie obsługujemy formatu rozrzednych danych.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. Ponadto w przypadku dużych zestawów danych i dużej liczby funkcji pojawią się ogólne problemy z pamięcią.Additionally, general memory issues will arise with large datasets and large number of features.

  • Modele prognozowania nie są obsługiwane z wyjaśnieniem modelu: Możliwości interpretacji, najlepsze wyjaśnienie modelu nie są dostępne dla eksperymentów prognozowania automatycznego uczenia maszynowego, które zalecają następujące algorytmy jako najlepszy model: TCNForecaster, AutoArima, Wylicz, ExponentialSmoothing, Average, Naive, Seasonal Average i Seasonal Naive.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. Prognozowanie automatycznegoml ma modele regresji, które obsługują wyjaśnienia.AutoML Forecasting has regression models which support explanations. Jednak na pulpicie nawigacyjnym wyjaśnienia karta "Ważność poszczególnych funkcji" nie jest obsługiwana w przypadku prognozowania ze względu na złożoność potoków danych.However, in the explanation dashboard, the "Individual feature importance" tab is just not supported for forecasting because of complexity in their data pipelines.

  • Lokalne wyjaśnienie indeksu danych: pulpit nawigacyjny z wyjaśnieniem nie obsługuje związku lokalnych wartości ważności z identyfikatorem wiersza z oryginalnego zestawu danych weryfikacji, jeśli ten zestaw danych jest większy niż 5000 punktów danych, ponieważ pulpit nawigacyjny losowo zmienia dane w dół.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. Jednak na pulpicie nawigacyjnym są przedstawiane nieprzetworzone wartości funkcji zestawu danych dla każdego punktu danych przekazanego do pulpitu nawigacyjnego na karcie Ważność poszczególnych funkcji. Użytkownicy mogą mapować lokalne znaczenie z powrotem na oryginalny zestaw danych, dopasowując wartości pierwotnych funkcji zestawu danych.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. Jeśli rozmiar zestawu danych walidacji jest mniejszy niż 5000 przykładów, funkcja w programie AzureML Studio będzie odpowiadać index indeksowi w zestawie danych weryfikacji.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.

  • Wykresy warunkowe/ICE nie są obsługiwane w programie Studio: wykresy What-If i indywidualne oczekiwania warunkowe (ICE Azure Machine Learning studio) nie są obsługiwane na karcie Wyjaśnienia, ponieważ przekazane wyjaśnienie wymaga aktywnego obliczenia w celu ponownego obliczenia przewidywań i prawdopodobieństwa perturbednych funkcji.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. Jest ona obecnie obsługiwana w notesach Jupyter w przypadku uruchamiania jako widżet przy użyciu zestawu SDK.It is currently supported in Jupyter notebooks when run as a widget using the SDK.

Następne krokiNext steps

Dowiedz się więcej o możliwości interpretowania modeluLearn more about model interpretability

Zapoznaj się z Azure Machine Learning przykładowych notesów możliwości interpretowaniaCheck out Azure Machine Learning Interpretability sample notebooks