Możliwość interpretowania: objaśnienie modelu w zautomatyzowanym uczeniu maszynowym (wersja zapoznawcza)

DOTYCZY:Zestaw SDK języka Python w wersji 1

Z tego artykułu dowiesz się, jak uzyskać wyjaśnienia dotyczące modeli zautomatyzowanego uczenia maszynowego (zautomatyzowanego uczenia maszynowego) w usłudze Azure Machine Learning przy użyciu zestawu SDK języka Python. Zautomatyzowane uczenie maszynowe pomaga zrozumieć znaczenie funkcji generowanych modeli.

Wszystkie wersje zestawu SDK po ustawieniu model_explainability=True domyślnie wersji 1.0.85. W zestawie SDK w wersji 1.0.85 i starszych użytkownicy muszą ustawić model_explainability=True obiekt w AutoMLConfig celu korzystania z możliwości interpretowania modelu.

W tym artykule omówiono sposób wykonywania następujących zadań:

  • Wykonywanie interpretacji podczas trenowania dla najlepszego modelu lub dowolnego modelu.
  • Włącz wizualizacje, aby ułatwić wyświetlanie wzorców w danych i wyjaśnieniach.
  • Implementowanie możliwości interpretacji podczas wnioskowania lub oceniania.

Wymagania wstępne

Możliwość interpretowania podczas trenowania dla najlepszego modelu

Pobierz wyjaśnienie z elementu best_run, który zawiera wyjaśnienia dotyczące zarówno nieprzetworzonych, jak i zaprojektowanych funkcji.

Uwaga

Możliwość interpretacji, wyjaśnienie modelu, nie jest dostępna dla modelu TCNForecaster zalecanego przez eksperymenty prognozowania automatycznego uczenia maszynowego.

Pobieranie znaczenia funkcji zaprojektowanych z najlepszego przebiegu

Możesz użyć ExplanationClient polecenia , aby pobrać opisy funkcji zaprojektowanych z magazynu artefaktów obiektu 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())

Pobieranie ważności nieprzetworzonych funkcji z najlepszego przebiegu

Możesz użyć ExplanationClient polecenia , aby pobrać nieprzetworzone wyjaśnienia funkcji z magazynu artefaktów .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())

Możliwość interpretowania podczas trenowania dowolnego modelu

Podczas obliczania wyjaśnień modelu i ich wizualizacji nie jest ograniczone do istniejącego wyjaśnienia modelu zautomatyzowanego uczenia maszynowego. Możesz również uzyskać wyjaśnienie modelu z różnymi danymi testowymi. W krokach w tej sekcji pokazano, jak obliczać i wizualizować znaczenie funkcji zaprojektowanych na podstawie danych testowych.

Pobieranie dowolnego innego modelu zautomatyzowanego uczenia maszynowego z trenowania

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

Konfigurowanie wyjaśnień modelu

Użyj automl_setup_model_explanations polecenia , aby uzyskać zaprojektowane i nieprzetworzone wyjaśnienia. Element fitted_model może wygenerować następujące elementy:

  • Polecane dane z przykładów wytrenowanych lub testowych
  • Listy nazw funkcji zaprojektowanych
  • Klasy z możliwością znajdowania w kolumnie oznaczonej etykietą w scenariuszach klasyfikacji

Zawiera automl_explainer_setup_obj wszystkie struktury z powyższej listy.

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

Inicjowanie narzędzia Wyjaśnij naśladownictwo pod kątem ważności funkcji

Aby wygenerować wyjaśnienie dla zautomatyzowanych modeli uczenia maszynowego, użyj MimicWrapper klasy . Zainicjuj program MimicWrapper przy użyciu następujących parametrów:

  • Obiekt konfiguracji objaśniającego
  • Obszar roboczy
  • Model zastępczy wyjaśniający zautomatyzowany model uczenia maszynowego fitted_model

Program MimicWrapper przyjmuje automl_run również obiekt, w którym zostaną przekazane zaprojektowane wyjaśnienia.

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)

Używanie narzędzia Mimic Explainer do przetwarzania i wizualizowania znaczenia funkcji zaprojektowanych

Metodę explain() można wywołać w programie MimicWrapper z przekształconymi przykładami testowymi, aby uzyskać znaczenie funkcji dla wygenerowanych funkcji zaprojektowanych funkcji. Możesz również zalogować się do Azure Machine Learning studio, aby wyświetlić wizualizację pulpitu nawigacyjnego objaśnień dotyczących wartości ważności funkcji wygenerowanych przez zautomatyzowane elementy cech uczenia maszynowego.

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

W przypadku modeli wytrenowanych za pomocą zautomatyzowanego uczenia maszynowego można uzyskać najlepszy model przy użyciu get_output() metody i wyjaśnień obliczeniowych lokalnie. Możesz zwizualizować wyniki ExplanationDashboard wyjaśnienia z raiwidgets pakietu.

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)

Używanie narzędzia Wyjaśnij naśladownictwo do przetwarzania i wizualizowania ważności nieprzetworzonych funkcji

Metodę explain() można wywołać w programie MimicWrapper z przekształconymi przykładami testowymi, aby uzyskać znaczenie funkcji dla nieprzetworzonych funkcji. W usłudze Machine Learning Studio możesz wyświetlić wizualizację pulpitu nawigacyjnego wartości ważności funkcji pierwotnych funkcji.

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

Możliwość interpretacji podczas wnioskowania

W tej sekcji dowiesz się, jak operacjonalizować zautomatyzowany model uczenia maszynowego za pomocą narzędzia objaśniającego, który został użyty do obliczenia wyjaśnień w poprzedniej sekcji.

Rejestrowanie modelu i objaśnienia oceniania

Użyj elementu TreeScoringExplainer , aby utworzyć objaśnienie oceniania, które będzie obliczać wartości znaczenia funkcji inżyniera w czasie wnioskowania. Należy zainicjować objaśnienie oceniania za pomocą obliczonego feature_map wcześniej elementu .

Zapisz objaśnienie oceniania, a następnie zarejestruj model i objaśnienie oceniania w usłudze zarządzania modelami. Uruchom następujący kod:

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

Tworzenie zależności conda na potrzeby konfigurowania usługi

Następnie utwórz niezbędne zależności środowiska w kontenerze dla wdrożonego modelu. Należy pamiętać, że wartość azureml-defaults z wersją >= 1.0.45 musi być wymieniona jako zależność pip, ponieważ zawiera ona funkcje wymagane do hostowania modelu jako usługi internetowej.

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

Tworzenie skryptu oceniania

Napisz skrypt, który ładuje model i generuje przewidywania i wyjaśnienia na podstawie nowej partii danych.

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

Wdrażanie usługi

Wdróż usługę przy użyciu pliku conda i pliku oceniania z poprzednich kroków.

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)

Wnioskowanie z danymi testowymi

Wnioskowanie z niektórymi danymi testowymi w celu wyświetlenia przewidywanej wartości z modelu automatycznego uczenia maszynowego, obecnie obsługiwanej tylko w zestawie SDK usługi Azure Machine Learning. Wyświetl znaczenie funkcji przyczyniające się do przewidywanej wartości.

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

Wizualizowanie odnajdywania wzorców w danych i wyjaśnieniach w czasie trenowania

Wykres ważności funkcji można wizualizować w obszarze roboczym w Azure Machine Learning studio. Po zakończeniu przebiegu rozwiązania AutoML wybierz pozycję Wyświetl szczegóły modelu , aby wyświetlić określony przebieg. Wybierz kartę Wyjaśnienia , aby wyświetlić wizualizacje na pulpicie nawigacyjnym wyjaśnienia.

Architektura interpretacji uczenia maszynowego

Aby uzyskać więcej informacji na temat wizualizacji pulpitu nawigacyjnego wyjaśnienia i określonych wykresów, zapoznaj się z dokumentacją dotyczącą możliwości interpretowania.

Następne kroki

Aby uzyskać więcej informacji na temat włączania wyjaśnień modelu i znaczenia funkcji w obszarach innych niż zautomatyzowane uczenie maszynowe, zobacz więcej technik interpretowania modelu.