Interpretabilitas Model

Model yang akurat namun tak terbaca sulit dipercaya, sulit diperbaiki, dan sulit dipertanggungjawabkan. Ketika prediksi ditolak pengguna, ketika regulator bertanya dasar keputusan, atau ketika performa anjlok tanpa gejala jelas — semuanya menuntut jawaban atas satu pertanyaan: fitur apa yang sebenarnya menggerakkan model ini? Interpretabilitas menyediakan teknik pengukuran untuk pertanyaan itu, dan seperti fairness, ia bekerja paling baik sebagai angka yang dihitung, bukan sebagai perasaan. Chapter ini mendemonstrasikan dua teknik yang dapat dijalankan pada model apa pun — permutation importance dan surrogate tree — lalu menutup dengan peringatan penting tentang attention.

Tiga Alasan Menjelaskan Model #

Baris pertama terhubung langsung ke Analisis Kesalahan : pola kesalahan yang dikumpulkan di sana menjadi hipotesis, interpretabilitas mengujinya pada bobot dan fitur. Baris kedua menghubungkan interpretabilitas dengan regulasi — putusan yang memengaruhi individu umumnya wajib dapat dijelaskan.

Demo: Enam Fitur, Tiga yang Sejati #

Berkas permutation_demo.py melatih random forest pada data sintetis enam fitur — tiga informatif (pendapatan, durasi panggilan, jumlah komplain) dan tiga murni derau. Permutation importance mengukur tiap fitur dengan cara yang sederhana namun jujur: acak satu kolom pada data uji sehingga hubungannya dengan label putus, lalu catat berapa akurasi jatuh. Fitur yang penting membuat akurasi anjlok saat diacak; fitur derau tidak berpengaruh. Bagian kedua melatih decision tree kecil untuk meniru keluaran random forest — surrogate yang dapat dibaca manusia:

"""Interpretabilitas: permutation importance dan surrogate tree.

Model ensemble pada data sintetis enam fitur (tiga informatif, tiga
derau). Permutation importance mengukur penurunan akurasi ketika satu
fitur diacak; surrogate tree merangkum perilaku model menjadi aturan
pendek yang dapat dibaca manusia.
"""

import numpy as np
from sklearn.datasets import make_classification
from sklearn.ensemble import RandomForestClassifier
from sklearn.tree import DecisionTreeClassifier, export_text

X, y = make_classification(
    n_samples=1200, n_features=6, n_informative=3,
    n_redundant=0, shuffle=False, random_state=9)
nama_fitur = ["pendapatan", "durasi_panggilan", "jumlah_komplain",
              "derau_a", "derau_b", "derau_c"]

idx = np.random.default_rng(9).permutation(len(y))
X_latih, y_latih = X[idx[:800]], y[idx[:800]]
X_uji, y_uji = X[idx[800:]], y[idx[800:]]

model = RandomForestClassifier(n_estimators=200, random_state=9)
model.fit(X_latih, y_latih)
akurasi = model.score(X_uji, y_uji)
print(f"akurasi uji random forest: {akurasi:.3f}")

# ---------- 1. Permutation importance manual ----------
rng = np.random.default_rng(9)
ulang = 10
print()
print("===== PERMUTATION IMPORTANCE (penurunan akurasi) =====")
hasil = []
for j in range(X_uji.shape[1]):
    drop = []
    for _ in range(ulang):
        X_acak = X_uji.copy()
        X_acak[:, j] = rng.permutation(X_acak[:, j])
        drop.append(akurasi - model.score(X_acak, y_uji))
    hasil.append((float(np.mean(drop)), float(np.std(drop))))

urut = sorted(range(6), key=lambda j: -hasil[j][0])
for j in urut:
    rata, std = hasil[j]
    bar = "#" * max(0, int(round(rata * 100)))
    tanda = "informatif" if j < 3 else "derau"
    print(f"{nama_fitur[j]:18s} turun {rata:6.3f} +/- {std:5.3f}  "
          f"{bar:14s} [{tanda}]")

# ---------- 2. Surrogate decision tree ----------
pohon = DecisionTreeClassifier(max_depth=2, random_state=9)
pohon.fit(X_uji, model.predict(X_uji))  # meniru label model, bukan ground truth
kesesuaian = (pohon.predict(X_uji) == model.predict(X_uji)).mean()
print()
print("===== SURROGATE TREE (max_depth=2) =====")
print(f"kesesuaian surrogate vs random forest: {kesesuaian:.1%}")
print(export_text(pohon, feature_names=nama_fitur, decimals=2))

Output yang Dihasilkan:

akurasi uji random forest: 0.917

===== PERMUTATION IMPORTANCE (penurunan akurasi) =====
pendapatan         turun  0.190 +/- 0.016  ################### [informatif]
jumlah_komplain    turun  0.181 +/- 0.013  ################## [informatif]
durasi_panggilan   turun  0.161 +/- 0.015  ################ [informatif]
derau_b            turun  0.000 +/- 0.004                 [derau]
derau_a            turun -0.001 +/- 0.005                 [derau]
derau_c            turun -0.006 +/- 0.003                 [derau]

===== SURROGATE TREE (max_depth=2) =====
kesesuaian surrogate vs random forest: 90.2%
|--- jumlah_komplain <= -0.22
|   |--- durasi_panggilan <= 0.06
|   |   |--- class: 1
|   |--- durasi_panggilan >  0.06
|   |   |--- class: 0
|--- jumlah_komplain >  -0.22
|   |--- pendapatan <= 0.12
|   |   |--- class: 1
|   |--- pendapatan >  0.12
|   |   |--- class: 0

Contoh di atas diuji nyata dengan scikit-learn 1.5.2 pada CPU dan selesai dalam waktu di bawah dua detik; seluruh pengacakan memakai seed tetap. Mari kita telaah kode di atas baris per baris:

1. Baris 14-21 (data dan pembagian): make_classification dengan shuffle=False menempatkan tiga fitur informatif di awal; 800 baris untuk latih, 400 untuk uji, dan nama_fitur memberi nama domain supaya keluaran terbaca sebagai laporan bisnis, bukan indeks kolom.
2. Baris 24-26 (model): random forest 200 pohon mencapai akurasi 0,917 — model ensemble yang akurat sekaligus mustahil dibaca langsung, kandidat tepat untuk dijelaskan lewat teknik pasca-hoc.
3. Baris 34-41 (permutation importance): untuk tiap fitur, kolomnya diacak sepuluh kali; drop mencatat selisih akurasi sebelum-sesudah, dan rata-rata plus simpangan baku dikumpulkan — pengulangan penting karena satu kali acak bisa kebetulan.
4. Baris 43-49 (urutan dan batang): fitur diurut dari penurunan terbesar dengan batang # sepanjang penurunan; hasilnya tegas — tiga fitur informatif menjatuhkan akurasi 0,161-0,190, sedangkan ketiga fitur derau efektif nol (bahkan sedikit negatif karena derau pengacakan).
5. Baris 52-54 (surrogate tree): decision tree berkedalaman 2 dilatih memprediksi keluaran random forest — perhatikan model.predict(X_uji) sebagai target, bukan label asli; kesesuaian mengukur seberapa sering surrogate sepakat dengan model yang ditiru.
6. Baris 58 (cetak aturan): export_text menghasilkan empat aturan if-then yang merangkum perilaku model — pembaca non-teknis dapat memverifikasi bahwa aturan tersebut masuk akal secara domain.

Attention Bukan Penjelasan #

Untuk arsitektur transformer, godaan terbesar adalah membaca bobot attention sebagai penjelasan: “model memandang token ini saat menjawab”. Riset menunjukkan hubungan itu tidak dapat diandalkan — bobot attention dapat didistribusikan rata pada banyak token, alternatif distribusi berbeda bisa menghasilkan keluaran yang sama, dan penjelasan yang diturunkan dari attention sering bertentangan dengan penjelasan berbasis gradien pada contoh yang sama. Attention adalah bagian mekanisme komputasi, bukan laporan alasan; memakainya sebagai penjelasan risiko menyesatkan pembaca dan pemberi keputusan. Chapter Attention Mechanism membahas peran komputasinya tanpa klaim penjelasan.

Untuk penjelasan per-prediksi yang lebih teruji, dua keluarga teknik menjadi rujukan industri: LIME menyetel model linear lokal di sekitar satu prediksi, dan SHAP menghitung kontribusi tiap fitur dari teori permainan (dokumentasi SHAP ); keduanya dihitung dari perilaku model terhadap gangguan input, semacam permutation importance yang dipindahkan ke level satu sampel. scikit-learn sendiri menyediakan permutation importance siap pakai dengan antarmuka fit standar.

Interpretabilitas menjelaskan model satu per satu. Pertanyaan terakhir section ini naik satu level: bagaimana merancang keseluruhan sistem — data, model, proses, dan dokumen — agar dapat dipertanggungjawabkan secara utuh. Chapter berikutnya merangkai semua benang menjadi kerangka Responsible AI.