Tolkningsbarhet: Modellförklarbarhet i automatiserad ML (förhandsversion)

GÄLLER FÖR:Python SDK azureml v1

I den här artikeln får du lära dig hur du får förklaringar för automatiserade ML-modeller (machine learning) i Azure Machine Learning med hjälp av Python SDK. Automatiserad ML hjälper dig att förstå funktionsvikten för de modeller som genereras.

Alla SDK-versioner efter 1.0.85 har angetts model_explainability=True som standard. I SDK version 1.0.85 och tidigare versioner måste användarna ange model_explainability=True i AutoMLConfig objektet för att kunna använda modelltolkning.

I den här artikeln kan du se hur du:

  • Utför tolkning under träning för bästa modell eller modell.
  • Aktivera visualiseringar som hjälper dig att se mönster i data och förklaringar.
  • Implementera tolkning vid slutsatsdragning eller bedömning.

Förutsättningar

Tolkning under träning för den bästa modellen

Hämta förklaringen best_runfrån , som innehåller förklaringar för både råa och konstruerade funktioner.

Anteckning

Tolkning, modellförklaring, är inte tillgängligt för TCNForecaster-modellen som rekommenderas av auto ML-prognostiseringsexperiment.

Ladda ned de konstruerade funktionsvikterna från den bästa körningen

Du kan använda ExplanationClient för att ladda ned de konstruerade funktionsförklaringarna från artefaktarkivet för best_run.

from azureml.interpret import ExplanationClient

client = ExplanationClient.from_run(best_run)
engineered_explanations = client.download_model_explanation(raw=False)
print(engineered_explanations.get_feature_importance_dict())

Ladda ned viktiga raw-funktioner från den bästa körningen

Du kan använda ExplanationClient för att ladda ned förklaringar av råfunktioner från artefaktarkivet för best_run.

from azureml.interpret import ExplanationClient

client = ExplanationClient.from_run(best_run)
raw_explanations = client.download_model_explanation(raw=True)
print(raw_explanations.get_feature_importance_dict())

Tolkning under träning för alla modeller

När du beräknar modellförklaringar och visualiserar dem är du inte begränsad till en befintlig modellförklaring för en AutoML-modell. Du kan också få en förklaring till din modell med olika testdata. Stegen i det här avsnittet visar hur du beräknar och visualiserar den konstruerade funktionsvikten baserat på dina testdata.

Hämta andra AutoML-modeller från träning

automl_run, fitted_model = local_run.get_output(metric='accuracy')

Konfigurera modellförklaringarna

Använd automl_setup_model_explanations för att hämta de konstruerade och råa förklaringarna. fitted_model Kan generera följande objekt:

  • Aktuella data från tränade eller testexempel
  • Lista över skapade funktionsnamn
  • Sökbara klasser i din märkta kolumn i klassificeringsscenarier

automl_explainer_setup_obj Innehåller alla strukturer från listan ovan.

from azureml.train.automl.runtime.automl_explain_utilities import automl_setup_model_explanations

automl_explainer_setup_obj = automl_setup_model_explanations(fitted_model, X=X_train, 
                                                             X_test=X_test, y=y_train, 
                                                             task='classification')

Initiera Mimic Explainer för funktionsvikt

Om du vill generera en förklaring till automatiserade ML-modeller använder du MimicWrapper klassen . Du kan initiera MimicWrapper med följande parametrar:

  • Installationsobjektet för förklaringen
  • Din arbetsyta
  • En surrogatmodell som förklarar den fitted_model automatiserade ML-modellen

MimicWrapper tar också objektet automl_run där de konstruerade förklaringarna laddas upp.

from azureml.interpret import MimicWrapper

# Initialize the Mimic Explainer
explainer = MimicWrapper(ws, automl_explainer_setup_obj.automl_estimator,
                         explainable_model=automl_explainer_setup_obj.surrogate_model, 
                         init_dataset=automl_explainer_setup_obj.X_transform, run=automl_run,
                         features=automl_explainer_setup_obj.engineered_feature_names, 
                         feature_maps=[automl_explainer_setup_obj.feature_map],
                         classes=automl_explainer_setup_obj.classes,
                         explainer_kwargs=automl_explainer_setup_obj.surrogate_model_params)

Använda Mimic Explainer för databehandling och visualisering av den konstruerade funktionsvikten

Du kan anropa explain() metoden i MimicWrapper med de transformerade testexemplen för att få funktionsprioritet för de genererade funktionerna. Du kan också logga in på Azure Machine Learning-studio för att visa förklaringsinstrumentpanelens visualisering av funktionsprioritetsvärdena för de genererade konstruerade funktionerna av automatiserade ML-funktionaliserare.

engineered_explanations = explainer.explain(['local', 'global'], eval_dataset=automl_explainer_setup_obj.X_test_transform)
print(engineered_explanations.get_feature_importance_dict())

För modeller som tränats med automatiserad ML kan du få den bästa modellen med hjälp av get_output() metoden och beräkningsförklaringarna lokalt. Du kan visualisera förklaringsresultatet raiwidgets med ExplanationDashboard från paketet.

best_run, fitted_model = remote_run.get_output()

from azureml.train.automl.runtime.automl_explain_utilities import AutoMLExplainerSetupClass, automl_setup_model_explanations
automl_explainer_setup_obj = automl_setup_model_explanations(fitted_model, X=X_train,
                                                             X_test=X_test, y=y_train,
                                                             task='regression')

from interpret.ext.glassbox import LGBMExplainableModel
from azureml.interpret.mimic_wrapper import MimicWrapper

explainer = MimicWrapper(ws, automl_explainer_setup_obj.automl_estimator, LGBMExplainableModel,
                         init_dataset=automl_explainer_setup_obj.X_transform, run=best_run,
                         features=automl_explainer_setup_obj.engineered_feature_names,
                         feature_maps=[automl_explainer_setup_obj.feature_map],
                         classes=automl_explainer_setup_obj.classes)
                         
pip install interpret-community[visualization]

engineered_explanations = explainer.explain(['local', 'global'], eval_dataset=automl_explainer_setup_obj.X_test_transform)
print(engineered_explanations.get_feature_importance_dict()),
from raiwidgets import ExplanationDashboard
ExplanationDashboard(engineered_explanations, automl_explainer_setup_obj.automl_estimator, datasetX=automl_explainer_setup_obj.X_test_transform)

 

raw_explanations = explainer.explain(['local', 'global'], get_raw=True,
                                     raw_feature_names=automl_explainer_setup_obj.raw_feature_names,
                                     eval_dataset=automl_explainer_setup_obj.X_test_transform)
print(raw_explanations.get_feature_importance_dict()),
from raiwidgets import ExplanationDashboard
ExplanationDashboard(raw_explanations, automl_explainer_setup_obj.automl_pipeline, datasetX=automl_explainer_setup_obj.X_test_raw)

Använda Mimic Explainer för databehandling och visualisering av rå funktionsvikt

Du kan anropa explain() metoden i MimicWrapper med de transformerade testexemplen för att få funktionsvikten för raw-funktionerna. I Machine Learning Studio kan du visa instrumentpanelens visualisering av funktionsviktsvärdena för de råa funktionerna.

raw_explanations = explainer.explain(['local', 'global'], get_raw=True,
                                     raw_feature_names=automl_explainer_setup_obj.raw_feature_names,
                                     eval_dataset=automl_explainer_setup_obj.X_test_transform,
                                     raw_eval_dataset=automl_explainer_setup_obj.X_test_raw)
print(raw_explanations.get_feature_importance_dict())

Tolkningsbarhet under slutsatsdragning

I det här avsnittet får du lära dig hur du operationaliserar en automatiserad ML-modell med förklaringen som användes för att beräkna förklaringarna i föregående avsnitt.

Registrera modellen och bedömningsförklaringen

TreeScoringExplainer Använd för att skapa bedömningsförklararen som beräknar de konstruerade funktionsvärdevärdena vid slutsatsdragningstiden. Du initierar bedömningsförklararen med den feature_map som beräknades tidigare.

Spara bedömningsförklaringen och registrera sedan modellen och bedömningsförklaringen med Modellhanteringstjänsten. Kör följande kod:

from azureml.interpret.scoring.scoring_explainer import TreeScoringExplainer, save

# Initialize the ScoringExplainer
scoring_explainer = TreeScoringExplainer(explainer.explainer, feature_maps=[automl_explainer_setup_obj.feature_map])

# Pickle scoring explainer locally
save(scoring_explainer, exist_ok=True)

# Register trained automl model present in the 'outputs' folder in the artifacts
original_model = automl_run.register_model(model_name='automl_model', 
                                           model_path='outputs/model.pkl')

# Register scoring explainer
automl_run.upload_file('scoring_explainer.pkl', 'scoring_explainer.pkl')
scoring_explainer_model = automl_run.register_model(model_name='scoring_explainer', model_path='scoring_explainer.pkl')

Skapa conda-beroenden för att konfigurera tjänsten

Skapa sedan nödvändiga miljöberoenden i containern för den distribuerade modellen. Observera att azureml-standardvärden med version >= 1.0.45 måste anges som ett pip-beroende, eftersom det innehåller de funktioner som krävs för att vara värd för modellen som en webbtjänst.

from azureml.core.conda_dependencies import CondaDependencies

azureml_pip_packages = [
    'azureml-interpret', 'azureml-train-automl', 'azureml-defaults'
]

myenv = CondaDependencies.create(conda_packages=['scikit-learn', 'pandas', 'numpy', 'py-xgboost<=0.80'],
                                 pip_packages=azureml_pip_packages,
                                 pin_sdk_version=True)

with open("myenv.yml","w") as f:
    f.write(myenv.serialize_to_string())

with open("myenv.yml","r") as f:
    print(f.read())

Skapa bedömningsskriptet

Skriv ett skript som läser in din modell och genererar förutsägelser och förklaringar baserat på en ny batch med data.

%%writefile score.py
import joblib
import pandas as pd
from azureml.core.model import Model
from azureml.train.automl.runtime.automl_explain_utilities import automl_setup_model_explanations


def init():
    global automl_model
    global scoring_explainer

    # Retrieve the path to the model file using the model name
    # Assume original model is named automl_model
    automl_model_path = Model.get_model_path('automl_model')
    scoring_explainer_path = Model.get_model_path('scoring_explainer')

    automl_model = joblib.load(automl_model_path)
    scoring_explainer = joblib.load(scoring_explainer_path)


def run(raw_data):
    data = pd.read_json(raw_data, orient='records')
    # Make prediction
    predictions = automl_model.predict(data)
    # Setup for inferencing explanations
    automl_explainer_setup_obj = automl_setup_model_explanations(automl_model,
                                                                 X_test=data, task='classification')
    # Retrieve model explanations for engineered explanations
    engineered_local_importance_values = scoring_explainer.explain(automl_explainer_setup_obj.X_test_transform)
    # Retrieve model explanations for raw explanations
    raw_local_importance_values = scoring_explainer.explain(automl_explainer_setup_obj.X_test_transform, get_raw=True)
    # You can return any data type as long as it is JSON-serializable
    return {'predictions': predictions.tolist(),
            'engineered_local_importance_values': engineered_local_importance_values,
            'raw_local_importance_values': raw_local_importance_values}

Distribuera tjänsten

Distribuera tjänsten med hjälp av conda-filen och bedömningsfilen från föregående steg.

from azureml.core.webservice import Webservice
from azureml.core.webservice import AciWebservice
from azureml.core.model import Model, InferenceConfig
from azureml.core.environment import Environment

aciconfig = AciWebservice.deploy_configuration(cpu_cores=1,
                                               memory_gb=1,
                                               tags={"data": "Bank Marketing",  
                                                     "method" : "local_explanation"},
                                               description='Get local explanations for Bank marketing test data')
myenv = Environment.from_conda_specification(name="myenv", file_path="myenv.yml")
inference_config = InferenceConfig(entry_script="score_local_explain.py", environment=myenv)

# Use configs and models generated above
service = Model.deploy(ws,
                       'model-scoring',
                       [scoring_explainer_model, original_model],
                       inference_config,
                       aciconfig)
service.wait_for_deployment(show_output=True)

Slutsatsdragning med testdata

Slutsatsdragning med vissa testdata för att se det förutsagda värdet från AutoML-modellen, som för närvarande endast stöds i Azure Machine Learning SDK. Visa de funktionsvikter som bidrar till ett förutsagt värde.

if service.state == 'Healthy':
    # Serialize the first row of the test data into json
    X_test_json = X_test[:1].to_json(orient='records')
    print(X_test_json)
    # Call the service to get the predictions and the engineered explanations
    output = service.run(X_test_json)
    # Print the predicted value
    print(output['predictions'])
    # Print the engineered feature importances for the predicted value
    print(output['engineered_local_importance_values'])
    # Print the raw feature importances for the predicted value
    print('raw_local_importance_values:\n{}\n'.format(output['raw_local_importance_values']))

Visualisera för att identifiera mönster i data och förklaringar vid träningstillfället

Du kan visualisera diagrammet för funktionsvikt i arbetsytan i Azure Machine Learning-studio. När AutoML-körningen är klar väljer du Visa modellinformation för att visa en specifik körning. Välj fliken Förklaringar för att se visualiseringarna på förklaringsinstrumentpanelen.

Arkitektur för maskininlärningstolkning

Mer information om visualiseringar av förklaringsinstrumentpaneler och specifika diagram finns i dokumentationen om tolkning.

Nästa steg

Mer information om hur du kan aktivera modellförklaringar och funktionsvikt inom andra områden än automatiserad ML finns i fler tekniker för modelltolkning.