02 — Supervised Classification

Estimasi: 5 jam Tujuan: Kuasai 5 algoritma klasifikasi paling umum dan kapan pakai mana.

Kenapa Materi Ini Penting?

Klasifikasi adalah tulang punggung 80% aplikasi ML di dunia nyata. Spam filter, deteksi fraud, diagnosa medis, rekomendasi produk, sentiment analysis — semuanya klasifikasi. Di bootcamp Dicoding nanti, kamu akan diuji kemampuan memilih algoritma yang tepat untuk masalah tertentu, bukan cuma tahu cara pakainya.

Setiap algoritma punya "kepribadian" sendiri. Logistic Regression cepat tapi linear, Random Forest powerful tapi kurang interpretable, KNN intuitif tapi lambat di prediksi. Memahami strength dan weakness tiap algoritma akan membuat kamu jadi engineer yang bisa berargumen kenapa pilih satu vs yang lain. Ini bedanya engineer junior (asal pakai) vs senior (paham trade-off).

Cara Membaca Diagram:

Tiap diamond = pertanyaan keputusan
Tiap leaf = rekomendasi algoritma
Path dari atas ke bawah = jalur pengambilan keputusan

Walkthrough Step-by-Step:

Mulai dari "Classification Problem"
Pertama, cek tipe data: tabular vs text vs image
Kalau tabular, lanjut ke ukuran dataset (kecil/medium/besar)
Pilih algoritma sesuai branch terakhir

Analogi Sehari-hari: Mirip resep masak — bahan apa? Berapa porsi? Lalu pilih wajan atau panci. Tidak satu algoritma yang cocok untuk semua situasi.

Diagram statis Mermaid sebagai fallback:

flowchart TD
    A["🎯 Classification<br/>Problem"] --> B{"Tipe data?"}
    B -->|Tabular| C{"Dataset size?"}
    B -->|Text| D["Naive Bayes<br/>atau Logistic"]
    B -->|Image| E["Deep Learning<br/>(Fase 6)"]
    C -->|Kecil| F["Logistic Regression<br/>atau Decision Tree"]
    C -->|Medium| G["Random Forest"]
    C -->|Besar| H["XGBoost / LightGBM"]
    F --> I{"Butuh<br/>interpretable?"}
    I -->|Ya| J["Decision Tree"]
    I -->|Tidak| K["KNN / SVM"]

Bagian 1 — Logistic Regression

Despite namanya "regression", ini classifier.

Analogi: Garis Batas Keputusan

Bayangkan ada dua kelompok titik di lapangan: tim merah dan tim biru. Logistic Regression = mencari garis lurus terbaik yang memisahkan kedua tim. Titik baru jatuh di sebelah mana garis? Itulah prediksinya. Output bukan cuma "merah" atau "biru" tapi probabilitas (e.g., 85% merah, 15% biru) lewat fungsi sigmoid.

Cara Membaca Diagram:

Kiri ke kanan: alur transformasi feature → probabilitas → kelas
Sigmoid mengubah angka tak terbatas (z) menjadi probabilitas [0, 1]
Threshold default 0.5

Walkthrough Step-by-Step:

Input feature x₁, x₂, ...
Hitung linear combination z = w·x + b
Apply sigmoid σ(z) = 1/(1+e⁻ᶻ) → probabilitas 0-1
Bandingkan dengan threshold (0.5 default)
0.5 → class 1, ≤ 0.5 → class 0

Analogi Sehari-hari: Kamu di dapur, bumbu mentah (feature) dicampur (linear), dipanaskan (sigmoid), keluar matang dengan tingkat kematangan 0-100% (probabilitas). Threshold = "kalau matang > 50% sajikan, kalau tidak masak lagi".

Diagram statis Mermaid sebagai fallback:

flowchart LR
    A["📥 Input<br/>x₁, x₂, ..."] --> B["⚖️ Linear:<br/>w·x + b"]
    B --> C["📈 Sigmoid<br/>1/(1+e⁻ᶻ)"]
    C --> D["🎯 Probabilitas<br/>0-1"]
    D --> E{"P > 0.5?"}
    E -->|Ya| F["Class 1"]
    E -->|Tidak| G["Class 0"]

Konsep

Hitung probabilitas pakai sigmoid:

P(class=1) = 1 / (1 + e^(-(w·x + b)))

Kalau P > 0.5 → class 1, else class 0.

Pakai

from sklearn.linear_model import LogisticRegression
from sklearn.datasets import load_iris
from sklearn.model_selection import train_test_split
from sklearn.preprocessing import StandardScaler

# Load data
iris = load_iris()
X, y = iris.data, iris.target

# Split + scale (Logistic butuh scaling)
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)
scaler = StandardScaler()
X_train_s = scaler.fit_transform(X_train)
X_test_s = scaler.transform(X_test)

# Train + predict
model = LogisticRegression(max_iter=1000)
model.fit(X_train_s, y_train)

y_pred = model.predict(X_test_s)
y_proba = model.predict_proba(X_test_s)    # probabilitas tiap class
print(f"Accuracy: {model.score(X_test_s, y_test):.4f}")

# Coefficient (untuk interpretation)
print(model.coef_)
print(model.intercept_)

Hyperparameter

C — regularization (kebalikan strength). Kecil = strong reg.
penalty — "l1", "l2", "elasticnet"
solver — "lbfgs" (default), "liblinear", "saga"

Pros

Cepat
Interpretable (coef = importance)
Probabilitas reliable
Baseline yang baik

Cons

Hanya linear boundary
Sensitive ke outlier
Butuh feature scaling

Bagian 2 — Decision Tree

Tree of if-else.

Analogi: Diagram Pohon Keputusan Dokter

Saat dokter mendiagnosa, dia tanya bertahap: "Demam? Batuk? Sesak nafas?" Tiap jawaban mempersempit kemungkinan diagnosa. Decision Tree persis sama. Mulai dari root (pertanyaan paling diskriminatif), turun ke leaf (kelas final). Algoritma otomatis pilih pertanyaan terbaik di tiap node berdasarkan gini impurity atau entropy.

Cara Membaca Diagram:

Atas (root): pertanyaan pertama, paling diskriminatif
Diamond = decision node (pertanyaan)
Box = leaf (kelas/diagnosa final)

Walkthrough Step-by-Step:

Mulai dari root: "Demam > 38°C?"
Ya → tanya "Batuk?"; Tidak → diagnosa "Sehat"
Lanjut ke node berikutnya sampai sampai leaf
Leaf = prediksi akhir

Analogi Sehari-hari: Game 20 pertanyaan. Tiap pertanyaan mempersempit kemungkinan. Pertanyaan pertama adalah yang paling memilah opsi (kategori, bukan detail).

Diagram statis Mermaid sebagai fallback:

flowchart TD
    A{"🩺 Demam > 38°C?"} -->|Ya| B{"😷 Batuk?"}
    A -->|Tidak| C["✅ Sehat"]
    B -->|Ya| D{"🫁 Sesak?"}
    B -->|Tidak| E["🤒 Flu Biasa"]
    D -->|Ya| F["🦠 Infeksi Berat"]
    D -->|Tidak| G["🤧 Flu"]
    style C fill:#d4f4dd
    style E fill:#d4f4dd
    style F fill:#ffd4d4
    style G fill:#fff4d4

            [Age > 30?]
            /          \
          Yes          No
          /              \
   [Income > 50k?]    [Class A]
   /         \
 Yes          No
 /              \
[Class B]     [Class C]

Pakai

from sklearn.tree import DecisionTreeClassifier
from sklearn.datasets import load_iris
from sklearn.model_selection import train_test_split

iris = load_iris()
X, y = iris.data, iris.target
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)

model = DecisionTreeClassifier(max_depth=5, random_state=42)
model.fit(X_train, y_train)
print(f"Accuracy: {model.score(X_test, y_test):.4f}")

Hyperparameter

max_depth — max kedalaman tree. Limit untuk hindari overfitting.
min_samples_split — min sample untuk split node
min_samples_leaf — min sample di leaf
criterion — "gini" or "entropy"

Visualisasi (Bonus, Powerful)

from sklearn.tree import plot_tree
import matplotlib.pyplot as plt

fig, ax = plt.subplots(figsize=(20, 10))
plot_tree(model, feature_names=X.columns, class_names=["A", "B"], filled=True, ax=ax)
plt.show()

Pros

Sangat interpretable
Tidak butuh scaling
Handle missing data
Non-linear

Cons

Easily overfit
Unstable (small change in data → different tree)

Bagian 3 — Random Forest

Ensemble dari banyak decision tree. Sangat populer untuk tabular data.

Analogi: Panel Banyak Ahli Voting

Mau diagnosis penyakit serius? Jangan tanya 1 dokter — tanya 100 dokter, lalu ambil suara terbanyak. Tiap dokter punya bias dan blind spot. Tapi rata-rata suara 100 dokter biasanya sangat akurat. Random Forest = panel 100 decision tree. Tiap tree dilatih dari subset random data dan subset random feature, jadi mereka punya "perspektif" beda. Voting mayoritas = prediksi akhir.

Cara Membaca Diagram:

Atas: training data tunggal
Tengah: bootstrap (sampling dengan replacement) menghasilkan N subset berbeda
Tiap subset → train 1 tree independen
Bawah: majority vote dari semua tree → prediksi final

Walkthrough Step-by-Step:

Bootstrap sample: ambil N sample acak dengan replacement dari training data
Tiap tree ke-i dilatih hanya dengan subset-i (dan subset feature random)
Tree-tree saling independen, bisa di-train paralel
Saat predict, tiap tree kasih prediksi → mayoritas menang

Analogi Sehari-hari: Wisdom of crowd. Tanya 100 orang berapa permen di toples — rata-rata jawaban biasanya jauh lebih akurat dari satu jawaban individual.

Diagram statis Mermaid sebagai fallback:

flowchart TD
    A["📦 Training Data"] --> B1["🎲 Bootstrap<br/>Sample 1"]
    A --> B2["🎲 Bootstrap<br/>Sample 2"]
    A --> B3["🎲 ..."]
    A --> B4["🎲 Bootstrap<br/>Sample N"]
    B1 --> C1["🌳 Tree 1"]
    B2 --> C2["🌳 Tree 2"]
    B3 --> C3["🌳 ..."]
    B4 --> C4["🌳 Tree N"]
    C1 --> D["🗳️ Majority<br/>Vote"]
    C2 --> D
    C3 --> D
    C4 --> D
    D --> E["🎯 Final<br/>Prediction"]

Konsep

Bikin N tree (e.g. 100)
Tiap tree dilatih di subset random data (bagging)
Tiap split pakai subset random feature
Predict = majority vote dari semua tree

Pakai

from sklearn.ensemble import RandomForestClassifier
from sklearn.datasets import load_breast_cancer
from sklearn.model_selection import train_test_split
import pandas as pd

# Load dataset
data = load_breast_cancer()
X = pd.DataFrame(data.data, columns=data.feature_names)
y = data.target

X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42, stratify=y)

model = RandomForestClassifier(
    n_estimators=100,
    max_depth=20,
    random_state=42,
    n_jobs=-1                # parallelize
)
model.fit(X_train, y_train)
print(f"Accuracy: {model.score(X_test, y_test):.4f}")

# Feature importance
importances = pd.Series(model.feature_importances_, index=X.columns)
importances.sort_values(ascending=False).head(10).plot.barh()

Pros

High accuracy out-of-box
Robust ke overfitting
Feature importance
Handle non-linear

Cons

Lebih lambat dari single tree
Less interpretable
Kurang baik untuk extrapolation (prediksi di luar range training)

Bagian 4 — Gradient Boosting (XGBoost, LightGBM)

Ensemble sequential — tiap tree fix kesalahan tree sebelumnya. Paling akurat untuk tabular data.

Analogi: Tim Belajar Bertahap dari Kesalahan

Random Forest = 100 dokter independen voting. Gradient Boosting = 100 dokter yang belajar berurutan. Dokter ke-2 belajar dari kasus yang dokter ke-1 salah diagnosa. Dokter ke-3 belajar dari kasus yang gabungan dokter 1+2 masih salah. Tiap iterasi, model fokus ke residual error sebelumnya. Hasilnya jauh lebih akurat dari single model atau bagging.

flowchart LR
    A["📥 Data"] --> B["🌳 Tree 1<br/>(prediksi awal)"]
    B --> C["📊 Hitung<br/>residual"]
    C --> D["🌳 Tree 2<br/>(fix kesalahan)"]
    D --> E["📊 Residual<br/>baru"]
    E --> F["🌳 Tree 3<br/>(fix lagi)"]
    F --> G["..."]
    G --> H["🎯 Sum semua<br/>tree → final"]
    style H fill:#d4f4dd

XGBoost

# pip install xgboost
import xgboost as xgb

model = xgb.XGBClassifier(
    n_estimators=200,
    max_depth=6,
    learning_rate=0.1,
    random_state=42,
)
model.fit(X_train, y_train)

LightGBM (Lebih Cepat)

# pip install lightgbm
import lightgbm as lgb

model = lgb.LGBMClassifier(
    n_estimators=200,
    max_depth=6,
    learning_rate=0.1,
    random_state=42,
)
model.fit(X_train, y_train)

Hyperparameter Penting

n_estimators — jumlah tree
max_depth — depth tiap tree
learning_rate — step size update
subsample — fraction sample tiap tree
colsample_bytree — fraction feature

Pros

State-of-the-art untuk tabular
Handle missing value
Fast (LightGBM especially)
Feature importance

Cons

Banyak hyperparameter
Bisa overfit kalau tidak di-tune

Insight: banyak Kaggle kompetisi tabular dimenangkan XGBoost atau LightGBM. Wajib paham.

Bagian 5 — K-Nearest Neighbors (KNN)

Lazy learning — tidak ada training, just hafalkan data.

Analogi: "Katakan Padaku Siapa Tetanggamu, Kuberitahu Siapa Kamu"

Pepatah lama: "Tell me who your friends are, and I'll tell you who you are." KNN persis itu. Mau tahu kelas titik baru? Cek 5 (atau K) tetangga terdekat. Mayoritas kelas mereka = kelasmu. Tidak ada model yang dilatih, semua data disimpan dan dipakai saat prediksi.

Cara Membaca Diagram:

Kiri: titik baru yang mau di-predict
Tengah: hitung jarak ke semua training points → pilih K terdekat
Kanan: voting kelas dari K tetangga → mayoritas = prediksi

Walkthrough Step-by-Step:

Tidak ada training (lazy learning) — data disimpan apa adanya
Saat predict, hitung jarak (Euclidean) titik baru ke SEMUA training points
Pilih K titik dengan jarak terkecil (default K=5)
Hitung suara kelas tiap tetangga
Mayoritas kelas → prediksi

Analogi Sehari-hari: Pindah kos baru, mau tahu suasana lingkungan. Tanya 5 tetangga terdekat, mayoritas bilang "ramah" — kemungkinan besar memang ramah.

Diagram statis Mermaid sebagai fallback:

flowchart TD
    A["❓ Titik baru"] --> B["📏 Hitung jarak<br/>ke semua titik"]
    B --> C["🔍 Pilih K terdekat<br/>(misal K=5)"]
    C --> D["🗳️ Hitung suara<br/>per kelas"]
    D --> E["🎯 Mayoritas =<br/>prediksi"]
    style A fill:#fff4d4
    style E fill:#d4f4dd

Konsep

Prediksi class titik baru = majority class dari K tetangga terdekat di training set.

Pakai

from sklearn.neighbors import KNeighborsClassifier
from sklearn.preprocessing import StandardScaler
from sklearn.datasets import load_iris
from sklearn.model_selection import train_test_split

iris = load_iris()
X_train, X_test, y_train, y_test = train_test_split(
    iris.data, iris.target, test_size=0.2, random_state=42, stratify=iris.target
)

# WAJIB scale untuk KNN
scaler = StandardScaler()
X_train_s = scaler.fit_transform(X_train)
X_test_s = scaler.transform(X_test)

model = KNeighborsClassifier(n_neighbors=5)
model.fit(X_train_s, y_train)
print(f"Accuracy: {model.score(X_test_s, y_test):.4f}")

Hyperparameter

n_neighbors (K) — biasanya 5-20
weights — "uniform" or "distance" (closer = more weight)
metric — "euclidean", "manhattan", "minkowski"

Tips

Scale features — KNN sensitif ke scale
K kecil → high variance (overfit)
K besar → high bias (underfit)
Pakai cross-validation untuk pilih K

Pros

Sangat simple
No training time
Bisa multi-class natural
Conceptually intuitif

Cons

Slow predict (cek semua training points)
Curse of dimensionality (kurang baik di high-dim)
Sensitive ke scale & outliers
Banyak memory

Bagian 6 — Support Vector Machine (SVM)

Cari hyperplane yang maksimalkan margin antar class.

Analogi: Mencari Pagar Paling Jauh dari Kedua Kelompok

Bayangkan kamu mau bangun pagar di antara 2 kelompok rumah (merah & biru). Pagarnya banyak pilihan, tapi pagar paling baik adalah yang paling jauh dari rumah terdekat di kedua sisi. Kalau ada rumah baru, prediksi warnanya = sisi mana dari pagar. SVM mencari hyperplane (garis di 2D, plane di 3D, hyperplane di nD) dengan margin maksimal ke "support vector" (titik terdekat).

flowchart LR
    A["📥 Data 2 kelas"] --> B["🔍 Cari hyperplane<br/>terbaik"]
    B --> C{"Linearly<br/>separable?"}
    C -->|Ya| D["📏 Linear kernel"]
    C -->|Tidak| E["🌀 Kernel trick<br/>(map ke high-dim)"]
    E --> F["📐 RBF / Poly<br/>kernel"]
    D --> G["🎯 Maksimalkan<br/>margin"]
    F --> G
    G --> H["✅ Support vector<br/>menentukan boundary"]

Konsep

   Class A           Class B
     o   o    │    x   x
       o     │      x
   o      o  │ x  x
            ↑
          margin (mau dimaksimalkan)

Pakai

from sklearn.svm import SVC

model = SVC(kernel="rbf", C=1.0, random_state=42)
model.fit(X_train, y_train)

Kernel Trick

Kalau data tidak linearly separable, map ke higher dimension dengan kernel:

linear — boundary lurus
poly — polinomial
rbf — radial basis function (paling populer)
sigmoid — mirip neural network

Hyperparameter

C — regularization. Kecil = wider margin (underfit risk), besar = narrow (overfit risk)
kernel — pilih kernel
gamma — untuk rbf/poly. Kecil = smooth boundary, besar = complex

Pros

Powerful, bisa handle non-linear (kernel)
Robust ke outlier (margin-based)
Bagus untuk high-dim

Cons

Sangat lambat untuk dataset besar (>100k)
Banyak hyperparameter
Less interpretable
Butuh scaling

Bagian 7 — Naive Bayes

Klasifikasi berbasis Bayes' theorem dengan asumsi independence.

Pakai

from sklearn.naive_bayes import GaussianNB, MultinomialNB

# Untuk numeric
model = GaussianNB()

# Untuk text/count data
model = MultinomialNB()

model.fit(X_train, y_train)

Pros

Sangat cepat
Bagus untuk text classification (spam, sentiment)
Robust ke fitur tidak relevan
Butuh sedikit data

Cons

Asumsi independence sering tidak realistic
Kurang akurat dari model modern

Bagian 8 — Decision Tree per Algoritma

Tabel Komparasi Lengkap

Algoritma	Speed Train	Speed Predict	Interpretable	Akurasi Tabular	Butuh Scaling?	Best For
Logistic Regression	⚡⚡⚡	⚡⚡⚡	✅✅✅	⭐⭐	Ya	Baseline, linear problem
Decision Tree	⚡⚡	⚡⚡⚡	✅✅✅	⭐⭐	Tidak	Interpretable, simple rules
Random Forest	⚡	⚡⚡	✅	⭐⭐⭐⭐	Tidak	Default tabular
XGBoost / LightGBM	⚡	⚡⚡	✅	⭐⭐⭐⭐⭐	Tidak	Kaggle, top accuracy
KNN	⚡⚡⚡	⚡	✅✅	⭐⭐⭐	Ya	Dataset kecil, simple
SVM	🐌	⚡⚡	❌	⭐⭐⭐	Ya	High-dim, dataset kecil
Naive Bayes	⚡⚡⚡	⚡⚡⚡	✅✅	⭐⭐	Tidak	Text classification

Decision Tree Pemilihan Algoritma

flowchart TD
    A["🎯 Mulai dari masalah"] --> B{"Dataset size?"}
    B -->|< 10k rows| C{"Butuh<br/>interpretable?"}
    B -->|10k-1M| D["🌲 Random Forest"]
    B -->|> 1M| E["⚡ LightGBM<br/>(memory efficient)"]
    C -->|Ya| F["🌳 Decision Tree<br/>atau Logistic"]
    C -->|Tidak| G["🌲 Random Forest<br/>atau KNN"]
    D --> H{"Mau push<br/>akurasi max?"}
    H -->|Ya| I["🚀 XGBoost +<br/>tune hyperparam"]
    H -->|Cukup| D

Cheat Sheet: Situasi → Algoritma

Situasi	Algoritma
Baseline cepat	Logistic Regression
Dataset tabular medium-besar	Random Forest
Mau win Kaggle	XGBoost / LightGBM
Dataset kecil + butuh interpretable	Decision Tree
Text classification	Naive Bayes / Logistic
Image / kompleks	Deep Learning (Fase 6)
Dataset kecil + non-linear	SVM

Bagian 9 — Best Practice

Selalu Mulai dari Baseline

# 1. Baseline: predict majority class
from sklearn.dummy import DummyClassifier
baseline = DummyClassifier(strategy="most_frequent")

# 2. Simple model
logistic = LogisticRegression()

# 3. Powerful model
rf = RandomForestClassifier()

# Kalau RF cuma sedikit lebih bagus dari baseline, ada masalah dengan data, bukan model.

Compare Banyak Model Cepat

from sklearn.ensemble import RandomForestClassifier, GradientBoostingClassifier
from sklearn.linear_model import LogisticRegression
from sklearn.neighbors import KNeighborsClassifier
from sklearn.svm import SVC
from sklearn.model_selection import cross_val_score

models = {
    "Logistic": LogisticRegression(max_iter=1000),
    "KNN": KNeighborsClassifier(),
    "RF": RandomForestClassifier(random_state=42),
    "GB": GradientBoostingClassifier(random_state=42),
    "SVM": SVC(),
}

for name, model in models.items():
    scores = cross_val_score(model, X, y, cv=5, scoring="f1")
    print(f"{name:15s} F1: {scores.mean():.4f} ± {scores.std():.4f}")

Common Mistakes & FAQ

Common Mistakes

flowchart TD
    A["⚠️ Common Mistakes"] --> B["📏 Lupa scaling<br/>untuk KNN/SVM/Logistic"]
    A --> C["⚖️ Imbalanced data<br/>tidak di-handle"]
    A --> D["🎯 Tune di test set"]
    A --> E["💧 Data leakage<br/>(target encoding)"]
    A --> F["📊 Cuma lihat accuracy<br/>untuk imbalanced"]
    style A fill:#ffe0e0

1. Lupa Scaling

KNN, SVM, Logistic Regression sangat sensitif ke skala. Feature dengan range besar (gaji jutaan) mendominasi feature kecil (umur). Tree-based (RF, XGBoost) tidak butuh scaling.

2. Imbalanced Class Diabaikan

Kalau 99% non-fraud, 1% fraud — model predict semua "non-fraud" dapat 99% accuracy. Useless.

✅ Pakai class_weight="balanced", SMOTE, atau lihat F1/AUC bukan accuracy.

3. Data Leakage di Target Encoding

Kalau hitung target mean dari seluruh data sebelum split, info dari test bocor ke train. Selalu hitung di train fold saja.

4. Random Forest "Cukup" untuk Semua

Banyak yang langsung loncat ke RF tanpa coba baseline. Logistic Regression sering cukup dan jauh lebih cepat untuk inference.

FAQ

Q: Random Forest atau XGBoost? A: RF default cepat dan robust. XGBoost lebih akurat tapi butuh tuning. Mulai RF, naik ke XGBoost kalau perlu push akurasi.

Q: Logistic Regression atau Linear SVM? A: Mirip-mirip untuk linearly separable. Logistic kasih probabilitas reliable, SVM lebih robust ke outlier.

Q: KNN bagus tidak? A: Conceptually intuitif, tapi jarang menang. Slow di prediksi, lemah di high-dim. Pakai sebagai baseline saja.

Q: Kenapa accuracy 100%? A: Curiga data leakage atau evaluasi di training set. Cek lagi pipeline.

Q: Berapa K untuk KNN? A: Coba K = 3, 5, 7, 11. Pakai cross-validation untuk pilih. K ganjil untuk binary classification (hindari tie).

Cek Pemahaman

Tahu kapan pakai Logistic vs Tree-based?
Bisa pakai sklearn API (fit, predict, score)?
Tahu kenapa Random Forest lebih robust dari single Decision Tree?
Paham cara kerja KNN (lazy learning)?
Tahu kenapa XGBoost menang di Kaggle?
Tahu mana algoritma yang butuh scaling?

Challenge 5.2

Challenge 1 — Algorithm Comparison

Dataset Titanic. Compare 6 algoritma di atas. Tulis tabel hasil + insight.

Challenge 2 — Hyperparameter Tuning

Pilih Random Forest. Tuning dengan GridSearchCV. Plot learning curve.

Challenge 3 — Feature Importance Analysis

Train RF dan XGBoost. Bandingkan feature importance. Apakah konsisten?

Challenge 4 — Visualisasi Decision Boundary (2D)

Pakai Iris dataset (2 features saja). Plot decision boundary 5 algoritma berbeda.

Selanjutnya: 03-supervised-regression.md