Gunakan paket kemampuan interpretasi Python untuk menjelaskan model & prediksi ML (pratinjau)
BERLAKU UNTUK:
Python SDK 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.
Pasang paket
azureml-interpret.pip install azureml-interpretLatih 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)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, danPFIExplainersecara lokal.TabularExplainermemanggil salah satu dari tiga penjelas SHAP di bawahnya (TreeExplainer,DeepExplainer, atauKernelExplainer).TabularExplainersecara 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
ExplanationClientdalam jarak jauh untuk mengunggah konteks interpretasi. - Unduh konteksnya di lingkungan lokal nanti.
Pasang paket
azureml-interpret.pip install azureml-interpretBuat 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')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.
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.
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).
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.
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.
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. |
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)
- Pilih Eksperimen di panel kiri untuk melihat daftar eksperimen yang telah Anda jalankan di Azure Machine Learning.
- Pilih eksperimen tertentu untuk melihat semua proses dalam eksperimen tersebut.
- Pilih eksekusi, lalu tab Penjelasan ke dasbor visualisasi penjelasan.
Panel model
- 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.
- 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:
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)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)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')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)Sebarkan gambar ke target komputasi, dengan mengikuti langkah-langkah berikut:
Jika perlu, daftarkan model prediksi asli Anda dengan mengikuti langkah-langkah di Menyebarkan model dengan Azure Machine Learning.
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}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')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())Buat dockerfile khusus dengan g++ diinstal.
%%writefile dockerfile RUN apt-get update && apt-get install -y g++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)
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)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,
indexfitur 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