Interpretovatelnost: Vysvětlitelnost modelů v automatizovaném strojovém učení (Preview)

Článek
03/03/2023
6 min ke čtení

PLATÍ PRO:Sada Python SDK azureml v1

V tomto článku se dozvíte, jak získat vysvětlení k modelům automatizovaného strojového učení (automatizovaného strojového učení) ve službě Azure Machine Learning s využitím sady Python SDK. Automatizované strojové učení pomáhá pochopit důležitost funkcí generovaných modelů.

Ve výchozím nastavení jsou nastavené model_explainability=True všechny verze sady SDK po verzi 1.0.85. V sadě SDK verze 1.0.85 a starších verzích musí uživatelé v objektu AutoMLConfig nastavitmodel_explainability=True, aby mohli používat interpretovatelnost modelu.

V tomto článku získáte informace o těchto tématech:

Provádějte interpretovatelnost během trénování pro nejlepší model nebo jakýkoli model.
Povolte vizualizace, které vám pomůžou zobrazit vzory v datech a vysvětlení.
Implementujte interpretovatelnost během odvozování nebo bodování.

Požadavky

Funkce interpretovatelnosti: Potřebný balíček získáte spuštěním příkazu pip install azureml-interpret .
Znalost vytváření experimentů automatizovaného strojového učení Další informace o tom, jak používat sadu Azure Machine Learning SDK, najdete v tomto kurzu k modelu rozpoznávání objektů nebo se podívejte, jak nakonfigurovat experimenty automatizovaného strojového učení.

Důležité

Tato funkce je v současné době ve verzi Public Preview. Tato verze Preview se poskytuje bez smlouvy o úrovni služeb a nedoporučuje se pro produkční úlohy. Některé funkce se nemusí podporovat nebo mohou mít omezené možnosti. Další informace najdete v dodatečných podmínkách použití pro verze Preview v Microsoft Azure.

Interpretovatelnost během trénování pro nejlepší model

Načtěte vysvětlení z best_run, které obsahuje vysvětlení pro nezpracované i zpracované funkce.

Poznámka

Interpretovatelnost a vysvětlení modelu není k dispozici pro model TCNForecaster doporučený v experimentech prognózování automatického strojového učení.

Stažení informací o důležitosti navržených funkcí z nejlepšího spuštění

Můžete použít ExplanationClient ke stažení vysvětlení navržených funkcí z úložiště artefaktů objektu 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())

Stažení nezpracovaných důležitostí funkcí z nejlepšího spuštění

Můžete použít ExplanationClient ke stažení nezpracovaných vysvětlení funkcí z úložiště artefaktů objektu 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())

Interpretovatelnost během trénování pro libovolný model

Když vypočítáte vysvětlení modelů a vizualizujete je, nejste omezeni na existující vysvětlení modelu automatizovaného strojového učení. Můžete také získat vysvětlení modelu s různými testovacími daty. Kroky v této části ukazují, jak vypočítat a vizualizovat důležitost navržených funkcí na základě testovacích dat.

Načtení jakéhokoli jiného modelu Automatizovaného strojového učení z trénování

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

Nastavení vysvětlení modelů

Pomocí automl_setup_model_explanations můžete získat zpracovaná a nezpracovaná vysvětlení. Nástroj fitted_model může generovat následující položky:

Doporučená data z natrénovaných nebo testovacích ukázek
Seznamy názvů navržených funkcí
Vyhledatelné třídy ve sloupci s popiskem ve scénářích klasifikace

Obsahuje automl_explainer_setup_obj všechny struktury z výše uvedeného seznamu.

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

Inicializace mimického vysvětlení pro důležitost funkce

Pokud chcete vygenerovat vysvětlení pro modely automatizovaného strojového MimicWrapper učení, použijte třídu . MimicWrapper můžete inicializovat pomocí těchto parametrů:

Objekt nastavení explaineru
Váš pracovní prostor
Náhradní model, který vysvětluje model automatizovaného strojového fitted_model učení

MimicWrapper také převezme automl_run objekt, do kterého se nahrají navržená vysvětlení.

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)

Použití mimic explaineru pro výpočet a vizualizaci důležitosti navržených funkcí

V mimicWrapperu můžete volat metodu explain() s transformovanými testovacími ukázkami, abyste získali důležitost funkce pro vygenerované funkce. Můžete se také přihlásit k studio Azure Machine Learning a zobrazit vizualizaci vysvětlení řídicího panelu s hodnotami důležitosti funkcí generovaných automatizovanými funkcemi ML featurizátory.

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

U modelů vytrénovaných pomocí automatizovaného strojového učení můžete získat nejlepší model pomocí get_output() vysvětlení metod a výpočetních prostředků místně. Výsledky vysvětlení můžete vizualizovat pomocí ExplanationDashboardraiwidgets balíčku.

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)

Použití mimic explaineru pro výpočet a vizualizaci nezpracované důležitosti funkcí

Můžete volat metodu explain() v MimicWrapper s transformovanými testovacími ukázkami, abyste získali důležitost funkce pro nezpracované funkce. V machine learning studiu můžete zobrazit vizualizaci hodnot důležitosti funkcí nezpracovaných funkcí na řídicím panelu.

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

Interpretovatelnost při odvození

V této části se dozvíte, jak zprovoznit model automatizovaného strojového učení pomocí vysvětlující funkce, která se použila k výpočtu vysvětlení v předchozí části.

Registrace modelu a vysvětlení skóre

TreeScoringExplainer Použijte k vytvoření vysvětlení skóre, který vypočítá hodnoty důležitosti navržených funkcí v době odvozování. Inicializujete vysvětlení skóre pomocí dříve vypočítaného objektu feature_map .

Uložte vysvětlení skóre a pak model a vysvětlení skóre zaregistrujte ve službě správa modelů. Spusťte následující kód:

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

Vytvoření závislostí conda pro nastavení služby

V dalším kroku vytvořte v kontejneru potřebné závislosti prostředí pro nasazený model. Upozorňujeme, že azureml-default s verzí >= 1.0.45 musí být uvedené jako závislost pip, protože obsahuje funkce potřebné k hostování modelu jako webové služby.

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

Vytvoření hodnoticího skriptu

Napište skript, který načte váš model a vytvoří předpovědi a vysvětlení na základě nové dávky dat.

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

Nasazení služby

Nasaďte službu pomocí souboru conda a hodnoticího souboru z předchozích kroků.

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)

Odvozovat s testovacími daty

Odvozujte s některými testovacími daty, abyste viděli předpovězenou hodnotu z modelu Automatizovaného strojového učení, který se v současné době podporuje pouze v sadě Azure Machine Learning SDK. Zobrazte důležitost funkcí, které přispívají k předpovězené hodnotě.

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

Vizualizace za účelem zjištění vzorů v datech a vysvětlení v době trénování

Graf důležitosti funkcí v pracovním prostoru můžete vizualizovat v studio Azure Machine Learning. Po dokončení spuštění Automatizovaného strojového učení vyberte Zobrazit podrobnosti modelu a zobrazte konkrétní spuštění. Výběrem karty Vysvětlení zobrazíte vizualizace na řídicím panelu vysvětlení.

Další informace o vizualizacích řídicího panelu vysvětlení a konkrétních grafech najdete v dokumentaci s postupy pro interpretovatelnost.

Další kroky

Další informace o tom, jak povolit vysvětlení modelu a důležitost funkcí v jiných oblastech než automatizované strojové učení, najdete v tématu další techniky pro interpretovatelnost modelu.