Memahami Konsep Active Learning: Implementasi dengan ModAL untuk Model yang Belajar dari Sedikit Data

Memahami Konsep Active Learning dan Masalah Biaya Pelabelan Data

Dalam supervised learning konvensional, model membutuhkan dataset berlabel lengkap sebelum proses pelatihan dimulai. Setiap sampel harus dilabeli oleh manusia, dan biaya pelabelan ini sering menjadi penghambat terbesar dalam proyek machine learning di dunia nyata. Untuk domain seperti medis atau legal, melabeli satu sampel bisa membutuhkan keahlian khusus dan waktu yang lama. Akibatnya, membangun dataset besar secara manual menjadi tidak realistis.

Active learning menawarkan pendekatan yang berbeda. Konsep intinya adalah model memilih sendiri sampel mana yang paling informatif untuk diminta labelnya kepada oracle — istilah teknis untuk human annotator yang menyediakan label. Alih-alih melabeli ribuan sampel secara acak, kita hanya melabeli sampel yang benar-benar membantu model belajar. Perbedaan fundamental dengan passive learning terletak pada siapa yang mengontrol pemilihan data latih: dalam passive learning data dipilih sebelum model dilatih, sedangkan dalam active learning pemilihan terjadi secara iteratif berdasarkan kondisi model saat itu.

Ada tiga skenario utama dalam active learning. Membership query synthesis membuat model mensintesis sampel baru untuk ditanyakan ke oracle. Stream-based selective sampling memutuskan satu per satu apakah sampel yang datang perlu dilabeli. Skenario yang paling umum digunakan, termasuk dalam tulisan ini, adalah pool-based sampling: kita memiliki kumpulan besar data tanpa label dan memilih sebagian kecil darinya untuk dilabeli setiap iterasi. Hasilnya, model bisa mencapai akurasi tinggi dengan jauh lebih sedikit data berlabel dibandingkan pendekatan pasif.

Dalam praktiknya, penghematan yang dihasilkan cukup signifikan. Riset di berbagai domain menunjukkan bahwa active learning bisa memangkas kebutuhan data berlabel hingga 80-90% pada kondisi ideal, terutama saat distribusi kelas tidak seimbang. Penghematan ini bukan hanya soal biaya finansial, tetapi juga waktu. Sebuah tim annotator yang butuh dua minggu untuk melabeli dataset penuh bisa menyelesaikan tugas yang sama dalam beberapa hari ketika dibantu active learning. Inilah alasan utama teknik ini semakin banyak diadopsi di industri.

Strategi Query untuk Memilih Sampel Paling Informatif

Pertanyaan kunci dalam active learning adalah bagaimana menentukan sampel yang paling informatif. Strategi paling populer adalah uncertainty sampling: pilih sampel yang membuat model paling tidak yakin. Cara mengukur ketidakyakinan ada beberapa variasi. Least confidence mengambil sampel dengan probabilitas prediksi tertinggi paling rendah. Margin sampling mengambil sampel dengan selisih terkecil antara dua probabilitas tertinggi. Entropy menghitung ketidakpastian menyeluruh dari distribusi probabilitas.

Strategi lain yang menarik adalah query-by-committee. Pendekatan ini melatih beberapa model secara bersamaan, lalu memilih sampel dengan disagreement tertinggi antar model. Jika para model "berdebat" sengit tentang sebuah sampel, sampel itu pasti sulit dan layak dilabeli. Ada juga expected model change yang memilih sampel yang paling mengubah model jika dilabeli, serta diversity-based sampling yang memastikan sampel terpilih tidak saling mirip.

Praktik terbaik biasanya menggabungkan eksplorasi dan eksploitasi. Uncertainty sampling murni bisa terlalu "serakah" dan memilih sampel yang mirip satu sama lain. Kombinasi dengan diversity menjaga model tetap melihat variasi data. Semua strategi ini membutuhkan estimator yang menghasilkan probabilitas kelas, seperti predict_proba pada scikit-learn, sebagai bahan baku pengukuran ketidakyakinan.

Gambar: Visualisasi pool-based active learning. Panel kiri menunjukkan dataset penuh berlabel, panel kanan menunjukkan sebagian kecil observasi berlabel, unlabeled pool, dan decision boundary classifier. — Sumber: arXiv (Evidential Uncertainty Sampling for Active Learning)

Gambar: Area ketidakyakinan model pada dataset 2D. Semakin merah warnanya, semakin tinggi ketidakyakinan model terhadap observasi di titik tersebut. — Sumber: arXiv (Evidential Uncertainty Sampling for Active Learning)

Pemilihan strategi sebaiknya disesuaikan dengan karakteristik masalah. Untuk dataset dengan kelas yang cukup seimbang, uncertainty sampling biasanya sudah memadai dan murah secara komputasi. Untuk dataset dengan banyak kelas atau struktur yang kompleks, query-by-committee sering memberikan hasil lebih stabil meskipun biaya pelatihannya lebih besar karena harus melatih beberapa model sekaligus. Yang terpenting adalah menetapkan metrik evaluasi sebelum memulai, misalnya akurasi pada hold-out set, sehingga perbandingan antar strategi bisa dilakukan secara objektif.

Membangun Pipeline Active Learning dengan ModAL

ModAL adalah library Python yang menyediakan framework siap pakai untuk active learning. Kita akan mengimplementasikan pipeline-nya secara langsung. Pertama, instal dependensi yang dibutuhkan.

!pip install modAL scikit-learn

import numpy as np
from sklearn.datasets import make_classification
from sklearn.model_selection import train_test_split
from sklearn.linear_model import LogisticRegression
from modAL.models import ActiveLearner

np.random.seed(42)

# Buat dataset klasifikasi dengan fitur redundan
X, y = make_classification(n_samples=2000, n_features=8, n_informative=4, n_redundant=3, class_sep=1.5, random_state=42)

# Pisahkan pool berlabel awal yang kecil dan pool tanpa label yang besar
X_initial, X_pool, y_initial, y_pool = train_test_split(
    X, y, train_size=10, test_size=1990, random_state=42
)
X_pool, X_test, y_pool, y_test = train_test_split(
    X_pool, y_pool, test_size=500, random_state=42
)

# Inisialisasi ActiveLearner dengan estimator scikit-learn
learner = ActiveLearner(
    estimator=LogisticRegression(max_iter=2000),
    X_training=X_initial,
    y_training=y_initial,
)

# Siklus query-teach: minta label untuk sampel paling informatif
n_queries = 30
X_pool_copy = X_pool.copy()
y_pool_copy = y_pool.copy()
for i in range(n_queries):
    query_idx, query_instance = learner.query(X_pool_copy)
    learner.teach(X_pool_copy[query_idx].reshape(1, -1), y_pool_copy[query_idx].reshape(1,))
    X_pool_copy = np.delete(X_pool_copy, query_idx, axis=0)
    y_pool_copy = np.delete(y_pool_copy, query_idx, axis=0)
    acc = learner.score(X_test, y_test)
    print(f"Iterasi {i+1}: akurasi = {acc:.4f}")

Output:

Iterasi 1: akurasi = 0.7080
Iterasi 2: akurasi = 0.7120
Iterasi 3: akurasi = 0.6660
Iterasi 4: akurasi = 0.7500
Iterasi 5: akurasi = 0.7540
Iterasi 6: akurasi = 0.8060
Iterasi 7: akurasi = 0.7780
Iterasi 8: akurasi = 0.7520
Iterasi 9: akurasi = 0.7780
Iterasi 10: akurasi = 0.7660
Iterasi 11: akurasi = 0.7900
Iterasi 12: akurasi = 0.7740
Iterasi 13: akurasi = 0.7780
Iterasi 14: akurasi = 0.8140
Iterasi 15: akurasi = 0.8160
Iterasi 16: akurasi = 0.8120
Iterasi 17: akurasi = 0.8120
Iterasi 18: akurasi = 0.8000
Iterasi 19: akurasi = 0.8000
Iterasi 20: akurasi = 0.7820
Iterasi 21: akurasi = 0.8060
Iterasi 22: akurasi = 0.8140
Iterasi 23: akurasi = 0.8100
Iterasi 24: akurasi = 0.8220
Iterasi 25: akurasi = 0.8160
Iterasi 26: akurasi = 0.8100
Iterasi 27: akurasi = 0.8220
Iterasi 28: akurasi = 0.8200
Iterasi 29: akurasi = 0.8140
Iterasi 30: akurasi = 0.8160

Alur kerja kode di atas mengikuti pola yang konsisten. ActiveLearner dibungkus di sekitar estimator scikit-learn dan dilatih dengan 10 sampel awal. Setiap iterasi, metode query() memilih indeks sampel paling informatif dari pool. Sampel itu dilabeli dan diberikan kembali melalui teach(), lalu dihapus dari pool agar tidak terpilih lagi. Kita hanya menggunakan 40 sampel berlabel total untuk mencapai akurasi di atas 0.8 pada data test — bukti bahwa active learning bekerja sangat efisien.

Perhatikan bahwa pemilihan sampel tidak pernah berulang pada data yang sama karena setiap sampel terpilih langsung dikeluarkan dari pool. Ini menjaga setiap label baru memberikan informasi tambahan. Pola query-teach ini bisa kita jadikan fungsi utilitas yang menerima pool dan budget pelabelan sebagai parameter, sehingga mudah digunakan ulang untuk dataset lain. ModAL juga mendukung strategi query yang berbeda hanya dengan mengganti argumen saat inisialisasi, misalnya menggunakan QueryStrategy khusus untuk committee-based query.

Mengevaluasi Kurva Pembelajaran: Active Learning vs Passive Learning

Untuk membuktikan keunggulan active learning, kita perlu membandingkannya dengan baseline passive learning. Pada pendekatan pasif, sampel dipilih secara acak dengan jumlah yang sama. Jika keduanya mencapai akurasi yang setara, active learning tidak membawa nilai tambah. Perbandingan ini divisualisasikan dalam kurva pembelajaran.

!pip install matplotlib modAL scikit-learn

import matplotlib.pyplot as plt
import numpy as np
from modAL.models import ActiveLearner
from sklearn.linear_model import LogisticRegression

np.random.seed(42)

# --- Baseline: passive learning dengan sampling acak ---
passive_accs = []
n_initial = 10
n_queries = 30
labels_total = n_initial + n_queries

for trial in range(7):
    np.random.seed(100 + trial)
    idx = np.random.choice(len(X_pool), size=labels_total, replace=False)
    X_passive = np.concatenate([X_initial, X_pool[idx]])
    y_passive = np.concatenate([y_initial, y_pool[idx]])
    model = LogisticRegression(max_iter=2000)
    model.fit(X_passive, y_passive)
    passive_accs.append(model.score(X_test, y_test))

passive_mean = np.mean(passive_accs)
passive_std = np.std(passive_accs)
print(f"Passive learning (acak, {labels_total} label): akurasi = {passive_mean:.4f} ± {passive_std:.4f}")

# --- Active learning: siklus penuh pada salinan pool sendiri ---
learner = ActiveLearner(
    estimator=LogisticRegression(max_iter=2000),
    X_training=X_initial,
    y_training=y_initial,
)
X_pool_copy = X_pool.copy()
y_pool_copy = y_pool.copy()
active_accs = [learner.score(X_test, y_test)]

for _ in range(n_queries):
    query_idx, _ = learner.query(X_pool_copy)
    learner.teach(X_pool_copy[query_idx].reshape(1, -1), y_pool_copy[query_idx].reshape(1,))
    X_pool_copy = np.delete(X_pool_copy, query_idx, axis=0)
    y_pool_copy = np.delete(y_pool_copy, query_idx, axis=0)
    active_accs.append(learner.score(X_test, y_test))

# --- Plot kurva pembelajaran ---
plt.figure(figsize=(8, 5))
plt.plot(range(n_initial, labels_total + 1), active_accs, marker="o", label="Active Learning")
plt.axhline(y=passive_mean, color="red", linestyle="--", label=f"Passive Learning ({passive_mean:.3f})")
plt.fill_between(range(n_initial, labels_total + 1), passive_mean - passive_std, passive_mean + passive_std, color="red", alpha=0.1)
plt.xlabel("Jumlah Data Berlabel")
plt.ylabel("Akurasi")
plt.title("Kurva Pembelajaran: Active vs Passive Learning")
plt.legend()
plt.grid(alpha=0.3)
plt.tight_layout()
plt.savefig("public/images/blog/memahami-konsep-active-learning-implementasi-dengan-modal-untuk-model-yang-belajar-dari-sedikit-data-output-1.png", dpi=100)
plt.show()

Output:

Passive learning (acak, 40 label): akurasi = 0.7391 ± 0.0296

Kurva di atas menunjukkan pola yang khas: garis active learning lebih curam di awal karena setiap sampel yang dilabeli memberikan informasi maksimal. Dengan 40 label yang sama, active learning mencapai sekitar 0.816 sedangkan passive learning hanya sekitar 0.739. Selisih ini melebar ketika jumlah label masih sedikit dan menyempit seiring bertambahnya data. Untuk perbandingan yang adil, kita harus menggunakan seed dan split data yang sama untuk kedua pendekatan, seperti yang dilakukan pada kode di atas.

Kapan Active Learning Tepat Digunakan dan Keterbatasannya

Active learning memberikan nilai terbesar ketika biaya pelabelan tinggi dan data tanpa label melimpah. Contoh nyata ada pada diagnosis medis, analisis dokumen legal, dan anotasi teks NLP yang membutuhkan annotator berpengalaman. Di sisi lain, active learning kurang bermanfaat jika pelabelan murah dan cepat, atau ketika dataset berlabel sudah cukup besar untuk kebutuhan model.

Ada beberapa keterbatasan yang perlu diperhatikan. Pertama, oracle yang tidak konsisten bisa memasukkan noise ke dalam label. Kedua, distribution shift antar batch query dapat membuat model salah arah jika pool berubah seiring waktu. Ketiga, masalah cold start muncul ketika semua sampel di pool tampak mirip, sehingga strategi query kesulitan membedakan mana yang informatif.

Praktik yang disarankan: mulai dengan sampel awal yang representatif, kombinasikan strategi uncertainty dengan diversity, dan evaluasi performa model setiap siklus. Dengan disiplin ini, active learning menjadi alat yang andal untuk membangun model dengan anggaran pelabelan yang terbatas.

Ingin mendalami machine learning dari dasar hingga implementasi nyata? Bergabunglah dengan program Data Science di Rumah Coding, tempat kita membangun model sungguhan dengan pendekatan praktis dan mentor yang siap membimbing.