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

Artikel
11/23/2024

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 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 någon 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

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 objektidentifieringsmodell eller 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 ett serviceavtal och vi rekommenderar det 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.

Kommentar

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

Ladda ned de konstruerade 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åa 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())

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
Lista över skapade funktionsnamn
Sökbara klasser i din märkta kolumn i klassificeringsscenarier

Innehåller automl_explainer_setup_obj 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

Använd klassen för att generera en förklaring till automatiserade ML-modeller MimicWrapper . 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 tekniska funktionsvikten

Du kan anropa explain() metoden i MimicWrapper med de transformerade testexemplen för att få funktionsvikten 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 slutsatsdragningstidpunkten. 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 Model Management Service. 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 funktionsviktsdiagrammet 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 förklaringen av instrumentpanelsvisualiseringar och specifika diagram finns i dokumentet 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.

Dela via