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

  • Artikel

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 till automatiserade maskininlärningsmodeller (automatiserad ML) 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 anges model_explainability=True som standard. I SDK version 1.0.85 och tidigare versioner måste användare 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öra 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 tolkningsbarhet under slutsatsdragning eller bedömning.

Förutsättningar

Viktigt

Den här funktionen är för närvarande i allmänt tillgänglig förhandsversion. Den här förhandsversionen tillhandahålls utan serviceavtal och vi rekommenderar den inte för produktionsarbetsbelastningar. Vissa funktioner kanske inte stöds eller kan vara begränsade.

Mer information finns i Kompletterande villkor för användning av Microsoft Azure-förhandsversioner.

Tolkningsbarhet 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

Tolkningsbarhet, modellförklaring, är inte tillgängligt för TCNForecaster-modellen som rekommenderas av experiment med automatiska ML-prognoser.

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

Du kan använda ExplanationClient för att ladda ned de skapade 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 raw-funktionsvikterna från den bästa körningen

Du kan använda ExplanationClient för att ladda ned förklaringar av rådatafunktioner 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())

Tolkningsbarhet 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
  • Namnlistor för utformade funktioner
  • Hitta 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 funktionsbetydelse

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 utformade funktionens betydelse

Du kan anropa explain() metoden i MimicWrapper med de transformerade testexemplen för att få funktionsprioritet för de genererade konstruerade 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 att beräkna och visualisera betydelsen av råa funktioner

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

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ömningsklareraren som beräknar de konstruerade funktionsviktsvärdena vid slutsatsdragningstiden. Du initierar bedömningsförklararen med feature_map den 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-defaults 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 på din arbetsyta 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 instrumentpaneler 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.