Usare il pacchetto di interpretabilità Python per spiegare le stime dei modelli & di Machine Learning (anteprima)
SI APPLICA A:
Python SDK azureml v1
Questa guida pratica illustra come usare il pacchetto di interpretabilità di Azure Machine Learning Python SDK per eseguire le attività seguenti:
Spiegare l'intero comportamento del modello o le singole previsioni nel computer personale in locale.
Abilitare le tecniche di interpretabilità per le funzionalità progettate.
Spiegare il comportamento dell'intero modello e delle singole previsioni in Azure.
Caricare le spiegazioni nella cronologia di esecuzioni di Azure Machine Learning.
Usare un dashboard di visualizzazione per interagire con le spiegazioni del modello, sia in un Jupyter Notebook che nel studio di Azure Machine Learning.
Distribuire un explainer dell'assegnazione di punteggi insieme al modello per osservare le spiegazioni durante l'inferenza.
Importante
Questa funzionalità è attualmente in anteprima pubblica. Questa versione di anteprima viene fornita senza contratto di servizio e non è consigliata per carichi di lavoro di produzione. Alcune funzionalità potrebbero non essere supportate o potrebbero presentare funzionalità limitate. Per altre informazioni, vedere Condizioni supplementari per l'utilizzo delle anteprime di Microsoft Azure.
Per altre informazioni sulle tecniche di interpretazione supportate e sui modelli di Machine Learning, vedere Interpretazione dei modelli in Azure Machine Learning e notebook di esempio.
Per indicazioni su come abilitare l'interpretabilità per i modelli sottoposti a training con Machine Learning automatizzato, vedere Interpretability: model explanations for automated Machine Learning models (preview).
Generare un valore di importanza della funzionalità nel computer personale
L'esempio seguente illustra come usare il pacchetto di interpretabilità nel computer personale senza contattare i servizi di Azure.
Installare il pacchetto
azureml-interpret.pip install azureml-interpretEseguire il training di un modello di esempio in un Jupyter Notebook locale.
# 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)Chiamare lo explainer in locale.
- Per inizializzare un oggetto spiegazione, passare il modello e alcuni dati di training al costruttore del spiegazione.
- Per rendere più informative le spiegazioni e le visualizzazioni, è possibile scegliere di passare i nomi delle funzionalità e i nomi delle classi di output se si esegue la classificazione.
I blocchi di codice seguenti illustrano come creare un'istanza di un oggetto explainer con
TabularExplainer,MimicExplainerePFIExplainerin locale.TabularExplainerchiama uno dei tre spiegatori SHAP sottostanti (TreeExplainer,DeepExplaineroKernelExplainer).TabularExplainerseleziona automaticamente quello più appropriato per il caso d'uso, ma è possibile chiamare direttamente ognuno dei tre spiegatori sottostanti.
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)oppure
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)oppure
from interpret.ext.blackbox import PFIExplainer # "features" and "classes" fields are optional explainer = PFIExplainer(model, features=breast_cancer_data.feature_names, classes=classes)
Spiegare l'intero comportamento del modello (spiegazione globale)
Fare riferimento all'esempio seguente per ottenere i valori di importanza delle funzionalità di aggregazione (globale).
# 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()
Spiegare una singola stima (spiegazione locale)
Ottenere i singoli valori di importanza delle caratteristiche di punti dati diversi chiamando spiegazioni per una singola istanza o un gruppo di istanze.
Nota
PFIExplainer non supporta le spiegazioni locali.
# 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()
Trasformazioni delle funzionalità non elaborate
È possibile scegliere di ottenere spiegazioni in termini di funzionalità non elaborate e non trasformate anziché funzionalità predefinite. Per questa opzione, passare la pipeline di trasformazione delle funzionalità al spiegazione in train_explain.py. In caso contrario, lo spiegante fornisce spiegazioni in termini di funzionalità ingegneriate.
Il formato delle trasformazioni supportate è lo stesso descritto in sklearn-pandas. In generale, tutte le trasformazioni sono supportate purché funzionino su una singola colonna in modo che sia chiaro che siano uno-a-molti.
Ottenere una spiegazione delle caratteristiche non elaborate usando un sklearn.compose.ColumnTransformer oggetto o con un elenco di tuple trasformatori montate. Nell'esempio seguente viene utilizzato 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)
Se si vuole eseguire l'esempio con l'elenco di tuple trasformatori montate, usare il codice seguente:
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)
Generare valori di importanza delle funzionalità tramite esecuzioni remote
Nell'esempio seguente viene illustrato come usare la classe per abilitare l'interpretazione ExplanationClient del modello per le esecuzioni remote. È concettualmente simile al processo locale, ad eccezione dell'utente:
ExplanationClientUsare nell'esecuzione remota per caricare il contesto di interpretabilità.- Scaricare il contesto in un secondo momento in un ambiente locale.
Installare il pacchetto
azureml-interpret.pip install azureml-interpretCreare uno script di training in un Jupyter Notebook locale. Ad esempio,
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')Configurare un ambiente di calcolo di Azure Machine Learning come destinazione di calcolo e inviare l'esecuzione del training. Per istruzioni, vedere Creare e gestire cluster di calcolo di Azure Machine Learning . È anche possibile trovare utili i notebook di esempio .
Scaricare la spiegazione nella Jupyter Notebook locale.
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))
Visualizzazioni
Dopo aver scaricato le spiegazioni nel Jupyter Notebook locale, è possibile usare le visualizzazioni nel dashboard delle spiegazioni per comprendere e interpretare il modello. Per caricare il widget dashboard spiegazioni nel Jupyter Notebook, usare il codice seguente:
from raiwidgets import ExplanationDashboard
ExplanationDashboard(global_explanation, model, datasetX=x_test)
Le visualizzazioni supportano le spiegazioni sulle funzionalità elaborate e non elaborate. Le spiegazioni non elaborate si basano sulle funzionalità del set di dati originale e le spiegazioni ingegneriate si basano sulle funzionalità del set di dati con la progettazione delle funzionalità applicata.
Quando si tenta di interpretare un modello rispetto al set di dati originale, è consigliabile usare spiegazioni non elaborate perché ogni importanza della funzionalità corrisponde a una colonna del set di dati originale. Uno scenario in cui le spiegazioni ingegneriate potrebbero essere utili è quando si esamina l'impatto delle singole categorie da una funzionalità categorica. Se una codifica one-hot viene applicata a una funzionalità categorica, le spiegazioni predefinite risultanti includeranno un valore di importanza diverso per categoria, uno per ogni funzionalità progettata in modalità one-hot. Questa codifica può essere utile quando si restringe la parte del set di dati più informativa al modello.
Nota
Le spiegazioni elaborate e non elaborate vengono calcolate in sequenza. Viene prima creata una spiegazione progettata in base al modello e alla pipeline di definizione delle caratteristiche. La spiegazione non elaborata viene quindi creata in base a quella spiegazione progettata aggregando l'importanza delle funzionalità ingegneriate provenienti dalla stessa caratteristica non elaborata.
Creare, modificare e visualizzare le coorti dei set di dati
La barra multifunzione superiore mostra le statistiche generali sul modello e sui dati. È possibile suddividere e suddividere i dati in coorti di set di dati o sottogruppi per analizzare o confrontare le prestazioni e le spiegazioni del modello in questi sottogruppi definiti. Confrontando le statistiche e le spiegazioni del set di dati tra i sottogruppi, è possibile capire perché si verificano errori in un gruppo rispetto a un altro.
Comprendere l'intero comportamento del modello (spiegazione globale)
Le prime tre schede del dashboard di spiegazione forniscono un'analisi complessiva del modello sottoposto a training insieme alle stime e alle spiegazioni.
Prestazioni del modello
Valutare le prestazioni del modello esplorando la distribuzione dei valori di stima e i valori delle metriche delle prestazioni del modello. È possibile esaminare ulteriormente il modello esaminando un'analisi comparativa delle prestazioni in coorti o sottogruppi diversi del set di dati. Selezionare i filtri lungo y-value e x-value per tagliare le diverse dimensioni. Visualizzare metriche come accuratezza, precisione, richiamo, tasso di falsi positivi (FPR) e tasso falso negativo (FNR).
Esplora set di dati
Esplorare le statistiche del set di dati selezionando diversi filtri lungo gli assi X, Y e color per filtrare i dati in base a dimensioni diverse. Creare coorti di set di dati precedenti per analizzare le statistiche del set di dati con filtri come risultato stimato, funzionalità del set di dati e gruppi di errori. Usare l'icona a forma di ingranaggio nell'angolo superiore destro del grafico per modificare i tipi di grafico.
Importanza delle funzionalità di aggregazione
Esplorare le principali funzionalità importanti che influisce sulle stime complessive del modello (nota anche come spiegazione globale). Usare il dispositivo di scorrimento per visualizzare i valori di importanza delle caratteristiche decrescente. Selezionare fino a tre coorti per visualizzare i valori di importanza delle caratteristiche affiancati. Selezionare una delle barre delle funzionalità nel grafico per vedere in che modo i valori della stima del modello di impatto sulle funzionalità selezionata vengono visualizzati nel grafico delle dipendenze riportato di seguito.
Informazioni sulle singole stime (spiegazione locale)
La quarta scheda della scheda di spiegazione consente di analizzare un singolo punto dati e le relative singole priorità di funzionalità. È possibile caricare il singolo tracciato di importanza delle caratteristiche per qualsiasi punto dati facendo clic su uno dei singoli punti dati nel grafico a dispersione principale o selezionando un punto dati specifico nella procedura guidata del pannello a destra.
| Grafico | Descrizione |
|---|---|
| Importanza delle singole caratteristiche | Mostra le principali caratteristiche importanti per una stima singola. Illustra il comportamento locale del modello sottostante in un punto dati specifico. |
| analisi What-If | Consente di modificare i valori delle funzionalità del punto dati reale selezionato e osservare le modifiche risultanti al valore di stima generando un punto dati ipotetico con i nuovi valori di funzionalità. |
| Aspettative condizionali individuali (ICE) | Consente di modificare il valore della funzionalità da un valore minimo a un valore massimo. Illustra come cambia la stima del punto dati quando viene modificata una funzionalità. |
Nota
Queste sono spiegazioni basate su molte approssimazioni e non sono la "causa" delle stime. Senza robustezza matematica di inferenza causale, non consigliamo agli utenti di prendere decisioni reali in base alle perturbazioni delle funzionalità dello strumento What-If. Questo strumento è principalmente per comprendere il modello e il debug.
Visualizzazione in studio di Azure Machine Learning
Se si completano i passaggi di interpretazione remota (caricamento di spiegazioni generate in Cronologia di esecuzione di Azure Machine Learning), è possibile visualizzare le visualizzazioni nel dashboard delle spiegazioni in studio di Azure Machine Learning. Questo dashboard è una versione più semplice del widget del dashboard generato all'interno del Jupyter Notebook. What-If generazione di datapoint e grafici ICE sono disabilitati perché non è disponibile alcun calcolo attivo in studio di Azure Machine Learning che può eseguire i calcoli in tempo reale.
Se il set di dati, le spiegazioni globali e locali sono disponibili, i dati popolano tutte le schede. Tuttavia, se è disponibile solo una spiegazione globale, la scheda Singola importanza della funzionalità verrà disabilitata.
Seguire uno di questi percorsi per accedere al dashboard delle spiegazioni in studio di Azure Machine Learning:
Riquadro Esperimenti (anteprima)
- Selezionare Esperimenti nel riquadro sinistro per visualizzare un elenco di esperimenti eseguiti in Azure Machine Learning.
- Selezionare un particolare esperimento per visualizzare tutte le esecuzioni in tale esperimento.
- Selezionare un'esecuzione e quindi la scheda Spiegazioni nel dashboard di visualizzazione della spiegazione.
Riquadro Modelli
- Se è stato registrato il modello originale seguendo la procedura descritta in Distribuire modelli con Azure Machine Learning, è possibile selezionare Modelli nel riquadro sinistro per visualizzarlo.
- Selezionare un modello e quindi la scheda Spiegazioni per visualizzare il dashboard delle spiegazioni .
Interpretazione in fase di inferenza
È possibile distribuire lo strumento di spiegazione insieme al modello originale e usarlo in fase di inferenza per fornire i singoli valori di importanza della funzionalità (spiegazione locale) per qualsiasi nuovo punto dati. Sono disponibili anche spiegazioni con punteggi più leggeri per migliorare le prestazioni di interpretazione in fase di inferenza, attualmente supportate solo in Azure Machine Learning SDK. Il processo di distribuzione di uno strumento di spiegazione dei punteggi di peso più leggero è simile alla distribuzione di un modello e include i passaggi seguenti:
Creare un oggetto spiegazione. Ad esempio, è possibile usare
TabularExplainer:from interpret.ext.blackbox import TabularExplainer explainer = TabularExplainer(model, initialization_examples=x_train, features=dataset_feature_names, classes=dataset_classes, transformations=transformations)Creare un spiegazione dei punteggi con l'oggetto spiegazione.
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)Configurare e registrare un'immagine che usa il modello di spiegazione dei punteggi.
# 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')Come passaggio facoltativo, è possibile recuperare lo strumento di spiegazione dei punteggi dal cloud e testare le spiegazioni.
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)Distribuire l'immagine in una destinazione di calcolo seguendo questa procedura:
Se necessario, registrare il modello di stima originale seguendo la procedura descritta in Distribuire modelli con Azure Machine Learning.
Creare un file di assegnazione dei punteggi.
%%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}Definire la configurazione della distribuzione.
Questa configurazione dipende dai requisiti del modello. Nell'esempio seguente viene definita una configurazione che usa un core CPU e un GB di memoria.
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')Creare un file con dipendenze dell'ambiente.
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())Creare un dockerfile personalizzato con g++ installato.
%%writefile dockerfile RUN apt-get update && apt-get install -y g++Distribuire l'immagine creata.
Questo processo richiede circa cinque minuti.
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)
Testare la distribuzione.
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)Eseguire la pulizia.
Per eliminare un servizio Web distribuito, usare
service.delete().
Risoluzione dei problemi
Dati di tipo sparse non supportati: il dashboard della spiegazione del modello interrompe/rallenta notevolmente con un numero elevato di funzionalità, pertanto attualmente non è supportato il formato dati sparse. Inoltre, i problemi di memoria generali si verificheranno con set di dati di grandi dimensioni e un numero elevato di funzionalità.
Matrice di spiegazioni supportate
| Scheda Spiegazione supportata | Caratteristiche non elaborate (densa) | Funzionalità non elaborate (sparse) | Funzionalità ingegneriate (densa) | Funzionalità ingegneriate (sparse) |
|---|---|---|---|---|
| Prestazioni del modello | Supportato (non previsto) | Supportato (non previsto) | Supportato | Supportato |
| Esplora set di dati | Supportato (non previsto) | Non supportato. Poiché i dati sparse non vengono caricati e l'interfaccia utente ha problemi di rendering dei dati sparse. | Supportato | Non supportato. Poiché i dati sparse non vengono caricati e l'interfaccia utente ha problemi di rendering dei dati sparse. |
| Importanza della funzionalità di aggregazione | Supportato | Supportato | Supportato | Supportato |
| Importanza singola delle funzionalità | Supportato (non previsto) | Non supportato. Poiché i dati sparse non vengono caricati e l'interfaccia utente ha problemi di rendering dei dati sparse. | Supportato | Non supportato. Poiché i dati sparse non vengono caricati e l'interfaccia utente ha problemi di rendering dei dati sparse. |
I modelli di previsione non sono supportati con spiegazioni del modello: Interpretazione, spiegazione migliore del modello, non è disponibile per gli esperimenti di previsione autoML che consigliano gli algoritmi seguenti come modello migliore: TCNForecaster, AutoArima, Profeta, EsponenzialeSmoothing, Media, Naive, Media stagionale e Naive stagionale. I modelli di regressione di previsione autoML supportano le spiegazioni. Nel dashboard della spiegazione, tuttavia, la scheda "Importanza singola funzionalità" non è supportata per la previsione a causa della complessità nelle pipeline di dati.
Spiegazione locale per l'indice dati: il dashboard di spiegazione non supporta la correlazione dei valori di importanza locale a un identificatore di riga del set di dati di convalida originale se tale set di dati è maggiore di 5000 punti dati come il dashboard esegue in modo casuale il downsamp dei dati. Tuttavia, il dashboard mostra i valori di funzionalità del set di dati non elaborati per ogni punto dati passato nel dashboard nella scheda Singola importanza della funzionalità. Gli utenti possono eseguire il mapping delle importanza locali al set di dati originale tramite la corrispondenza dei valori delle funzionalità del set di dati non elaborati. Se le dimensioni del set di dati di convalida sono inferiori a 5000 esempi, la
indexfunzionalità in studio di Azure Machine Learning corrisponderà all'indice nel set di dati di convalida.I tracciati what-if/ICE non sono supportati in studio: What-If e singoli tracciati di aspettative condizionali (ICE) non sono supportati in studio di Azure Machine Learning sotto la scheda Spiegazioni poiché la spiegazione caricata necessita di un calcolo attivo per ricalcolare stime e probabilità delle funzionalità inturbate. Attualmente è supportato nei notebook di Jupyter quando viene eseguito come widget usando l'SDK.
Passaggi successivi
Tecniche per l'interpretazione dei modelli in Azure Machine Learning
Vedere i notebook di esempio di interpretazione di Azure Machine Learning