Usare il pacchetto di interpretabilità Python per spiegare i modelli e le stime 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 notebook di Jupyter 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 un contratto di servizio e non è consigliabile per i carichi di lavoro di produzione. Alcune funzionalità potrebbero non essere supportate o potrebbero presentare funzionalità limitate.

Per altre informazioni, vedere le Condizioni supplementari per l'uso delle anteprime di Microsoft Azure.

Per altre informazioni sulle tecniche di interpretazione supportate e sui modelli di Machine Learning, vedere Interpretaribilità dei modelli in Azure Machine Learning e notebook di esempio.

Per indicazioni su come abilitare l'interpretazione per i modelli sottoposti a training con Machine Learning automatizzato, vedere Interpretability: model explanations for automated Machine Learning models (preview) (Interpretaribilità: spiegazioni del modello per i modelli di Machine Learning automatizzati (anteprima).

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.

  1. Installare il pacchetto azureml-interpret.

    pip install azureml-interpret
    
  2. Eseguire il training di un modello di esempio in un notebook jupyter 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)
    
  3. Chiamare lo explainer in locale.

    • Per inizializzare un oggetto spiegazione, passare il modello e alcuni dati di training al costruttore dello strumento di spiegazione.
    • Per rendere le spiegazioni e le visualizzazioni più informative, è 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, MimicExplainere PFIExplainer localmente.

    • TabularExplainer chiama uno dei tre spiegatori SHAP sottostanti (TreeExplainer, DeepExplainero KernelExplainer).
    • TabularExplainer seleziona 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 della 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 di funzionalità non elaborate

È possibile scegliere di ottenere spiegazioni in termini di funzionalità non elaborate e non convertite anziché funzionalità predefinite. Per questa opzione, si passa la pipeline di trasformazione delle funzionalità al visualizzatore in train_explain.py. In caso contrario, il spiegazione fornisce spiegazioni in termini di funzionalità ingegneriate.

Il formato delle trasformazioni supportate è uguale a quello descritto in sklearn-pandas. In generale, tutte le trasformazioni sono supportate purché funzionino su una singola colonna in modo che siano chiare 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)

Nel caso in cui si voglia 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 di quanto riportato di seguito:

  • ExplanationClient Usare nell'esecuzione remota per caricare il contesto di interpretabilità.
  • Scaricare il contesto più avanti in un ambiente locale.
  1. Installare il pacchetto azureml-interpret.

    pip install azureml-interpret
    
  2. Creare uno script di training in un notebook jupyter 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')
    
  3. 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.

  4. Scaricare la spiegazione nel notebook jupyter 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 notebook jupyter locale, è possibile usare le visualizzazioni nel dashboard delle spiegazioni per comprendere e interpretare il modello. Per caricare il widget dashboard spiegazioni in Jupyter Notebook, usare il codice seguente:

from raiwidgets import ExplanationDashboard

ExplanationDashboard(global_explanation, model, datasetX=x_test)

Le visualizzazioni supportano le spiegazioni sia sulle funzionalità elaborate che sulle funzionalità 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à corrisponderà a una colonna del set di dati originale. Uno scenario in cui le spiegazioni ingegneriate potrebbero essere utili è esaminare l'impatto delle singole categorie da una funzionalità categorica. Se una codifica one-hot viene applicata a una funzionalità categorica, le spiegazioni strutturate risultanti includeranno un valore di importanza diverso per categoria, uno per ogni funzionalità progettata a caldo. 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. Prima di tutto viene 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 funzionalità non elaborata.

Creare, modificare e visualizzare le coorti dei set di dati

La barra multifunzione superiore mostra le statistiche complessive sul modello e sui dati. È possibile 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 in questi sottogruppi, è possibile comprendere il motivo per cui si verificano errori in un gruppo rispetto a un altro.

Creating, editing, and viewing dataset cohorts

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 relative stime e spiegazioni.

Prestazioni modello

Valutare le prestazioni del modello esplorando la distribuzione dei valori di stima e i valori delle metriche delle prestazioni del modello. È possibile analizzare ulteriormente il modello esaminando un'analisi comparativa delle prestazioni in coorti o sottogruppi diversi del set di dati. Selezionare i filtri lungo valori y e x-value per tagliare le diverse dimensioni. Visualizzare metriche come accuratezza, precisione, richiamo, tasso falso positivo (FPR) e tasso falso negativo (FNR).

Model performance tab in the explanation visualization

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 il risultato stimato, le funzionalità del set di dati e i gruppi di errori. Usare l'icona a forma di ingranaggio nell'angolo superiore destro del grafico per modificare i tipi di grafo.

Dataset explorer tab in the explanation visualization

Importanza delle funzionalità di aggregazione

Esplorare le principali k funzionalità importanti che influisce sulle stime complessive del modello (note anche come spiegazioni globali). 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 visualizzare il modo in cui i valori della stima del modello di impatto sulle caratteristiche selezionata nel grafico delle dipendenze riportato di seguito.

Aggregate feature importance tab in the explanation visualization

Informazioni sulle singole stime (spiegazione locale)

La quarta scheda della scheda di spiegazione consente di esaminare un singolo punto dati e le relative singole priorità di funzionalità. È possibile caricare il tracciato dell'importanza delle singole 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 k caratteristiche importanti per una singola stima. Illustra il comportamento locale del modello sottostante in un punto dati specifico.
Analisi di simulazione Consente di modificare i valori delle caratteristiche 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. Aiuta a illustrare il modo in cui cambia la stima del punto dati quando cambia una funzionalità.

Individual feature importance and What-if tab in explanation dashboard

Nota

Queste sono spiegazioni basate su molte approssimazioni e non sono la "causa" delle stime. Senza robustezza matematica rigorosa dell'inferenza causale, non consigliamo agli utenti di prendere decisioni reali in base alle perturbazioni delle caratteristiche 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 nella 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 di Jupyter Notebook. La generazione dei punti dati e i tracciati ICE di simulazione sono disabilitati perché non è disponibile alcun calcolo attivo in studio di Azure Machine Learning in grado di eseguire i calcoli in tempo reale.

Se sono disponibili il set di dati, le spiegazioni globali e locali, i dati popolano tutte le schede. Tuttavia, se è disponibile solo una spiegazione globale, la scheda Importanza singola funzionalità verrà disabilitata.

Seguire uno di questi percorsi per accedere al dashboard delle spiegazioni in studio di Azure Machine Learning:

  • Riquadro Esperimenti (anteprima)

    1. Selezionare Esperimenti nel riquadro sinistro per visualizzare un elenco di esperimenti eseguiti in Azure Machine Learning.
    2. Selezionare un particolare esperimento per visualizzare tutte le esecuzioni dell'esperimento.
    3. Selezionare un'esecuzione e quindi la scheda Spiegazioni nel dashboard di visualizzazione della spiegazione.

    Visualization Dashboard with Aggregate Feature Importance in Azure Machine Learning studio in experiments

  • Riquadro Modelli

    1. Se il modello originale è stato registrato seguendo la procedura descritta in Distribuire modelli con Azure Machine Learning, è possibile selezionare Modelli nel riquadro sinistro per visualizzarlo.
    2. 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 inoltre disponibili strumenti di spiegazione dei punteggi più leggeri per migliorare le prestazioni di interpretazione in fase di inferenza, attualmente supportata solo in Azure Machine Learning SDK. Il processo di distribuzione di uno strumento di spiegazione dei punteggi più leggero è simile alla distribuzione di un modello e include i passaggi seguenti:

  1. 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)
    
  2. Creare un spiegazione del punteggio 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)
    
  3. Configurare e registrare un'immagine che usa il modello di spiegazione dell'assegnazione 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')
    
  4. Come passaggio facoltativo, è possibile recuperare lo strumento di spiegazione dell'assegnazione 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)
    
  5. Distribuire l'immagine in una destinazione di calcolo seguendo questa procedura:

    1. Se necessario, registrare il modello di stima originale seguendo la procedura descritta in Distribuire modelli con Azure Machine Learning.

    2. 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}
      
    3. Definire la configurazione della distribuzione.

      Questa configurazione dipende dai requisiti del modello. L'esempio seguente definisce 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')
      
    4. 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())
      
    5. Creare un dockerfile personalizzato con g++ installato.

      %%writefile dockerfile
      RUN apt-get update && apt-get install -y g++
      
    6. 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)
      
  6. 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)
    
  7. Eseguire la pulizia.

    Per eliminare un servizio Web distribuito, usare service.delete().

Risoluzione dei problemi

  • Dati di tipo sparse non supportati: il dashboard di spiegazione del modello interrompe/rallenta notevolmente con un numero elevato di funzionalità, pertanto attualmente non è supportato il formato dati sparse. Inoltre, si verificheranno problemi di memoria generali con set di dati di grandi dimensioni e un numero elevato di funzionalità.

  • Matrice delle funzionalità di spiegazioni supportate

Scheda Spiegazione supportata Caratteristiche non elaborate (dense) Caratteristiche non elaborate (sparse) Funzionalità ingegneriate (dense) Funzionalità ingegneriate (sparse)
Prestazioni modello Supportato (non previsto) Supportato (non previsto) Supportata Supportata
Esplora set di dati Supportato (non previsto) Non supportato. Poiché i dati di tipo sparse non vengono caricati e l'interfaccia utente presenta problemi di rendering dei dati di tipo sparse. Supportata Non supportato. Poiché i dati di tipo sparse non vengono caricati e l'interfaccia utente presenta problemi di rendering dei dati di tipo sparse.
Importanza delle funzionalità di aggregazione Supportata Supportato Supportato Supportata
Importanza delle singole caratteristiche Supportato (non previsto) Non supportato. Poiché i dati di tipo sparse non vengono caricati e l'interfaccia utente presenta problemi di rendering dei dati di tipo sparse. Supportata Non supportato. Poiché i dati di tipo sparse non vengono caricati e l'interfaccia utente presenta problemi di rendering dei dati di tipo sparse.
  • I modelli di previsione non sono supportati con le spiegazioni del modello: l'interpretazione, la spiegazione migliore del modello, non è disponibile per gli esperimenti di previsione AutoML che consigliano gli algoritmi seguenti come modello migliore: TCNForecaster, AutoArima, Prophet, ExponentialSmoothing, Average, Naive, Stagional Average e Stagionale Naive. I modelli di regressione di previsione autoML supportano le spiegazioni. Tuttavia, nel dashboard di spiegazione la scheda "Importanza singola funzionalità" non è supportata per la previsione a causa della complessità nelle pipeline di dati.

  • Spiegazione locale per l'indice dei 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 perché il dashboard esegue il downcampionamento casuale dei dati. Tuttavia, il dashboard mostra i valori delle funzionalità del set di dati non elaborati per ogni punto dati passato nel dashboard nella scheda Importanza singola funzionalità. Gli utenti possono eseguire il mapping delle priorità 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 campioni, la index funzionalità in studio di Azure Machine Learning corrisponderà all'indice nel set di dati di convalida.

  • Tracciati di simulazione/ICE non supportati in studio: i tracciati di simulazione e delle aspettative condizionali individuali (ICE) non sono supportati in studio di Azure Machine Learning nella scheda Spiegazioni perché la spiegazione caricata richiede un calcolo attivo per ricalcolare le stime e le probabilità delle funzionalità perturbate. È 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 notebook di esempio di interpretabilità di Azure Machine Learning