Het Python-pakket voor interpretability gebruiken om voorspellingen van ML-modellen & uit te leggen (preview)

VAN TOEPASSING OP:Python SDK azureml v1

In deze handleiding leert u hoe u het interpretability-pakket van de Azure Machine Learning Python SDK gebruikt om de volgende taken uit te voeren:

  • Leg lokaal het gedrag van het hele model of afzonderlijke voorspellingen op uw persoonlijke computer uit.

  • Schakel interpreteerbaarheidstechnieken in voor ontworpen functies.

  • Leg het gedrag uit voor het hele model en afzonderlijke voorspellingen in Azure.

  • Upload uitleg naar De uitvoeringsgeschiedenis van Azure Machine Learning.

  • Gebruik een visualisatiedashboard om te communiceren met uw modeluitleg, zowel in een Jupyter Notebook als in de Azure Machine Learning-studio.

  • Implementeer een scoring explainer naast uw model om verklaringen tijdens de deductie te observeren.

Zie Modelinterpretabiliteit in Azure Machine Learning en voorbeeldnotebooks voor meer informatie over de ondersteunde interpreteerbaarheidstechnieken en machine learning-modellen.

Zie Interpretability: model explanations for automated machine learning models (preview) voor hulp bij het inschakelen van interpreteerbaarheid voor modellen die zijn getraind met geautomatiseerde machine learning.

Waarde voor functie-urgentie genereren op uw persoonlijke computer

In het volgende voorbeeld ziet u hoe u het interpretability-pakket op uw persoonlijke computer gebruikt zonder dat u contact opneemt met Azure-services.

  1. Installeer het azureml-interpret-pakket.

    pip install azureml-interpret
    
  2. Een voorbeeldmodel trainen in een lokale Jupyter Notebook.

    # load breast cancer dataset, a well-known small dataset that comes with scikit-learn
    from sklearn.datasets import load_breast_cancer
    from sklearn import svm
    from sklearn.model_selection import train_test_split
    breast_cancer_data = load_breast_cancer()
    classes = breast_cancer_data.target_names.tolist()
    
    # split data into train and test
    from sklearn.model_selection import train_test_split
    x_train, x_test, y_train, y_test = train_test_split(breast_cancer_data.data,            
                                                        breast_cancer_data.target,  
                                                        test_size=0.2,
                                                        random_state=0)
    clf = svm.SVC(gamma=0.001, C=100., probability=True)
    model = clf.fit(x_train, y_train)
    
  3. Roep de uitlegfunctie lokaal aan.

    • Als u een uitlegobject wilt initialiseren, geeft u het model en enkele trainingsgegevens door aan de constructor van de uitlegfunctie.
    • Als u uw uitleg en visualisaties meer informatief wilt maken, kunt u ervoor kiezen om functienamen en namen van uitvoerklassen door te geven als u classificatie uitvoert.

    De volgende codeblokken laten zien hoe u een uitlegobject maakt met TabularExplainer, MimicExplaineren PFIExplainer lokaal.

    • TabularExplainer roept een van de drie SHAP-uitlegfuncties hieronder aan (TreeExplainer, DeepExplainer, of KernelExplainer).
    • TabularExplainer selecteert automatisch de meest geschikte voor uw gebruikscase, maar u kunt elk van de drie onderliggende uitlegfuncties rechtstreeks aanroepen.
    from interpret.ext.blackbox import TabularExplainer
    
    # "features" and "classes" fields are optional
    explainer = TabularExplainer(model, 
                                 x_train, 
                                 features=breast_cancer_data.feature_names, 
                                 classes=classes)
    

    of

    
    from interpret.ext.blackbox import MimicExplainer
    
    # you can use one of the following four interpretable models as a global surrogate to the black box model
    
    from interpret.ext.glassbox import LGBMExplainableModel
    from interpret.ext.glassbox import LinearExplainableModel
    from interpret.ext.glassbox import SGDExplainableModel
    from interpret.ext.glassbox import DecisionTreeExplainableModel
    
    # "features" and "classes" fields are optional
    # augment_data is optional and if true, oversamples the initialization examples to improve surrogate model accuracy to fit original model.  Useful for high-dimensional data where the number of rows is less than the number of columns.
    # max_num_of_augmentations is optional and defines max number of times we can increase the input data size.
    # LGBMExplainableModel can be replaced with LinearExplainableModel, SGDExplainableModel, or DecisionTreeExplainableModel
    explainer = MimicExplainer(model, 
                               x_train, 
                               LGBMExplainableModel, 
                               augment_data=True, 
                               max_num_of_augmentations=10, 
                               features=breast_cancer_data.feature_names, 
                               classes=classes)
    

    of

    from interpret.ext.blackbox import PFIExplainer
    
    # "features" and "classes" fields are optional
    explainer = PFIExplainer(model,
                             features=breast_cancer_data.feature_names, 
                             classes=classes)
    

Het gedrag van het hele model uitleggen (algemene uitleg)

Raadpleeg het volgende voorbeeld om u te helpen bij het ophalen van de waarden voor het belang van de statistische (globale) functie.


# you can use the training data or the test data here, but test data would allow you to use Explanation Exploration
global_explanation = explainer.explain_global(x_test)

# if you used the PFIExplainer in the previous step, use the next line of code instead
# global_explanation = explainer.explain_global(x_train, true_labels=y_train)

# sorted feature importance values and feature names
sorted_global_importance_values = global_explanation.get_ranked_global_values()
sorted_global_importance_names = global_explanation.get_ranked_global_names()
dict(zip(sorted_global_importance_names, sorted_global_importance_values))

# alternatively, you can print out a dictionary that holds the top K feature names and values
global_explanation.get_feature_importance_dict()

Een afzonderlijke voorspelling uitleggen (lokale uitleg)

Haal de waarden voor het belang van afzonderlijke functies van verschillende gegevenspunten op door uitleg aan te roepen voor een afzonderlijk exemplaar of een groep exemplaren.

Notitie

PFIExplainer biedt geen ondersteuning voor lokale uitleg.

# get explanation for the first data point in the test set
local_explanation = explainer.explain_local(x_test[0:5])

# sorted feature importance values and feature names
sorted_local_importance_names = local_explanation.get_ranked_local_names()
sorted_local_importance_values = local_explanation.get_ranked_local_values()

Onbewerkte functietransformaties

U kunt ervoor kiezen om uitleg te krijgen in termen van onbewerkte, niet-vertaalde functies in plaats van ontworpen functies. Voor deze optie geeft u de pijplijn voor functietransformatie door aan de uitleg in train_explain.py. Anders biedt de uitleg uitleg in termen van ontworpen functies.

De indeling van ondersteunde transformaties is hetzelfde als beschreven in sklearn-pandas. Over het algemeen worden transformaties ondersteund zolang ze op één kolom werken, zodat het duidelijk is dat ze een-op-veel zijn.

Krijg een uitleg voor onbewerkte functies met behulp van een sklearn.compose.ColumnTransformer of met een lijst met passende transformator-tuples. In het volgende voorbeeld wordt gebruikt sklearn.compose.ColumnTransformer.

from sklearn.compose import ColumnTransformer

numeric_transformer = Pipeline(steps=[
    ('imputer', SimpleImputer(strategy='median')),
    ('scaler', StandardScaler())])

categorical_transformer = Pipeline(steps=[
    ('imputer', SimpleImputer(strategy='constant', fill_value='missing')),
    ('onehot', OneHotEncoder(handle_unknown='ignore'))])

preprocessor = ColumnTransformer(
    transformers=[
        ('num', numeric_transformer, numeric_features),
        ('cat', categorical_transformer, categorical_features)])

# append classifier to preprocessing pipeline.
# now we have a full prediction pipeline.
clf = Pipeline(steps=[('preprocessor', preprocessor),
                      ('classifier', LogisticRegression(solver='lbfgs'))])


# clf.steps[-1][1] returns the trained classification model
# pass transformation as an input to create the explanation object
# "features" and "classes" fields are optional
tabular_explainer = TabularExplainer(clf.steps[-1][1],
                                     initialization_examples=x_train,
                                     features=dataset_feature_names,
                                     classes=dataset_classes,
                                     transformations=preprocessor)

Als u het voorbeeld wilt uitvoeren met de lijst met aangepaste transformator-tuples, gebruikt u de volgende code:

from sklearn.pipeline import Pipeline
from sklearn.impute import SimpleImputer
from sklearn.preprocessing import StandardScaler, OneHotEncoder
from sklearn.linear_model import LogisticRegression
from sklearn_pandas import DataFrameMapper

# assume that we have created two arrays, numerical and categorical, which holds the numerical and categorical feature names

numeric_transformations = [([f], Pipeline(steps=[('imputer', SimpleImputer(
    strategy='median')), ('scaler', StandardScaler())])) for f in numerical]

categorical_transformations = [([f], OneHotEncoder(
    handle_unknown='ignore', sparse=False)) for f in categorical]

transformations = numeric_transformations + categorical_transformations

# append model to preprocessing pipeline.
# now we have a full prediction pipeline.
clf = Pipeline(steps=[('preprocessor', DataFrameMapper(transformations)),
                      ('classifier', LogisticRegression(solver='lbfgs'))])

# clf.steps[-1][1] returns the trained classification model
# pass transformation as an input to create the explanation object
# "features" and "classes" fields are optional
tabular_explainer = TabularExplainer(clf.steps[-1][1],
                                     initialization_examples=x_train,
                                     features=dataset_feature_names,
                                     classes=dataset_classes,
                                     transformations=transformations)

Waarden voor functie-urgentie genereren via externe uitvoeringen

In het volgende voorbeeld ziet u hoe u de ExplanationClient klasse kunt gebruiken om modelinterpreteerbaarheid voor externe uitvoeringen in te schakelen. Het is conceptueel vergelijkbaar met het lokale proces, behalve dat u:

  • Gebruik de ExplanationClient in de externe uitvoering om de context van de interpretatiebaarheid te uploaden.
  • Download de context later in een lokale omgeving.
  1. Installeer het azureml-interpret-pakket.

    pip install azureml-interpret
    
  2. Maak een trainingsscript in een lokale Jupyter Notebook. Bijvoorbeeld train_explain.py.

    from azureml.interpret import ExplanationClient
    from azureml.core.run import Run
    from interpret.ext.blackbox import TabularExplainer
    
    run = Run.get_context()
    client = ExplanationClient.from_run(run)
    
    # write code to get and split your data into train and test sets here
    # write code to train your model here 
    
    # explain predictions on your local machine
    # "features" and "classes" fields are optional
    explainer = TabularExplainer(model, 
                                 x_train, 
                                 features=feature_names, 
                                 classes=classes)
    
    # explain overall model predictions (global explanation)
    global_explanation = explainer.explain_global(x_test)
    
    # uploading global model explanation data for storage or visualization in webUX
    # the explanation can then be downloaded on any compute
    # multiple explanations can be uploaded
    client.upload_model_explanation(global_explanation, comment='global explanation: all features')
    # or you can only upload the explanation object with the top k feature info
    #client.upload_model_explanation(global_explanation, top_k=2, comment='global explanation: Only top 2 features')
    
  3. Stel een Azure Machine Learning Compute in als uw rekendoel en dien de trainingsuitvoering in. Zie Azure Machine Learning-rekenclusters maken en beheren voor instructies. Mogelijk vindt u de voorbeeldnotitieblokken ook nuttig.

  4. Download de uitleg in uw lokale Jupyter Notebook.

    from azureml.interpret import ExplanationClient
    
    client = ExplanationClient.from_run(run)
    
    # get model explanation data
    explanation = client.download_model_explanation()
    # or only get the top k (e.g., 4) most important features with their importance values
    explanation = client.download_model_explanation(top_k=4)
    
    global_importance_values = explanation.get_ranked_global_values()
    global_importance_names = explanation.get_ranked_global_names()
    print('global importance values: {}'.format(global_importance_values))
    print('global importance names: {}'.format(global_importance_names))
    

Visualisaties

Nadat u de uitleg in uw lokale Jupyter Notebook hebt gedownload, kunt u de visualisaties in het uitlegdashboard gebruiken om uw model te begrijpen en te interpreteren. Gebruik de volgende code om de widget uitlegdashboard in uw Jupyter Notebook te laden:

from raiwidgets import ExplanationDashboard

ExplanationDashboard(global_explanation, model, datasetX=x_test)

De visualisaties ondersteunen uitleg over zowel ontworpen als onbewerkte functies. Onbewerkte uitleg is gebaseerd op de functies uit de oorspronkelijke gegevensset en de ontworpen uitleg is gebaseerd op de functies uit de gegevensset waarop functie-engineering is toegepast.

Wanneer u probeert een model te interpreteren met betrekking tot de oorspronkelijke gegevensset, is het raadzaam om onbewerkte uitleg te gebruiken, omdat het belang van elke functie overeenkomt met een kolom uit de oorspronkelijke gegevensset. Een scenario waarin ontworpen verklaringen nuttig kunnen zijn, is bij het onderzoeken van de impact van afzonderlijke categorieën op basis van een categorisch kenmerk. Als een one-hot codering wordt toegepast op een categorische functie, bevatten de resulterende ontworpen uitleg een andere urgentiewaarde per categorie, één per one-hot engineered-functie. Deze codering kan handig zijn bij het beperken van welk deel van de gegevensset het meest informatief is voor het model.

Notitie

Ontworpen en onbewerkte verklaringen worden opeenvolgend berekend. Eerst wordt een ontworpen uitleg gemaakt op basis van het model en de featurization-pijplijn. Vervolgens wordt de onbewerkte uitleg gemaakt op basis van die engineered uitleg door het belang van ontworpen functies die afkomstig zijn van dezelfde onbewerkte functie te aggregeren.

Cohorten voor gegevenssets maken, bewerken en weergeven

Op het bovenste lint worden de algemene statistieken voor uw model en gegevens weergegeven. U kunt uw gegevens segmenteren in cohorten van gegevenssets of subgroepen om de prestaties en uitleg van uw model in deze gedefinieerde subgroepen te onderzoeken of te vergelijken. Door uw gegevenssetstatistieken en uitleg in deze subgroepen te vergelijken, krijgt u een idee waarom mogelijke fouten optreden in de ene groep versus de andere.

Gegevenssetcohorten maken, bewerken en weergeven

Het gedrag van het hele model begrijpen (algemene uitleg)

De eerste drie tabbladen van het uitlegdashboard bieden een algemene analyse van het getrainde model, samen met de voorspellingen en uitleg.

Modelprestaties

Evalueer de prestaties van uw model door de distributie van uw voorspellingswaarden en de waarden van de metrische prestatiegegevens van uw model te verkennen. U kunt uw model verder onderzoeken door te kijken naar een vergelijkende analyse van de prestaties in verschillende cohorten of subgroepen van uw gegevensset. Selecteer filters langs y-waarde en x-waarde om verschillende dimensies te snijden. Metrische gegevens weergeven, zoals nauwkeurigheid, precisie, relevante overeenkomsten, fout-positieve frequentie (FPR) en fout-negatieve frequentie (FNR).

Tabblad Modelprestaties in de uitlegvisualisatie

Gegevenssetverkenner

Verken uw gegevenssetstatistieken door verschillende filters langs de X-, Y- en kleurassen te selecteren om uw gegevens over verschillende dimensies te segmenteren. Maak gegevenssetcohorten hierboven om gegevenssetstatistieken te analyseren met filters zoals voorspeld resultaat, gegevenssetfuncties en foutgroepen. Gebruik het tandwielpictogram in de rechterbovenhoek van de grafiek om grafiektypen te wijzigen.

Tabblad Gegevenssetverkenner in de visualisatie uitleg

Belang van aggregatie van functies

Verken de belangrijkste belangrijke functies die van invloed zijn op uw algemene modelvoorspellingen (ook wel globale uitleg genoemd). Gebruik de schuifregelaar om aflopende waarden voor het belang van functies weer te geven. Selecteer maximaal drie cohorten om de waarden voor functie-urgentie naast elkaar te bekijken. Selecteer een van de functiebalken in de grafiek om te zien hoe waarden van het geselecteerde functiemodel voorspellen in het onderstaande afhankelijkheidsdiagram.

Tabblad Urgentie van functie samenvoegen in de visualisatie met uitleg

Inzicht in afzonderlijke voorspellingen (lokale uitleg)

Op het vierde tabblad van het tabblad Uitleg kunt u inzoomen op een afzonderlijk gegevenspunt en de bijbehorende kenmerken. U kunt de afzonderlijke functie-urgentieplot voor elk gegevenspunt laden door te klikken op een van de afzonderlijke gegevenspunten in het hoofdspreidingsplot of door een specifiek gegevenspunt te selecteren in de deelvensterwizard aan de rechterkant.

Plotten Description
Belang van afzonderlijke functies Toont de belangrijkste functies voor een afzonderlijke voorspelling. Helpt het lokale gedrag van het onderliggende model op een specifiek gegevenspunt te illustreren.
What-If analyse Hiermee kunt u wijzigingen aan functiewaarden van het geselecteerde echte gegevenspunt wijzigen en de resulterende wijzigingen in de voorspellingswaarde observeren door een hypothetisch gegevenspunt te genereren met de nieuwe functiewaarden.
Individuele voorwaardelijke verwachting (ICE) Hiermee kunt u de functiewaarde wijzigen van een minimumwaarde naar een maximumwaarde. Hiermee kunt u zien hoe de voorspelling van het gegevenspunt verandert wanneer een functie wordt gewijzigd.

Het belang van afzonderlijke functies en het what-if-tabblad in het uitlegdashboard

Notitie

Dit zijn verklaringen op basis van veel benaderingen en zijn niet de 'oorzaak' van voorspellingen. Zonder strikte wiskundige robuustheid van causale deductie raden we gebruikers niet aan om echte beslissingen te nemen op basis van de functie-verstoringen van het hulpprogramma What-If. Dit hulpprogramma is voornamelijk bedoeld om inzicht te krijgen in uw model en foutopsporing.

Visualisatie in Azure Machine Learning-studio

Als u de stappen voor externe interpretatiebaarheid (het uploaden van gegenereerde uitleg naar De uitvoeringsgeschiedenis van Azure Machine Learning) voltooit, kunt u de visualisaties bekijken op het dashboard uitleg in Azure Machine Learning-studio. Dit dashboard is een eenvoudigere versie van de dashboardwidget die wordt gegenereerd in uw Jupyter Notebook. What-If het genereren van gegevenspunten en ICE-plots zijn uitgeschakeld omdat er geen actieve berekeningen zijn in Azure Machine Learning-studio die hun realtime berekeningen kunnen uitvoeren.

Als de gegevensset, algemene en lokale uitleg beschikbaar zijn, worden alle tabbladen gevuld met gegevens. Als er echter alleen een algemene uitleg beschikbaar is, wordt het tabblad Belang van afzonderlijke functies uitgeschakeld.

Volg een van deze paden voor toegang tot het dashboard uitleg in Azure Machine Learning-studio:

  • Deelvenster Experimenten (preview)

    1. Selecteer Experimenten in het linkerdeelvenster voor een lijst met experimenten die u hebt uitgevoerd op Azure Machine Learning.
    2. Selecteer een bepaald experiment om alle uitvoeringen in dat experiment weer te geven.
    3. Selecteer een uitvoering en vervolgens het tabblad Uitleg naar het dashboard voor uitlegvisualisatie.

    Visualisatiedashboard met aggregatiefunctie belang in AzureML Studio in experimenten

  • Deelvenster Modellen

    1. Als u uw oorspronkelijke model hebt geregistreerd door de stappen in Modellen implementeren met Azure Machine Learning te volgen, kunt u Modellen selecteren in het linkerdeelvenster om het weer te geven.
    2. Selecteer een model en vervolgens het tabblad Uitleg om het dashboard uitleg weer te geven.

Interpreteerbaarheid bij deductietijd

U kunt de uitleg samen met het oorspronkelijke model implementeren en deze op het moment van deductie gebruiken om de waarden voor het belang van afzonderlijke functies (lokale uitleg) op te geven voor elk nieuw gegevenspunt. We bieden ook uitleg over lichtere scores om de interpreteerbaarheid tijdens deductie te verbeteren. Dit wordt momenteel alleen ondersteund in de Azure Machine Learning SDK. Het proces voor het implementeren van een uitleg van een lichtere score is vergelijkbaar met het implementeren van een model en omvat de volgende stappen:

  1. Maak een uitlegobject. U kunt bijvoorbeeld gebruiken TabularExplainer:

     from interpret.ext.blackbox import TabularExplainer
    
    
    explainer = TabularExplainer(model, 
                                 initialization_examples=x_train, 
                                 features=dataset_feature_names, 
                                 classes=dataset_classes, 
                                 transformations=transformations)
    
  2. Maak een scoring explainer met het uitlegobject.

    from azureml.interpret.scoring.scoring_explainer import KernelScoringExplainer, save
    
    # create a lightweight explainer at scoring time
    scoring_explainer = KernelScoringExplainer(explainer)
    
    # pickle scoring explainer
    # pickle scoring explainer locally
    OUTPUT_DIR = 'my_directory'
    save(scoring_explainer, directory=OUTPUT_DIR, exist_ok=True)
    
  3. Configureer en registreer een afbeelding die gebruikmaakt van het scoring explainer-model.

    # register explainer model using the path from ScoringExplainer.save - could be done on remote compute
    # scoring_explainer.pkl is the filename on disk, while my_scoring_explainer.pkl will be the filename in cloud storage
    run.upload_file('my_scoring_explainer.pkl', os.path.join(OUTPUT_DIR, 'scoring_explainer.pkl'))
    
    scoring_explainer_model = run.register_model(model_name='my_scoring_explainer', 
                                                 model_path='my_scoring_explainer.pkl')
    print(scoring_explainer_model.name, scoring_explainer_model.id, scoring_explainer_model.version, sep = '\t')
    
  4. Als optionele stap kunt u de scoring explainer ophalen uit de cloud en de uitleg testen.

    from azureml.interpret.scoring.scoring_explainer import load
    
    # retrieve the scoring explainer model from cloud"
    scoring_explainer_model = Model(ws, 'my_scoring_explainer')
    scoring_explainer_model_path = scoring_explainer_model.download(target_dir=os.getcwd(), exist_ok=True)
    
    # load scoring explainer from disk
    scoring_explainer = load(scoring_explainer_model_path)
    
    # test scoring explainer locally
    preds = scoring_explainer.explain(x_test)
    print(preds)
    
  5. Implementeer de installatiekopieën in een rekendoel door de volgende stappen uit te voeren:

    1. Registreer indien nodig uw oorspronkelijke voorspellingsmodel door de stappen in Modellen implementeren met Azure Machine Learning te volgen.

    2. Maak een scorebestand.

      %%writefile score.py
      import json
      import numpy as np
      import pandas as pd
      import os
      import pickle
      from sklearn.externals import joblib
      from sklearn.linear_model import LogisticRegression
      from azureml.core.model import Model
      
      def init():
      
         global original_model
         global scoring_model
      
         # retrieve the path to the model file using the model name
         # assume original model is named original_prediction_model
         original_model_path = Model.get_model_path('original_prediction_model')
         scoring_explainer_path = Model.get_model_path('my_scoring_explainer')
      
         original_model = joblib.load(original_model_path)
         scoring_explainer = joblib.load(scoring_explainer_path)
      
      def run(raw_data):
         # get predictions and explanations for each data point
         data = pd.read_json(raw_data)
         # make prediction
         predictions = original_model.predict(data)
         # retrieve model explanations
         local_importance_values = scoring_explainer.explain(data)
         # you can return any data type as long as it is JSON-serializable
         return {'predictions': predictions.tolist(), 'local_importance_values': local_importance_values}
      
    3. De implementatieconfiguratie configureren.

      Deze configuratie is afhankelijk van de vereisten van uw model. In het volgende voorbeeld wordt een configuratie gedefinieerd die gebruikmaakt van één CPU-kern en één GB geheugen.

      from azureml.core.webservice import AciWebservice
      
       aciconfig = AciWebservice.deploy_configuration(cpu_cores=1,
                                                 memory_gb=1,
                                                 tags={"data": "NAME_OF_THE_DATASET",
                                                       "method" : "local_explanation"},
                                                 description='Get local explanations for NAME_OF_THE_PROBLEM')
      
    4. Maak een bestand met omgevingsafhankelijkheden.

      from azureml.core.conda_dependencies import CondaDependencies
      
      # WARNING: to install this, g++ needs to be available on the Docker image and is not by default (look at the next cell)
      
      azureml_pip_packages = ['azureml-defaults', 'azureml-core', 'azureml-telemetry', 'azureml-interpret']
      
      
      # specify CondaDependencies obj
      myenv = CondaDependencies.create(conda_packages=['scikit-learn', 'pandas'],
                                       pip_packages=['sklearn-pandas'] + azureml_pip_packages,
                                       pin_sdk_version=False)
      
      
      with open("myenv.yml","w") as f:
         f.write(myenv.serialize_to_string())
      
      with open("myenv.yml","r") as f:
         print(f.read())
      
    5. Maak een aangepast dockerfile waarop g++ is geïnstalleerd.

      %%writefile dockerfile
      RUN apt-get update && apt-get install -y g++
      
    6. Implementeer de gemaakte installatiekopieën.

      Dit proces duurt ongeveer vijf minuten.

      from azureml.core.webservice import Webservice
      from azureml.core.image import ContainerImage
      
      # use the custom scoring, docker, and conda files we created above
      image_config = ContainerImage.image_configuration(execution_script="score.py",
                                                      docker_file="dockerfile",
                                                      runtime="python",
                                                      conda_file="myenv.yml")
      
      # use configs and models generated above
      service = Webservice.deploy_from_model(workspace=ws,
                                          name='model-scoring-service',
                                          deployment_config=aciconfig,
                                          models=[scoring_explainer_model, original_model],
                                          image_config=image_config)
      
      service.wait_for_deployment(show_output=True)
      
  6. Test de implementatie.

    import requests
    
    # create data to test service with
    examples = x_list[:4]
    input_data = examples.to_json()
    
    headers = {'Content-Type':'application/json'}
    
    # send request to service
    resp = requests.post(service.scoring_uri, input_data, headers=headers)
    
    print("POST to url", service.scoring_uri)
    # can covert back to Python objects from json string if desired
    print("prediction:", resp.text)
    
  7. Opschonen.

    Als u een geïmplementeerde webservice wilt verwijderen, gebruikt u service.delete().

Problemen oplossen

  • Sparse-gegevens worden niet ondersteund: het dashboard voor modeluitleg verbreekt/vertraagt aanzienlijk met een groot aantal functies. Daarom bieden we momenteel geen ondersteuning voor de sparse-gegevensindeling. Daarnaast treden er algemene geheugenproblemen op bij grote gegevenssets en een groot aantal functies.

  • Ondersteunde matrix met uitlegfuncties

Tabblad Ondersteunde uitleg Onbewerkte functies (dicht) Onbewerkte functies (sparse) Ontworpen functies (dicht) Ontworpen functies (sparse)
Modelprestaties Ondersteund (geen prognose) Ondersteund (geen prognose) Ondersteund Ondersteund
Gegevenssetverkenner Ondersteund (geen prognose) Wordt niet ondersteund. Omdat sparse-gegevens niet worden geüpload en de gebruikersinterface problemen heeft met het weergeven van sparse gegevens. Ondersteund Wordt niet ondersteund. Omdat sparse-gegevens niet worden geüpload en de gebruikersinterface problemen heeft met het weergeven van sparse gegevens.
Belang van aggregatie van functies Ondersteund Ondersteund Ondersteund Ondersteund
Belang van afzonderlijke functies Ondersteund (geen prognose) Wordt niet ondersteund. Omdat sparse-gegevens niet worden geüpload en de gebruikersinterface problemen heeft met het weergeven van sparse gegevens. Ondersteund Wordt niet ondersteund. Omdat sparse-gegevens niet worden geüpload en de gebruikersinterface problemen heeft met het weergeven van sparse gegevens.
  • Prognosemodellen worden niet ondersteund met modeluitleg: Interpretability, best model explanation, is not available for AutoML forecasting experiments that recommend the following algorithms as the best model: TCNForecaster, AutoArima, Prophet, ExponentialSmoothing, Average, Naive, Seasonal Average en Seasonal Naive. Regressiemodellen voor AutoML-prognose bieden ondersteuning voor uitleg. In het uitlegdashboard wordt het tabblad Afzonderlijke functie belangrijkheid echter niet ondersteund voor prognoses vanwege de complexiteit van hun gegevenspijplijnen.

  • Lokale uitleg voor gegevensindex: het uitlegdashboard biedt geen ondersteuning voor het koppelen van waarden voor lokaal belang aan een rij-id uit de oorspronkelijke validatiegegevensset als die gegevensset groter is dan 5000 gegevenspunten omdat het dashboard de gegevens willekeurig downsampt. Op het dashboard worden echter onbewerkte gegevenssetfunctiewaarden weergegeven voor elk gegevenspunt dat is doorgegeven aan het dashboard op het tabblad Prioriteit van afzonderlijke functies. Gebruikers kunnen lokale urgenties toewijzen aan de oorspronkelijke gegevensset door de functiewaarden van de onbewerkte gegevensset te vinden. Als de grootte van de validatiegegevensset minder dan 5000 voorbeelden is, komt de index functie in AzureML Studio overeen met de index in de validatiegegevensset.

  • Wat-als-/ICE-plots worden niet ondersteund in studio: What-If- en ICE-plots (Individual Conditional Expectation) worden niet ondersteund in Azure Machine Learning-studio op het tabblad Uitleg, omdat voor de geüploade uitleg een actieve berekening nodig is om voorspellingen en waarschijnlijkheden van verstoorde functies opnieuw te berekenen. Het wordt momenteel ondersteund in Jupyter-notebooks wanneer deze wordt uitgevoerd als een widget met behulp van de SDK.

Volgende stappen

Technieken voor modelinterpretabiliteit in Azure ML

Bekijk voorbeeldnotebooks van Azure Machine Learning-interpretability