Interpretabilità: spiegazione del modello in ML automatizzato (anteprima)

SI APPLICA A:Python SDK azureml v1

Questo articolo illustra come ottenere spiegazioni per i modelli automatizzati di Machine Learning (Machine Learning automatizzato) in Azure Machine Learning usando Python SDK. Machine Learning automatizzato consente di comprendere l'importanza delle funzionalità dei modelli generati.

Tutte le versioni dell'SDK dopo la versione 1.0.85 impostate model_explainability=True per impostazione predefinita. In SDK versione 1.0.85 e versioni precedenti gli utenti devono impostare model_explainability=True nell'oggetto per usare l'interpretabilità AutoMLConfig del modello.

In questo articolo vengono illustrate le operazioni seguenti:

• Eseguire l'interpretazione durante il training per un modello ottimale o per qualsiasi modello.
• Abilitare le visualizzazioni per visualizzare i modelli nei dati e nelle spiegazioni.
• Implementare l'interpretazione durante l'inferenza o l'assegnazione dei punteggi.

Prerequisiti

• Caratteristiche di interpretabilità. Eseguire pip install azureml-interpret per ottenere il pacchetto necessario.
• Conoscenza della creazione di esperimenti di Machine Learning automatizzati. Per altre informazioni su come usare Azure Machine Learning SDK, completare questa esercitazione sul modello di rilevamento oggetti o vedere come configurare esperimenti di Machine Learning automatizzati.

Importante

Questa funzionalità è attualmente in anteprima pubblica. Questa versione di anteprima viene fornita senza contratto di servizio e non è consigliata per carichi di lavoro di produzione. Alcune funzionalità potrebbero non essere supportate o potrebbero presentare funzionalità limitate. Per altre informazioni, vedere Condizioni supplementari per l'utilizzo delle anteprime di Microsoft Azure.

Interpretabilità durante il training per il modello migliore

Recuperare la spiegazione da best_run, che include spiegazioni sia per le funzionalità non elaborate che per le funzionalità ingegneriate.

Nota

L'interpretazione, la spiegazione del modello, non è disponibile per il modello TCNForecaster consigliato dagli esperimenti di previsione di Machine Learning automatico.

Scaricare le priorità delle funzionalità ingegneriate dall'esecuzione migliore

È possibile usare ExplanationClient per scaricare le spiegazioni delle funzionalità ingegneriate dall'archivio artefatti di 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())

Scaricare le priorità delle funzionalità non elaborate dall'esecuzione migliore

È possibile usare ExplanationClient per scaricare le spiegazioni delle funzionalità non elaborate dall'archivio artefatti di 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())

Interpretabilità durante il training per qualsiasi modello

Quando si calcolano le spiegazioni del modello e le si visualizza, non ci si limita a una spiegazione del modello esistente per un modello AutoML. È anche possibile ottenere una spiegazione per il modello con dati di test diversi. I passaggi descritti in questa sezione illustrano come calcolare e visualizzare l'importanza delle funzionalità progettata in base ai dati di test.

Recuperare qualsiasi altro modello AutoML dal training

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

Configurare le spiegazioni del modello

Usare automl_setup_model_explanations per ottenere le spiegazioni elaborate e non elaborate. Può fitted_model generare gli elementi seguenti:

• Dati in primo piano da esempi di training o test
• Elenchi dei nomi delle funzionalità progettati
• Classi individuabili nella colonna etichettata negli scenari di classificazione

Contiene automl_explainer_setup_obj tutte le strutture dell'elenco precedente.

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

Inizializzare lo explainer simula per l'importanza della funzionalità

Per generare una spiegazione per i modelli di Machine Learning automatizzati, usare la MimicWrapper classe . È possibile inizializzare MimicWrapper con questi parametri:

• Oggetto di installazione dello explainer
• Area di lavoro
• Un modello surrogato per spiegare il fitted_model modello di Machine Learning automatizzato

MimicWrapper accetta anche l'oggetto automl_run in cui verranno caricate le spiegazioni ingegneriate.

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)

Usare Mimic Explainer per il calcolo e la visualizzazione dell'importanza delle funzionalità ingegnerizzate

È possibile chiamare il explain() metodo in MimicWrapper con gli esempi di test trasformati per ottenere l'importanza della funzionalità per le funzionalità generate. È anche possibile accedere a studio di Azure Machine Learning per visualizzare la visualizzazione del dashboard delle spiegazioni dei valori di importanza delle funzionalità delle funzionalità generate dalle funzionalità automatizzate di Machine Learning.

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

Per i modelli sottoposti a training con Machine Learning automatizzato, è possibile ottenere il modello migliore usando il get_output() metodo e le spiegazioni di calcolo in locale. È possibile visualizzare i risultati della spiegazione con ExplanationDashboard dal raiwidgets pacchetto.

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)

Usare Mimic Explainer per il calcolo e la visualizzazione dell'importanza delle funzionalità non elaborate

È possibile chiamare il explain() metodo in MimicWrapper con gli esempi di test trasformati per ottenere l'importanza della funzionalità per le funzionalità non elaborate. In Machine Learning Studio è possibile visualizzare la visualizzazione dashboard dei valori di importanza delle funzionalità delle funzionalità non elaborate.

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

Interpretazione durante l'inferenza

In questa sezione viene illustrato come rendere operativo un modello di Machine Learning automatizzato con lo strumento di spiegazione usato per calcolare le spiegazioni nella sezione precedente.

Registrare il modello e lo strumento di spiegazione dei punteggi

Usare per TreeScoringExplainer creare lo explainer di assegnazione dei punteggi che calcola i valori di importanza delle funzionalità progettati in fase di inferenza. Inizializzare lo explainer di assegnazione dei punteggi con l'oggetto feature_map calcolato in precedenza.

Salvare lo strumento di spiegazione dei punteggi e quindi registrare il modello e lo strumento di spiegazione dei punteggi con il servizio gestione modelli. Eseguire il codice seguente:

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

Creare le dipendenze conda per la configurazione del servizio

Creare quindi le dipendenze di ambiente necessarie nel contenitore per il modello distribuito. Si noti che azureml-defaults con versione >= 1.0.45 deve essere elencato come dipendenza pip, perché contiene le funzionalità necessarie per ospitare il modello come servizio Web.

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

Creare lo script di assegnazione dei punteggi

Scrivere uno script che carica il modello e produce stime e spiegazioni in base a un nuovo batch di dati.

%%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}

Distribuire il servizio

Distribuire il servizio usando il file conda e il file di assegnazione dei punteggi dei passaggi precedenti.

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)

Inferenza con dati di test

Inferenza con alcuni dati di test per visualizzare il valore stimato dal modello AutoML, attualmente supportato solo in Azure Machine Learning SDK. Visualizzare le priorità delle funzionalità che contribuiscono a un valore stimato.

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

Visualizzare per individuare i modelli nei dati e nelle spiegazioni in fase di training

È possibile visualizzare il grafico dell'importanza delle funzionalità nell'area di lavoro in studio di Azure Machine Learning. Al termine dell'esecuzione di AutoML, selezionare Visualizza i dettagli del modello per visualizzare un'esecuzione specifica. Selezionare la scheda Spiegazioni per visualizzare le visualizzazioni nel dashboard di spiegazione.

Per altre informazioni sulle visualizzazioni del dashboard di spiegazione e sui tracciati specifici, vedere la documentazione sulle procedure per l'interpretazione.

Passaggi successivi

Per altre informazioni su come abilitare le spiegazioni dei modelli e l'importanza delle funzionalità in aree diverse da Machine Learning automatizzato, vedere altre tecniche per l'interpretazione del modello.