Interpretowanie: objaśnienie modelu w zautomatyzowanym uczeniu maszynowym (wersja zapoznawcza)

DOTYCZY:Zestaw SDK języka Python w wersji 1

W tym artykule 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 ułatwia zrozumienie znaczenia funkcji generowanych modeli.

Wszystkie wersje zestawu SDK po ustawieniu domyślnie wersji 1.0.85 model_explainability=True . W zestawie SDK w wersji 1.0.85 i starszych wersji 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 w celu uzyskania najlepszego modelu lub dowolnego modelu.
• Włącz wizualizacje, aby ułatwić wyświetlanie wzorców w danych i wyjaśnieniach.
• Implementuj możliwość interpretacji podczas wnioskowania lub oceniania.

Wymagania wstępne

• Funkcje interpretacji. Uruchom polecenie , pip install azureml-interpret aby uzyskać niezbędny pakiet.
• Znajomość tworzenia eksperymentów zautomatyzowanego uczenia maszynowego. Aby uzyskać więcej informacji na temat korzystania z zestawu Azure Machine Learning SDK, wykonaj ten samouczek dotyczący modelu wykrywania obiektów lub zobacz, jak skonfigurować eksperymenty zautomatyzowanego uczenia maszynowego.

Ważne

Ta funkcja jest obecnie w publicznej wersji zapoznawczej. Ta wersja zapoznawcza jest udostępniana bez umowy dotyczącej poziomu usług i nie zalecamy jej obsługi obciążeń produkcyjnych. Niektóre funkcje mogą być nieobsługiwane lub ograniczone.

Aby uzyskać więcej informacji, zobacz Uzupełniające warunki korzystania z wersji zapoznawczych platformy Microsoft Azure.

Możliwość interpretowania podczas trenowania najlepszego modelu

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

Uwaga

Interpretacja, wyjaśnienie modelu nie jest dostępna dla modelu TCNForecaster zalecanego przez eksperymenty prognozowania automatycznego uczenia maszynowego.

Pobierz zaprojektowane znaczenie funkcji z najlepszego przebiegu

Możesz użyć ExplanationClient polecenia , aby pobrać objaśnienia funkcji inżyniera z magazynu artefaktów programu 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 pierwotnych ważności 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 wizualizowania nie jest ograniczone do istniejącego wyjaśnienia modelu rozwiązania AutoML. 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 rozwiązania AutoML ze szkolenia

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

Konfigurowanie wyjaśnień modelu

Służy automl_setup_model_explanations do uzyskiwania zaprojektowanych i pierwotnych wyjaśnień. 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

Element automl_explainer_setup_obj zawiera 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')

Zainicjuj objaśnienie naśladowane pod kątem ważności funkcji

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

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

Element 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 cech zaprojektowanych

Możesz wywołać metodę w narzędziu explain() 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 cechy 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 przy użyciu zautomatyzowanego uczenia maszynowego można uzyskać najlepszy model przy użyciu get_output() metody i wyjaśnień obliczeniowych lokalnie. Wyniki objaśnień można wizualizować za pomocą ExplanationDashboardraiwidgets 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 Mimic Explainer do przetwarzania i wizualizowania ważności nieprzetworzonych funkcji

Możesz wywołać metodę w narzędziu explain() MimicWrapper z przekształconymi przykładami testowymi, aby uzyskać znaczenie funkcji dla nieprzetworzonych funkcji. W usłudze Machine Learning Studio można 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ć narzędzie objaśniające ocenianie, które obliczy wartości ważności cech zaprojektowanych w czasie wnioskowania. Zainicjujesz objaśnienie oceniania za pomocą obliczonego feature_map wcześniej elementu .

Zapisz wyjaśnienie oceniania, a następnie zarejestruj model i objaśnienie oceniania za pomocą usługi 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 funkcjonalność wymaganą 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 tworzy 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 AutoML, obecnie obsługiwanej tylko w zestawie AZURE Machine Learning SDK. 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 w celu 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.

Aby uzyskać więcej informacji na temat wizualizacji pulpitu nawigacyjnego wyjaśnień 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.