Interpreteerbaarheid: Modelverklaarbaarheid in geautomatiseerde ML (preview)

  • Artikel

VAN TOEPASSING OP:Python SDK azureml v1

In dit artikel leert u hoe u uitleg krijgt voor modellen voor geautomatiseerde machine learning (geautomatiseerde ML) in Azure Machine Learning met behulp van de Python SDK. Geautomatiseerde ML helpt u inzicht te krijgen in het functie-belang 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 het trainen voor het beste model of een willekeurig model.
  • Schakel visualisaties in om patronen in gegevens en uitleg te zien.
  • Implementeer interpreteerbaarheid tijdens deductie of score.

Vereisten

  • Functies voor interpreteerbaarheid. Voer uit pip install azureml-interpret om het benodigde pakket op te halen.
  • Kennis van het bouwen van geautomatiseerde ML-experimenten. Voltooi deze zelfstudie over het objectdetectiemodel voor meer informatie over het gebruik van de Azure Machine Learning SDK of zie geautomatiseerde ML-experimenten configureren.

Belangrijk

Deze functie is momenteel beschikbaar als openbare preview-versie. Deze preview-versie wordt geleverd zonder serviceovereenkomst en wordt niet aanbevolen voor productieworkloads. Misschien worden bepaalde functies niet ondersteund of zijn de mogelijkheden ervan beperkt.

Zie Supplemental Terms of Use for Microsoft Azure Previews (Aanvullende gebruiksvoorwaarden voor Microsoft Azure-previews) voor meer informatie.

Interpreteerbaarheid tijdens de training voor het beste model

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

Notitie

Interpretatiebaarheid, modeluitleg, is niet beschikbaar voor het TCNForecaster-model dat wordt aanbevolen door experimenten met automatische ML-prognose.

Download de ontworpen functie-urgenties van de beste uitvoering

U kunt gebruiken ExplanationClient om de ontworpen functie-uitleg te downloaden uit de artefactopslag 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())

Download de onbewerkte functiebelangen van de beste uitvoering

U kunt gebruiken ExplanationClient om de onbewerkte functie-uitleg te downloaden uit de artefactopslag 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 training voor elk model

Wanneer u modeluitleg berekent en deze visualiseert, bent u niet beperkt tot een bestaande modeluitleg voor een AutoML-model. U kunt ook een uitleg voor uw model krijgen met verschillende testgegevens. De stappen in deze sectie laten zien hoe u de urgentie van ontworpen functies berekent en visualiseert 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 om de ontworpen en onbewerkte uitleg op te halen. De fitted_model kan de volgende items genereren:

  • Aanbevolen gegevens uit getrainde of testvoorbeelden
  • Aangepaste functienaamlijsten
  • 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 uitlegobject instellen
  • Uw werkruimte
  • Een surrogaatmodel om het fitted_model geautomatiseerde ML-model uit te leggen

De MimicWrapper neemt ook het automl_run object op 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 het berekenen en visualiseren van het belang van ontworpen functies

U kunt de explain() methode in MimicWrapper aanroepen met de getransformeerde testvoorbeelden om het functie-belang voor de gegenereerde engineered functies op te vragen. U kunt zich ook aanmelden bij Azure Machine Learning-studio om de visualisatie van het uitlegdashboard van de waarden voor functiebelang 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 krijgen met behulp van de get_output() methode en berekeningsuitleg lokaal. U kunt de resultaten van de uitleg visualiseren met ExplanationDashboard uit het raiwidgets pakket.

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 in MimicWrapper aanroepen met de getransformeerde testvoorbeelden om het functie-belang voor de onbewerkte functies op te vragen. In de Machine Learning-studio kunt u de dashboardvisualisatie bekijken van de waarden voor functie-urgentie van de onbewerkte functies.

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 explainer registreren

Gebruik de TreeScoringExplainer om de scoring explainer te maken waarmee de waarde van de aangepaste functie-urgentie op de deductietijd wordt berekend. U initialiseert de scoring explainer met de feature_map die eerder is berekend.

Sla de scoring explainer op en registreer het model en de scoring explainer met de Service voor modelbeheer. 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 een 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 dat uw model laadt en voorspellingen en uitleg produceert 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, momenteel alleen ondersteund in Azure Machine Learning SDK. Bekijk de functiebelangen 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 tijdens de training te ontdekken

U kunt de grafiek met functie-urgentie in uw werkruimte visualiseren in Azure Machine Learning-studio. 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

Voor meer informatie over de uitlegdashboardvisualisaties en specifieke plots raadpleegt u het instructiedocument over interpreteerbaarheid.

Volgende stappen

Zie Meer technieken voor modelinterpreteerbaarheid voor meer informatie over het inschakelen van modeluitleg en functiebelang op andere gebieden dan geautomatiseerde ML.