Erläutern von ML-Modellen und -Vorhersagen mithilfe des Python-Interpretierbarkeitspakets (Vorschau)

In diesem Leitfaden erfahren Sie, wie Sie das Interpretierbarkeitspaket des Python-SDK für Azure Machine Learning für die folgenden Aufgaben nutzen können:

  • Erläutern Sie das gesamte Modellverhalten oder einzelne Vorhersagen lokal auf Ihrem persönlichen Computer.

  • Aktivieren Sie Techniken zur Interpretierbarkeit von entwickelten Features.

  • Erläutern Sie das Verhalten für das gesamte Modell und einzelne Vorhersagen in Azure.

  • Laden Sie Erklärungen zum Azure Machine Learning-Ausführungsverlauf hoch.

  • Verwenden Sie ein Visualisierungsdashboard, um sowohl in einem Jupyter Notebook als auch in Azure Machine Learning Studio mit Ihren Modellerklärungen zu interagieren.

  • Stellen Sie einen Bewertungsexplainer mit Ihrem Modell bereit, um die Erklärungen während der Rückschlüsse zu beobachten.

Weitere Informationen zu den unterstützten Interpretierbarkeitstechniken und den Modellen des maschinellen Lernens finden Sie unter Modellinterpretierbarkeit in Azure Machine Learning und Beispielnotebooks.

Eine Anleitung zum Aktivieren der Interpretierbarkeit für Modelle, die mit automatisiertem maschinellem Lernen trainiert wurden, finden Sie unter Interpretierbarkeit: Modellerklärungen beim automatisierten maschinellen Lernen (Vorschau).

Generieren des Werts für die Featurerelevanz auf Ihrem persönlichen Computer

Das folgende Beispiel zeigt, wie Sie das Interpretierbarkeitspaket auf Ihrem persönlichen Computer verwenden, ohne auf Azure-Dienste zurückzugreifen.

  1. Installieren Sie das azureml-interpret-Paket.

    pip install azureml-interpret
    
  2. Trainieren Sie ein Beispielmodell in einem lokalen 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. Rufen Sie den Explainer lokal auf.

    • Übergeben Sie das Modell und einige Trainingsdaten an den Konstruktor des Explainers, um ein Explainer-Objekt zu initialisieren.
    • Sie können während der Klassifizierung optional auch Namen von Features und Ausgabeklassen übergeben, mit denen Ihre Erklärungen und Visualisierungen informativer gestaltet werden.

    Die folgenden Codeblocks veranschaulichen, wie ein Explainer-Objekt mit TabularExplainer, MimicExplainer und PFIExplainer lokal instanziiert wird.

    • TabularExplainer ruft einen der drei SHAP-Explainer darunter auf (TreeExplainer, DeepExplainer oder KernelExplainer).
    • TabularExplainer wählt automatisch den Explainer aus, der für Ihren Anwendungsfall geeignet ist, aber Sie können jeden der drei zugrunde liegenden Explainer direkt aufrufen.
    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)
    

    oder

    
    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)
    

    oder

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

Erläutern des gesamten Modellverhalten (globale Erklärung)

Die aggregierten (globalen) Featurerelevanzwerte können Sie dem nachfolgenden Beispiel entnehmen.


# 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()

Erläutern einer individuellen Vorhersage (lokale Erklärung)

Rufen Sie die Relevanzwerte individueller Features von verschiedenen Datenpunkten ab, indem Sie eine einzelne Instanz oder eine Gruppe von Instanzen erklären.

Hinweis

PFIExplainer unterstützt keine lokalen Erklärungen.

# 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()

Rohfeaturetransformationen

Sie können Erklärungen in Bezug auf rohe, unveränderte Features anstelle von entwickelten Features abonnieren. Bei dieser Option übergeben Sie Ihre Featuretransformationspipeline an den Explainer in train_explain.py. Andernfalls bietet der Explainer Erklärungen in Bezug auf entwickelte Features.

Das Format der unterstützten Transformationen entspricht dem unter sklearn-pandas beschriebenen. Grundsätzlich werden alle Transformationen unterstützt, solange sie eine einzelne Spalte verarbeiten, sodass sie eindeutig eine 1:n-Transformation darstellen.

Erhalten Sie eine Erklärung für Rohfeatures, indem Sie sklearn.compose.ColumnTransformer oder eine Liste mit passenden Transformationstupeln verwenden. Im folgenden Beispiel wird sklearn.compose.ColumnTransformer verwendet.

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)

Verwenden Sie den folgenden Code, falls Sie das Beispiel mit der Liste mit den passenden Transformationstupeln ausführen möchten:

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)

Generieren von Featurerelevanzwerten über Remoteausführungen

Das folgende Beispiel zeigt die Verwendung der ExplanationClient-Klasse zum Aktivieren der Modellinterpretierbarkeit für Remoteausführungen. Es ähnelt dem lokalen Prozess, aber Sie:

  • verwenden ExplanationClient in der Remoteausführung, um den Interpretbarkeitskontext hochzuladen.
  • laden den Kontext später in einer lokalen Umgebung herunter.
  1. Installieren Sie das azureml-interpret-Paket.

    pip install azureml-interpret
    
  2. Erstellen Sie ein Trainingsskript in einem lokalen Jupyter Notebook. Beispiel: 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. Legen Sie ein Azure Machine Learning Compute-Ziel fest, und übermitteln Sie dann eine Trainingsausführung. Anweisungen finden Sie unter Erstellen und Verwalten von Azure Machine Learning-Computeclustern. Die Beispielnotebooks könnten Sie auch interessieren.

  4. Laden Sie die Erklärung in Ihr lokales Jupyter Notebook herunter.

    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))
    

Visualisierungen

Nachdem Sie die Erklärungen in Ihre lokale Jupyter Notebook-Instanz heruntergeladen haben, können Sie Ihr Modell anhand der Visualisierungen auf dem Erklärungsdashboard auswerten und interpretieren. Verwenden Sie den folgenden Code, um das Erklärungsdashboard-Widget in Ihrer Jupyter Notebook-Instanz zu laden:

from raiwidgets import ExplanationDashboard

ExplanationDashboard(global_explanation, model, datasetX=x_test)

Die Visualisierungen unterstützen Erklärungen für entwickelte Features sowie für Features im Rohformat. Erklärungen im Rohformat basieren auf den Features des ursprünglichen Datasets, und Erklärungen im entwickelten Format basieren auf den Features des Datasets mit Anwendung von Feature Engineering („Featurisierung“).

Beim Interpretieren eines Modells in Bezug auf das ursprüngliche Dataset wird empfohlen, Erklärungen im Rohformat zu nutzen, da jede Featurerelevanz jeweils einer Spalte aus dem ursprünglichen Dataset entspricht. Ein Szenario, in dem Erklärungen im entwickelten Format ggf. hilfreich sind, sind Untersuchungen der Auswirkung einzelner Kategorien eines kategorischen Features. Wenn eine 1-Hot-Codierung auf ein kategorisches Feature angewendet wird, enthalten die sich ergebenden Erklärungen im entwickelten Format einen anderen Relevanzwert pro Kategorie (einen pro entwickeltem Feature mit 1-Hot-Codierung). Diese Codierung kann hilfreich sein, wenn eingegrenzt werden soll, welcher Teil des Datasets für das Modell die meisten Informationen enthält.

Hinweis

Erklärungen im entwickelten und im Rohformat werden sequenziell berechnet. Zuerst wird basierend auf der Modell- und Featurisierungspipeline eine entwickelte Erklärung erstellt. Anschließend wird basierend auf dieser entwickelten Erklärung die Erklärung im Rohformat erstellt, indem die Relevanz der entwickelten Features, die aus demselben Rohfeature stammen, aggregiert wird.

Erstellen, Bearbeiten und Anzeigen von Datasetkohorten

Im oberen Menüband wird die Gesamtstatistik für Ihr Modell und die Daten angezeigt. Sie können Ihre Daten in Datasetkohorten oder Untergruppen aufteilen, um die Leistung Ihres Modells und die Erklärungen für diese definierten Untergruppen zu untersuchen bzw. zu vergleichen. Indem Sie Ihre Datasetstatistik und die Erklärungen für diese Untergruppen vergleichen, können Sie ermitteln, warum in bestimmten Gruppen ggf. Fehler auftreten.

Creating, editing, and viewing dataset cohorts

Verstehen des gesamten Modellverhalten (globale Erklärung)

Die ersten drei Registerkarten im Dashboard für die Erklärungen enthalten eine Gesamtanalyse des trainierten Modells mit den zugehörigen Vorhersagen und Erklärungen.

Modellleistung

Evaluieren Sie die Leistung Ihres Modells, indem Sie die Verteilung Ihrer Vorhersagewerte und die Werte Ihrer Modellleistungsmetriken untersuchen. Sie können Ihr Modell genauer untersuchen, indem Sie sich eine vergleichende Analyse der Leistung für verschiedene Kohorten oder Untergruppen Ihres Datasets ansehen. Wählen Sie Filter für den Y-Wert und X-Wert aus, um unterschiedliche Dimensionen anzuzeigen. Zeigen Sie Metriken an, z. B. Genauigkeit, Rückruf, False Positive-Rate (FPR) und False-Negative-Rate (FNR).

Model performance tab in the explanation visualization

Dataset-Explorer

Untersuchen Sie Ihre Datasetstatistik, indem Sie unterschiedliche Filter für die X-, Y- und Farbachsen auswählen, um Ihre Daten in verschiedene Dimensionen zu unterteilen. Erstellen Sie oben Datasetkohorten, um Datasetstatistiken mit Filtern zu analysieren, z. B. in Bezug auf vorhergesagtes Ergebnis, Datasetfeatures und Fehlergruppen. Verwenden Sie das Zahnradsymbol in der oberen rechten Ecke des Graphen, um die Graphtypen zu ändern.

Dataset explorer tab in the explanation visualization

Aggregierte Featurerelevanz

Untersuchen Sie die Features mit Top-k-Relevanz, die sich auf Ihre Modellvorhersagen (auch als globale Erklärungen bezeichnet) insgesamt auswirken. Verwenden Sie den Schieberegler, um die Werte für die Featurerelevanz in absteigender Reihenfolge anzuzeigen. Wählen Sie bis zu drei Kohorten aus, um die entsprechenden Werte für die Featurerelevanz nebeneinander anzuzeigen. Wählen Sie im Graphen einen beliebigen Featurebalken aus, um anzuzeigen, wie sich die Werte des ausgewählten Features auf die Modellvorhersage unten im Abhängigkeitsplot auswirken.

Aggregate feature importance tab in the explanation visualization

Verstehen individueller Vorhersagen (lokale Erklärung)

Auf der vierten Registerkarte der Seite mit den Erklärungen können Sie einen Drilldown für einen Datenpunkt durchführen und die einzelnen Featurerelevanzwerte anzeigen. Sie können den jeweiligen Featurerelevanz-Plot für einen beliebigen Datenpunkt laden, indem Sie im Hauptpunktdiagramm auf einen beliebigen Datenpunkt klicken oder rechts im Bereichs-Assistenten einen bestimmten Datenpunkt auswählen.

Plot BESCHREIBUNG
Individuelle Featurerelevanz Zeigt die wichtigsten Top-k-Features für eine individuelle Vorhersage an. Veranschaulicht das lokale Verhalten des zugrunde liegenden Modells an einem bestimmten Datenpunkt.
Was-wäre-wenn-Analyse Ermöglicht das Vornehmen von Änderungen an Featurewerten des ausgewählten realen Datenpunkts und das Beobachten der sich ergebenden Änderungen des Vorhersagewerts, indem ein hypothetischer Datenpunkt mit den neuen Featurewerten generiert wird.
Individual Conditional Expectation (ICE) Ermöglicht die Änderung von Featurewerten von einem Mindestwert zu einem Maximalwert. Veranschaulicht, wie sich bei einer Änderung des Features die Vorhersage des Datenpunkts ändert.

Individual feature importance and What-if tab in explanation dashboard

Hinweis

Diese Erklärungen basieren auf vielen Näherungen und sind nicht die „Ursache“ von Vorhersagen. Wir raten Benutzern davon ab, basierend auf den Featurestörungen des Was-wäre-wenn-Tools Entscheidungen für das reale Leben zu treffen, sofern nicht die absolute mathematische Belastbarkeit der kausalen Rückschlüsse sichergestellt ist. Dieses Tool dient hauptsächlich dem Verständnis des Modells und zum Debuggen.

Visualisierung in Azure Machine Learning-Studio

Wenn Sie die Schritte zur Remoteinterpretierbarkeit (Hochladen der generierten Erklärungen in den Azure Machine Learning-Ausführungsverlauf) abgeschlossen haben, können Sie die Visualisierungen auf dem Erklärungsdashboard in Azure Machine Learning Studio anzeigen. Bei diesem Dashboard handelt es sich um eine einfachere Version des Dashboardwidgets, das in Ihrem Jupyter Notebook generiert wird. Die Generierung von Was-wäre-wenn-Datenpunkten und die ICE-Plots sind deaktiviert, da in Azure Machine Learning Studio keine aktive Computeressource vorhanden ist, mit der die Echtzeitberechnungen durchgeführt werden können.

Wenn die Dataset-, globalen und lokalen Erklärungen verfügbar sind, werden auf allen Registerkarten Daten eingefügt. Falls jedoch nur eine globale Erklärung verfügbar ist, wird die Registerkarte für „Individuelle Featurerelevanz“ deaktiviert.

Sie haben zwei Möglichkeiten, um auf das Erklärungsdashboard in Azure Machine Learning Studio zuzugreifen:

  • Bereich Experimente (Vorschau)

    1. Klicken Sie im linken Bereich auf Experimente, damit Ihnen eine Liste mit Experimenten angezeigt wird, die Sie in Azure Machine Learning ausgeführt haben.
    2. Wählen Sie ein bestimmtes Experiment aus, um alle Ausführungen in diesem Experiment anzuzeigen.
    3. Wählen Sie eine Ausführung aus, und klicken Sie dann auf die Registerkarte Erklärungen, um das Dashboard zur Erklärungsvisualisierung anzuzeigen.

    Visualization Dashboard with Aggregate Feature Importance in AzureML studio in experiments

  • Bereich Modelle

    1. Wenn Sie Ihr ursprüngliches Modell mithilfe der Schritte unter Bereitstellen von Modellen mit Azure Machine Learning registriert haben, können Sie Modelle im linken Bereich auswählen, um sie anzuzeigen.
    2. Wählen Sie ein Modell und anschließend die Registerkarte Erklärungen aus, um das Erklärungsdashboard anzuzeigen.

Interpretierbarkeit beim Ziehen von Rückschlüssen

Sie können den Explainer zusammen mit dem ursprünglichen Modell bereitstellen und ihn zur Rückschlusszeit verwenden, um die einzelnen Werte für die Featurerelevanz (lokale Erklärung) für beliebige neue Datenpunkte bereitzustellen. Wir bieten auch einfachere Bewertungsexplainer, um die Leistung der Interpretierbarkeit beim Ziehen von Rückschlüssen zu verbessern. Dies wird derzeit nur über das Azure Machine Learning SDK unterstützt. Der Bereitstellungsvorgang für einen einfacheren Bewertungsexplainer ähnelt der Bereitstellung eines Modells und umfasst die folgenden Schritte:

  1. Erstellen Sie ein Erklärungsobjekt. Sie können z. B. TabularExplainer verwenden:

     from interpret.ext.blackbox import TabularExplainer
    
    
    explainer = TabularExplainer(model, 
                                 initialization_examples=x_train, 
                                 features=dataset_feature_names, 
                                 classes=dataset_classes, 
                                 transformations=transformations)
    
  2. Erstellen Sie mit dem Erklärungsobjekt einen Bewertungsexplainer.

    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. Konfigurieren und Registrieren eines Images, das das Bewertungsexplainermodell verwendet

    # 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. Optional können Sie den Bewertungsexplainer aus der Cloud abrufen und die Erklärungen testen.

    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. Stellen Sie das Image einem Computeziel bereit, indem Sie folgende Schritte ausführen:

    1. Registrieren Sie gegebenenfalls Ihr ursprüngliches Vorhersagemodell mithilfe der Schritte unter Bereitstellen von Modellen mit Azure Machine Learning.

    2. Erstellen Sie eine Bewertungsdatei.

      %%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. Definieren Sie die Bereitstellungskonfiguration.

      Diese Konfiguration hängt von den Anforderungen Ihres Modells ab. Das folgende Beispiel definiert eine Konfiguration, die einen CPU-Kern und 1 GB Arbeitsspeicher verwendet.

      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. Erstellen Sie eine Datei mit Umgebungsabhängigkeiten.

      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. Erstellen Sie ein benutzerdefiniertes Dockerfile mit installiertem g++.

      %%writefile dockerfile
      RUN apt-get update && apt-get install -y g++
      
    6. Stellen Sie das erstellte Image bereit.

      Dieser Vorgang dauert ca. 5 Minuten.

      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. Testen Sie die Bereitstellung.

    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. Bereinigen

    Verwenden Sie zum Löschen eines bereitgestellten Webdiensts service.delete().

Problembehandlung

  • Keine Unterstützung von Daten mit geringer Dichte: Da für das Dashboard für die Modellerklärungen Fehler auftreten können bzw. die Leistung erheblich verringert werden kann, wenn eine große Zahl von Features vorhanden ist, werden Daten mit geringer Dichte derzeit nicht unterstützt. Darüber hinaus treten bei großen Datasets und einer großen Anzahl von Features allgemeine Speicherprobleme auf.

  • Matrix für unterstützte Erklärungsfeatures

Unterstützte Erklärungsregisterkarte Rohfeatures (dicht) Rohfeatures (mit geringer Dichte) Entwickelte Features (dicht) Entwickelte Features (mit geringer Dichte)
Modellleistung Unterstützt (keine Vorhersage) Unterstützt (keine Vorhersage) Unterstützt Unterstützt
Dataset-Explorer Unterstützt (keine Vorhersage) Wird nicht unterstützt. Da Daten mit geringer Dichte nicht hochgeladen werden und die Benutzeroberfläche Probleme beim Rendern von Daten mit geringer Dichte hat. Unterstützt Wird nicht unterstützt. Da Daten mit geringer Dichte nicht hochgeladen werden und die Benutzeroberfläche Probleme beim Rendern von Daten mit geringer Dichte hat.
Aggregierte Featurerelevanz Unterstützt Unterstützt Unterstützt Unterstützt
Individuelle Featurerelevanz Unterstützt (keine Vorhersage) Wird nicht unterstützt. Da Daten mit geringer Dichte nicht hochgeladen werden und die Benutzeroberfläche Probleme beim Rendern von Daten mit geringer Dichte hat. Unterstützt Wird nicht unterstützt. Da Daten mit geringer Dichte nicht hochgeladen werden und die Benutzeroberfläche Probleme beim Rendern von Daten mit geringer Dichte hat.
  • Keine Unterstützung von Vorhersagemodellen für Modellerklärungen: Interpretierbarkeit, die beste Modellerklärung, ist nicht für AutoML-Vorhersageexperimente verfügbar, die die folgenden Algorithmen als bestes Modell empfehlen: TCNForecaster, AutoArima, ExponentialSmoothing, Average, Naive, Seasonal Average und Seasonal Naive. Bei Vorhersagen mit automatisiertem maschinellem Lernen unterstützen Regressionsmodelle auch Erklärungen. Im Erklärungsdashboard wird die Registerkarte „Individuelle Featurerelevanz“ aufgrund der Komplexität der Datenpipelines aber nicht für Vorhersagen unterstützt.

  • Lokale Erklärung für Datenindex: Das Erklärungsdashboard verfügt nicht über die Unterstützung für das Abgleichen der lokalen Relevanzwerte mit einem Zeilenbezeichner aus dem ursprünglichen Validierungsdataset, wenn das Dataset mehr als 5000 Datenpunkte umfasst. Der Grund ist, dass für die Daten im Dashboard ein Downsampling nach dem Zufallsprinzip durchgeführt wird. Im Dashboard werden aber für jeden Datenpunkt, der an das Dashboard übergeben wird, auf der Registerkarte „Individuelle Featurerelevanz“ die Rohfeaturewerte für das Dataset angezeigt. Die Benutzer können die lokalen Relevanzwerte wieder dem ursprünglichen Dataset zuordnen, indem sie einen Abgleich mit den Rohfeaturewerten für das Dataset durchführen. Wenn die Größe des Validierungsdatasets weniger als 5.000 Stichproben umfasst, entspricht das Feature index in AzureML Studio dem Index im Validierungsdataset.

  • Keine Unterstützung von Was-wäre-wenn-/ICE-Plots in Studio: Was-wäre-wenn- und ICE-Plots (Individual Conditional Expectation) werden in Azure Machine Learning Studio auf der Registerkarte „Erklärungen“ nicht unterstützt, da für die hochgeladene Erklärung eine Computeressource benötigt wird, um die Vorhersagen und Wahrscheinlichkeiten von gestörten Features neu berechnen zu können. Dies wird derzeit in Jupyter Notebooks unterstützt, wenn für die Ausführung ein Widget mit dem SDK verwendet wird.

Nächste Schritte

Verfahren zur Interpretierbarkeit von Modellen in Azure ML

Weitere Informationen finden Sie in den Azure Machine Learning-Beispielnotebooks zur Interpretierbarkeit