Model Inversion dan Data Leakage

Data leakage pada bab Data Leakage berarti informasi uji bocor ke training sehingga skor tergelembung. Bab ini membahas kebocoran yang arahnya berlawanan dan jauh lebih sensitif: data latih bocor keluar dari model yang sudah dilatih. Model yang terbiasa overfit menyimpan jejak anggotanya pada pola confidence, penyerang membaca jejak itu dari keluaran publik, dan pada kasus ekstrem model bahasa memuntahkan potongan data latihnya secara harfiah. Kita mendemonstrasikan membership inference dengan angka nyata — sebuah aturan tebakan satu baris yang mencapai 71% — lalu meninjau model inversion dan memorization LLM sebagai keluarganya.

Membership Inference: Menebak Keanggotaan #

Serangan membership inference (Shokri dkk., arXiv:1610.05820 ) menjawab satu pertanyaan sederhana: apakah rekaman data ini ikut melatih model? Penyerang tidak butuh akses internal — cukup keluaran confidence yang biasanya tersedia melalui API. Sinyalnya lahir dari mekanisme yang sudah kita kenal pada Overfitting dan Underfitting : model yang menghafal data latih memberi confidence nyaris sempurna pada anggota, sementara data yang tak pernah dilihatnya meninggalkan confidence lebih rendah.

Berkas membership_inference.py melatih MLP pada 150 rekaman sintetis 100 fitur (kapasitas jauh melebihi jumlah data — resep overfit klasik), lalu menyerang dengan aturan satu baris: tebak “anggota” bila confidence melewati titik tengah rata-rata kedua kelompok. Distribusi confidence per ember memperlihatkan pemisahannya, dan bagian akhir mengulang semuanya dengan regularisasi L2 yang kuat:

"""Membership inference: membedakan anggota data latih dari orang luar.

Model yang overfit memberi confidence lebih tinggi pada data yang
pernah dilatihnya. Penyerang hanya memakai keluaran confidence yang
bisa dibaca dari API publik untuk menebak keanggotaan. Regularisasi
menutup sebagian celah ini.
"""

import numpy as np
from sklearn.datasets import make_classification
from sklearn.neural_network import MLPClassifier

# 150 rekaman pertama melatih model ("anggota"),
# 150 rekaman berikutnya tidak pernah dilihat model ("bukan anggota")
X, y = make_classification(
    n_samples=1000, n_features=100, n_informative=8,
    n_redundant=5, class_sep=0.8, random_state=3)
n = 150
X_anggota, y_anggota = X[:n], y[:n]
X_luar, y_luar = X[500:500 + n], y[500:500 + n]

model = MLPClassifier(hidden_layer_sizes=(256, 256), alpha=1e-6,
                      max_iter=3000, random_state=3)
model.fit(X_anggota, y_anggota)
print(f"akurasi data latih : {model.score(X_anggota, y_anggota):.3f}")
print(f"akurasi data luar  : {model.score(X_luar, y_luar):.3f}")


def confidence(m, Xd):
    return m.predict_proba(Xd).max(axis=1)


conf_in = confidence(model, X_anggota)
conf_out = confidence(model, X_luar)
print()
print("===== CONFIDENCE: ANGGOTA VS BUKAN ANGGOTA =====")
print(f"rata-rata confidence anggota      : {conf_in.mean():.3f}")
print(f"rata-rata confidence bukan anggota: {conf_out.mean():.3f}")

# serangan: threshold sederhana pada confidence
ambang = (conf_in.mean() + conf_out.mean()) / 2
tebak = np.concatenate([conf_in >= ambang, conf_out >= ambang])
kebenaran = np.concatenate([np.ones(n, dtype=bool),
                            np.zeros(n, dtype=bool)])
akurasi_serangan = (tebak == kebenaran).mean()
print()
print("===== SERANGAN MEMBERSHIP INFERENCE =====")
print(f"aturan: tebak 'anggota' bila confidence >= {ambang:.3f}")
print(f"akurasi serangan: {akurasi_serangan:.1%} "
      f"(tebakan acak: 50.0%)")

# distribusi confidence per ember
print()
print("===== DISTRIBUSI CONFIDENCE PER EMBER =====")
print(f"{'rentang':>10s} {'anggota':>8s} {'bukan anggota':>13s}")
for lo in [0.5, 0.6, 0.7, 0.8, 0.9]:
    hi = lo + 0.1
    a = ((conf_in >= lo) & (conf_in < hi)).sum()
    b = ((conf_out >= lo) & (conf_out < hi)).sum()
    print(f"{lo:.1f}-{hi:.1f} {a:8d} {b:13d}")

# ---------- mitigasi: regularisasi kuat ----------
model_reg = MLPClassifier(hidden_layer_sizes=(256, 256), alpha=10.0,
                          max_iter=3000, random_state=3)
model_reg.fit(X_anggota, y_anggota)
conf_in_r = confidence(model_reg, X_anggota)
conf_out_r = confidence(model_reg, X_luar)
ambang_r = (conf_in_r.mean() + conf_out_r.mean()) / 2
tebak_r = np.concatenate([conf_in_r >= ambang_r,
                          conf_out_r >= ambang_r])
akurasi_serangan_r = (tebak_r == kebenaran).mean()
print()
print("===== MITIGASI: REGULARISASI L2 KUAT (alpha=10.0) =====")
print(f"akurasi data luar model teregularisasi : "
      f"{model_reg.score(X_luar, y_luar):.3f}")
print(f"rata-rata confidence anggota / luar    : "
      f"{conf_in_r.mean():.3f} / {conf_out_r.mean():.3f}")
print(f"akurasi serangan turun menjadi         : "
      f"{akurasi_serangan_r:.1%}")

Output yang Dihasilkan:

akurasi data latih : 1.000
akurasi data luar  : 0.707

===== CONFIDENCE: ANGGOTA VS BUKAN ANGGOTA =====
rata-rata confidence anggota      : 0.999
rata-rata confidence bukan anggota: 0.922

===== SERANGAN MEMBERSHIP INFERENCE =====
aturan: tebak 'anggota' bila confidence >= 0.961
akurasi serangan: 71.0% (tebakan acak: 50.0%)

===== DISTRIBUSI CONFIDENCE PER EMBER =====
   rentang  anggota bukan anggota
0.5-0.6        0             8
0.6-0.7        0             5
0.7-0.8        0             7
0.8-0.9        0            17
0.9-1.0      150           113

===== MITIGASI: REGULARISASI L2 KUAT (alpha=10.0) =====
akurasi data luar model teregularisasi : 0.747
rata-rata confidence anggota / luar    : 0.928 / 0.833
akurasi serangan turun menjadi         : 65.7%

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

1. Baris 15-20 (pembagian data): 150 rekaman pertama menjadi anggota training, 150 rekaman dari indeks 500 menjadi pembanding; keduanya berasal dari distribusi yang sama sehingga perbedaan confidence murni berasal dari ingatan model, bukan dari perbedaan data.
2. Baris 22-26 (model overfit): MLP dua lapisan 256 unit dengan alpha=1e-6 — hampir tanpa regularisasi; jurang akurasi 1,000 pada data latih versus 0,707 pada data luar adalah bahan bakar serangan.
3. Baris 29-34 (sinyal confidence): confidence mengambil probabilitas kelas tertinggi — nilai yang biasa dikembalikan API prediksi publik; rata-rata 0,999 untuk anggota versus 0,922 untuk orang luar.
4. Baris 41-49 (serangan threshold): ambang dipilih di titik tengah kedua rata-rata, tebakan dibandingkan kebenaran, dan hasilnya 71,0% — jauh di atas tebakan acak 50% untuk serangan yang hanya membaca keluaran publik.
5. Baris 56-60 (distribusi per ember): seluruh 150 anggota duduk di ember 0,9-1,0 sementara 37 orang luar tersebar di bawah 0,9 — pemisahan yang terlihat jelas pada tabel sederhana sekalipun.
6. Baris 63-78 (mitigasi regularisasi): MLP identik dengan alpha=10.0 menutup jurang confidence menjadi 0,928 versus 0,833; akurasi serangan turun ke 65,7% dan — bonus penting — akurasi data luar naik dari 0,707 ke 0,747.

Keluarga Serangan yang Lebih Dalam #

Model inversion bekerja lebih jauh lagi: dengan mengoptimasi input yang memaksimalkan keluaran model untuk satu kelas, penyerang merekonstruksi citra representatif kelas tersebut — pada kasus terkenal di literatur, wajah rata-rata dari data pelatihan pengenalan wajah dapat didekati ulang dari bobot model. Ancaman ini menjadi alasan data pelatihan wajah dan medis diperlakukan sebagai aset sensitif, dan mengapa Chapter Data Privacy menekankan differential privacy sejak desain dataset. Pada LLM, bentuk ketiganya adalah memorization: model bahasa yang dilatih pada korpus mengandung potongan teks yang diulang dapat memuntahkannya kembali secara harfiah, termasuk nomor telepon dan kunci akses yang lolos penyaringan — dibahas rinci pada Keterbatasan dan Risiko LLM .

Kebocoran dan keracunan sama-sama menyerang model dari luar jangkauan desain awalnya. Chapter berikutnya beralih ke kegagalan yang tidak butuh penyerang sama sekali: dunia yang bergeser perlahan sudah cukup untuk membuat akurasi runtuh.