Vysvětlení predikcí modelů & ML pomocí balíčku interpretovatelnosti Pythonu (Preview)

Článek
03/15/2023
15 min ke čtení

PLATÍ PRO:Sada Python SDK azureml v1

V tomto návodu se naučíte používat balíček interpretovatelnosti sady Python SDK služby Azure Machine Learning k provádění následujících úloh:

Vysvětlete místně celé chování modelu nebo jednotlivé předpovědi na osobním počítači.
Povolte techniky interpretovatelnosti pro technické funkce.
Vysvětlit chování celého modelu a jednotlivých předpovědí v Azure.
Nahrajte vysvětlení do historie spuštění služby Azure Machine Learning.
Pomocí řídicího panelu vizualizace můžete pracovat s vysvětleními modelu, a to jak v Jupyter Notebook, tak v studio Azure Machine Learning.
Společně s modelem nasaďte vysvětlující bodování, abyste během odvozování mohli sledovat vysvětlení.

Důležité

Tato funkce je v současné době ve verzi Public Preview. Tato verze Preview se poskytuje bez smlouvy o úrovni služeb a nedoporučuje se pro produkční úlohy. Některé funkce se nemusí podporovat nebo mohou mít omezené možnosti. Další informace najdete v dodatečných podmínkách použití pro verze Preview v Microsoft Azure.

Další informace o podporovaných technikách interpretovatelnosti a modelech strojového učení najdete v tématu Interpretovatelnost modelů ve službě Azure Machine Learning a ukázkové poznámkové bloky.

Pokyny k povolení interpretovatelnosti pro modely vytrénované pomocí automatizovaného strojového učení najdete v tématu Interpretability: vysvětlení modelů automatizovaného strojového učení (Preview).

Generování hodnoty důležitosti funkce na osobním počítači

Následující příklad ukazuje, jak používat balíček interpretability na osobním počítači bez kontaktování služeb Azure.

Nainstalujte balíček azureml-interpret.
```
pip install azureml-interpret
```

Trénování ukázkového modelu v místním 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)

Zavolejte vysvětlující nástroj místně.

Pokud chcete inicializovat objekt vysvětlujícího objektu, předejte model a některá trénovací data konstruktoru vysvětlovače.
Pokud chcete, aby vaše vysvětlení a vizualizace byly informativnější, můžete se rozhodnout předat názvy funkcí a názvy výstupních tříd, pokud provádíte klasifikaci.

Následující bloky kódu ukazují, jak vytvořit instanci vysvětlující objekt pomocí TabularExplainer, MimicExplainera PFIExplainer místně.

TabularExplainer zavolá jeden ze tří vysvětlovačů SHAP pod (TreeExplainer, DeepExplainernebo KernelExplainer).
TabularExplainer automaticky vybere ten nejvhodnější pro váš případ použití, ale každý z jeho tří základních vysvětlení můžete volat přímo.

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)

nebo


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)

nebo

from interpret.ext.blackbox import PFIExplainer

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

Vysvětlení celého chování modelu (globální vysvětlení)

Projděte si následující příklad, který vám pomůže získat agregované (globální) hodnoty důležitosti funkcí.


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

Vysvětlení individuální předpovědi (místní vysvětlení)

Získejte hodnoty důležitosti jednotlivých funkcí různých datových bodů voláním vysvětlení pro jednotlivé instance nebo skupinu instancí.

Poznámka

PFIExplainer nepodporuje místní vysvětlení.

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

Nezpracované transformace funkcí

Můžete se rozhodnout, že budete dostávat vysvětlení z hlediska nezpracovaných, netransformovaných funkcí, nikoli z hlediska navržených funkcí. Pro tuto možnost předáte kanál transformace funkcí do vysvětlujícího prvku v train_explain.pynástroji . V opačném případě vysvětlení poskytuje vysvětlení z hlediska navržených funkcí.

Formát podporovaných transformací je stejný jako v části sklearn-pandas. Obecně platí, že všechny transformace jsou podporované, pokud pracují s jedním sloupcem, takže je jasné, že jsou 1:N.

Získejte vysvětlení pro nezpracované funkce pomocí sklearn.compose.ColumnTransformer nebo se seznamem řazených řazených transformátorů. Následující příklad používá 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)

Pokud chcete spustit příklad se seznamem řazených transformátorů, použijte následující kód:

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)

Generování hodnot důležitosti funkce prostřednictvím vzdálených spuštění

Následující příklad ukazuje, jak pomocí ExplanationClient třídy povolit interpretovatelnost modelu pro vzdálená spuštění. Je koncepčně podobný místnímu procesu s výjimkou vás:

Pomocí příkazu ExplanationClient ve vzdáleném spuštění nahrajte kontext interpretovatelnosti.
Stáhněte si kontext později v místním prostředí.

Nainstalujte balíček azureml-interpret.
```
pip install azureml-interpret
```

Vytvořte trénovací skript v místním Jupyter Notebook. Například, 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')

Nastavte výpočetní prostředky Azure Machine Learning jako cíl výpočetních prostředků a odešlete trénovací běh. Pokyny najdete v tématu Vytváření a správa výpočetních clusterů Azure Machine Learning . Užitečné mohou být i ukázkové poznámkové bloky .

Stáhněte si vysvětlení v místním 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))

Vizualizace

Po stažení vysvětlení v místním Jupyter Notebook můžete pomocí vizualizací na řídicím panelu vysvětlení porozumět modelu a interpretovat je. Pokud chcete do Jupyter Notebook načíst widget řídicího panelu vysvětlení, použijte následující kód:

from raiwidgets import ExplanationDashboard

ExplanationDashboard(global_explanation, model, datasetX=x_test)

Vizualizace podporují vysvětlení pro technické i nezpracované funkce. Nezpracovaná vysvětlení jsou založená na funkcích z původní datové sady a technická vysvětlení jsou založená na funkcích z datové sady s použitým inženýrstvím funkcí.

Při pokusu o interpretaci modelu s ohledem na původní datovou sadu se doporučuje použít nezpracovaná vysvětlení, protože každá důležitost funkce bude odpovídat sloupci z původní datové sady. Jedním ze scénářů, kde by mohla být užitečná inženýrská vysvětlení, je zkoumání dopadu jednotlivých kategorií z funkce kategorií. Pokud se u funkce kategorií použije kódování s jedním horkým kódem, pak výsledná navržená vysvětlení budou obsahovat jinou hodnotu důležitosti pro každou kategorii, jednu pro jednu funkci za aktivního inženýra. Toto kódování může být užitečné při zúžení části datové sady, která je pro model nejinformativnější.

Poznámka

Navržená a nezpracovaná vysvětlení se počítají postupně. Nejprve se vytvoří technické vysvětlení založené na modelu a kanálu featurizace. Na základě tohoto vytvořeného vysvětlení se pak vytvoří nezpracované vysvětlení agregací důležitosti navržených funkcí, které pocházejí ze stejné nezpracované funkce.

Vytváření, úpravy a zobrazení kohort datových sad

Na horním pásu karet se zobrazují celkové statistiky modelu a dat. Data můžete rozdělit do kohort datových sad nebo podskupin, abyste mohli prozkoumat nebo porovnat výkon a vysvětlení modelu napříč těmito definovanými podskupinami. Porovnáním statistik a vysvětlení datových sad napříč těmito podskupinami získáte představu o tom, proč k možným chybám dochází v jedné skupině a v jiné.

Vysvětlení celého chování modelu (globální vysvětlení)

První tři karty řídicího panelu vysvětlení poskytují celkovou analýzu natrénovaného modelu spolu s jeho predikcemi a vysvětleními.

Výkon modelu

Vyhodnoťte výkon modelu prozkoumáním distribuce hodnot predikce a hodnot metrik výkonu modelu. Model můžete dále prozkoumat tak, že se podíváte na srovnávací analýzu jeho výkonu napříč různými kohortami nebo podskupinami vaší datové sady. Vyberte filtry mezi hodnotami y a x, které chcete rozřezat mezi různými dimenzemi. Zobrazit metriky, jako je přesnost, přesnost, úplnost, míra falešně pozitivních výsledků (FPR) a míra falešně negativních výsledků (FNR).

Průzkumník datových sad

Prozkoumejte statistiky datové sady tak, že vyberete různé filtry podél osy X, Y a barev, abyste data roztřižovali podle různých dimenzí. Vytvořte výše uvedené kohorty datových sad a analyzujte statistiky datových sad pomocí filtrů, jako jsou predikovaný výsledek, funkce datové sady a skupiny chyb. Pomocí ikony ozubeného kola v pravém horním rohu grafu můžete změnit typy grafů.

Agregace důležitosti funkce

Prozkoumejte nejdůležitější funkce, které mají vliv na celkové předpovědi modelu (označované také jako globální vysvětlení). Pomocí posuvníku můžete zobrazit sestupné hodnoty důležitosti funkce. Vyberte až tři kohorty, abyste viděli hodnoty důležitosti funkcí vedle sebe. Vyberte některý z pruhů funkcí v grafu a podívejte se, jak hodnoty vybrané funkce ovlivňují predikci modelu v následujícím grafu závislosti.

Vysvětlení jednotlivých predikcí (místní vysvětlení)

Čtvrtá karta vysvětlení umožňuje přejít k podrobnostem jednotlivých datových bodů a jejich důležitosti jednotlivých funkcí. Graf důležitosti jednotlivých prvků pro libovolný datový bod můžete načíst kliknutím na některý z jednotlivých datových bodů v hlavním bodovém grafu nebo výběrem určitého datového bodu v průvodci panelem na pravé straně.

Plot	Popis
Důležitost jednotlivých funkcí	Zobrazuje nejdůležitější funkce pro jednotlivé predikce. Pomáhá ilustrovat místní chování základního modelu u konkrétního datového bodu.
analýza What-If	Umožňuje změny hodnot funkcí vybraného reálného datového bodu a sledovat výsledné změny hodnoty predikce generováním hypotetického datového bodu s novými hodnotami funkcí.
Individuální podmíněné očekávání (ICE)	Umožňuje změnu hodnoty funkce z minimální hodnoty na maximální hodnotu. Pomáhá znázornit, jak se při změně funkce mění predikce datového bodu.

Poznámka

Jedná se o vysvětlení založená na mnoha aproximacích a nejsou "příčinou" předpovědí. Bez striktní matematické robustnosti kauzálního odvozování nedoporučujeme uživatelům, aby se v reálném životě rozhodovali na základě funkcí nástroje What-If. Tento nástroj je primárně určený pro pochopení modelu a ladění.

Vizualizace v studio Azure Machine Learning

Pokud dokončíte kroky pro vzdálenou interpretovatelnost (nahrání vygenerovaných vysvětlení do historie spuštění služby Azure Machine Learning), můžete zobrazit vizualizace na řídicím panelu vysvětlení v studio Azure Machine Learning. Tento řídicí panel je jednodušší verzí widgetu řídicího panelu, který se generuje v rámci vašeho Jupyter Notebook. What-If generování datových bodů a grafů ICE jsou zakázané, protože v studio Azure Machine Learning nejsou žádné aktivní výpočetní prostředky, které by mohly provádět výpočty v reálném čase.

Pokud jsou k dispozici datová sada, globální a místní vysvětlení, data naplní všechny karty. Pokud je však k dispozici pouze globální vysvětlení, karta Důležitost jednotlivých funkcí bude zakázána.

Pokud chcete získat přístup k řídicímu panelu vysvětlení v studio Azure Machine Learning, postupujte podle jedné z těchto cest:

Podokno Experimenty (Preview)
1. V levém podokně vyberte Experimenty a zobrazte seznam experimentů, které jste spustili ve službě Azure Machine Learning.
2. Výběrem konkrétního experimentu zobrazíte všechna spuštění v daném experimentu.
3. Vyberte spuštění a pak na kartě Vysvětlení přejděte na řídicí panel vizualizace vysvětlení.
Podokno Modely
1. Pokud jste původní model zaregistrovali podle kroků v tématu Nasazení modelů pomocí služby Azure Machine Learning, můžete ho zobrazit výběrem možnosti Modely v levém podokně.
2. Vyberte model a pak na kartě Vysvětlení zobrazte řídicí panel vysvětlení.

Interpretovatelnost v době odvození

Vysvětlení můžete nasadit společně s původním modelem a použít ho v době odvozování k poskytnutí hodnot důležitosti jednotlivých funkcí (místní vysvětlení) pro jakýkoli nový datový bod. Nabízíme také odlehčené vysvětlení skóre, které zlepšují výkon interpretovatelnosti v době odvozování, což je v současné době podporováno pouze v sadě Azure Machine Learning SDK. Proces nasazení vysvětlení skóre s nižší hmotností se podobá nasazení modelu a zahrnuje následující kroky:

Vytvořte objekt vysvětlení. Můžete například použít TabularExplainer:

 from interpret.ext.blackbox import TabularExplainer


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

Vytvořte vysvětlení skóre s objektem explanation.

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)

Nakonfigurujte a zaregistrujte image, která používá model vysvětlení skóre.

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

Jako volitelný krok můžete načíst vysvětlení skóre z cloudu a otestovat vysvětlení.

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)

Nasaďte image do cílového výpočetního objektu pomocí následujících kroků:

V případě potřeby zaregistrujte původní prediktivní model podle kroků v tématu Nasazení modelů pomocí služby Azure Machine Learning.

Vytvořte soubor hodnocení.

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

Definujte konfiguraci nasazení.

Tato konfigurace závisí na požadavcích modelu. Následující příklad definuje konfiguraci, která používá jedno jádro procesoru a jeden GB paměti.

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

Vytvořte soubor se závislostmi prostředí.

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

Vytvořte vlastní soubor dockerfile s nainstalovaným g++.

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

Nasaďte vytvořenou image.

Tento proces trvá přibližně pět minut.

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)

Otestujte nasazení.

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)

Vyčistěte ho.

Pokud chcete odstranit nasazenou webovou službu, použijte service.delete().

Řešení potíží

Řídká data nejsou podporovaná: Řídicí panel vysvětlení modelu se výrazně zpomalí nebo výrazně zpomalí s velkým počtem funkcí, proto v současné době formát zhuštěných dat nepodporujeme. U velkých datových sad a velkého počtu funkcí navíc dojde k obecným problémům s pamětí.
Matice podporovaných funkcí vysvětlení

Karta Podporované vysvětlení	Nezpracované prvky (hustá)	Nezpracované funkce (řídké)	Navržená funkce (hustá)	Technické funkce (zhuštěné)
Výkon modelu	Podporováno (bez prognózování)	Podporováno (bez prognózování)	Podporováno	Podporováno
Průzkumník datových sad	Podporováno (bez prognózování)	Nepodporováno Vzhledem k tomu, že se řídká data nenahrávají a uživatelské rozhraní má problémy s vykreslováním zhuštěná data.	Podporováno	Nepodporováno Vzhledem k tomu, že se řídká data nenahrávají a uživatelské rozhraní má problémy s vykreslováním zhuštěná data.
Agregace důležitosti funkce	Podporováno	Podporováno	Podporováno	Podporováno
Důležitost jednotlivých funkcí	Podporováno (bez prognózování)	Nepodporováno Vzhledem k tomu, že se řídká data nenahrávají a uživatelské rozhraní má problémy s vykreslováním zhuštěná data.	Podporováno	Nepodporováno Vzhledem k tomu, že se řídká data nenahrávají a uživatelské rozhraní má problémy s vykreslováním zhuštěná data.

Modely prognózování nejsou podporovány s vysvětleními modelů: Interpretovatelnost, nejlepší vysvětlení modelu, není k dispozici pro experimenty prognóz autoML, které jako nejlepší model doporučují následující algoritmy: TCNForecaster, AutoArima, Prorok, ExponentialSmoothing, Average, Naive, Seasonal Average a Seasonal Naive. Regresní modely prognóz AutoML podporují vysvětlení. Na řídicím panelu vysvětlení se ale kvůli složitosti datových kanálů nepodporuje pro prognózování karta Důležitost jednotlivých funkcí.
Místní vysvětlení indexu dat: Řídicí panel vysvětlení nepodporuje přiřazení hodnot místní důležitosti k identifikátoru řádku z původní ověřovací datové sady, pokud je tato datová sada větší než 5 000 datových bodů, protože řídicí panel náhodně převzorkuje data. Řídicí panel ale zobrazuje nezpracované hodnoty funkcí datové sady pro každý datový bod předaný do řídicího panelu na kartě Důležitost jednotlivých funkcí. Uživatelé můžou mapovat místní důležitost zpět na původní datovou sadu tak, že odpovídají nezpracovaným hodnotám funkcí datové sady. Pokud je velikost ověřovací datové sady menší než 5 000 vzorků, index bude funkce v studio Azure Machine Learning odpovídat indexu v ověřovací datové sadě.
Grafy what-if/ICE nejsou ve studiu podporované: What-If a grafy ICE (Individual Conditional Expectation) nejsou podporovány v studio Azure Machine Learning na kartě Vysvětlení, protože nahrané vysvětlení vyžaduje aktivní výpočetní výkon k přepočítání předpovědí a pravděpodobností perturovaných funkcí. V současné době se podporuje v poznámkových blocích Jupyter, když se spouští jako widget pomocí sady SDK.

Další kroky

Techniky pro interpretovatelnost modelů ve službě Azure Machine Learning

Projděte si ukázkové poznámkové bloky pro interpretovatelnost služby Azure Machine Learning.

Vysvětlení predikcí modelů & ML pomocí balíčku interpretovatelnosti Pythonu (Preview)

Generování hodnoty důležitosti funkce na osobním počítači

Vysvětlení celého chování modelu (globální vysvětlení)

Vysvětlení individuální předpovědi (místní vysvětlení)

Nezpracované transformace funkcí

Generování hodnot důležitosti funkce prostřednictvím vzdálených spuštění

Vizualizace

Vytváření, úpravy a zobrazení kohort datových sad

Vysvětlení celého chování modelu (globální vysvětlení)

Výkon modelu

Průzkumník datových sad

Agregace důležitosti funkce

Vysvětlení jednotlivých predikcí (místní vysvětlení)

Vizualizace v studio Azure Machine Learning

Interpretovatelnost v době odvození

Řešení potíží

Další kroky

Další materiály

Další materiály