Gunakan paket kemampuan interpretasi Python untuk menjelaskan model & prediksi ML (pratinjau)

  • Artikel

BERLAKU UNTUK:SDK Python azureml v1

Dalam panduan ini, Anda belajar cara menggunakan paket interpretasi dari Azure Machine Learning Python SDK untuk melakukan tugas-tugas berikut:

  • Jelaskan seluruh perilaku model atau prediksi individu pada mesin pribadi Anda secara lokal.

  • Aktifkan teknik interpretasi untuk fitur yang direkayasa.

  • Jelaskan perilaku untuk seluruh model dan prediksi individu di Azure.

  • Unggah penjelasan ke Riwayat Proses Azure Machine Learning.

  • Gunakan dasbor visualisasi untuk berinteraksi dengan penjelasan model Anda, baik di Jupyter Notebook maupun di studio Azure Machine Learning.

  • Sebarkan penjelas skor di samping model Anda untuk mengamati penjelasan selama melakukan inferensi.

Penting

Fitur ini masih dalam pratinjau umum. Versi pratinjau ini disediakan tanpa perjanjian tingkat layanan, dan tidak disarankan untuk beban kerja produksi. Fitur tertentu mungkin tidak didukung atau mungkin memiliki kemampuan terbatas.

Untuk mengetahui informasi selengkapnya, lihat Ketentuan Penggunaan Tambahan untuk Pratinjau Microsoft Azure.

Untuk informasi lebih lanjut tentang teknik interpretasi yang didukung dan model pembelajaran mesin, lihat Kemampuan interpretasi model dalam Azure Machine Learning dan sampel buku catatan.

Untuk panduan tentang cara mengaktifkan interpretasi untuk model yang dilatih dengan pembelajaran mesin otomatis, lihat, Interpretasi: penjelasan model untuk model pembelajaran mesin otomatis (pratinjau).

Hasilkan nilai penting fitur pada mesin pribadi Anda

Contoh berikut menunjukkan cara menggunakan paket interpretasi pada mesin pribadi Anda tanpa menghubungi layanan Azure.

  1. Pasang paket azureml-interpret.

    pip install azureml-interpret

  2. Latih model sampel di Jupyter Notebook lokal.

    # 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. Hubungi penjelas secara lokal.

    • Untuk menginisialisasi objek penjelas, berikan model Anda dan beberapa data pelatihan ke konstruktor penjelas.
    • Untuk membuat penjelasan dan visualisasi lebih informatif, Anda dapat memilih untuk memasukkan nama fitur dan nama kelas output ketika melakukan klasifikasi.

    Blok kode berikut menunjukkan cara membuat instans objek penjelas dengan TabularExplainer, MimicExplainer, dan PFIExplainer secara lokal.

    • TabularExplainer memanggil salah satu dari tiga penjelas SHAP di bawahnya (TreeExplainer, DeepExplainer, atau KernelExplainer).
    • TabularExplainer secara otomatis memilih yang paling sesuai untuk kasus penggunaan Anda, tetapi Anda dapat memanggil masing-masing dari tiga penjelas yang mendasarinya secara langsung.
    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)

    or

    
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)

    or

    from interpret.ext.blackbox import PFIExplainer

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

Menjelaskan seluruh perilaku model (penjelasan global)

Lihat contoh berikut untuk membantu Anda mendapatkan nilai kepentingan fitur agregat (global).


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

Menjelaskan prediksi individu (penjelasan lokal)

Dapatkan nilai kepentingan fitur individual dari datapoint yang berbeda dengan memanggil penjelas untuk instans individual atau sekelompok instans.

Catatan

PFIExplainer tidak mendukung penjelasan lokal.

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

Transformasi fitur mentah

Anda dapat memilih untuk mendapatkan penjelasan dalam hal fitur mentah yang tidak berubah daripada fitur yang direkayasa. Untuk opsi ini, Anda meneruskan alur transformasi fitur ke penjelas di train_explain.py. Jika tidak, penjelas memberikan penjelasan dalam hal fitur yang direkayasa.

Format transformasi yang didukung sama seperti yang dijelaskan di sklearn-pandas. Secara umum, setiap transformasi didukung selama beroperasi pada satu kolom, sehingga jelas bahwa transformasinya merupakan transformasi dari satu-ke-banyak.

Dapatkan penjelasan untuk fitur mentah dengan menggunakan sklearn.compose.ColumnTransformer atau dengan daftar tupel transformator yang dipasang. Contoh berikut menggunakan 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)

Jika Anda ingin menjalankan contoh dengan daftar tupel transformator yang dipasang, gunakan kode berikut:

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)

Hasilkan nilai kepentingan fitur melalui jarak jauh

Contoh berikut menunjukkan cara untuk menggunakan kelas ExplanationClient untuk mengaktifkan interpretasi model untuk dijalankan jarak jauh. Secara konseptual, mirip dengan proses lokal, kecuali:

  • Gunakan ExplanationClient dalam jarak jauh untuk mengunggah konteks interpretasi.
  • Unduh konteksnya di lingkungan lokal nanti.

  1. Pasang paket azureml-interpret.

    pip install azureml-interpret

  2. Buat skrip pelatihan di Jupyter Notebook lokal. Contohnya, 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. Siapkan Azure Machine Learning Compute sebagai target komputasi Anda dan kirimkan pelatihan Anda. Lihat Membuat dan mengelola kluster komputasi Azure Machine Learning untuk mendapatkan instruksi. Anda mungkin juga menemukan contoh buku catatan yang bermanfaat.

  4. Unduh penjelasan di Jupyter Notebook lokal Anda.

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

Visualisasi

Setelah mengunduh penjelasan di Jupyter Notebook lokal, Anda dapat menggunakan visualisasi di dasbor penjelasan untuk memahami dan menginterpretasikan model Anda. Untuk memuat widget dasbor penjelasan di Jupyter Notebook Anda, gunakan kode berikut:

from raiwidgets import ExplanationDashboard

ExplanationDashboard(global_explanation, model, datasetX=x_test)

Visualisasi mendukung penjelasan tentang fitur rekayasa dan mentah. Penjelasan mentah didasarkan pada fitur dari himpunan data asli, dan penjelasan yang direkayasa didasarkan pada fitur dari himpunan data dengan rekayasa fitur yang diterapkan.

Saat mencoba menafsirkan model sehubungan dengan himpunan data yang asli, sebaiknya gunakan penjelasan mentah, karena setiap kepentingan fitur akan sesuai dengan kolom dari himpunan data yang asli. Satu skenario saat penjelasan yang direkayasa mungkin berguna adalah ketika memeriksa dampak kategori individual dari fitur kategoris. Jika pengodean one-hot diterapkan ke fitur kategoris, penjelasan rekayasa yang dihasilkan akan menyertakan nilai penting yang berbeda per kategori, satu per fitur rekayasa one-hot. Pengkodean ini dapat berguna saat mempersempit bagian mana dari kumpulan data yang paling informatif bagi model.

Catatan

Penjelasan yang direkayasa dan mentah dihitung secara berurutan. Pertama, penjelasan rekayasa dibuat berdasarkan model dan alur fitur. Lalu, penjelasan mentah dibuat berdasarkan penjelasan yang direkayasa dengan menggabungkan kepentingan fitur yang direkayasa yang berasal dari fitur mentah yang sama.

Membuat, mengedit, dan menampilkan kelompok himpunan data

Pita atas menunjukkan statistik keseluruhan pada model dan data Anda. Anda dapat memotong dan membagi data ke dalam kelompok himpunan data, atau subgrup, untuk menyelidiki atau membandingkan kinerja dan penjelasan model Anda di seluruh subgrup yang ditentukan ini. Dengan membandingkan statistik dan penjelasan kumpulan data Anda di seluruh subgrup tersebut, Anda dapat memahami mengapa kemungkinan kesalahan terjadi dalam satu grup versus grup lainnya.

Creating, editing, and viewing dataset cohorts

Memahami seluruh perilaku model (penjelasan global)

Tiga tab pertama dasbor penjelasan memberikan analisis keseluruhan dari model yang dilatih bersama dengan prediksi dan penjelasannya.

Performa model

Evaluasi kinerja model Anda dengan menjelajahi distribusi nilai prediksi dan nilai metrik kinerja model Anda. Anda dapat menyelidiki lebih lanjut model Anda dengan melihat analisis komparatif performanya di berbagai kelompok atau subkelompok himpunan data Anda. Pilih filter di sepanjang nilai-y dan nilai-x untuk memotong dimensi yang berbeda. Tampilkan metrik seperti akurasi, presisi, pengenalan, tarif positif palsu (FPR) dan tarif negatif palsu (FNR).

Model performance tab in the explanation visualization

Penjelajah himpunan data

Jelajahi statistik himpunan data Anda dengan memilih filter yang berbeda di sepanjang sumbu X, Y, dan warna untuk memotong data Anda di sepanjang dimensi yang berbeda. Buat kelompok himpunan data di atas untuk menganalisis statistik himpunan data dengan filter seperti hasil yang diprediksi, fitur himpunan data, dan grup kesalahan. Gunakan ikon roda gigi di sudut kanan atas grafik untuk mengubah jenis grafik.

Dataset explorer tab in the explanation visualization

Kepentingan fitur agregat

Jelajahi fitur-fitur penting teratas yang memengaruhi prediksi model Anda secara keseluruhan (juga dikenal sebagai penjelasan global). Gunakan penggeser untuk menampilkan nilai kepentingan menurun. Pilih hingga tiga kelompok untuk melihat nilai kepentingan fitur secara berdampingan. Klik salah satu bilah fitur di grafik untuk melihat bagaimana nilai fitur yang dipilih berdampak pada prediksi model di plot dependensi di bawah ini.

Aggregate feature importance tab in the explanation visualization

Memahami prediksi individu (penjelasan lokal)

Tab keempat dari tab penjelasan memungkinkan Anda menelusuri datapoint individual dan kepentingan fitur masing-masing. Anda dapat memuat plot kepentingan fitur individual untuk datapoint apa pun dengan mengklik salah satu datapoint individual di plot sebar utama atau memilih datapoint tertentu di wizard panel di sebelah kanan.

Plot Deskripsi
Kepentingan fitur individual Menampilkan fitur penting k teratas untuk prediksi individual. Membantu mengilustrasikan perilaku lokal model yang mendasarinya pada datapoint tertentu.
Analisis What-if Mengizinkan perubahan nilai fitur dari datapoint nyata yang dipilih dan mengamati perubahan yang dihasilkan pada nilai prediksi dengan menghasilkan datapoint hipotetis dengan nilai fitur baru.
Ekspektasi Bersyarat Individu (ICE) Memungkinkan nilai fitur berubah dari nilai minimum ke nilai maksimum. Membantu mengilustrasikan bagaimana prediksi datapoint berubah saat fitur berubah.

Individual feature importance and What-if tab in explanation dashboard

Catatan

Ini adalah penjelasan berdasarkan banyak perkiraan dan bukan "penyebab" prediksi. Tanpa ketahanan matematis yang ketat dari inferensi kausal, kami tidak menyarankan pengguna untuk membuat keputusan nyata berdasarkan gangguan fitur alat What-If. Alat ini terutama untuk memahami model dan debugging Anda.

Visualisasi di studio Azure Machine Learning

Jika Anda menyelesaikan langkah interpretasi jarak jauh (mengunggah penjelasan yang dihasilkan ke Riwayat Eksekusi Azure Machine Learning), Anda dapat melihat visualisasi di dasbor penjelasan di studio Azure Machine Learning. Dasbor ini merupakan versi sederhana widget dasbor yang dibuat di dalam Jupyter Notebook Anda. Pembuatan titik data what-if dan plot ICE dinonaktifkan karena tidak ada komputasi yang aktif di studio Azure Machine Learning yang dapat menjalankan komputasi real time.

Jika himpunan data, penjelasan global, dan lokal tersedia, data akan mengisi semua tab. Namun, jika hanya ada penjelasan global saja yang tersedia, tab Kepentingan fitur individual akan dinonaktifkan.

Ikuti salah satu jalur ini untuk mengakses dasbor penjelasan di studio Azure Machine Learning:

  • Panel eksperimen (Pratinjau)

    1. Pilih Eksperimen di panel kiri untuk melihat daftar eksperimen yang telah Anda jalankan di Azure Machine Learning.
    2. Pilih eksperimen tertentu untuk melihat semua proses dalam eksperimen tersebut.
    3. Pilih eksekusi, lalu tab Penjelasan ke dasbor visualisasi penjelasan.

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

  • Panel model

    1. Jika Anda mendaftarkan model asli Anda dengan mengikuti langkah-langkah di Menyebarkan model dengan Azure Machine Learning, Anda dapat memilih Model di panel kiri untuk melihatnya.
    2. Pilih model, lalu tab Penjelasan untuk melihat dasbor penjelasan.

Interpretasi pada waktu inferensi

Anda dapat menerapkan penjelas bersama dengan model asli dan menggunakannya pada waktu inferensi untuk memberikan nilai kepentingan fitur individual (penjelasan lokal) untuk setiap datapoint baru. Kami juga menawarkan penjelas skor yang lebih ringan untuk meningkatkan performa interpretasi pada waktu inferensi, yang saat ini hanya didukung di Azure Machine Learning SDK. Proses penyebaran penjelas skor yang lebih ringan mirip dengan penyebaran model dan mencakup langkah-langkah berikut:

  1. Buat objek penjelasan. Misalnya, Anda dapat menggunakan TabularExplainer:

     from interpret.ext.blackbox import TabularExplainer


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

  2. Buat penjelas skor dengan objek penjelasan.

    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. Konfigurasikan dan daftarkan gambar yang menggunakan model penjelasan skor.

    # 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. Sebagai langkah opsional, Anda dapat mengambil penjelas skor dari cloud dan menguji penjelasannya.

    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. Sebarkan gambar ke target komputasi, dengan mengikuti langkah-langkah berikut:

    1. Jika perlu, daftarkan model prediksi asli Anda dengan mengikuti langkah-langkah di Menyebarkan model dengan Azure Machine Learning.

    2. Buat file skor.

      %%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. Tentukan konfigurasi penyebaran.

      Konfigurasi ini tergantung pada persyaratan model Anda. Contoh berikut mendefinisikan konfigurasi yang menggunakan satu core CPU dan satu GB memori.

      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. Buat file dengan dependensi lingkungan.

      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. Buat dockerfile khusus dengan g++ diinstal.

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

    6. Sebarkan gambar yang dibuat.

      Proses ini memakan waktu kurang lebih lima menit.

      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. Uji penyebaran.

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

    Untuk menghapus layanan web yang diterapkan, gunakan service.delete().

Pemecahan Masalah

  • Sparse data tidak didukung: Dasbor penjelasan model rusak/melambat secara substansial dengan sejumlah besar fitur, oleh karena itu, saat ini kami tidak mendukung format sparse data. Selain itu, masalah memori umum akan muncul dengan himpunan data yang besar dan sejumlah besar fitur.

  • Matriks fitur penjelasan yang didukung

Tab penjelasan yang didukung Fitur mentah (padat) Fitur mentah (tersebar) Fitur rekayasa (padat) Fitur rekayasa (tersebar)
Performa model Didukung (tidak memprakirakan) Didukung (tidak memprakirakan) Didukung Didukung
Penjelajah himpunan data Didukung (tidak memprakirakan) Tidak didukung. Karena sparse data tidak diunggah dan antarmuka pengguna memiliki masalah dalam merender sparse data. Didukung Tidak didukung. Karena sparse data tidak diunggah dan antarmuka pengguna memiliki masalah dalam merender sparse data.
Kepentingan fitur agregat Didukung Didukung Didukung Didukung
Kepentingan fitur individual Didukung (tidak memprakirakan) Tidak didukung. Karena sparse data tidak diunggah dan antarmuka pengguna memiliki masalah dalam merender sparse data. Didukung Tidak didukung. Karena sparse data tidak diunggah dan antarmuka pengguna memiliki masalah dalam merender sparse data.

  • Memperkirakan model tidak didukung dengan penjelasan model: Interpretasi serta penjelasan model terbaik tidak tersedia untuk eksperimen prakiraan AutoML yang merekomendasikan algoritma berikut sebagai model terbaik: TCNForecaster, AutoArima, Prophet, ExponentialSmoothing, Average, Naive, Seasonal Average, dan Seasonal Naive. Model regresi AutoML Forecasting mendukung penjelasan. Namun, di dalam dasbor penjelasan, tab "Kepentingan fitur individu" tidak didukung untuk prakiraan karena kerumitan dalam alur datanya.

  • Penjelasan lokal untuk indeks data: Dasbor penjelasan tidak mendukung mengaitkan nilai kepentingan lokal dengan pengidentifikasi baris dari himpunan data validasi asli jika himpunan data tersebut lebih besar dari 5000 titik data, karena dasbor menurunkan sampel data secara acak. Namun, dasbor menunjukkan nilai fitur kumpulan data mentah untuk setiap datapoint yang diteruskan ke dasbor di bawah tab Pentingnya fitur individual. Pengguna dapat memetakan kepentingan lokal kembali ke set data asli melalui pencocokan nilai fitur himpunan data mentah. Jika ukuran himpunan data validasi kurang dari 5000 sampel, index fitur di studio Azure Pembelajaran Mesin akan sesuai dengan indeks dalam himpunan data validasi.

  • Plot What-if/ICE tidak didukung di studio: Plot What-If dan Ekspektasi Bersyarat Individu (ICE) tidak didukung di studio Azure Machine Learning di tab Penjelasan, karena penjelasan yang diunggah memerlukan komputasi yang aktif untuk menghitung ulang prediksi dan peluang fitur yang terganggu. Saat ini didukung di buku catatan Jupyter saat dijalankan sebagai widget dengan menggunakan SDK.

Langkah berikutnya

Teknik untuk interpretasi model di Azure Pembelajaran Mesin

Lihat buku catatan sampel Kemampuan Interpretasi Azure Machine Learning