Kemampuan interpretasi: Kemampuan model untuk dapat dijelaskan dalam ML otomatis (pratinjau)

  • Artikel

BERLAKU UNTUK:SDK Python azureml v1

Dalam artikel ini, Anda akan mempelajari cara mendapatkan penjelasan untuk model pembelajaran mesin otomatis (ML otomatis) di Azure Machine Learning menggunakan SDK Python. ML otomatis membantu Anda memahami kepentingan fitur model yang dihasilkan.

Semua versi SDK setelah 1.0.85 menetapkan model_explainability=True secara default. Di SDK versi 1.0.85 dan yang lebih lama, pengguna harus mengatur model_explainability=True di objek AutoMLConfig untuk menggunakan interpretabilitas model.

Dalam artikel ini, Anda akan mempelajari cara:

  • Melakukan interpretabilitas selama pelatihan untuk model terbaik atau model apa pun.
  • Aktifkan visualisasi untuk membantu Anda melihat pola dalam data dan penjelasan.
  • Terapkan interpretabilitas selama inferensi atau penilaian.

Prasyarat

  • Fitur interpretabilitas. Jalankan pip install azureml-interpret untuk mendapatkan paket yang diperlukan.
  • Pengetahuan tentang membuat eksperimen ML otomatis. Untuk informasi selengkapnya tentang cara menggunakan SDK Azure Machine Learning, selesaikan tutorial model deteksi objek ini atau lihat cara mengonfigurasi eksperimen ML otomatis.

Penting

Fitur ini sedang 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 yang dibatasi.

Untuk informasi lebih lanjut, lihat Ketentuan Penggunaan Tambahan untuk Pratinjau Microsoft Azure.

Interpretabilitas selama pelatihan untuk model terbaik

Ambil penjelasan dari best_run, yang mencakup penjelasan untuk fitur mentah dan rekayasa.

Catatan

Interpretabilitas, penjelasan model, tidak tersedia untuk model TCNForecaster yang direkomendasikan oleh eksperimen perkiraan ML Auto.

Unduh kepentingan fitur rekayasa dari eksekusi terbaik

Anda dapat menggunakan ExplanationClient untuk mengunduh penjelasan fitur rekayasa dari penyimpanan artefak best_run.

from azureml.interpret import ExplanationClient

client = ExplanationClient.from_run(best_run)
engineered_explanations = client.download_model_explanation(raw=False)
print(engineered_explanations.get_feature_importance_dict())

Unduh kepentingan fitur mentah dari eksekusi terbaik

Anda dapat menggunakan ExplanationClient untuk mengunduh penjelasan fitur mentah dari penyimpanan artefak best_run.

from azureml.interpret import ExplanationClient

client = ExplanationClient.from_run(best_run)
raw_explanations = client.download_model_explanation(raw=True)
print(raw_explanations.get_feature_importance_dict())

Interpretabilitas selama pelatihan untuk setiap model

Saat menghitung penjelasan model dan memvisualisasikannya, Anda tidak terbatas pada penjelasan model yang ada untuk model AutoML. Anda juga bisa mendapatkan penjelasan untuk model Anda dengan data pengujian yang berbeda. Langkah-langkah di bagian ini menunjukkan cara menghitung dan memvisualisasikan kepentingan fitur rekayasa berdasarkan data pengujian Anda.

Mengambil model AutoML lainnya dari pelatihan

automl_run, fitted_model = local_run.get_output(metric='accuracy')

Menyiapkan penjelasan model

Gunakan automl_setup_model_explanations untuk mendapatkan penjelasan rekayasa dan mentah. fitted_model dapat menghasilkan item berikut:

  • Data unggulan dari sampel terlatih atau pengujian
  • Daftar nama fitur rekayasa
  • Kelas yang dapat ditemukan di kolom berlabel Anda dalam skenario klasifikasi

automl_explainer_setup_obj berisi semua struktur dari daftar di atas.

from azureml.train.automl.runtime.automl_explain_utilities import automl_setup_model_explanations

automl_explainer_setup_obj = automl_setup_model_explanations(fitted_model, X=X_train, 
                                                             X_test=X_test, y=y_train, 
                                                             task='classification')

Menginisialisasi Mimic Explainer untuk kepentingan fitur

Untuk membuat penjelasan untuk model ML otomatis, gunakan kelas MimicWrapper. Anda dapat menginisialisasi MimicWrapper dengan parameter berikut:

  • Objek penyiapan penjelas
  • Ruang kerja Anda
  • Model pengganti untuk menjelaskan model ML otomatis fitted_model

MimicWrapper juga mengambil objek automl_run tempat penjelasan yang direkayasa akan diunggah.

from azureml.interpret import MimicWrapper

# Initialize the Mimic Explainer
explainer = MimicWrapper(ws, automl_explainer_setup_obj.automl_estimator,
                         explainable_model=automl_explainer_setup_obj.surrogate_model, 
                         init_dataset=automl_explainer_setup_obj.X_transform, run=automl_run,
                         features=automl_explainer_setup_obj.engineered_feature_names, 
                         feature_maps=[automl_explainer_setup_obj.feature_map],
                         classes=automl_explainer_setup_obj.classes,
                         explainer_kwargs=automl_explainer_setup_obj.surrogate_model_params)

Gunakan Mimic Explainer untuk menghitung dan memvisualisasikan kepentingan fitur rekayasa

Anda bisa memanggil metode explain() di MimicWrapper dengan sampel pengujian yang diubah untuk mendapatkan kepentingan fitur untuk fitur rekayasa yang dihasilkan. Anda juga dapat masuk ke studio Azure Machine Learning untuk melihat visualisasi dasbor penjelasan tentang nilai pentingnya fitur dari fitur rekayasa yang dihasilkan oleh fitur ML otomatis.

engineered_explanations = explainer.explain(['local', 'global'], eval_dataset=automl_explainer_setup_obj.X_test_transform)
print(engineered_explanations.get_feature_importance_dict())

Untuk model yang dilatih dengan ML otomatis, Anda bisa mendapatkan model terbaik menggunakan metode get_output() dan menghitung penjelasan secara lokal. Anda dapat memvisualisasikan hasil penjelasan denganExplanationDashboard dari raiwidgets paket.

best_run, fitted_model = remote_run.get_output()

from azureml.train.automl.runtime.automl_explain_utilities import AutoMLExplainerSetupClass, automl_setup_model_explanations
automl_explainer_setup_obj = automl_setup_model_explanations(fitted_model, X=X_train,
                                                             X_test=X_test, y=y_train,
                                                             task='regression')

from interpret.ext.glassbox import LGBMExplainableModel
from azureml.interpret.mimic_wrapper import MimicWrapper

explainer = MimicWrapper(ws, automl_explainer_setup_obj.automl_estimator, LGBMExplainableModel,
                         init_dataset=automl_explainer_setup_obj.X_transform, run=best_run,
                         features=automl_explainer_setup_obj.engineered_feature_names,
                         feature_maps=[automl_explainer_setup_obj.feature_map],
                         classes=automl_explainer_setup_obj.classes)
                         
pip install interpret-community[visualization]

engineered_explanations = explainer.explain(['local', 'global'], eval_dataset=automl_explainer_setup_obj.X_test_transform)
print(engineered_explanations.get_feature_importance_dict()),
from raiwidgets import ExplanationDashboard
ExplanationDashboard(engineered_explanations, automl_explainer_setup_obj.automl_estimator, datasetX=automl_explainer_setup_obj.X_test_transform)

 

raw_explanations = explainer.explain(['local', 'global'], get_raw=True,
                                     raw_feature_names=automl_explainer_setup_obj.raw_feature_names,
                                     eval_dataset=automl_explainer_setup_obj.X_test_transform)
print(raw_explanations.get_feature_importance_dict()),
from raiwidgets import ExplanationDashboard
ExplanationDashboard(raw_explanations, automl_explainer_setup_obj.automl_pipeline, datasetX=automl_explainer_setup_obj.X_test_raw)

Menggunakan Mimic Explainer untuk menghitung dan memvisualisasikan kepentingan fitur mentah

Anda bisa memanggil metode explain() di MimicWrapper dengan sampel pengujian yang diubah untuk mendapatkan kepentingan fitur untuk fitur mentah. Di studio Azure Machine Learning, Anda dapat melihat visualisasi dasbor nilai kepentingan fitur dari fitur mentah.

raw_explanations = explainer.explain(['local', 'global'], get_raw=True,
                                     raw_feature_names=automl_explainer_setup_obj.raw_feature_names,
                                     eval_dataset=automl_explainer_setup_obj.X_test_transform,
                                     raw_eval_dataset=automl_explainer_setup_obj.X_test_raw)
print(raw_explanations.get_feature_importance_dict())

Interpretabilitas selama inferensi

Di bagian ini, Anda mempelajari cara mengoperasionalkan model ML otomatis dengan penjelas yang digunakan untuk menghitung penjelasan di bagian sebelumnya.

Mendaftarkan model dan penjelas penilaian

Gunakan TreeScoringExplainer untuk membuat penjelasan penilaian yang akan menghitung nilai kepentingan fitur rekayasa pada waktu inferensi. Anda menginisialisasi penjelas penilaian dengan feature_map yang dihitung sebelumnya.

Simpan penjelas penilaian, lalu daftarkan model dan penjelas penilaian dengan Layanan Manajemen Model. Jalankan kode berikut:

from azureml.interpret.scoring.scoring_explainer import TreeScoringExplainer, save

# Initialize the ScoringExplainer
scoring_explainer = TreeScoringExplainer(explainer.explainer, feature_maps=[automl_explainer_setup_obj.feature_map])

# Pickle scoring explainer locally
save(scoring_explainer, exist_ok=True)

# Register trained automl model present in the 'outputs' folder in the artifacts
original_model = automl_run.register_model(model_name='automl_model', 
                                           model_path='outputs/model.pkl')

# Register scoring explainer
automl_run.upload_file('scoring_explainer.pkl', 'scoring_explainer.pkl')
scoring_explainer_model = automl_run.register_model(model_name='scoring_explainer', model_path='scoring_explainer.pkl')

Membuat dependensi conda untuk menyiapkan layanan

Selanjutnya, buat dependensi lingkungan yang diperlukan dalam kontainer untuk model yang disebarkan. Harap diingat bahwa azureml-default dengan versi >= 1.0.45 harus tercantum sebagai dependensi pip, karena berisi fungsionalitas yang diperlukan untuk meng-hosting model sebagai layanan web.

from azureml.core.conda_dependencies import CondaDependencies

azureml_pip_packages = [
    'azureml-interpret', 'azureml-train-automl', 'azureml-defaults'
]

myenv = CondaDependencies.create(conda_packages=['scikit-learn', 'pandas', 'numpy', 'py-xgboost<=0.80'],
                                 pip_packages=azureml_pip_packages,
                                 pin_sdk_version=True)

with open("myenv.yml","w") as f:
    f.write(myenv.serialize_to_string())

with open("myenv.yml","r") as f:
    print(f.read())

Membuat skrip penilaian

Tulis skrip yang memuat model Anda dan menghasilkan prediksi dan penjelasan berdasarkan batch data baru.

%%writefile score.py
import joblib
import pandas as pd
from azureml.core.model import Model
from azureml.train.automl.runtime.automl_explain_utilities import automl_setup_model_explanations


def init():
    global automl_model
    global scoring_explainer

    # Retrieve the path to the model file using the model name
    # Assume original model is named automl_model
    automl_model_path = Model.get_model_path('automl_model')
    scoring_explainer_path = Model.get_model_path('scoring_explainer')

    automl_model = joblib.load(automl_model_path)
    scoring_explainer = joblib.load(scoring_explainer_path)


def run(raw_data):
    data = pd.read_json(raw_data, orient='records')
    # Make prediction
    predictions = automl_model.predict(data)
    # Setup for inferencing explanations
    automl_explainer_setup_obj = automl_setup_model_explanations(automl_model,
                                                                 X_test=data, task='classification')
    # Retrieve model explanations for engineered explanations
    engineered_local_importance_values = scoring_explainer.explain(automl_explainer_setup_obj.X_test_transform)
    # Retrieve model explanations for raw explanations
    raw_local_importance_values = scoring_explainer.explain(automl_explainer_setup_obj.X_test_transform, get_raw=True)
    # You can return any data type as long as it is JSON-serializable
    return {'predictions': predictions.tolist(),
            'engineered_local_importance_values': engineered_local_importance_values,
            'raw_local_importance_values': raw_local_importance_values}

Menyebarkan layanan

Sebarkan layanan menggunakan file conda dan file penilaian dari langkah-langkah sebelumnya.

from azureml.core.webservice import Webservice
from azureml.core.webservice import AciWebservice
from azureml.core.model import Model, InferenceConfig
from azureml.core.environment import Environment

aciconfig = AciWebservice.deploy_configuration(cpu_cores=1,
                                               memory_gb=1,
                                               tags={"data": "Bank Marketing",  
                                                     "method" : "local_explanation"},
                                               description='Get local explanations for Bank marketing test data')
myenv = Environment.from_conda_specification(name="myenv", file_path="myenv.yml")
inference_config = InferenceConfig(entry_script="score_local_explain.py", environment=myenv)

# Use configs and models generated above
service = Model.deploy(ws,
                       'model-scoring',
                       [scoring_explainer_model, original_model],
                       inference_config,
                       aciconfig)
service.wait_for_deployment(show_output=True)

Inferensi dengan data pengujian

Inferensi dengan beberapa data pengujian untuk melihat prediksi nilai dari model AutoML, saat ini hanya didukung di Azure Machine Learning SDK. Lihat kepentingan fitur yang berkontribusi terhadap prediksi nilai.

if service.state == 'Healthy':
    # Serialize the first row of the test data into json
    X_test_json = X_test[:1].to_json(orient='records')
    print(X_test_json)
    # Call the service to get the predictions and the engineered explanations
    output = service.run(X_test_json)
    # Print the predicted value
    print(output['predictions'])
    # Print the engineered feature importances for the predicted value
    print(output['engineered_local_importance_values'])
    # Print the raw feature importances for the predicted value
    print('raw_local_importance_values:\n{}\n'.format(output['raw_local_importance_values']))

Visualisasi untuk menemukan pola dalam data dan penjelasan pada waktu pelatihan

Anda dapat memvisualisasikan bagan kepentingan fitur di ruang kerja Anda di studio Azure Machine Learning. Setelah eksekusi AutoML Anda selesai, pilih Lihat detail model untuk melihat eksekusi tertentu. Pilih tab Penjelasan untuk melihat visualisasi di dasbor penjelasan.

Arsitektur Interpretabilitas Pembelajaran Mesin

Untuk informasi selengkapnya tentang visualisasi dasbor penjelasan dan plot tertentu, lihat cara membuat dok pada interpretabilitas.

Langkah berikutnya

Untuk informasi lebih lanjut tentang bagaimana Anda dapat mengaktifkan penjelasan model dan fitur penting di bidang selain ML otomatis, lihat lebih banyak teknik untuk interpretasi model.