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 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
- Tolkningsfunktioner. Kör
pip install azureml-interpret
för att hämta det nödvändiga paketet. - Kunskap om att skapa automatiserade ML-experiment. Mer information om hur du använder Azure Machine Learning SDK finns i självstudien om objektidentifieringsmodellen eller se hur du konfigurerar automatiserade ML-experiment.
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_run
frå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.
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.