Interpretazione: spiegazione del modello in ML automatizzato (anteprima)

Articolo
09/03/2024

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

Per impostazione predefinita, tutte le versioni dell'SDK successive alla versione 1.0.85 presentano impostazione model_explainability=True. In SDK versione 1.0.85 e versioni precedenti gli utenti devono impostare model_explainability=True nell'oggetto AutoMLConfig per usare l'interpretabilità del modello.

In questo articolo vengono illustrate le operazioni seguenti:

Eseguire l'interpretabilità durante il training per un modello ottimale o per qualsiasi modello.
Abilitare le visualizzazioni per mostrare i criteri nei dati e nelle spiegazioni.
Implementare l'interpretabilità durante l'inferenza o l'assegnazione di punteggi.

Prerequisiti

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

Importante

Questa funzionalità è attualmente in anteprima pubblica. Questa versione di anteprima viene fornita senza contratto di servizio, pertanto se ne sconsiglia l’uso per i carichi di lavoro in ambienti di produzione. Alcune funzionalità potrebbero non essere supportate o potrebbero presentare funzionalità limitate.

Per altre informazioni, vedere le Condizioni supplementari per l'uso 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 quelle progettate.

Nota

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

Scaricare le importanze delle caratteristiche progettate dall'esecuzione migliore

È possibile usare ExplanationClient per scaricare le spiegazioni delle funzionalità progettate 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à progettate 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 si è limitati 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 di questa sezione illustrano come calcolare e visualizzare l'importanza della caratteristica 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 progettate e non elaborate. fitted_model può generare gli elementi seguenti:

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

automl_explainer_setup_obj contiene 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 Mimic Explainer per l'importanza della caratteristica

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

L'oggetto di configurazione dell'explainer
La propria area di lavoro
Un modello surrogato per spiegare il modello di Machine Learning automatizzato fitted_model

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

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 l'elaborazione e la visualizzazione dell'importanza della caratteristica progettata

È possibile chiamare il metodo explain() in MimicWrapper con gli esempi di test trasformati per ottenere l'importanza della caratteristica per le funzionalità progettate generate. È anche possibile accedere a Studio di Azure Machine Learning per visualizzare il dashboard delle spiegazioni dei valori di importanza delle caratteristiche progettate generate dalle utilità di funzioni di ML automatizzato.

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 ML automatizzato, è possibile ottenere il modello migliore usando il metodo get_output() e le spiegazioni di calcolo in locale. È possibile visualizzare i risultati della spiegazione con ExplanationDashboard dal pacchetto raiwidgets.

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 della funzionalità non elaborata

È possibile chiamare il metodo explain() in MimicWrapper con gli esempi di test trasformati per ottenere l'importanza della caratteristica per le funzionalità non elaborate. In Studio di Machine Learningè possibile visualizzare il dashboard dei valori di importanza delle caratteristiche 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 ML automatizzato con l'explainer usato per calcolare le spiegazioni nella sezione precedente.

Registrare il modello e l'explainer sull'assegnazione dei punteggi

Usare TreeScoringExplainer per creare l'explainer sull'assegnazione dei punteggi che calcola i valori di importanza della caratteristica progettatai in fase di inferenza. Inizializzare l'explainer sull'assegnazione dei punteggi con feature_map calcolato in precedenza.

Salvare l'explainer sull'assegnazione dei punteggi e registrare il modello e l'explainer con il servizio di 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

Successivamente, creare le dipendenze di ambiente necessarie nel contenitore per il modello distribuito. Si noti che è necessario che azureml-defaults con versione >= 1.0.45 sia indicato 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 punteggio

Scrivere uno script che carica il modello e produce previsioni 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 SDK Azure Machine Learning. Visualizzare le importanze delle caratteristiche 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 criteri nei dati e nelle spiegazioni in fase di training

È possibile visualizzare il grafico delle importanza delle caratteristiche 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 vedere le visualizzazioni nel dashboard delle spiegazioni.

Per altre informazioni sulle visualizzazioni del dashboard delle spiegazioni 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 caratteristiche in aree diverse dal MT automatizzato, vedere altre tecniche per l'interpretazione dei modelli.

Condividi tramite