Compartilhar via

Capacidade de interpretação: explicabilidade do modelo no ML automatizado (versão prévia)

  • Artigo

APLICA-SE A: SDK do Python azureml v1

Neste artigo, você saberá como obter explicações sobre modelos de ML automatizado (machine learning automatizado) no Azure Machine Learning usando o SDK do Python. O ML automatizado ajuda a entender a importância dos recursos dos modelos gerados.

Todas as versões do SDK posteriores a 1.0.85 têm model_explainability=True definido por padrão. Na versão do SDK 1.0.85 e versões anteriores, os usuários precisam definir model_explainability=True no objeto AutoMLConfig para usar a interpretabilidade do modelo.

Neste artigo, você aprenderá como:

  • Executar a interpretabilidade durante o treinamento para o melhor modelo ou qualquer modelo.
  • Habilitar visualizações para ajudá-lo a ver padrões em dados e explicações.
  • Implementar a interpretabilidade durante a inferência ou a pontuação.

Pré-requisitos

Importante

Esse recurso está atualmente em visualização pública. Essa versão prévia é fornecida sem um contrato de nível de serviço e não é recomendada para cargas de trabalho de produção. Alguns recursos podem não ter suporte ou podem ter restrição de recursos.

Para obter mais informações, consulte Termos de Uso Complementares de Versões Prévias do Microsoft Azure.

Interpretabilidade durante o treinamento para o melhor modelo

Recupere a explicação do best_run, que inclui explicações para recursos brutos e com engenharia.

Observação

A interpretação, a explicação do modelo, não está disponível para o modelo TCNForecaster recomendado por experimentos de previsão de Auto ML.

Baixar as importâncias dos recursos com engenharia da melhor execução

É possível usar ExplanationClient para baixar as explicações de recursos com engenharia do repositório de artefatos do 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())

Baixar as importâncias dos recursos brutos da melhor execução

É possível usar ExplanationClient para baixar as explicações do recurso bruto do repositório de artefatos do 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())

Interpretabilidade durante o treinamento para qualquer modelo

Ao computar explicações de modelo e visualizá-las, você não está limitado a uma explicação de modelo existente para um modelo AutoML. Você também pode obter uma explicação para seu modelo com dados de teste diferentes. As etapas nesta seção mostram como computar e visualizar a importância dos recursos com engenharia baseado em seus dados de teste.

Recuperar qualquer outro modelo de AutoML do treinamento

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

Configurar as explicações do modelo

Use automl_setup_model_explanations para obter as explicações para recursos brutos e com engenharia. O fitted_model pode gerar os seguintes relatórios:

  • Dados de recursos retirados de amostras treinadas ou de teste
  • Listas de nomes de recursos com engenharia
  • Classes localizáveis em sua coluna rotulada em cenários de classificação

O automl_explainer_setup_obj contém todas as estruturas da lista acima.

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 o Mimic Explainer para a importância do recurso

Para gerar uma explicação para modelos ML automatizado, use a classe MimicWrapper. Você pode inicializar o MimicWrapper com estes parâmetros:

  • O objeto de instalação do explicador
  • Seu espaço de trabalho
  • Um modelo substituto para explicar o modelo ML automatizado fitted_model

O MimicWrapper também usa o objeto automl_run no qual as explicações com engenharia serão carregadas.

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 o Mimic Explainer para computação e visualização da importância do recurso com engenharia

Você pode chamar o método explain() em MimicWrapper com os exemplos de teste transformados para obter a importância do recurso para os recursos com engenharia gerados. Você também pode entrar no Estúdio do Azure Machine Learning para exibir as explicações da visualização do painel dos valores de importância do recurso para os recursos com engenharia gerados por criadores de recursos do ML automatizado.

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

Para modelos treinados com ML automatizado, você pode obter o melhor modelo usando as explicações de computação e o método get_output() localmente. Você pode ver os resultados da explicação com ExplanationDashboard do pacote 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 o Mimic Explainer para computação e visualização da importância do recurso bruto

Você pode chamar o método explain() no MimicWrapper com os exemplos de teste transformados para obter a importância do recurso para os recursos brutos. No Estúdio do ML, você pode exibir a visualização do painel dos valores de importância do recurso dos recursos brutos.

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

Interpretabilidade durante a inferência

Nesta seção, você aprenderá a colocar em operação um modelo ML automatizado com o explicador que foi usado para calcular as explicações na seção anterior.

Registrar o modelo e o explicador de pontuação

Use o TreeScoringExplainer para criar o explicador de pontuação que calculará os valores de importância dos recursos com engenharia no tempo de inferência. Você inicializa o explicador de pontuação com o feature_map que foi calculado anteriormente.

Salve o explicador de pontuação e registre o modelo e o explicador de pontuação com o Serviço de Gerenciamento de Modelos. Execute o código a seguir:

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

Criar as dependências de Conda para configurar o serviço

Em seguida, crie as dependências de ambiente necessárias no contêiner para o modelo implantado. Observe que o azureml-defaults com a versão >= 1.0.45 ou superior deve ser listado como uma dependência PIP, pois ele contém a funcionalidade necessária para hospedar o modelo como um serviço 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())

Criar o script de pontuação

Escreva um script que carregue seu modelo e produza previsões e explicações com base em um novo lote de dados.

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

Implantar o serviço

Implante o serviço usando o arquivo Conda e o arquivo de pontuação das etapas 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)

Inferência com dados de teste

A inferência com alguns dados de teste para ver o valor previsto do modelo AutoML, atualmente tem suporte apenas no SDK do Azure Machine Learning. Exiba as importâncias do recurso que contribuem para um valor previsto.

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

Visualizar para descobrir padrões em dados e explicações no tempo de treinamento

É possível visualizar o gráfico de importância dos recursos em seu espaço de trabalho no Estúdio do Azure Machine Learning. Depois que a execução do AutoML for concluída, selecione Exibir detalhes do modelo para exibir uma execução específica. Selecione a guia Explicações para exibir as visualizações no painel de explicação.

Arquitetura de interpretabilidade de Machine Learning

Para saber mais sobre as visualizações do painel de explicação e plotagens específicas, consulte o Documento de instruções sobre interpretabilidade.

Próximas etapas

Para obter mais informações sobre como você pode habilitar as explicações do modelo e a importância do recurso em áreas diferentes de ML automatizado, confira mais técnicas para a capacidade de interpretação do modelo.