Använda Python-tolkningspaketet för att förklara förutsägelser för ML-modeller & (förhandsversion)

  • Artikel

GÄLLER FÖR:Python SDK azureml v1

I den här instruktionsguiden lär du dig att använda tolkningspaketet för Azure Machine Learning Python SDK för att utföra följande uppgifter:

  • Förklara hela modellbeteendet eller enskilda förutsägelser på din personliga dator lokalt.

  • Aktivera tolkningstekniker för utformade funktioner.

  • Förklara beteendet för hela modellen och enskilda förutsägelser i Azure.

  • Ladda upp förklaringar till Körningshistorik för Azure Machine Learning.

  • Använd en visualiseringsinstrumentpanel för att interagera med dina modellförklaringar, både i en Jupyter Notebook och i Azure Machine Learning-studio.

  • Distribuera en bedömningsförklaring tillsammans med din modell för att observera förklaringar under slutsatsdragning.

Viktigt

Den här funktionen är för närvarande i allmänt tillgänglig förhandsversion. Den här förhandsversionen tillhandahålls utan serviceavtal och rekommenderas inte för produktionsarbetsbelastningar. Vissa funktioner kanske inte stöds eller kan vara begränsade. Mer information finns i Kompletterande villkor för användning av Microsoft Azure-förhandsversioner.

Mer information om de tolkningstekniker och maskininlärningsmodeller som stöds finns i Modelltolkning i Azure Machine Learning och exempel på notebook-filer.

Vägledning om hur du aktiverar tolkning för modeller som tränats med automatiserad maskininlärning finns i Tolkning: modellförklaringar för automatiserade maskininlärningsmodeller (förhandsversion).

Generera värde för funktionsprimitet på din personliga dator

I följande exempel visas hur du använder tolkningspaketet på din personliga dator utan att kontakta Azure-tjänster.

  1. Installera paketet azureml-interpret.

    pip install azureml-interpret

  2. Träna en exempelmodell i en lokal 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. Anropa förklaringen lokalt.

    • Om du vill initiera ett förklarande objekt skickar du din modell och vissa träningsdata till förklaringskonstruktorn.
    • Om du vill göra dina förklaringar och visualiseringar mer informativa kan du välja att skicka in funktionsnamn och utdataklassnamn om du gör klassificering.

    Följande kodblock visar hur du instansierar ett förklaringsobjekt med TabularExplainer, MimicExplaineroch PFIExplainer lokalt.

    • TabularExplainer anropar en av de tre SHAP-förklaringarna under (TreeExplainer, DeepExplainereller KernelExplainer).
    • TabularExplainer väljer automatiskt den lämpligaste för ditt användningsfall, men du kan anropa var och en av dess tre underliggande förklaringar direkt.
    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)

    eller

    
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)

    eller

    from interpret.ext.blackbox import PFIExplainer

# "features" and "classes" fields are optional
explainer = PFIExplainer(model,
                         features=breast_cancer_data.feature_names, 
                         classes=classes)

Förklara hela modellbeteendet (global förklaring)

I följande exempel får du hjälp med att hämta mängdvärdena (global) för funktionsbetydning.


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

Förklara en enskild förutsägelse (lokal förklaring)

Hämta de enskilda funktionsvärdevärdena för olika datapunkter genom att anropa förklaringar för en enskild instans eller en grupp med instanser.

Anteckning

PFIExplainer stöder inte lokala förklaringar.

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

Raw-funktionstransformeringar

Du kan välja att få förklaringar när det gäller råa, otransformerade funktioner i stället för konstruerade funktioner. För det här alternativet skickar du pipelinen för funktionstransformering till förklaringen i train_explain.py. Annars ger förklaringen förklaringar när det gäller utformade funktioner.

Formatet för transformeringar som stöds är detsamma som det som beskrivs i sklearn-pandas. I allmänhet stöds alla transformeringar så länge de fungerar på en enda kolumn så att det är tydligt att de är en-till-många.

Få en förklaring av rådatafunktioner med hjälp av en sklearn.compose.ColumnTransformer eller med en lista över anpassade transformatortupplar. I följande exempel används 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)

Om du vill köra exemplet med listan över anpassade transformatortupplar använder du följande kod:

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)

Generera värden för funktionsprisitet via fjärrkörningar

I följande exempel visas hur du kan använda ExplanationClient klassen för att aktivera modelltolkning för fjärrkörningar. Det är begreppsmässigt likt den lokala processen, förutom att du:

  • ExplanationClient Använd i fjärrkörningen för att ladda upp tolkningskontexten.
  • Ladda ned kontexten senare i en lokal miljö.

  1. Installera paketet azureml-interpret.

    pip install azureml-interpret

  2. Skapa ett träningsskript i en lokal Jupyter Notebook. Till exempel 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. Konfigurera en Azure Machine Learning Compute som beräkningsmål och skicka träningskörningen. Instruktioner finns i Skapa och hantera Azure Machine Learning-beräkningskluster . Det kan också vara användbart med notebook-exempelanteckningsböcker .

  4. Ladda ned förklaringen i din lokala 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))

Visualiseringar

När du har laddat ned förklaringarna i din lokala Jupyter Notebook kan du använda visualiseringarna på instrumentpanelen för förklaringar för att förstå och tolka din modell. Om du vill läsa in instrumentpanelswidgeten för förklaringar i Jupyter Notebook använder du följande kod:

from raiwidgets import ExplanationDashboard

ExplanationDashboard(global_explanation, model, datasetX=x_test)

Visualiseringarna stöder förklaringar av både konstruerade och råa funktioner. Rådataförklaringar baseras på funktionerna från den ursprungliga datauppsättningen och de utformade förklaringarna baseras på funktionerna från datauppsättningen med funktionsframställning tillämpad.

När du försöker tolka en modell med avseende på den ursprungliga datauppsättningen rekommenderar vi att du använder rådataförklaringar eftersom varje funktionsvikt motsvarar en kolumn från den ursprungliga datauppsättningen. Ett scenario där utformade förklaringar kan vara användbara är när du undersöker effekten av enskilda kategorier från en kategorisk funktion. Om en one-hot-kodning tillämpas på en kategorisk funktion innehåller de resulterande utformade förklaringarna ett annat prioritetsvärde per kategori, ett per en frekvent konstruerad funktion. Den här kodningen kan vara användbar när du begränsar vilken del av datamängden som är mest informativ för modellen.

Anteckning

Utformade och råa förklaringar beräknas sekventiellt. Först skapas en konstruerad förklaring baserat på modellen och funktionaliseringspipelinen. Sedan skapas den råa förklaringen baserat på den utformade förklaringen genom att aggregera vikten av konstruerade funktioner som kom från samma råfunktion.

Skapa, redigera och visa datamängdskohorter

Det översta menyfliksområdet visar den övergripande statistiken för din modell och dina data. Du kan dela upp och tärna dina data i datamängdskohorter, eller undergrupper, för att undersöka eller jämföra modellens prestanda och förklaringar i dessa definierade undergrupper. Genom att jämföra datamängdsstatistiken och förklaringarna mellan dessa undergrupper kan du få en uppfattning om varför möjliga fel inträffar i en grupp jämfört med en annan.

Skapa, redigera och visa datamängdskohorter

Förstå hela modellbeteendet (global förklaring)

De första tre flikarna på förklaringsinstrumentpanelen ger en övergripande analys av den tränade modellen tillsammans med dess förutsägelser och förklaringar.

Modellprestanda

Utvärdera modellens prestanda genom att utforska fördelningen av dina förutsägelsevärden och värdena för modellens prestandamått. Du kan undersöka din modell ytterligare genom att titta på en jämförande analys av dess prestanda i olika kohorter eller undergrupper av din datauppsättning. Välj filter längs y-värde och x-värde för att skära över olika dimensioner. Visa mått som noggrannhet, precision, träffsäkerhet, falsk positiv frekvens (FPR) och falsk negativ frekvens (FNR).

Fliken Modellprestanda i förklaringsvisualiseringen

Datauppsättningsutforskaren

Utforska din datamängdsstatistik genom att välja olika filter längs X-, Y- och färgaxlarna för att segmentera dina data längs olika dimensioner. Skapa datamängdskohorter ovan för att analysera datamängdsstatistik med filter som förutsagt resultat, datamängdsfunktioner och felgrupper. Använd kugghjulsikonen i det övre högra hörnet av grafen för att ändra diagramtyper.

Fliken Datauppsättningsutforskaren i förklaringsvisualiseringen

Mängdfunktionsvikt

Utforska de viktigaste funktionerna som påverkar dina övergripande modellförutsägelser (kallas även global förklaring). Använd skjutreglaget för att visa värden för fallande funktionsbetydning. Välj upp till tre kohorter för att se deras funktionsvärde sida vid sida. Välj någon av funktionsstaplarna i diagrammet för att se hur värdena för den valda funktionen påverkar modellförutsägelserna i beroendediagrammet nedan.

Fliken Mängdfunktionsbetydning i förklaringsvisualiseringen

Förstå enskilda förutsägelser (lokal förklaring)

På den fjärde fliken på förklaringsfliken kan du öka detaljnivån för en enskild datapunkt och deras enskilda funktionsvikter. Du kan läsa in det enskilda funktionspridande diagrammet för valfri datapunkt genom att klicka på någon av de enskilda datapunkterna i huvudpunktsdiagrammet eller välja en specifik datapunkt i panelguiden till höger.

Tomt Beskrivning
Prioritet för enskilda funktioner Visar de viktigaste funktionerna för en enskild förutsägelse. Hjälper till att illustrera det lokala beteendet för den underliggande modellen på en specifik datapunkt.
What-If analys Tillåter ändringar av funktionsvärden för den valda verkliga datapunkten och observerar resulterande ändringar i förutsägelsevärdet genom att generera en hypotetisk datapunkt med de nya funktionsvärdena.
Individuell villkorsstyrd förväntan (ICE) Tillåter funktionsvärdesändringar från ett minimivärde till ett högsta värde. Hjälper till att illustrera hur datapunktens förutsägelse ändras när en funktion ändras.

Enskild funktionsbetydning och konsekvensflik i förklaringsinstrumentpanelen

Anteckning

Det här är förklaringar baserade på många uppskattningar och är inte "orsaken" till förutsägelser. Utan strikt matematisk robusthet av kausal slutsatsdragning rekommenderar vi inte användare att fatta verkliga beslut baserat på funktionsavvikelser i What-If-verktyget. Det här verktyget är främst till för att förstå din modell och felsökning.

Visualisering i Azure Machine Learning-studio

Om du slutför stegen för fjärrtolkning (ladda upp genererade förklaringar till Körningshistorik för Azure Machine Learning) kan du visa visualiseringarna på instrumentpanelen för förklaringar i Azure Machine Learning-studio. Den här instrumentpanelen är en enklare version av instrumentpanelswidgeten som genereras i din Jupyter Notebook. What-If datapunktsgenerering och ICE-diagram inaktiveras eftersom det inte finns någon aktiv beräkning i Azure Machine Learning-studio som kan utföra sina beräkningar i realtid.

Om datauppsättningen, globala och lokala förklaringar är tillgängliga fyller data i alla flikar. Men om det bara finns en global förklaring inaktiveras fliken Individual feature importance (Individuell funktionsbetydning).

Följ någon av dessa sökvägar för att komma åt instrumentpanelen för förklaringar i Azure Machine Learning-studio:

  • Fönstret Experiment (förhandsversion)

    1. Välj Experiment i den vänstra rutan för att se en lista över experiment som du har kört på Azure Machine Learning.
    2. Välj ett visst experiment för att visa alla körningar i experimentet.
    3. Välj en körning och sedan fliken Förklaringar till instrumentpanelen för förklaringsvisualisering.

    Visualiseringsinstrumentpanel med aggregerad funktionsvikt i Azure Machine Learning-studio i experiment

  • Fönstret Modeller

    1. Om du registrerade din ursprungliga modell genom att följa stegen i Distribuera modeller med Azure Machine Learning kan du välja Modeller i det vänstra fönstret för att visa den.
    2. Välj en modell och sedan fliken Förklaringar för att visa instrumentpanelen för förklaringar.

Tolkning vid slutsatsdragningstid

Du kan distribuera förklaringen tillsammans med den ursprungliga modellen och använda den vid inferenstillfället för att ange de enskilda egenskapsvärdevärdena (lokal förklaring) för alla nya datapunkter. Vi erbjuder också lättare poängförklarare för att förbättra tolkningsprestanda vid slutsatsdragning, som för närvarande endast stöds i Azure Machine Learning SDK. Processen för att distribuera en bedömningsförklaring med lägre vikt liknar distributionen av en modell och omfattar följande steg:

  1. Skapa ett förklaringsobjekt. Du kan till exempel använda TabularExplainer:

     from interpret.ext.blackbox import TabularExplainer


explainer = TabularExplainer(model, 
                             initialization_examples=x_train, 
                             features=dataset_feature_names, 
                             classes=dataset_classes, 
                             transformations=transformations)

  2. Skapa en bedömningsförklaring med förklaringsobjektet.

    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. Konfigurera och registrera en avbildning som använder bedömningsförklaringsmodellen.

    # 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. Som ett valfritt steg kan du hämta bedömningsförklaringen från molnet och testa förklaringarna.

    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. Distribuera avbildningen till ett beräkningsmål genom att följa dessa steg:

    1. Om det behövs registrerar du din ursprungliga förutsägelsemodell genom att följa stegen i Distribuera modeller med Azure Machine Learning.

    2. Skapa en bedömningsfil.

      %%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. Definiera distributionskonfigurationen.

      Den här konfigurationen beror på kraven för din modell. I följande exempel definieras en konfiguration som använder en CPU-kärna och en GB minne.

      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. Skapa en fil med miljöberoenden.

      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. Skapa en anpassad dockerfile med g++ installerat.

      %%writefile dockerfile
RUN apt-get update && apt-get install -y g++

    6. Distribuera den skapade avbildningen.

      Den här processen tar cirka fem minuter.

      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. Testa distributionen.

    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. Rensa.

    Om du vill ta bort en distribuerad webbtjänst använder du service.delete().

Felsökning

  • Glesa data stöds inte: Instrumentpanelen för modellförklaringen bryts/saktas ned avsevärt med ett stort antal funktioner, och därför stöder vi för närvarande inte glesa dataformat. Dessutom uppstår allmänna minnesproblem med stora datamängder och ett stort antal funktioner.

  • Funktionsmatris för förklaringar som stöds

Förklaringsflik som stöds Råfunktioner (tät) Råfunktioner (gles) Utformade funktioner (kompakta) Utformade funktioner (glesa)
Modellprestanda Stöds (inte prognostisering) Stöds (inte prognostisering) Stöds Stöds
Datauppsättningsutforskaren Stöds (inte prognostisering) Stöds inte. Eftersom glesa data inte laddas upp och användargränssnittet har problem med att återge glesa data. Stöds Stöds inte. Eftersom glesa data inte laddas upp och användargränssnittet har problem med att återge glesa data.
Mängdfunktionsvikt Stöds Stöds Stöds Stöds
Prioritet för enskilda funktioner Stöds (inte prognostisering) Stöds inte. Eftersom glesa data inte laddas upp och användargränssnittet har problem med att återge glesa data. Stöds Stöds inte. Eftersom glesa data inte laddas upp och användargränssnittet har problem med att återge glesa data.

  • Prognosmodeller som inte stöds med modellförklaringar: Tolkning, bästa modellförklaring, är inte tillgängligt för AutoML-prognosexperiment som rekommenderar följande algoritmer som den bästa modellen: TCNForecaster, AutoArima, Prophet, ExponentialSmoothing, Average, Naive, Seasonal Average och Seasonal Naive. AutoML-prognostiseringsregressionsmodeller har stöd för förklaringar. I förklaringsinstrumentpanelen stöds dock inte fliken "Individual feature importance" (Enskild funktionsbetydning) för prognostisering på grund av komplexiteten i deras datapipelines.

  • Lokal förklaring för dataindex: Förklaringsinstrumentpanelen stöder inte relaterade lokala prioritetsvärden till en radidentifierare från den ursprungliga valideringsdatauppsättningen om datauppsättningen är större än 5 000 datapunkter eftersom instrumentpanelen slumpmässigt minskar datamängden. Instrumentpanelen visar dock funktionsvärden för rådatauppsättningar för varje datapunkt som skickas till instrumentpanelen under fliken Individual feature importance (Individuell funktionsbetydning). Användare kan mappa lokala prioriteter tillbaka till den ursprungliga datauppsättningen genom att matcha funktionsvärdena för rådatamängden. Om storleken på valideringsdatauppsättningen är mindre än 5 000 exempel index motsvarar funktionen i Azure Machine Learning-studio indexet i valideringsdatauppsättningen.

  • Konsekvensdiagram/ICE-diagram som inte stöds i Studio: What-If- och ICE-diagram (Individual Conditional Expectation) stöds inte i Azure Machine Learning-studio på fliken Förklaringar eftersom den uppladdade förklaringen behöver en aktiv beräkning för att beräkna om förutsägelser och sannolikheter för störda funktioner. Det stöds för närvarande i Jupyter Notebooks när det körs som en widget med hjälp av SDK.

Nästa steg

Tekniker för modelltolkning i Azure Machine Learning

Ta en titt på notebook-exempelanteckningsböcker för Azure Machine Learning-tolkning