Interpretabilidade: Explicabilidade do modelo em ML automatizado (visualização)
APLICA-SE A:
Python SDK azureml v1
Neste artigo, você aprenderá a obter explicações para modelos de aprendizado de máquina automatizado (ML automatizado) no Aprendizado de Máquina do Azure 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 após 1.0.85 definidas model_explainability=True por padrão. No SDK versão 1.0.85 e versões anteriores, os usuários precisam definir model_explainability=True o objeto para usar a interpretabilidade do AutoMLConfig modelo.
Neste artigo, vai aprender a:
- Execute a interpretabilidade durante o treinamento para o melhor modelo ou qualquer modelo.
- Habilite visualizações para ajudá-lo a ver padrões em dados e explicações.
- Implementar a interpretabilidade durante a inferência ou pontuação.
Pré-requisitos
- Recursos de interpretabilidade. Execute
pip install azureml-interpretpara obter o pacote necessário. - Conhecimento da construção de experimentos automatizados de ML. Para obter mais informações sobre como usar o SDK do Azure Machine Learning, conclua este tutorial de modelo de deteção de objeto ou veja como configurar experimentos automatizados de ML.
Importante
Esta funcionalidade está atualmente em pré-visualização pública. Esta versão de pré-visualização é fornecida sem um contrato de nível de serviço e não a recomendamos para cargas de trabalho de produção. Algumas funcionalidades poderão não ser suportadas ou poderão ter capacidades limitadas.
Para obter mais informações, veja Termos Suplementares de Utilização para Pré-visualizações do Microsoft Azure.
Interpretabilidade durante a formação para o melhor modelo
Recupere a explicação do best_run, que inclui explicações para recursos brutos e projetados.
Nota
A interpretabilidade, explicação do modelo, não está disponível para o modelo TCNForecaster recomendado pelos experimentos de previsão do Auto ML.
Faça o download das importâncias dos recursos projetados da melhor execução
Você pode usar ExplanationClient para baixar as explicações de recursos projetados 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())
Faça o download das importâncias dos recursos brutos da melhor execução
Você pode usar ExplanationClient para baixar as explicações de recursos brutos 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 a formação para qualquer modelo
Quando você calcula explicações de modelo e as visualiza, não está limitado a uma explicação de modelo existente para um modelo AutoML. Você também pode obter uma explicação para o seu modelo com diferentes dados de teste. As etapas nesta seção mostram como calcular e visualizar a importância do recurso de engenharia com base em seus dados de teste.
Recupere qualquer outro modelo 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 brutas e de engenharia. O fitted_model pode gerar os seguintes itens:
- Dados em destaque de amostras treinadas ou de teste
- Listas de nomes de recursos projetados
- Classes localizáveis na 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 de ML automatizados, use a MimicWrapper classe. Você pode inicializar o MimicWrapper com estes parâmetros:
- O objeto de configuração do explicador
- O seu espaço de trabalho
- Um modelo substituto para explicar o modelo automatizado de
fitted_modelML
O MimicWrapper também leva o automl_run objeto onde as explicações projetadas 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 calcular e visualizar a importância dos recursos projetados
Você pode chamar o explain() método em MimicWrapper com as amostras de teste transformadas para obter a importância do recurso para os recursos de engenharia gerados. Você também pode entrar no estúdio do Azure Machine Learning para exibir a visualização do painel de explicações dos valores de importância do recurso dos recursos de engenharia gerados por participantes automatizados de ML.
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 o get_output() método e explicações de computação localmente. Você pode visualizar os resultados da explicação com ExplanationDashboard o raiwidgets pacote.
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 calcular e visualizar a importância do recurso bruto
Você pode chamar o explain() método em MimicWrapper com as amostras de teste transformadas para obter a importância do recurso para os recursos brutos. No estúdio de Aprendizado de Máquina, 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 operacionalizar um modelo de ML automatizado com o explicador que foi usado para calcular as explicações na seção anterior.
Registre 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 do recurso projetado no momento da inferência. Você inicializa o explicador de pontuação com o feature_map que foi computado anteriormente.
Salve o explicador de pontuação e, em seguida, registre o modelo e o explicador de pontuação com o Serviço de Gerenciamento de Modelo. Execute o seguinte código:
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 azureml-defaults com versão >= 1.0.45 deve ser listado como uma dependência pip, pois 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}
Implementar 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
Inferência com alguns dados de teste para ver o valor previsto do modelo AutoML, atualmente suportado apenas no SDK do Azure Machine Learning. Veja as importâncias dos recursos 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']))
Visualize para descobrir padrões em dados e explicações no momento do treinamento
Você pode visualizar o gráfico de importância do recurso em seu espaço de trabalho no estúdio do Azure Machine Learning. Após a conclusão da execução do AutoML, selecione Exibir detalhes do modelo para exibir uma execução específica. Selecione a guia Explicações para ver as visualizações no painel de explicações.
Para obter mais informações sobre as visualizações do painel de explicação e gráficos específicos, consulte o documento de instruções sobre interpretabilidade.
Próximos passos
Para obter mais informações sobre como habilitar explicações de modelo e importância de recursos em áreas diferentes do ML automatizado, consulte mais técnicas para interpretabilidade de modelo.
Comentários
Brevemente: Ao longo de 2024, vamos descontinuar progressivamente o GitHub Issues como mecanismo de feedback para conteúdos e substituí-lo por um novo sistema de feedback. Para obter mais informações, veja: https://aka.ms/ContentUserFeedback.
Submeter e ver comentários