Capacidade de interpretação: explicação do modelo no ML automatizado (pré-visualização)

APLICA-SE A:SDK python azureml v1

Neste artigo, vai aprender a obter explicações para modelos de machine learning automatizado (ML automatizado) no Azure Machine Learning com o SDK Python. O ML automatizado ajuda-o a compreender a importância das funcionalidades dos modelos gerados.

Todas as versões do SDK depois da 1.0.85 definidas model_explainability=True por predefinição. No SDK versão 1.0.85 e versões anteriores, os utilizadores têm de definir model_explainability=True no objeto para utilizar a interpretabilidade do AutoMLConfig modelo.

Neste artigo, vai aprender a:

• Efetue a interpretação durante a preparação para o melhor modelo ou qualquer modelo.
• Ative as visualizações para o ajudar a ver padrões em dados e explicações.
• Implemente a interpretabilidade durante a inferência ou a classificação.

Pré-requisitos

• Funcionalidades de interpretação. Execute pip install azureml-interpret para obter o pacote necessário.
• Conhecimento da criação de experimentações de ML automatizadas. Para obter mais informações sobre como utilizar o SDK do Azure Machine Learning, conclua este tutorial de modelo de deteção de objetos ou veja como configurar experimentações de ML automatizadas.

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 preparação para o melhor modelo

Obtenha a explicação do best_run, que inclui explicações para funcionalidades não processadas e concebidas.

Nota

A interpretação, explicação do modelo, não está disponível para o modelo TCNForecaster recomendado pelas experimentações de previsão de ML Automático.

Transferir as importâncias da funcionalidade concebida a partir da melhor execução

Pode utilizar ExplanationClient para transferir as explicações de funcionalidades concebidas a partir do arquivo de artefactos 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())

Transferir as importâncias da funcionalidade não processada a partir da melhor execução

Pode utilizar ExplanationClient para transferir as explicações de funcionalidades não processadas do arquivo de artefactos 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 preparação para qualquer modelo

Quando calcula explicações do modelo e as visualiza, não está limitado a uma explicação de modelo existente para um modelo de AutoML. Também pode obter uma explicação para o modelo com dados de teste diferentes. Os passos nesta secção mostram-lhe como calcular e visualizar a importância das funcionalidades concebidas com base nos seus dados de teste.

Obter qualquer outro modelo de AutoML a partir da preparação

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

Configurar as explicações do modelo

Utilize automl_setup_model_explanations para obter as explicações criadas e não processadas. O fitted_model pode gerar os seguintes itens:

• Dados em destaque de exemplos preparados ou de teste
• Listas de nomes de funcionalidades concebidas
• Classes localizáveis na coluna etiquetada em cenários de classificação

Contém automl_explainer_setup_obj 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 Explicador de Imitação para a importância da funcionalidade

Para gerar uma explicação para modelos de ML automatizados, utilize a MimicWrapper classe . Pode inicializar o MimicWrapper com estes parâmetros:

• O objeto de configuração do explicador
• A sua área de trabalho
• Um modelo de substituição para explicar o fitted_model modelo de ML automatizado

O MimicWrapper também leva o automl_run objeto onde as explicações concebidas 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)

Utilizar o Mimic Explainer para computação e visualização da importância da funcionalidade concebida

Pode chamar o explain() método no MimicWrapper com os exemplos de teste transformados para obter a importância da funcionalidade para as funcionalidades geradas. Também pode iniciar sessão no estúdio do Azure Machine Learning para ver as explicações da visualização do dashboard dos valores de importância da funcionalidade das funcionalidades geradas pelos caracterizadores de ML automatizados.

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

Para modelos preparados com ML automatizado, pode obter o melhor modelo com o get_output() método e as explicações de computação localmente. Pode visualizar os resultados da explicação a ExplanationDashboard partir do 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)

Utilizar o Mimic Explainer para computação e visualizar a importância da funcionalidade não processada

Pode chamar o explain() método em MimicWrapper com os exemplos de teste transformados para obter a importância da funcionalidade para as funcionalidades não processadas. No estúdio do Machine Learning, pode ver a visualização do dashboard dos valores de importância da funcionalidade das funcionalidades não processadas.

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

Capacidade de interpretação durante a inferência

Nesta secção, vai aprender a operacionalizar um modelo de ML automatizado com o explicador que foi utilizado para calcular as explicações na secção anterior.

Registar o modelo e o explicador de classificação

Utilize o TreeScoringExplainer para criar o explicador de classificação que irá calcular os valores de importância da funcionalidade concebida no momento da inferência. Vai inicializar o explicador de classificação com o feature_map que foi calculado anteriormente.

Guarde o explicador de classificação e, em seguida, registe o modelo e o explicador de classificação no Serviço de Gestão de Modelos. 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 conda para configurar o serviço

Em seguida, crie as dependências de ambiente necessárias no contentor para o modelo implementado. Tenha em atenção que as predefinições azureml com a versão >= 1.0.45 têm de estar listadas como uma dependência pip, porque contém a funcionalidade necessária para alojar 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 classificação

Escreva um script que carregue o seu modelo e produz predições e explicações com base num 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

Implemente o serviço com o ficheiro conda e o ficheiro de classificação dos passos 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 de AutoML, atualmente suportado apenas no SDK do Azure Machine Learning. Veja as importâncias da funcionalidade 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 detetar padrões em dados e explicações no momento da preparação

Pode visualizar o gráfico de importância da funcionalidade na área de trabalho no estúdio do Azure Machine Learning. Após a conclusão da execução do AutoML, selecione Ver detalhes do modelo para ver uma execução específica. Selecione o separador Explicações para ver as visualizações no dashboard de explicações.

Para obter mais informações sobre as visualizações do dashboard de explicação e os gráficos específicos, veja o documento de procedimentos sobre interpretação.

Passos seguintes

Para obter mais informações sobre como pode ativar explicações de modelos e importância de funcionalidades em áreas que não o ML automatizado, veja mais técnicas de interpretação de modelos.