Memahami mengapa sebuah model machine learning (ML) membuat prediksi tertentu seringkali sama pentingnya dengan akurasi prediksi itu sendiri. Model yang kompleks seperti Random Forest atau XGBoost bisa menjadi 'kotak hitam' (black box), di mana logika internalnya sulit dipahami. Kebutuhan akan transparansi ini krusial untuk membangun kepercayaan pengguna, melakukan debugging, memastikan keadilan (fairness), dan mematuhi regulasi. Di sinilah konsep Explainable AI (XAI) Python berperan penting. SHAP (Shapley Additive exPlanations) hadir sebagai salah satu kerangka kerja terdepan untuk interpretasi model machine learning. Berbasis teori permainan kooperatif, khususnya nilai Shapley (Shapley values), SHAP menyediakan metode yang konsisten dan akurat secara teoritis untuk mengukur kontribusi setiap fitur terhadap prediksi individual maupun secara global. Tutorial ini akan memandu Anda langkah demi langkah menggunakan SHAP Library Python untuk menjelaskan prediksi model Anda, menjadikannya bagian penting dari perangkat Data Science Anda.
Prasyarat Mengikuti Tutorial SHAP Python
Sebelum kita menyelami kode, pastikan Anda memiliki beberapa hal berikut sebagai persiapan.
Library Python yang Dibutuhkan
Anda memerlukan library Python berikut terinstal di lingkungan Anda:
pandas: Untuk manipulasi dan analisis data.scikit-learn: Untuk memuat dataset contoh, membagi data, dan melatih model machine learning.shap: Library inti untuk menghitung dan memvisualisasikan nilai SHAP (SHAP Library Python).matplotlib/seaborn: Untuk membuat visualisasi plot SHAP.xgboostataulightgbm(Opsional): Jika Anda ingin menginterpretasikan model XGBoost atau LightGBM secara spesifik (tutorial ini akan menggunakan Random Forest sebagai contoh utama, tetapi SHAP juga sangat efisien untuk model-model ini).
Pengetahuan Dasar yang Diasumsikan
Tutorial ini mengasumsikan Anda memiliki pemahaman dasar tentang:
- Pemrograman Python dasar (variabel, fungsi, struktur data).
- Konsep dasar Machine Learning (supervised learning, fitur, target, data latih/uji, proses training dan prediksi).
- Penggunaan library
pandasuntuk manipulasi DataFrame danscikit-learnuntuk tugas ML dasar.
Langkah 1: Menginstal SHAP dan Library Pendukung
Langkah pertama adalah menginstal library SHAP beserta dependensi lainnya jika belum terpasang. Anda bisa melakukannya menggunakan pip. Buka terminal atau command prompt Anda dan jalankan perintah berikut untuk Install SHAP Python:
pip install shap pandas scikit-learn matplotlib seaborn
# Jika ingin menggunakan XGBoost, tambahkan:
# pip install xgboost
Perintah ini akan mengunduh dan menginstal SHAP Library Python serta library lain yang kita perlukan. Disarankan untuk melakukan instalasi ini dalam lingkungan virtual (virtual environment) untuk menghindari konflik dependensi.
Langkah 2: Mempersiapkan Data untuk Interpretasi
Untuk mendemonstrasikan Cara Menggunakan SHAP, kita akan menggunakan dataset klasik sebagai contoh. Setelah instalasi selesai, langkah berikutnya adalah menyiapkan data.
Memuat Contoh Dataset
Kita akan menggunakan dataset Iris dari scikit-learn, yang merupakan masalah klasifikasi multikelas sederhana.
import pandas as pd
from sklearn.datasets import load_iris
from sklearn.model_selection import train_test_split
# Memuat dataset Iris
iris = load_iris()
X = pd.DataFrame(iris.data, columns=iris.feature_names)
y = iris.target
# Menampilkan beberapa baris pertama data fitur
print("Contoh Data Fitur (X):")
print(X.head())
# Menampilkan target (opsional)
# print("\nTarget (y):")
# print(y[:5]) # 0: setosa, 1: versicolor, 2: virginica
Kode di atas memuat data fitur ke dalam DataFrame Pandas X dan target ke dalam array NumPy y.
Preprocessing Data Sederhana
Langkah preprocessing penting adalah memisahkan data menjadi set pelatihan (train) dan set pengujian (test). Model akan dilatih pada data latih, dan SHAP akan digunakan untuk menjelaskan prediksi pada data uji.
# Memisahkan data menjadi data latih dan data uji
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)
print(f"\nUkuran data latih (X_train): {X_train.shape}")
print(f"Ukuran data uji (X_test): {X_test.shape}")
Untuk dataset Iris dan model berbasis pohon seperti Random Forest, preprocessing lebih lanjut seperti penskalaan (scaling) biasanya tidak diperlukan. Dengan data yang siap, kita bisa melatih model.
Langkah 3: Melatih Model Machine Learning
Selanjutnya, mari kita latih model machine learning yang akan kita interpretasikan. Kita akan menggunakan Random Forest Classifier sebagai contoh utama.
Contoh Kode Melatih Model Random Forest
from sklearn.ensemble import RandomForestClassifier
from sklearn.metrics import accuracy_score
# Inisialisasi model Random Forest Classifier
rf_model = RandomForestClassifier(n_estimators=100, random_state=42)
# Melatih model menggunakan data latih
rf_model.fit(X_train, y_train)
# (Opsional) Mengevaluasi performa model pada data uji
y_pred = rf_model.predict(X_test)
accuracy = accuracy_score(y_test, y_pred)
print(f"\nAkurasi Model Random Forest pada data uji: {accuracy:.4f}")
Kita kini memiliki model rf_model yang sudah terlatih dan siap untuk proses interpretasi model machine learning menggunakan SHAP.
(Opsional) Contoh Kode Melatih Model XGBoost
Jika Anda lebih tertarik pada XGBoost, berikut cara melatihnya (pastikan library xgboost sudah terinstal):
# import xgboost as xgb
# # Inisialisasi model XGBoost Classifier
# xgb_model = xgb.XGBClassifier(objective='multi:softprob', eval_metric='mlogloss', use_label_encoder=False, random_state=42)
# # Melatih model
# xgb_model.fit(X_train, y_train)
# # (Opsional) Evaluasi
# y_pred_xgb = xgb_model.predict(X_test)
# accuracy_xgb = accuracy_score(y_test, y_pred_xgb)
# print(f"\nAkurasi Model XGBoost pada data uji: {accuracy_xgb:.4f}")
# # Jika menggunakan XGBoost, ganti 'rf_model' dengan 'xgb_model' di langkah selanjutnya
Setelah model terlatih, saatnya menerapkan SHAP.
Langkah 4: Menggunakan SHAP untuk Menjelaskan Model
Inti dari SHAP adalah menghitung 'SHAP values'. Nilai ini sangat penting dalam Explainable AI Python.
Inisialisasi SHAP Explainer
Langkah pertama dalam menggunakan SHAP adalah membuat objek 'Explainer'. Jenis Explainer yang digunakan bergantung pada tipe model Anda. Untuk model berbasis pohon seperti Random Forest, Gradient Boosting, XGBoost, dan LightGBM, shap.TreeExplainer adalah pilihan yang paling efisien.
import shap
# Membuat explainer untuk model Random Forest
# Gunakan model yang sudah dilatih (rf_model)
explainer = shap.TreeExplainer(rf_model)
Ini adalah Contoh Kode SHAP Python pertama kita untuk inisialisasi explainer.
Menghitung SHAP Values (Apa Itu SHAP Value?)
SHAP Value adalah ukuran kontribusi setiap fitur dalam mendorong output prediksi model dari nilai dasar (rata-rata prediksi di seluruh dataset pelatihan) ke nilai prediksi akhir untuk suatu instance data spesifik. Nilai positif menunjukkan fitur mendorong prediksi ke arah yang lebih tinggi (atau kelas tertentu), sementara nilai negatif mendorong ke arah sebaliknya. Setelah memiliki explainer, kita dapat menghitung SHAP values untuk setiap instance data yang ingin kita jelaskan (biasanya data uji).
# Menghitung SHAP values untuk data uji (X_test)
# Proses ini mungkin memerlukan waktu tergantung ukuran data dan kompleksitas model
shap_values = explainer.shap_values(X_test)
Variabel shap_values kini berisi nilai SHAP. Untuk masalah klasifikasi multikelas seperti Iris (3 kelas), shap_values akan menjadi list berisi array NumPy, di mana setiap array mewakili SHAP values untuk satu kelas. shap_values[0] untuk kelas 0 (setosa), shap_values[1] untuk kelas 1 (versicolor), dan shap_values[2] untuk kelas 2 (virginica). Dimensi setiap array biasanya (jumlah_sampel, jumlah_fitur).
Untuk masalah regresi atau klasifikasi biner, shap_values biasanya hanya berupa satu array NumPy.
Dengan nilai SHAP yang telah dihitung, kita dapat melanjutkan ke visualisasi untuk interpretasi yang lebih mudah.
Langkah 5: Visualisasi dan Interpretasi Hasil SHAP
Nilai SHAP mentah mungkin sulit diinterpretasikan secara langsung. Untungnya, SHAP menyediakan berbagai fungsi Visualisasi SHAP Value yang sangat berguna untuk memahami kontribusi fitur.
summary_plot: Memahami Pengaruh Fitur Global
summary_plot memberikan gambaran umum tentang fitur mana yang paling penting secara global dan bagaimana nilai fitur tersebut memengaruhi prediksi.
# Visualisasi summary plot (tipe bar) - Menunjukkan rata-rata magnitudo SHAP value per fitur
print("\nSHAP Summary Plot (Bar): Global Feature Importance")
shap.summary_plot(shap_values, X_test, plot_type="bar", feature_names=iris.feature_names)
# Visualisasi summary plot (tipe dot/default) - Menunjukkan distribusi SHAP value
# Warna menunjukkan nilai fitur (merah=tinggi, biru=rendah)
# Posisi horizontal menunjukkan dampak SHAP value pada prediksi kelas target
# Kita akan fokus pada kelas 1 (versicolor) sebagai contoh
print("\nSHAP Summary Plot (Dot): Feature Importance & Effect (Kelas 1 - Versicolor)")
shap.summary_plot(shap_values[1], X_test, feature_names=iris.feature_names, plot_title="SHAP Summary untuk Kelas 1 (Versicolor)")
Interpretasi:
- Plot tipe 'bar' menunjukkan fitur yang memiliki dampak rata-rata terbesar pada magnitudo prediksi model, diurutkan dari yang paling penting. Ini adalah bagian penting dari Penjelasan Model Machine Learning secara keseluruhan.
- Plot tipe 'dot' (default) lebih kaya informasi. Setiap titik mewakili satu instance data untuk satu fitur. Sumbu X adalah nilai SHAP (dampak pada prediksi kelas 1). Warna menunjukkan nilai asli fitur tersebut (misal, panjang petal). Kita bisa melihat, misalnya, bahwa nilai 'petal length (cm)' yang rendah (biru) cenderung memiliki SHAP value negatif (mengurangi kemungkinan prediksi kelas 1), sedangkan nilai yang tinggi (merah) memiliki SHAP value positif (meningkatkan kemungkinan prediksi kelas 1). Fitur 'petal width (cm)' tampaknya menjadi pembeda paling kuat untuk kelas ini.
dependence_plot: Menganalisis Hubungan dan Interaksi Fitur
dependence_plot menunjukkan bagaimana perubahan nilai satu fitur memengaruhi SHAP value-nya di seluruh dataset. Plot ini juga bisa secara otomatis memilih fitur lain yang paling berinteraksi dengannya dan mewarnai titik berdasarkan nilai fitur interaksi tersebut.
# Menganalisis fitur 'petal width (cm)' untuk kelas 1
# Warna titik akan menunjukkan fitur lain yang paling berinteraksi dengannya
print("\nSHAP Dependence Plot: Efek 'petal width (cm)' pada Prediksi Kelas 1")
shap.dependence_plot("petal width (cm)", shap_values[1], X_test, feature_names=iris.feature_names, interaction_index="auto")
# Anda bisa juga menentukan fitur interaksi secara manual
# shap.dependence_plot("petal width (cm)", shap_values[1], X_test, feature_names=iris.feature_names, interaction_index="petal length (cm)")
Interpretasi: Plot ini menunjukkan hubungan antara nilai 'petal width (cm)' (sumbu X) dan SHAP value-nya untuk kelas 1 (sumbu Y). Kita bisa melihat tren umum (misal, petal width yang lebih besar meningkatkan SHAP value untuk kelas 1). Warna titik (yang mewakili nilai fitur interaksi, misal 'petal length (cm)') dapat memberikan petunjuk tentang efek interaksi: apakah hubungan antara 'petal width' dan SHAP value-nya berbeda tergantung pada nilai 'petal length'?
force_plot: Menjelaskan Prediksi Individual
Ini adalah salah satu visualisasi SHAP yang paling kuat untuk menjelaskan *mengapa* model membuat prediksi tertentu untuk *satu* instance data. Ini menunjukkan bagaimana setiap fitur 'mendorong' atau 'menarik' prediksi dari nilai dasar (base value) ke nilai akhir.
Mari kita lakukan Interpretasi Model Random Forest dengan SHAP untuk satu instance data.
# Inisialisasi Javascript untuk plotting interaktif (jika menggunakan notebook)
shap.initjs()
# Pilih satu instance data dari data uji (misalnya, instance pertama)
instance_index = 0
print(f"\nMenjelaskan Prediksi untuk Instance Data ke-{instance_index} (Kelas Sebenarnya: {y_test[instance_index]})")
# Menampilkan force plot untuk kelas 1 (versicolor)
# expected_value[1] adalah base value untuk kelas 1
# shap_values[1][instance_index, :] adalah SHAP values untuk instance ini, kelas 1
# X_test.iloc[instance_index, :] adalah nilai fitur untuk instance ini
print(f"\nForce Plot untuk Kelas 1 (Versicolor):")
shap.force_plot(explainer.expected_value[1],
shap_values[1][instance_index, :],
X_test.iloc[instance_index, :],
feature_names=iris.feature_names,
matplotlib=True) # Gunakan matplotlib=True jika tidak di notebook atau ingin plot statis
# (Opsional) Menampilkan force plot untuk semua kelas dalam satu plot (jika versi SHAP mendukung)
# print("\nForce Plot Gabungan untuk Semua Kelas:")
# shap.force_plot(explainer.expected_value, shap_values, X_test.iloc[instance_index,:], feature_names=iris.feature_names)
# (Opsional) Menampilkan force plot untuk beberapa instance data sekaligus (waterfall plot)
# print("\nForce Plot (Waterfall) untuk Beberapa Instance Pertama (Kelas 1):")
# shap.force_plot(explainer.expected_value[1], shap_values[1][:5,:], X_test.iloc[:5,:], feature_names=iris.feature_names)
Interpretasi:
- Base Value (
explainer.expected_value[1]): Nilai rata-rata prediksi model untuk kelas 1 di seluruh data latih. Ini adalah titik awal penjelasan. - Output Value (f(x)): Prediksi akhir model untuk instance ini (dalam skala log-odds atau probabilitas, tergantung pada explainer dan model). Ini adalah nilai akhir yang dicapai setelah mempertimbangkan semua fitur.
- Fitur Merah: Fitur yang nilainya pada instance ini mendorong prediksi ke arah yang lebih TINGGI (meningkatkan kemungkinan kelas 1). Panjang panah menunjukkan besarnya kontribusi (magnitudo SHAP value).
- Fitur Biru: Fitur yang nilainya pada instance ini mendorong prediksi ke arah yang lebih RENDAH (mengurangi kemungkinan kelas 1). Panjang panah menunjukkan besarnya kontribusi.
Dengan melihat fitur mana yang berwarna merah atau biru dan seberapa panjang panahnya, kita bisa menjelaskan mengapa model menghasilkan prediksi tertentu untuk instance tersebut. Ini adalah inti dari Tutorial SHAP Python ini: memberikan penjelasan tingkat instance.
Studi Kasus: Membedah Prediksi Spesifik
Mari kita pilih satu instance lain, misalnya instance ke-5 dari data uji, dan lakukan Penjelasan Model Machine Learning yang lebih mendalam menggunakan force_plot untuk memahami mengapa model membuat prediksi tersebut.
# Pilih instance lain, misalnya index 5
instance_index = 5
actual_class = y_test[instance_index]
predicted_class = rf_model.predict(X_test.iloc[[instance_index]])[0]
print(f"\n--- Studi Kasus: Instance Data ke-{instance_index} ---")
print(f"Kelas Aktual: {actual_class} ({iris.target_names[actual_class]})")
print(f"Kelas Prediksi: {predicted_class} ({iris.target_names[predicted_class]})")
print("\nNilai Fitur:")
print(X_test.iloc[instance_index])
# Fokus pada penjelasan untuk kelas yang diprediksi (misalnya kelas 2 - virginica)
target_class_index = 2 # Indeks untuk Virginica
print(f"\nMenampilkan Force Plot untuk Kelas {target_class_index} ({iris.target_names[target_class_index]}):")
shap.force_plot(explainer.expected_value[target_class_index],
shap_values[target_class_index][instance_index, :],
X_test.iloc[instance_index, :],
feature_names=iris.feature_names,
matplotlib=True)
Analisis Force Plot (Contoh): Berdasarkan plot yang dihasilkan untuk instance ke-5 dan kelas Virginica (kelas 2), kita mungkin melihat bahwa nilai 'petal length (cm)' yang tinggi (misal 5.1 cm) dan 'petal width (cm)' yang tinggi (misal 1.9 cm) menjadi pendorong utama (merah) yang meningkatkan probabilitas prediksi kelas Virginica. Sebaliknya, mungkin nilai 'sepal width (cm)' yang relatif sedang (misal 2.8 cm) sedikit menahan (biru) prediksi tersebut, tetapi pengaruhnya lebih kecil dibandingkan fitur petal. Analisis ini memberikan pemahaman konkret mengapa model mengklasifikasikan bunga spesifik ini sebagai Virginica.
Kesimpulan: Manfaat Utama Menggunakan SHAP
Melalui tutorial Cara Menggunakan SHAP ini, kita telah melihat bagaimana library SHAP di Python memungkinkan kita membuka 'kotak hitam' model machine learning. SHAP menyediakan kerangka kerja yang kuat dan konsisten secara teoritis untuk:
- Mengukur kontribusi setiap fitur terhadap prediksi (SHAP Value adalah kuncinya).
- Mengidentifikasi fitur paling penting secara global (
summary_plot). - Memahami bagaimana nilai fitur memengaruhi prediksi dan potensi interaksinya (
dependence_plot). - Memberikan penjelasan rinci untuk prediksi individual (
force_plot).
Kemampuan interpretasi model machine learning ini sangat berharga untuk membangun kepercayaan, melakukan debugging, memastikan keadilan, dan memenuhi persyaratan regulasi dalam aplikasi AI. Menguasai alat seperti SHAP adalah langkah penting dalam praktik Explainable AI Python dan meningkatkan kualitas serta keandalan solusi machine learning Anda.
Langkah selanjutnya bagi Anda adalah mencoba menerapkan SHAP pada model dan dataset Anda sendiri. Eksplorasi jenis explainer lain seperti KernelExplainer (untuk model yang tidak berbasis pohon) atau visualisasi SHAP lainnya yang tersedia untuk mendapatkan wawasan yang lebih dalam.
Butuh Bantuan Implementasi AI dan Interpretasi Model?
Memahami dan mengimplementasikan teknik interpretasi model seperti SHAP adalah bagian penting dari pengembangan solusi AI yang bertanggung jawab dan efektif. Namun, membangun, menerapkan, dan mengoptimalkan sistem AI yang kompleks seringkali membutuhkan keahlian khusus dan sumber daya yang signifikan. Jika Anda atau bisnis Anda membutuhkan dukungan dalam mengimplementasikan solusi machine learning yang tidak hanya kuat tetapi juga transparan dan mudah dipahami, atau ingin mengeksplorasi bagaimana AI dapat mengotomatisasi tugas, meningkatkan SEO, atau mengoptimalkan proses bisnis Anda lebih lanjut, tim ahli di Kirim.ai siap membantu. Sebagai penyedia solusi digital berbasis AI terdepan, kami menawarkan pengembangan platform (web & mobile), AI Agent untuk SEO, serta berbagai alat AI canggih untuk mendorong pertumbuhan bisnis Anda. Dapatkan konsultasi gratis untuk mendiskusikan kebutuhan spesifik Anda.
Tanggapan (0 )