Lompati ke konten utama
Browser ini sudah tidak didukung.
Mutakhirkan ke Microsoft Edge untuk memanfaatkan fitur, pembaruan keamanan, dan dukungan teknis terkini.
Gunakan paket kemampuan interpretasi Python untuk menjelaskan model & prediksi ML (pratinjau)
- Artikel
- 08/30/2022
- 15 menit untuk membaca
Dalam artikel ini
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.
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.
Memasang paket azureml-interpret
pip install azureml-interpret
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)
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)
atau
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)
atau
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()
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.
Memasang paket azureml-interpret
pip install azureml-interpret
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')
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:
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, fitur index
di studio AzureML 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 kemampuan interpretasi model di
Azure ML
Lihat buku catatan sampel Kemampuan Interpretasi Azure Machine Learning
Apa itu NumPy Ndarray?
NumPy array merupakan sebuah objek ndarray, yang merupakan singkatan dari n-dimensional array. Pengecekan tipe data element pada array menggunakan fungsi dtype. Dalam membuat sebuah array, kita dapat menetapkan tipe data dengan menambahkan parameter dtype.
Apa kegunaan NumPy pada Python?
Numpy singkatan dari Numerik Python adalah Library Python yang digunakan untuk membuat objek kelas array tunggal dan multidimensi. Objek array di NumPy disebut ndarray, yang berguna menyediakan banyak fungsi pendukung yang membuat bekerja dengan ndarray sangat mudah.
Apa perbedaan Pandas dan NumPy?
Ternyata numpy menjadi salah satu library yang digunakan oleh library lain dalam proses analisa data, seperti Scikit-Learn. Sedangkan Pandas digunakan untuk memanipulasi data, seperti proses membaca data dari berbagai format (xlsx., csv., txt., dan lain sebagainya).
Apa itu Package NumPy?
NumPy merupakan singkatan dari Numerical Python. NumPy merupakan salah satu library Python yang berfungsi untuk proses komputasi numerik. NumPy memiliki kemampuan untuk membuat objek N-dimensi array.