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

Článek
09/01/2024

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

Všechny verze sady SDK po 1.0.85 jsou standardně nastavené model_explainability=True . V sadě SDK verze 1.0.85 a starších verzích musí uživatelé v objektu AutoMLConfig nastavit model_explainability=True interpretovatelnost modelu.

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

Při trénování můžete provádět interpretovatelnost pro nejlepší model nebo jakýkoli model.
Povolte vizualizace, které vám pomůžou zobrazit vzory v datech a vysvětleních.
Implementujte interpretovatelnost během odvozování nebo vyhodnocování.

Požadavky

Interpretovatelnost funkcí Spuštěním pip install azureml-interpret získejte potřebný balíček.
Znalost vytváření automatizovaných experimentů ML Další informace o použití sady Azure Machine Learning SDK najdete v tomto kurzu k modelu rozpoznávání objektů nebo zjistěte, jak nakonfigurovat automatizované experimenty ML.

Důležité

Tato funkce je v současné době ve verzi Public Preview. Tato verze Preview je poskytována bez smlouvy o úrovni služeb a nedoporučujeme ji 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 objektu best_run, který obsahuje vysvětlení nezpracovaných i inženýrových funkcí.

Poznámka:

Interpretovatelnost, vysvětlení modelu není k dispozici pro model TCNForecaster doporučený experimenty s prognózováním automatického strojového učení.

Stažení důležitosti funkcí z nejlepšího spuštění

Můžete použít ExplanationClient ke stažení vysvětlení vysvětlovaných funkcí z úložiště artefaktů v úložišti artefaktů 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 běhu

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

Když vypočítáte vysvětlení modelu a vizualizujete je, nejste omezeni na vysvětlení existujícího modelu pro model AutoML. 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 funkcí na základě testovacích dat.

Načtení jakéhokoli jiného modelu AutoML z trénování

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

Nastavení vysvětlení modelu

Slouží automl_setup_model_explanations k získání inženýrovaných a nezpracovaných vysvětlení. Může fitted_model 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 Mimic Explaineru pro důležitost funkce

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

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

MimicWrapper také vezme objekt, automl_run kde se nahrají popisy inženýrů.

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 významu funkcí inženýrů

Metodu v MimicWrapperu explain() můžete volat 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 řídicího panelu vysvětlení hodnot důležitosti funkcí vygenerovaných vygenerovaných funkcí automatizovanými featurizátory ML.

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

U modelů natrénovaných pomocí automatizovaného strojového get_output() učení můžete získat nejlepší model pomocí metody a vysvětlení výpočetních prostředků místně. Výsledky vysvětlení můžete vizualizovat raiwidgets pomocí ExplanationDashboard 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 důležitosti nezpracovaných funkcí

Metodu v MimicWrapperu explain() můžete volat pomocí transformovaných testovacích ukázek, abyste získali důležitost funkce pro nezpracované funkce. V nástroji Machine Learning Studio můžete zobrazit vizualizaci řídicího panelu hodnot důležitosti funkcí nezpracovaných funkcí.

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 během odvození

V této části se dozvíte, jak zprovoznit automatizovaný model ML s vysvětlením, který se použil k výpočtu vysvětlení v předchozí části.

Registrace modelu a vysvětlení skóre

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

Uložte vysvětlující nástroj pro vyhodnocování a pak zaregistrujte model a vysvětlení skóre 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

Dále vytvořte potřebné závislosti prostředí v kontejneru pro nasazený model. Upozorňujeme, že výchozí hodnoty azureml 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 model a vytváří 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 souboru bodování 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)

Odvozování s testovacími daty

Odvozování s některými testovacími daty, abyste viděli predikovanou hodnotu z modelu AutoML, aktuálně podporovaná pouze v sadě Azure Machine Learning SDK. Prohlédněte si důležitosti funkcí, které přispívají k predikované 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 zjišťování vzorů v datech a vysvětleních 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í AutoML 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ích panelů vysvětlení a konkrétních grafech najdete v dokumentaci k interpretovatelnosti.

Další kroky

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

Sdílet prostřednictvím