Interpreteerbaarheid: modelverklaarbaarheid in geautomatiseerde ML (preview)

VAN TOEPASSING OP:Python SDK azureml v1

In dit artikel leert u hoe u uitleg krijgt over geautomatiseerde machine learning-modellen (geautomatiseerde ML) in Azure Machine Learning met behulp van de Python SDK. Geautomatiseerde ML helpt u inzicht te krijgen in het belang van functies van de modellen die worden gegenereerd.

Alle SDK-versies na 1.0.85 zijn standaard ingesteld model_explainability=True . In SDK-versie 1.0.85 en eerdere versies moeten gebruikers in het AutoMLConfig object instellen model_explainability=True om modelinterpreteerbaarheid te kunnen gebruiken.

In dit artikel leert u het volgende:

  • Interpreteerbaarheid uitvoeren tijdens de training voor het beste model of elk model.
  • Schakel visualisaties in om patronen in gegevens en uitleg te zien.
  • Implementeer interpreteerbaarheid tijdens deductie of score.

Vereisten

Interpreteerbaarheid tijdens de training voor het beste model

Haal de uitleg op uit de best_run, die uitleg bevat voor zowel onbewerkte als ontworpen functies.

Notitie

Interpreteerbaarheid, modeluitleg, is niet beschikbaar voor het TCNForecaster-model dat wordt aanbevolen door auto ML-voorspellingsexperimenten.

De belangrijke kenmerken van de ontworpen functie downloaden uit de beste uitvoering

U kunt ExplanationClient de technische functie-uitleg downloaden uit het artefactarchief van de 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())

De belangrijke functies voor onbewerkte functies downloaden uit de beste uitvoering

U kunt ExplanationClient de onbewerkte functie-uitleg downloaden uit het artefactarchief van de 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())

Interpreteerbaarheid tijdens de training voor elk model

Wanneer u uitleg van een model berekent en deze visualiseert, bent u niet beperkt tot een bestaande modeluitleg voor een AutoML-model. U kunt ook een uitleg krijgen over uw model met verschillende testgegevens. In de stappen in deze sectie ziet u hoe u het belang van de ontworpen functie kunt berekenen en visualiseren op basis van uw testgegevens.

Een ander AutoML-model ophalen uit de training

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

De modeluitleg instellen

Gebruik automl_setup_model_explanations dit om de technicus en onbewerkte uitleg te krijgen. De fitted_model volgende items kunnen worden gegenereerd:

  • Aanbevolen gegevens uit getrainde of testvoorbeelden
  • Lijst met naamlijsten voor ontworpen functies
  • Vindbare klassen in uw gelabelde kolom in classificatiescenario's

De automl_explainer_setup_obj bevat alle structuren uit de bovenstaande lijst.

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

De Mimic Explainer initialiseren voor het belang van functies

Gebruik de MimicWrapper klasse om een uitleg te genereren voor geautomatiseerde ML-modellen. U kunt de MimicWrapper initialiseren met deze parameters:

  • Het installatieobject van de uitleg
  • Uw werkruimte
  • Een surrogaatmodel om het fitted_model geautomatiseerde ML-model uit te leggen

De MimicWrapper neemt ook het automl_run object waar de ontworpen uitleg wordt ge├╝pload.

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)

Mimic Explainer gebruiken voor computing en het visualiseren van het belang van de functie

U kunt de explain() methode aanroepen in MimicWrapper met de getransformeerde testvoorbeelden om het belang van de functie voor de gegenereerde, ontworpen functies te verkrijgen. U kunt zich ook aanmelden bij Azure Machine Learning-studio om de visualisatie van het dashboard uitleg van de belangrijke waarden voor de functie van de gegenereerde functies door geautomatiseerde ML-featurizers weer te geven.

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

Voor modellen die zijn getraind met geautomatiseerde ML, kunt u het beste model verkrijgen met behulp van de get_output() methode en rekenverklaringen lokaal. U kunt de uitlegresultaten ExplanationDashboard van het raiwidgets pakket visualiseren.

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)

Mimic Explainer gebruiken voor het berekenen en visualiseren van het belang van onbewerkte functies

U kunt de explain() methode aanroepen in MimicWrapper met de getransformeerde testvoorbeelden om het belang van de functie voor de onbewerkte functies te verkrijgen. In Machine Learning Studio kunt u de dashboardvisualisatie van de belangrijke waarden voor functies van de onbewerkte functies bekijken.

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

Interpreteerbaarheid tijdens deductie

In deze sectie leert u hoe u een geautomatiseerd ML-model operationeel kunt maken met de uitleg die is gebruikt om de uitleg in de vorige sectie te berekenen.

Het model en de scoring-uitleg registreren

Gebruik de TreeScoringExplainer functie om de score-uitleg te maken waarmee de belangrijke waarden voor de engineered functie tijdens deductietijd worden berekend. U initialiseert de score-uitleg met de feature_map berekening die eerder is berekend.

Sla de score-uitleg op en registreer vervolgens het model en de scoring-uitleg bij de Model Management Service. Voer de volgende code uit:

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

De conda-afhankelijkheden maken voor het instellen van de service

Maak vervolgens de benodigde omgevingsafhankelijkheden in de container voor het geïmplementeerde model. Houd er rekening mee dat azureml-defaults met versie >= 1.0.45 moeten worden vermeld als pip-afhankelijkheid, omdat deze de functionaliteit bevat die nodig is om het model als webservice te hosten.

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

Het scorescript maken

Schrijf een script waarmee uw model wordt geladen en produceert voorspellingen en uitleg op basis van een nieuwe batch gegevens.

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

De service implementeren

Implementeer de service met behulp van het Conda-bestand en het scorebestand uit de vorige stappen.

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)

Deductie met testgegevens

Deductie met enkele testgegevens om de voorspelde waarde van het AutoML-model te zien, die momenteel alleen wordt ondersteund in de Azure Machine Learning SDK. Bekijk de belangrijke kenmerken die bijdragen aan een voorspelde waarde.

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

Visualiseren om patronen in gegevens en uitleg te detecteren tijdens het trainen

U kunt in Azure Machine Learning-studio de grafiek met functiebelang in uw werkruimte visualiseren. Nadat de AutoML-uitvoering is voltooid, selecteert u Modeldetails weergeven om een specifieke uitvoering weer te geven. Selecteer het tabblad Uitleg om de visualisaties in het uitlegdashboard weer te geven.

Architectuur voor interpreteerbaarheid van Machine Learning

Raadpleeg het uitlegdashboardvisualisaties en specifieke grafieken voor meer informatie over de uitlegdashboardvisualisaties en specifieke grafieken.

Volgende stappen

Zie voor meer informatie over hoe u modeluitleg en functiebelang kunt inschakelen op andere gebieden dan geautomatiseerde ML meer technieken voor modelinterpreteerbaarheid.