Interpretación: capacidad de explicación de modelos de aprendizaje automático automatizado (versión preliminar)

Artículo
09/03/2024

SE APLICA A: Azure ML del SDK de Python v1

En este artículo, aprenderá a obtener explicaciones de los modelos de aprendizaje automático automatizado (ML automatizado) en Azure Machine Learning con el SDK de Python. El aprendizaje automático automatizado ayuda a comprender la importancia de las características de los modelos que se generan.

De forma predeterminada, todas las versiones del SDK posteriores a 1.0.85 establecen model_explainability=True. En la versión 1.0.85 del SDK y anteriores, los usuarios deben establecer model_explainability=True en el objeto AutoMLConfig para poder usar la interpretación de modelos.

En este artículo aprenderá a:

Interpretar durante el entrenamiento para el mejor o cualquier modelo.
Habilitar visualizaciones para ayudarle a ver patrones en datos y explicaciones.
Implementar la interpretación durante la inferencia o puntuación.

Prerrequisitos

Características de interoperabilidad. Ejecute pip install azureml-interpret para obtener el paquete necesario.
Conocimiento de la compilación de experimentos de aprendizaje automático automatizado. Para más información sobre cómo usar el SDK de Azure Machine Learning, complete este tutorial de modelo de detección de objetos o consulte cómo configurar experimentos de aprendizaje automático automatizado.

Importante

Esta característica actualmente está en su versión preliminar pública. Esta versión preliminar se ofrece sin un Acuerdo de Nivel de Servicio y no se recomienda para cargas de trabajo de producción. Es posible que algunas características no sean compatibles o que tengan sus funcionalidades limitadas.

Para más información, consulte Términos de uso complementarios de las Versiones Preliminares de Microsoft Azure.

Interpretación durante el entrenamiento del mejor modelo

Recupere la explicación de best_run, que incluye explicaciones de las características diseñadas y sin formato.

Nota

La interpretabilidad, es decir, la explicación del modelo, no está disponible para el modelo TCNForecaster recomendado por los experimentos de previsión de ML automático.

Descargue las importancias de las características diseñadas de la mejor ejecución

Puede usar ExplanationClient para descargar las explicaciones de las características diseñadas del almacén de artefactos de 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())

Descargue las importancias de las características sin diseño de la mejor ejecución

Puede usar ExplanationClient para descargar las explicaciones de las características sin diseño del almacén de artefactos de 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())

Interpretación durante el entrenamiento de cualquier modelo

Al calcular las explicaciones del modelo y visualizarlas, no está limitado a una explicación de modelo existente para un modelo de AutoML. También puede obtener una explicación del modelo con datos de prueba diferentes. Los pasos de esta sección muestran cómo calcular y visualizar la importancia de las características diseñadas según los datos de prueba.

Recuperar cualquier otro modelo de aprendizaje automático automatizado del entrenamiento

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

Configuración de las explicaciones del modelo

Utilice automl_setup_model_explanations para obtener las explicaciones diseñadas y sin diseño. fitted_model puede generar los siguientes elementos:

Datos destacados de ejemplos entrenados o de prueba
Listas de nombres de características diseñadas
Clases de búsqueda en la columna etiquetada de los escenarios de clasificación

automl_explainer_setup_obj contiene todas las estructuras de la lista anterior.

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

Inicializar el explicador Mimic para la importancia de la característica

Para generar una explicación de los modelos de aprendizaje automático automatizado, utilice la clase MimicWrapper. MimicWrapper se puede inicializar con estos parámetros:

El objeto de configuración del explicador
El área de trabajo
Un modelo suplente para explicar el modelo de ML automatizado fitted_model

MimicWrapper también toma el objeto automl_run donde se cargarán las explicaciones diseñadas.

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)

Use Mimic Explainer para calcular y visualizar la importancia de las características diseñadas

Puede llamar al método explain() de MimicWrapper con los ejemplos de prueba transformados para obtener la importancia de las características diseñadas que se generaron. También puede iniciar sesión en Azure Machine Learning Studio para obtener las visualizaciones del panel de explicaciones de los valores de importancia de las características diseñadas generadas por los caracterizadores de aprendizaje automático automatizado.

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

En el caso de los modelos entrenados con el aprendizaje automático automatizado, puede obtener el mejor modelo mediante el método get_output() y las explicaciones de proceso de forma local. Puede visualizar los resultados de la explicación con ExplanationDashboard desde el paquete 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)

Use MimicExplainer para calcular y visualizar la importancia de las características sin procesar

Puede llamar al método explain() de MimicWrapper con los ejemplos de prueba transformados para obtener la importancia de las características sin procesar. En Machine Learning Studio, puede obtener la visualización del panel de valores de importancia de las características sin procesar.

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

Interpretación durante la inferencia

En esta sección, obtendrá información sobre cómo operar un modelo de aprendizaje automático automatizado con el explicador, que se utilizó para calcular las explicaciones de la sección anterior.

Registre el modelo y la explicación de la puntuación

Use TreeScoringExplainer para crear el explicador de puntuación, que calculará los valores de importancia de las características diseñadas a la hora de la inferencia. El explicador de puntuación se inicializa con el feature_map que se calculó previamente.

Guarde el explicador de puntuación y, a continuación, registre el modelo y el explicador de puntuación con el servicio de Administración de modelos. Ejecute el código siguiente:

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

Crear las dependencias de conda para configurar el servicio

Después, cree las dependencias de entorno necesarias en el contenedor para el modelo implementado. Tenga en cuenta que azureml-defaults con versión > = 1.0.45 debe indicarse como una dependencia de PIP, ya que contiene la funcionalidad necesaria para hospedar el modelo como un servicio 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())

Creación del script de puntuación

Escriba un script que cargue el modelo y genere predicciones y explicaciones basadas en un nuevo lote de datos.

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

Implementación del servicio

Implementar el servicio con el archivo conda y el archivo de puntuación de los pasos anteriores.

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)

Inferencia con datos de prueba

La inferencia con algunos datos de prueba para ver el valor de predicción del modelo de AutoML, actualmente solo se admite en Azure Machine Learning SDK. Vea la importancia de las características que contribuyen a un valor predicho.

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

Visualización para detectar patrones en datos y explicaciones durante el entrenamiento

Puede visualizar la tabla de importancia de las características en el área de trabajo de Azure Machine Learning Studio. Una vez completada la ejecución de AutoML, seleccione Ver detalles del modelo para ver una ejecución específica. Seleccione la pestaña Explicaciones para obtener las visualizaciones del panel de explicaciones.

Para obtener más información sobre las visualizaciones de paneles de explicación y trazados específicos, consulte el documento de procedimientos sobre la interpretación.

Pasos siguientes

Para obtener más información sobre cómo puede habilitar las explicaciones de los modelos y la importancia de las características en áreas distintas de ML automatizado, consulte más técnicas para la interpretación de modelos.

Compartir vía