Belajar AI #9: Klasifikasi — Logistic Regression dan Decision Tree

Episode penutup blok dasar-dasar machine learning klasik: klasifikasi. Kalau episode lalu model saya belajar menebak angka, sekarang dia belajar menebak kategori — spam atau bukan, churn atau tidak, foto kucing atau anjing. Dua algoritma yang saya pakai untuk latihan: logistic regression dan decision tree.

Klasifikasi itu memprediksi kategori

Bedakan dengan regresi (episode 8): output regresi adalah angka kontinu, output klasifikasi adalah kelas. Klasifikasi biner punya dua kelas; multiclass lebih dari dua. Tugasnya supervised — butuh data berlabel, seperti biasa.

Logistic regression: regresi yang dipaksa pilih kelas

Nama membingungkan — ada kata “regression” padahal ini algoritma klasifikasi. Logikanya begini: hitung dulu skor linear persis seperti linear regression, lalu masukkan skor itu ke fungsi sigmoid yang melengkung dari 0 ke 1. Hasilnya probabilitas. Di atas threshold (biasanya 0,5) → kelas positif; di bawah → negatif.

Fungsi sigmoid: jantung logistic regression

Rumus sigmoid: σ(z) = 1 / (1 + e^-z), di mana z = w₁x₁ + w₂x₂ + … + b. Analoginya seperti thermometer digital yang mengubah suhu mentah (z) menjadi angka 0 sampai 1. Apapun nilainya — negatif besar, nol, atau positif besar — output-nya selalu terkurung antara 0 dan 1. Titik tengah tepat di z = 0 menghasilkan 0,5, yaitu batas keputusan. Kita bisa membayangkan sigmoid seperti S-curve yang landai di tengah dan mendatar di kedua ujung — model hanya percaya diri pada ekstrem, ragu-ragu di tengah.

import numpy as np

def sigmoid(z):
    return 1 / (1 + np.exp(-z))

# Coba berbagai nilai input
for z in [-5, 0, 5]:
    print(f"sigmoid({z:>+3d}) = {sigmoid(z):.4f}")

# sigmoid( -5) = 0.0067  → hampir pasti kelas 0
# sigmoid(  0) = 0.5000  → titik keputusan
# sigmoid( +5) = 0.9933  → hampir pasti kelas 1

Cepat dan sederhana, cocok jadi baseline klasifikasi.
Output probabilitas — bisa disetel threshold-nya sesuai harga kesalahan (ingat precision vs recall di episode 7).
Batasan utama: asumsi hubungan yang bisa dipisahkan garis lurus. Data yang polanya melingkar atau rumit akan gagal meski fitur sudah di-scale.

Pitfall: multikolinearity

Logistic regression sensitif terhadap fitur yang saling berkorelasi tinggi (multikolinearity). Ketika dua fitur hampir identik, bobot model menjadi tidak stabil — koefisien bisa berubah drastis hanya dari penambahan sedikit data. Solusi praktis: periksa matriks korelasi sebelum training, atau pakai regularisasi (L1/L2) yang sudah tersedia di scikit-learn via parameter penalty. Ini hal yang saya abaikan di awal dan baru menyadari setelah hasil model berubah-ubah antar run.

Decision tree: serangkaian if-else yang belajar sendiri

Kalau logistic regression terasa asing, decision tree justru terasa familiar — strukturnya mirip flowchart if-else yang kita tulis tiap hari. Bedanya, pertanyaan-pertanyaan di tiap cabang (“apakah luas > 100?”, “apakah umur < 5 tahun?”) tidak ditulis manusia, tapi dicari otomatis dari data dengan mengukur pemisahan kelas terbaik di tiap titik.

Splitting criteria: Gini vs Entropy

Pertanyaan kuncinya: “fitur mana dan ambang berapa yang paling memurnikan data di tiap cabang?” Dua metrik utama untuk mengukur kemurnian (impurity) sebelum dan sesudah splitting:

Kriteria	Rumus	Karakteristik
Gini Impurity	1 − Σ(pᵢ²)	Default scikit-learn. Cepat dihitung, sensitif pada perubahan proporsi kelas besar.
Entropy (Information Gain)	− Σ(pᵢ log₂ pᵢ)	Dari teori informasi. Menghasilkan tree lebih seimbang, sedikit lebih lambat.

Dalam praktik, perbedaan keduanya jarang signifikan. Saya biasanya mulai dari Gini (default), lalu coba Entropy kalau hasilnya kurang memuaskan. Yang lebih penting daripada memilih criteria: membatasi kedalaman tree supaya tidak menghafal.

Sangat mudah dibaca — bisa digambar dan dijelaskan ke stakeholder.
Tidak butuh scaling — ambang batasnya per fitur, bukan jarak.
Risiko besar: overfitting — tree yang boleh tumbuh bebas akan menghafal data latih sampai daunnya cuma satu contoh. Penangkalnya: batasi kedalaman (max_depth) atau jumlah contoh minimum per daun.

Visualisasi tree

from sklearn.tree import export_text

tree_text = export_text(dt, feature_names=list(
    load_breast_cancer().feature_names
))
print(tree_text[:600])  # potongan tree sebagai aturan if-else

Fungsi export_text mencetak tree sebagai teks hirarkis yang bisa langsung dibaca — tidak perlu matplotlib. Ini sangat berguna ketika saya harus menjelaskan keputusan model ke tim non-teknis.

Random Forest: kekuatan kerumunan pohon

Decision tree tunggal punya masalah klasik: jika dibiarkan tumbuh bebas, ia menghafal data latih; jika dibatasi terlalu ketat, ia kehilangan kekuatan. Random Forest menjawab masalah ini dengan cara yang elegan — latih ratusan pohon kecil masing-masing dengan subset data dan fitur yang berbeda, lalu biarkan mereka “berdiskusi” melalui voting. Hasil akhir mengikuti mayoritas, sehingga noise dari satu pohon tertutup oleh konsensus yang lain.

from sklearn.ensemble import RandomForestClassifier
from sklearn.metrics import f1_score

rf = RandomForestClassifier(
    n_estimators=100, max_depth=6, random_state=42
).fit(X_train, y_train)

print("RF F1:", f1_score(y_test, rf.predict(X_test)))
# Biasanya mengalahkan single decision tree

Insight yang saya catat: n_estimators=100 sudah cukup untuk sebagian besar kasus. Menambah ke 500 atau 1000 meningkatkan akurasi tipis, tapi melipatgandakan waktu training. Trade-off yang perlu dipertimbangkan.

Evaluasi: confusion matrix dan kaitannya dengan precision-recall

Di episode 7 saya sudah membahas precision, recall, dan F1-score. Sekarang waktunya melihat dari mana angka-angka itu berasal — confusion matrix. Matriks 2×2 ini memecah prediksi menjadi empat kuadran: True Positive, True Negative, False Positive, dan False Negative. Semua metrik klasifikasi (precision, recall, F1, accuracy) adalah turunan dari keempat angka ini.

from sklearn.metrics import confusion_matrix, classification_report

y_pred = lr.predict(X_test)
print(confusion_matrix(y_test, y_pred))
print(classification_report(y_test, y_pred))

Saat saya pertama kali menjalankan classification_report dan melihat angka-angkanya sejajar rapi — precision, recall, f1, support — saya merasakan kepuasan yang aneh. Semua konsep abstrak yang saya baca selama berminggu-minggu akhirnya terwujud dalam tabel nyata. Itulah momen di mana teori terasa nyata.

Panduan praktis: kapan pakai mana?

Situasi	Pilihan	Alasan
Butuh baseline cepat	Logistic Regression	3 baris kode, hasil langsung bisa dipercaya.
Stakeholder minta penjelasan	Decision Tree	Rule-based, bisa divisualisasikan.
Data punya fitur non-linear kompleks	Random Forest	Menangkap interaksi antar fitur.
Butuh interpretasi + akurasi tinggi	Logistic + feature engineering	Kombinasi yang kuat dan transparan.
Dataset kecil (< 1000 baris)	Logistic Regression	Lebih stabil dari tree di data kecil.

Praktik: dua model, satu dataset

from sklearn.datasets import load_breast_cancer
from sklearn.model_selection import train_test_split
from sklearn.linear_model import LogisticRegression
from sklearn.tree import DecisionTreeClassifier
from sklearn.metrics import f1_score

X, y = load_breast_cancer(return_X_y=True)
X_train, X_test, y_train, y_test = train_test_split(
    X, y, test_size=0.25, random_state=42
)

lr = LogisticRegression(max_iter=5000).fit(X_train, y_train)
dt = DecisionTreeClassifier(max_depth=4, random_state=42).fit(
    X_train, y_train
)

print("LR F1:", f1_score(y_test, lr.predict(X_test)))
print("DT F1:", f1_score(y_test, dt.predict(X_test)))

Detail kecil yang saya pelajari cara susah: max_iter=5000 pada logistic regression karena default-nya kadang belum konvergen di dataset ini, dan max_depth=4 pada tree supaya tidak menghafal. Dua parameter kecil, dampak besar pada hasil evaluasi.

Pitfall: overfitting pada decision tree

Overfitting adalah musuh terbesar single decision tree. Gejalanya: akurasi training mendekati 100% tapi akurasi test jauh lebih rendah. Beberapa cara membatasi overfitting yang sudah saya coba: membatasi max_depth, menetapkan min_samples_leaf (minimal data di tiap daun), atau min_samples_split (minimal data sebelum splitting). Random Forest mengatasi overfitting secara inheren melalui bagging — jadi jika performa single tree kurang memuaskan, ensemble sering kali menjadi solusi yang tepat.

Catatan untuk diri sendiri

Hal pertama yang saya ingat dari episode ini: ketika pertama kali menjalankan logistic regression dan melihat model mengklasifikasikan tumor sebagai “malignant” atau “benign” dengan akurasi 96%, saya merasa seperti memiliki mesin kecil yang bisa membantu dokter mengambil keputusan. Meskipun jelas masih sangat jauh dari produksi medis nyata, momen itu membuat saya memahami potensi sebenarnya dari machine learning — bukan sekadar akademis, tapi bermanfaat.

Hal kedua: mulai selalu dari baseline sederhana sebelum menyentuh ensemble atau neural network — sering kali cukup, dan kalau tidak cukup, jadi tolok ukur. Ketiga, keluarga decision tree ternyata pintu masuk ke topik menarik berikutnya: random forest dan gradient boosting, yang rencananya akan saya bahas di episode mendatang. Blok dasar sudah selesai — setelah ini kita naik level.

Pos-pos Terbaru

Komentar Terbaru

Arsip

Kategori