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

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 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 verzi 1.0.85 jsou ve výchozím nastavení nastavené model_explainability=True . V sadě SDK verze 1.0.85 a starších verzích musí uživatelé nastavit model_explainability=True v objektu AutoMLConfig , 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ích.
• Implementujte interpretovatelnost během odvozování nebo bodování.

Požadavky

• Funkce interpretovatelnosti. Spuštěním příkazu pip install azureml-interpret získejte potřebný balíček.
• Znalost vytváření automatizovaných experimentů ML. Další informace o tom, jak používat sadu Azure Machine Learning SDK, najdete v tomto kurzu k modelu detekce objektů nebo se dozvíte, jak nakonfigurovat automatizované experimenty ML.

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_runsouboru , který obsahuje vysvětlení pro nezpracované i technické funkce.

Poznámka

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

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

Můžete použít ExplanationClient ke stažení navržených vysvětlení 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 automatického strojového učení. Můžete také získat vysvětlení pro váš model 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í libovolného jiného modelu AutoML z trénování

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

Nastavení vysvětlení modelu

Použijte automl_setup_model_explanations k získání technického a nezpracovaného vysvětlení. Může fitted_model vygenerovat následující položky:

• Doporučená data z natrénovaných nebo testovacích ukázek
• Seznamy názvů navržených funkcí
• Najítelné 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í důležitosti funkce

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

• Objekt nastavení vysvětlující aplikace
• Váš pracovní prostor
• Náhradní model pro vysvětlení automatizovaného modelu strojového fitted_model učení

MimicWrapper také převezme automl_run objekt, do kterého se nahrají zpracovaná 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í

Můžete volat metodu explain() v MimicWrapperu s transformovanými testovacími ukázkami, abyste získali důležitost funkce pro vygenerované technické 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í generovaných automatizovanými funkcemi strojového učení.

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čty 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 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 odvozováním

V této části se dozvíte, jak zprovoznit automatizovaný model ML 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

Pomocí příkazu TreeScoringExplainer vytvořte vysvětlující bodování, který vypočítá hodnoty důležitosti funkce v době odvozování. Vysvětlení skóre inicializujete 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

Dále vytvořte potřebné závislosti prostředí v kontejneru pro nasazený model. Mějte na paměti, že výchozí hodnoty azureml s verzí >= 1.0.45 musí být uvedené jako závislost pip, protože obsahují 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í bodovacího skriptu

Napište skript, který načte 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 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)

Odvozovat s testovacími daty

Odvozujte s některými testovacími daty, abyste viděli předpovězenou hodnotu z modelu AutoML, která se v současné době podporuje pouze v sadě Azure Machine Learning SDK. Podívejte se na 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 pro 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í 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 k interpretovatelnosti.

Další kroky

Další informace o tom, jak můžete 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.