Delen via

Interpreteerbaarheid: Model legbaarheid in geautomatiseerde ML (preview)

  • Artikel

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.
  • U kunt visualisaties inschakelen om patronen in gegevens en uitleg te zien.
  • Interpreteerbaarheid implementeren tijdens deductie of score.

Vereisten

  • Interpreteerbaarheidsfuncties. Voer pip install azureml-interpret uit om het benodigde pakket op te halen.
  • Kennis van het bouwen van geautomatiseerde ML-experimenten. Voor meer informatie over het gebruik van de Azure Machine Learning SDK, voltooit u deze zelfstudie over objectdetectiemodellen of bekijkt u hoe u geautomatiseerde ML-experimenten configureert.

Belangrijk

Deze functie is momenteel beschikbaar als openbare preview-versie. Deze preview-versie wordt geleverd zonder een service level agreement en we raden deze niet aan voor productieworkloads. Misschien worden bepaalde functies niet ondersteund of zijn de mogelijkheden ervan beperkt.

Zie 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 ontworpen functies.

Notitie

Interpretability, model explanation, is not available for the TCNForecaster model recommended by Auto ML forecasting experiments.

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

U kunt de ExplanationClient ontworpen 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 urgenties van onbewerkte functies downloaden van 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 over het rekenmodel en deze visualiseert, bent u niet beperkt tot een bestaande modeluitleg voor een AutoML-model. U kunt ook een uitleg krijgen voor 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
  • Lijsten met ontworpen functienamen
  • 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 uitleg
  • Uw werkruimte
  • Een surrogaatmodel om het fitted_model geautomatiseerde ML-model uit te leggen

De MimicWrapper neemt ook het automl_run object waarin 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 de ontworpen functie

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

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 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 in MimicWrapper aanroepen met de getransformeerde testvoorbeelden om het belang van de functie voor de onbewerkte functies te verkrijgen. In de Machine Learning Studio kunt u de dashboardvisualisatie van de belangrijke waarden van de 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 waarden voor het belang van de functie worden berekend op deductietijd. U initialiseert de score-uitleg met de feature_map berekening die eerder is berekend.

Sla de scoring-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 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, 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 op trainingstijd te detecteren

In Azure Machine Learning-studio kunt u de urgentiegrafiek van de functie 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 plots voor meer informatie over de uitleg van dashboardvisualisaties en specifieke plots.

Volgende stappen

Zie meer technieken voor modelinterpretabiliteit voor meer informatie over het inschakelen van modeluitleg en het belang van functies op andere gebieden dan geautomatiseerde ML.