Skip to main content

Machine Learning — Panduan StatQuest

Materi berdiri sendiri berdasarkan buku Josh Starmer

Penulis

Anggit Wirasto, S.Si., M.Eng.

Materi ini adalah modul berdiri sendiri yang merangkum The StatQuest Illustrated Guide to Machine Learning (Josh Starmer, StatQuest Publications, 2022). Filosofi StatQuest sederhana tetapi kuat: algoritme ML yang tampak rumit dipecah menjadi potongan kecil, setiap potongan dilengkapi gambar, analogi, dan contoh angka agar Anda memahami mengapa rumus bekerja — bukan sekadar menghafal bagaimana mengetiknya.

Josh Starmer sering memulai dengan pertanyaan nyata (“Bagaimana memprediksi berat badan dari tinggi?”), lalu secara bertahap memperkenalkan notasi. Materi ini mengikuti pola yang sama: bahasa awam dulu, formulasi matematis setelah intuisi terbentuk.

Referensi utama: Starmer, J. (2022). The StatQuest Illustrated Guide to Machine Learning!!! StatQuest Publications. PDF: 610435041-The-StatQuest-Illustrated-Guide-to-Machine-Learning-Josh-Starmer.pdf. Video pendukung: StatQuest with Josh Starmer.

0.1 Tujuan pembelajaran

Setelah mempelajari materi ini, mahasiswa diharapkan mampu:

  1. Menjelaskan konsep dasar ML — supervised vs unsupervised, regresi vs klasifikasi, parameter vs hiperparameter, overfitting — dengan contoh domain yang relevan.
  2. Menerapkan cross-validation untuk estimasi performa dan pemilihan model secara disiplin, serta menjelaskan mengapa satu split latih/uji saja bisa menipu.
  3. Menggunakan statistik dasar (mean, varians, distribusi normal, korelasi, standard error) sebagai fondasi pemahaman algoritme.
  4. Memformulasikan dan menginterpretasikan regresi linear, gradient descent, dan regresi logistik pada contoh kasus konkret.
  5. Menjelaskan Naive Bayes, metrik evaluasi, dan regularisasi (Ridge/Lasso) serta memilih metrik yang selaras biaya kesalahan bisnis.
  6. Membandingkan pohon keputusan, SVM, dan neural networks — kapan memakai masing-masing, dan apa trade-off-nya.
  7. Menjalankan studi kasus end-to-end — dari EDA, baseline, pemodelan dengan Pipeline, cross-validation, hingga evaluasi final di set uji.

1 Peta materi (12 bab StatQuest)

Bab Judul (StatQuest) Inti yang dipelajari
1 Fundamental Concepts in Machine Learning Apa itu ML, jenis pembelajaran, overfitting
2 Cross Validation Estimasi performa stabil, pemilihan model
3 Fundamental Concepts in Statistics Mean, varians, normal, korelasi
4 Linear Regression Garis terbaik, residual, OLS
5 Gradient Descent Optimasi iteratif, learning rate
6 Logistic Regression Probabilitas kelas, sigmoid
7 Naive Bayes Teorema Bayes, asumsi independensi
8 Assessing Model Performance Confusion matrix, precision, ROC
9 Preventing Overfitting with Regularization Ridge, Lasso, penalti parameter
10 Decision Trees Split, entropy, interpretabilitas
11 Support Vector Classifiers and Machines Margin, kernel, support vectors
12 Neural Networks Lapisan, aktivasi, backpropagation
— Studi kasus end-to-end EDA → model → evaluasi (bab penutup)

2 Konsep dasar machine learning (Bab 1)

2.1 Apa itu machine learning?

Machine learning (ML) adalah cabang ilmu di mana komputer belajar pola dari data untuk membuat prediksi atau keputusan pada observasi baru — tanpa diprogram secara eksplisit aturan untuk setiap kemungkinan input.

2.1.1 Analogi StatQuest: tinggi → berat

Bayangkan klinik ingin memperkirakan berat badan (kg) pasien dari tinggi badan (cm). Pendekatan manual:

  • Dokter menulis aturan: “tinggi 170 cm → berat sekitar 65 kg.”
  • Aturan ini kaku; tidak menangkap variasi tubuh, usia, atau jenis kelamin.

Pendekatan ML:

  1. Kumpulkan ribuan pasangan (tinggi, berat) dari pemeriksaan sebelumnya.
  2. Algoritme menyesuaikan parameter (misalnya kemiringan garis) agar prediksi mendekati data.
  3. Pasien baru yang belum pernah ada di data latih → model memprediksi beratnya.

Inilah inti ML: pola dipelajari dari contoh, bukan ditulis tangan.

2.1.2 Istilah dasar

Istilah Makna Contoh
Observasi / sampel satu baris data satu transaksi e-commerce
Fitur (\(x\)) variabel input luas rumah, usia pelanggan
Target / label (\(y\)) yang ingin diprediksi harga rumah, churn ya/tidak
Model fungsi \(f\) yang memetakan \(x \to \hat{y}\) garis regresi, pohon keputusan
Prediksi (\(\hat{y}\)) output model harga perkiraan Rp 450 juta

2.1.3 Contoh aplikasi ML di berbagai domain

Domain Pertanyaan bisnis Jenis ML
Perbankan Apakah pinjaman ini akan macet? Klasifikasi (supervised)
Ritel Berapa unit terjual minggu depan? Regresi (supervised)
Kesehatan Segmentasi pasien risiko tinggi/rendah Klasifikasi atau klastering
Pertanian Kelompokkan lahan dengan pola NDVI serupa Klastering (unsupervised)
Media sosial Rekomendasi konten yang relevan Ranking / klasifikasi

2.2 Supervised vs unsupervised learning

2.2.1 Supervised learning — label sudah diketahui

Setiap contoh latih punya jawaban benar \(y\). Algoritme belajar: “jika fitur \(x\) seperti ini, target-nya biasanya \(y\).”

Contoh supervised:

  • Klasifikasi spam: \(x\) = kata-kata dalam email, \(y\) = spam / bukan spam.
  • Prediksi harga rumah: \(x\) = luas, lokasi, kamar tidur; \(y\) = harga transaksi (juta Rp).
  • Diagnosis penyakit: \(x\) = hasil lab; \(y\) = positif / negatif.

2.2.2 Unsupervised learning — tanpa label

Hanya ada fitur \(x\). Algoritme mencari struktur — klaster, outlier, komponen utama — tanpa “jawaban kunci.”

Contoh unsupervised:

  • Segmentasi pelanggan e-commerce: kelompokkan pembeli berdasarkan frekuensi & nilai belanja tanpa label “loyal/tidak” sebelumnya.
  • Deteksi anomali transaksi: temukan pola transaksi yang jarang terjadi tanpa daftar penipuan lengkap.
  • Kompresi fitur (PCA): ringkas 50 sensor menjadi 5 komponen utama.
import matplotlib.pyplot as plt
import numpy as np
from sklearn.cluster import KMeans
from sklearn.datasets import make_blobs

X, y = make_blobs(n_samples=120, centers=3, cluster_std=0.9, random_state=42)

fig, axes = plt.subplots(1, 2, figsize=(10, 4))
for k, c in zip(range(3), ["#e74c3c", "#3498db", "#27ae60"]):
    mask = y == k
    axes[0].scatter(X[mask, 0], X[mask, 1], c=c, s=50, edgecolors="white", label=f"Kelas {k}")
axes[0].set_title("Supervised — label diketahui")
axes[0].legend(fontsize=8)
axes[0].set_xlabel("$x_1$")
axes[0].set_ylabel("$x_2$")

km = KMeans(n_clusters=3, n_init=10, random_state=42).fit(X)
for k, c in zip(range(3), ["#e74c3c", "#3498db", "#27ae60"]):
    mask = km.labels_ == k
    axes[1].scatter(X[mask, 0], X[mask, 1], c=c, s=50, edgecolors="white", label=f"Klaster {k}")
axes[1].set_title("Unsupervised — K-means")
axes[1].legend(fontsize=8)
axes[1].set_xlabel("$x_1$")
axes[1].set_ylabel("$x_2$")
plt.tight_layout()
Gambar 1: Kiri: supervised — warna = label kelas yang diketahui saat latih. Kanan: unsupervised — K-means menemukan 3 klaster tanpa label.

Membaca gambar: di kiri, warna titik adalah “kebenaran” yang diajarkan ke model. Di kanan, algoritme menebak pengelompokan hanya dari posisi titik — hasilnya bisa masuk akal, tetapi label klaster (0, 1, 2) tidak otomatis sama dengan label asli.

2.3 Regresi vs klasifikasi

Keduanya termasuk supervised learning, tetapi bentuk target \(y\) berbeda:

Target \(y\) Nama tugas Contoh \(y\) Output model
Numerik kontinu Regresi harga, suhu, kWh bilangan real (mis. 472,5)
Kategorik / diskret Klasifikasi spam/bukan, A/B/C nama kelas atau probabilitas kelas

Contoh regresi — sewa apartemen: fitur = luas (m²), lantai, jarak ke stasiun; target = sewa bulanan (juta Rp). Model mengeluarkan angka, misalnya ŷ = 4,2 juta.

Contoh klasifikasi — persetujuan KPR: fitur = penghasilan, utang, skor kredit; target = disetujui / ditolak. Model mengeluarkan kelas atau \(P(\text{disetujui}) = 0{,}73\).

Kesalahan umum: memakai regresi linear langsung untuk klasifikasi (memprediksi 0,7 dan 1,3 untuk kelas 0/1). Regresi logistik (Bab 6) dirancang khusus untuk output probabilitas \([0, 1]\).

2.4 Parameter vs hiperparameter

Pembedaan ini sering membingungkan; StatQuest menekankannya sejak awal karena kesalahan di sini membuat eksperimen tidak reproduksibel dan evaluasi bias.

Istilah Siapa yang menetapkan? Kapan ditetapkan? Contoh
Parameter model Dipelajari dari data latih saat fit() \(\beta\) regresi, bobot neural net
Hiperparameter Anda sebagai praktisi ML sebelum fit() \(k\) k-NN, kedalaman pohon, \(\alpha\) Ridge

2.4.1 Contoh konkret: k-Nearest Neighbors

  • Parameter: tidak ada bobot global — yang “disimpan” adalah seluruh data latih (instance-based).
  • Hiperparameter \(k\): berapa tetangga yang diambil suaranya?
    • \(k = 1\): sangat sensitif noise — satu titik anomali bisa mengubah prediksi.
    • \(k = 50\): batas keputusan halus — tetapi bisa mengaburkan pola lokal.

Anda tidak memilih \(k\) berdasarkan akurasi set uji berulang kali. Anda memilih \(k\) dengan cross-validation di data latih (Bab 2).

2.5 Data latih, data uji, dan kebocoran informasi

2.5.1 Analogi: buku latihan vs ujian resmi

  • Data latih = buku soal latihan yang dipakai berulang kali saat belajar.
  • Data uji = lembar ujian resmi yang sengaja tidak pernah dibuka saat belajar.

Jika Anda menghafal jawaban ujian karena kebetulan sudah melihatnya, nilai ujian tinggi tetapi kemampuan sebenarnya rendah. Model ML yang “melihat” set uji saat latih mengalami hal serupa — skor test terlalu optimis.

Subset Peran Kesalahan yang harus dihindari
Training sesuaikan parameter menilai performa final di sini saja
Testing estimasi generalisasi tuning hiperparameter berulang di sini

2.5.2 Data leakage — contoh nyata

Kebocoran Mengapa menipu
Normalisasi dihitung dari train + test Mean/std test ikut “mengajar” transformasi
Fitur “total pembayaran” untuk prediksi churn Hanya terisi setelah pelanggan pergi
Duplikat baris di train dan test Uji tidak independen

Aturan emas: semua langkah yang mempelajari statistik dari data (StandardScaler, imputasi median, encoding kategori langka) harus fit di train, lalu transform di test — idealnya dalam satu Pipeline.

2.6 Overfitting, underfitting, dan bias–varians

2.6.1 Underfitting — model terlalu sederhana

Model tidak cukup fleksibel menangkap pola. Contoh: memprediksi harga rumah selalu sama (rata-rata) tanpa mempedulikan luas. Error tinggi di latih dan uji.

2.6.2 Overfitting — model terlalu fleksibel

Model menghafal noise di data latih. Contoh: polinomial derajat 15 yang melengkung liar mengikuti setiap titik latih, tetapi meleset besar di uji.

StatQuest mengilustrasikan dengan tiga tingkat kompleksitas:

import matplotlib.pyplot as plt
import numpy as np
from sklearn.linear_model import LinearRegression
from sklearn.metrics import mean_squared_error
from sklearn.model_selection import train_test_split
from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import make_pipeline

rng = np.random.default_rng(99)
x = rng.uniform(0, 4, 60)
y = 1.2 + 0.9 * x + 0.35 * np.sin(2.5 * x) + rng.normal(0, 0.25, 60)
X = x.reshape(-1, 1)
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.35, random_state=1)
x_line = np.linspace(0, 4, 300).reshape(-1, 1)

models = [
    ("Underfit (mean)", None),
    ("Pas (linear)", LinearRegression().fit(X_train, y_train)),
    ("Overfit (poly-12)", make_pipeline(PolynomialFeatures(12), LinearRegression()).fit(X_train, y_train)),
]

fig, axes = plt.subplots(1, 3, figsize=(10, 4.2), sharey=True)
for ax, (name, m) in zip(axes, models):
    ax.scatter(X_train, y_train, c="#e74c3c", s=35, edgecolors="white", label="Latih")
    ax.scatter(X_test, y_test, c="#3498db", s=35, edgecolors="white", label="Uji")
    if m is None:
        ax.axhline(y_train.mean(), color="k", lw=2)
        pred_test = np.full_like(y_test, y_train.mean())
    else:
        ax.plot(x_line, m.predict(x_line), "k-", lw=2)
        pred_test = m.predict(X_test)
    rmse = float(np.sqrt(mean_squared_error(y_test, pred_test)))
    ax.set_title(f"{name}\nRMSE uji = {rmse:.3f}")
    ax.set_xlabel("x")
axes[0].set_ylabel("y")
axes[0].legend(fontsize=7)
plt.suptitle("Generalisasi diukur di set uji", y=1.02, fontsize=10)
plt.tight_layout()
Gambar 2: Underfit (rata-rata), pas (linear), overfit (polinomial derajat 12). RMSE di set uji — bukan latih — menentukan pilihan.

Cara membaca: model tengah (linear) biasanya RMSE uji terendah — titik kompromi. Model kanan mungkin hampir sempurna di latih (merah) tetapi buruk di uji (biru).

2.6.3 Dekomposisi error (bias–varians)

\[ \mathbb{E}\bigl[(Y - \hat{f}(x))^2\bigr] \approx \underbrace{\text{Bias}^2(\hat{f}(x))}_{\text{model terlalu sederhana}} + \underbrace{\mathbb{V}\text{ar}(\hat{f}(x))}_{\text{model terlalu sensitif terhadap sampel}} + \underbrace{\sigma^2}_{\text{noise yang tidak bisa dihilangkan}} \]

  • Bias tinggi: prediksi sistematis meleset (underfit).
  • Varians tinggi: prediksi berubah-ubah jika data latih sedikit berubah (overfit).
  • \(\sigma^2\): noise inheren — misalnya fluktuasi harga yang tidak bisa dijelaskan fitur yang tersedia.

Regularisasi (Bab 9) sengaja menambah sedikit bias agar varians turun — sering memperbaiki error uji.

2.7 Alur kerja machine learning (ringkas)

  1. Definisikan masalah — regresi atau klasifikasi? apa metrik bisnisnya?
  2. Kumpulkan data — pastikan fitur tersedia saat prediksi (bukan setelah kejadian).
  3. Bersihkan & rekayasa fitur — tangani missing, skala, encoding.
  4. Pisahkan latih / uji — kunci set uji.
  5. Latih kandidat model — mulai dari yang sederhana.
  6. Tuning hiperparameter via cross-validation.
  7. Evaluasi final di set uji — laporkan metrik yang sudah disepakati stakeholder.
  8. Deploy — simpan model + preprocessor identik dengan yang dilatih.

3 Cross-validation (Bab 2)

3.1 Mengapa satu split latih/uji tidak cukup?

Bayangkan Anda mengocok 100 kartu mahasiswa, mengambil 80 untuk latih dan 20 untuk uji. Kebetulan, 20 kartu uji bisa berisi mahasiswa yang “mudah” atau “sulit” diprediksi. Skor uji 80% bisa turun menjadi 65% jika pengocokan diulang dengan random_state berbeda.

Cross-validation (CV) mengatasi ini dengan mengulang evaluasi berkali-kali pada fold berbeda, lalu merata-rata skor. Hasilnya lebih stabil dan lebih mencerminkan performa model pada data baru.

3.2 K-fold cross-validation — langkah demi langkah

Misalkan \(K = 5\) dan 500 sampel latih:

  1. Bagi data menjadi 5 fold @ 100 sampel.
  2. Iterasi 1: fold 1 = validasi, fold 2–5 = latih → hitung metrik \(M_1\).
  3. Iterasi 2: fold 2 = validasi, sisanya = latih → \(M_2\).
  4. … ulangi hingga iterasi 5.
  5. Skor CV = \((M_1 + M_2 + M_3 + M_4 + M_5) / 5\).
import matplotlib.pyplot as plt
import matplotlib.patches as mpatches
import numpy as np

K, n = 5, 50
fold_size = n // K
colors = ["#e74c3c", "#3498db", "#27ae60", "#9b59b6", "#f39c12"]

fig, ax = plt.subplots(figsize=(9, 3.5))
for i in range(K):
    start = i * fold_size
    end = start + fold_size if i < K - 1 else n
    for j in range(n):
        c = colors[i] if start <= j < end else "#ecf0f1"
        ax.add_patch(mpatches.Rectangle((j, i), 1, 0.8, facecolor=c, edgecolor="white"))
    ax.text(-3, i + 0.4, f"Iter {i+1}", ha="right", va="center", fontsize=9)
ax.set_xlim(-4, n)
ax.set_ylim(-0.5, K)
ax.set_xlabel("Indeks sampel")
ax.set_yticks([])
ax.set_title(f"{K}-fold cross-validation")
plt.tight_layout()
Gambar 3: 5-fold CV — setiap baris = satu iterasi; kotak berwarna = fold validasi sementara.

3.2.1 Varian CV yang perlu dikenal

Varian Kapan dipakai
Stratified \(K\)-fold Klasifikasi — proporsi kelas di tiap fold ≈ populasi
Leave-one-out (LOOCV) \(K = n\) — data sangat kecil; mahal komputasi
Time-series split Data deret waktu — validasi selalu di masa depan

Contoh stratified: dataset pinjaman macet 5% vs lancar 95%. Tanpa stratify, satu fold validasi bisa kebetulan tanpa satupun macet → metrik tidak bermakna.

3.3 Protokol disiplin (StatQuest)

  1. Pisahkan set uji sekali di awal — dikunci sampai laporan akhir.
  2. Di data latih saja, jalankan \(K\)-fold CV untuk setiap kandidat model/hiperparameter.
  3. Pilih kandidat dengan rata-rata skor CV terbaik (dan simpan standar deviasi skor fold).
  4. Latih ulang model terpilih pada seluruh latih (praktik umum sebelum deploy).
  5. Laporkan skor final sekali di set uji — tidak mengulang eksperimen karena skor test “kurang bagus.”

3.3.1 Contoh: memilih Ridge vs Linear pada diabetes

Dataset diabetes (sklearn): 10 fitur fisiologis, target = perkembangan penyakit satu tahun kemudian. Ini contoh regresi medis — RMSE mengukur seberapa jauh prediksi menyimpang dari nilai aktual.

import numpy as np
import pandas as pd
from sklearn.datasets import load_diabetes
from sklearn.linear_model import LinearRegression, Ridge
from sklearn.metrics import mean_squared_error
from sklearn.model_selection import cross_val_score, train_test_split
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler

data = load_diabetes(as_frame=True)
X_train, X_test, y_train, y_test = train_test_split(
    data.data, data.target, test_size=0.25, random_state=42
)

candidates = {
    "Linear (tanpa skala)": LinearRegression(),
    "Ridge α=1 + skala": Pipeline([("sc", StandardScaler()), ("m", Ridge(alpha=1.0))]),
    "Ridge α=10 + skala": Pipeline([("sc", StandardScaler()), ("m", Ridge(alpha=10.0))]),
}

rows = []
for name, model in candidates.items():
    cv = -cross_val_score(model, X_train, y_train, cv=5, scoring="neg_root_mean_squared_error")
    model.fit(X_train, y_train)
    rmse_test = float(np.sqrt(mean_squared_error(y_test, model.predict(X_test))))
    rows.append({
        "Model": name,
        "RMSE CV (rata-rata)": round(cv.mean(), 4),
        "RMSE CV (std fold)": round(cv.std(), 4),
        "RMSE uji (final)": round(rmse_test, 4),
    })

pd.DataFrame(rows)
Model RMSE CV (rata-rata) RMSE CV (std fold) RMSE uji (final)
0 Linear (tanpa skala) 55.9990 2.9987 53.3696
1 Ridge α=1 + skala 55.9707 2.8219 53.3182
2 Ridge α=10 + skala 55.9934 2.5675 53.2042

Interpretasi:

  • Pilih model berdasarkan RMSE CV (rata-rata) — bukan kolom uji.
  • Kolom std fold besar → performa tidak stabil antar fold; waspada dataset kecil atau heterogen.
  • Kolom uji hanya konfirmasi sekali; jika jauh lebih buruk dari CV, cek kebocoran atau distribusi train/test yang berbeda.

4 Konsep statistik dasar (Bab 3)

StatQuest menempatkan statistik sebelum regresi karena hampir semua algoritme ML bergantung pada tiga ide: pusat data (mean), penyebaran (varians), dan bentuk distribusi (normal). Tanpa ini, koefisien regresi dan probabilitas Naive Bayes terasa seperti angka ajaib.

4.1 Populasi, sampel, mean, dan varians

  • Populasi — seluruh entitas yang diminati (semua penduduk Indonesia, semua transaksi tahun ini).
  • Sampel — subset yang kita ukur (500 responden survei, 10.000 transaksi bulan lalu).

Karena kita hampir tidak pernah punya populasi penuh, ML bekerja pada sampel — dan sampel membawa ketidakpastian.

\[ \bar{x} = \frac{1}{n}\sum_{i=1}^n x_i, \qquad s^2 = \frac{1}{n-1}\sum_{i=1}^n (x_i - \bar{x})^2, \qquad s = \sqrt{s^2} \]

Contoh — nilai ujian 30 mahasiswa: \(\bar{x} = 72\) berarti rata-rata kelas 72. Jika \(s = 18\), sebaran lebar — ada yang 40 dan ada yang 95. Model prediksi nilai individu akan lebih sulit dibanding jika \(s = 5\).

4.2 Distribusi normal

Banyak fenomena alam dan error pengukuran mendekati distribusi normal (Gaussian):

\[ f(x) = \frac{1}{\sigma\sqrt{2\pi}} \exp\!\left(-\frac{(x-\mu)^2}{2\sigma^2}\right) \]

68–95–99,7 rule (StatQuest):

  • ~68% data dalam \(\mu \pm \sigma\)
  • ~95% dalam \(\mu \pm 2\sigma\)
  • ~99,7% dalam \(\mu \pm 3\sigma\)

Contoh — tinggi badan mahasiswa: \(\mu = 170\) cm, \(\sigma = 8\) cm. Sekitar 68% berada antara 162–178 cm. Naive Bayes Gaussian memodelkan setiap fitur per kelas sebagai “lonceng” seperti ini.

import matplotlib.pyplot as plt
import numpy as np
from scipy.stats import norm

mu, sigma = 170, 8
x = np.linspace(mu - 4 * sigma, mu + 4 * sigma, 400)
y = norm.pdf(x, mu, sigma)

fig, ax = plt.subplots(figsize=(8, 4))
ax.plot(x, y, "k-", lw=2)
ax.fill_between(x, y, where=(x >= mu - sigma) & (x <= mu + sigma), alpha=0.35, color="#3498db", label="±1σ (~68%)")
ax.fill_between(x, y, where=(x >= mu - 2*sigma) & (x <= mu + 2*sigma), alpha=0.2, color="#3498db", label="±2σ (~95%)")
ax.axvline(mu, color="#e74c3c", ls="--", label=f"μ = {mu} cm")
ax.set_xlabel("Tinggi badan (cm)")
ax.set_ylabel("Kepadatan probabilitas")
ax.set_title("Distribusi normal — fondasi OLS & Naive Bayes Gaussian")
ax.legend(fontsize=8)
plt.tight_layout()
Gambar 4: Distribusi normal — μ = 170 cm, σ = 8 cm. Area biru = ±1σ (~68%) dan ±2σ (~95%).

4.3 Standard error — ketidakpastian estimasi

Mean sampel \(\bar{x}\) bervariasi jika kita ambil sampel berbeda. Standard error mengukur seberapa besar variasi itu:

\[ \mathrm{SE}(\bar{x}) = \frac{s}{\sqrt{n}} \]

Ukuran sampel \(n\) SE (jika \(s = 18\)) Interpretasi
30 \(18/\sqrt{30} \approx 3{,}3\) Rata-rata sampel bisa menyimpang ±3 poin dari populasi
300 \(18/\sqrt{300} \approx 1{,}0\) Estimasi jauh lebih presisi
3000 \(18/\sqrt{3000} \approx 0{,}3\) Hampir stabil

Kaitan ML: model dengan data latih sedikit cenderung varians tinggi — performa uji tidak stabil. Ini alasan mengapa deep learning rakus data.

4.4 Korelasi — bukan kausalitas

Korelasi Pearson \(r \in [-1, 1]\) mengukur kekuatan hubungan linear:

\[ r = \frac{\sum_i (x_i - \bar{x})(y_i - \bar{y})}{\sqrt{\sum_i (x_i - \bar{x})^2}\sqrt{\sum_i (y_i - \bar{y})^2}} \]

Nilai \(r\) Interpretasi kasar
\(r \approx 0{,}9\) Hubungan linear kuat positif
\(r \approx 0\) Hubungan linear lemah
\(r \approx -0{,}8\) Naik \(x\) cenderung turunkan \(y\)

Contoh — harga rumah vs luas: \(r = 0{,}85\) wajar — luas besar cenderung harga tinggi. Regresi linear memanfaatkan ini.

Jebakan: \(r\) tinggi bukan bukti sebab-akibat. Penjualan es krim dan kasus tenggelam bisa berkorelasi karena keduanya naik di musim panas (variabel perancu: suhu).

Multikolinearitas: dua fitur \(r = 0{,}95\) (luas tanah & luas bangunan) membuat koefisien regresi tidak stabil — Ridge (Bab 9) sering membantu.

import matplotlib.pyplot as plt
import numpy as np

rng = np.random.default_rng(12)
fig, axes = plt.subplots(1, 3, figsize=(10, 3.5))
for ax, (title, r_target) in zip(axes, [("Positif kuat", 0.85), ("Lemah", 0.15), ("Negatif", -0.75)]):
    cov = np.array([[1, r_target], [r_target, 1]])
    pts = rng.multivariate_normal([0, 0], cov, size=80)
    r = np.corrcoef(pts[:, 0], pts[:, 1])[0, 1]
    ax.scatter(pts[:, 0], pts[:, 1], s=40, c="#3498db", edgecolors="white")
    ax.set_title(f"{title}\n(r = {r:.2f})")
    ax.axhline(0, color="gray", lw=0.5)
    ax.axvline(0, color="gray", lw=0.5)
axes[0].set_ylabel("y")
plt.suptitle("Korelasi Pearson — regresi linear paling cocok saat awan mengikuti garis", y=1.05, fontsize=10)
plt.tight_layout()
Gambar 5: Korelasi positif kuat, lemah, dan negatif — perhatikan bentuk awan titik.

5 Regresi linear (Bab 4)

Regresi linear menjawab: “Berapa nilai \(y\) yang diperkirakan jika fitur \(x\) bernilai tertentu?” Jawabannya berupa garis (atau hyperplane di dimensi tinggi) yang paling dekat dengan data menurut kriteria kuadrat error.

5.1 Model dan OLS

\[ \hat{y} = \beta_0 + \beta_1 x_1 + \cdots + \beta_p x_p \]

  • \(\beta_0\) = intercept — prediksi saat semua \(x = 0\) (hati-hati interpretasi jika 0 tidak realistis).
  • \(\beta_j\) = perubahan \(\hat{y}\) per satuan kenaikan \(x_j\) jika fitur lain tetap.

Ordinary Least Squares (OLS) meminimumkan jumlah kuadrat residual:

\[ \min_{\beta} \sum_{i=1}^n (y_i - \hat{y}_i)^2 \]

Residual \(e_i = y_i - \hat{y}_i\) = seberapa jauh titik data dari garis. OLS membuat jumlah \(e_i^2\) sekecil mungkin — residual besar dihukum sangat berat (kuadrat).

5.1.1 Regresi sederhana — solusi tertutup

\[ \beta_1 = \frac{\sum_i (x_i-\bar{x})(y_i-\bar{y})}{\sum_i (x_i-\bar{x})^2}, \qquad \beta_0 = \bar{y} - \beta_1 \bar{x} \]

5.1.2 Contoh kasus: jam belajar → skor ujian

Seorang dosen mencatat jam belajar per minggu (\(x\)) dan skor ujian (\(y\)) 80 mahasiswa. Model menemukan \(\beta_1 \approx 1{,}35\): setiap jam tambahan belajar diasosiasikan dengan kenaikan skor 1,35 poin (linear, pada rentang data yang diamati).

import matplotlib.pyplot as plt
import numpy as np
from sklearn.linear_model import LinearRegression

rng = np.random.default_rng(9)
n = 80
x = rng.uniform(2, 18, size=n)
y = 5.0 + 1.35 * x + rng.normal(0, 2.2, size=n)
X = x.reshape(-1, 1)
model = LinearRegression().fit(X, y)
xp = np.linspace(x.min(), x.max(), 200).reshape(-1, 1)
y_hat = model.predict(X)
res = y - y_hat

fig, axes = plt.subplots(1, 2, figsize=(10, 4.2))
axes[0].scatter(x, y, alpha=0.85, edgecolors="white", label="Data")
axes[0].plot(xp.ravel(), model.predict(xp), color="darkred", lw=2, label="OLS")
axes[0].set_xlabel("Jam belajar / minggu")
axes[0].set_ylabel("Skor ujian")
axes[0].legend()
axes[0].set_title("Regresi linear sederhana")
axes[1].scatter(x, res, alpha=0.85, edgecolors="white")
axes[1].axhline(0, color="darkred", lw=1.5)
axes[1].set_xlabel("Jam belajar")
axes[1].set_ylabel("Residual (y − ŷ)")
axes[1].set_title("Plot residual")
plt.tight_layout()
print(f"β₀ (intercept) = {model.intercept_:.3f}")
print(f"β₁ (slope)     = {model.coef_[0]:.3f}")
print("→ Setiap +1 jam belajar, skor diprediksi naik ≈", round(model.coef_[0], 2), "poin")
β₀ (intercept) = 4.785
β₁ (slope)     = 1.414
→ Setiap +1 jam belajar, skor diprediksi naik ≈ 1.41 poin
Gambar 6: Kiri: garis OLS menyeberangi awan titik. Kanan: residual tersebar acak di sekitar 0 — tanda model linear wajar.

Membaca residual: pola melengkung (U atau ∩) di plot kanan → hubungan mungkin nonlinear; pertimbangkan transformasi atau polinomial (dengan waspada overfitting).

5.1.3 Regresi berganda — contoh sewa apartemen

\[ \hat{\text{sewa}} = \beta_0 + \beta_1 \cdot \text{luas} + \beta_2 \cdot \text{lantai} + \beta_3 \cdot \text{jarak\_stasiun} \]

\(\beta_1\) = kenaikan sewa per m² jika lantai dan jarak tetap. Ini interpretasi marginal — sangat berguna untuk stakeholder properti.

5.1.4 Metrik evaluasi regresi

Metrik Rumus (intuisi) Kapan diprioritaskan
RMSE \(\sqrt{\text{mean}(e_i^2)}\) Outlier penting; selaras dengan OLS
MAE \(\text{mean}(|e_i|)\) Outlier ekstrem harus tidak terlalu menghukum
\(R^2\) proporsi varians terjelaskan Perbandingan model pada dataset sama

\(R^2 = 0{,}85\) berarti model menjelaskan ~85% variasi \(y\) dibanding model “tebak rata-rata saja.” Jebakan: \(R^2\) tinggi di latih tetapi rendah di uji → overfitting.

5.1.5 Dampak outlier pada OLS

Satu rumah dengan harga ekstrem (mis. vila mewah) dapat menarik garis secara tidak proporsional karena error dikuadratkan. Solusi praktis: cek residual, pertimbangkan MAE sebagai metrik, transformasi \(\log(y)\), atau regularisasi.

6 Gradient descent (Bab 5)

OLS punya solusi tertutup untuk regresi linear — tidak perlu iterasi. Namun regresi logistik pada jutaan baris, pohon dengan loss kompleks, dan neural networks tidak punya rumus satu langkah. Di sinilah gradient descent menjadi fondasi.

6.1 Ide inti: turun lereng

Bayangkan Anda berdiri di pegunungan berkabut dan ingin mencapai lembah terendah (minimum loss). Anda tidak melihat seluruh peta; Anda hanya merasakan kemiringan di bawah kaki (gradien) dan melangkah ke arah menurun.

\[ \theta \leftarrow \theta - \eta \,\frac{\partial \mathcal{L}}{\partial \theta} \]

  • \(\theta\) = parameter yang disesuaikan (misalnya \(\beta_1\)).
  • \(\mathcal{L}\) = fungsi kerugian (MSE, log-loss, dll.).
  • \(\eta\) = learning rate — seberapa besar langkah.
import matplotlib.pyplot as plt
import numpy as np

def loss(theta):
    return (theta - 3.0) ** 2 + 1.0

def grad(theta):
    return 2 * (theta - 3.0)

theta_grid = np.linspace(-1, 7, 300)
fig, ax = plt.subplots(figsize=(8, 4.5))
ax.plot(theta_grid, loss(theta_grid), "k-", lw=2, label="Loss L(θ)")

for eta, color, label in [(0.15, "#27ae60", "η = 0,15 (stabil)"), (0.85, "#e74c3c", "η = 0,85 (overshoot)")]:
    theta, path = -0.5, []
    for _ in range(12):
        path.append(theta)
        theta = theta - eta * grad(theta)
    ax.plot(path, [loss(t) for t in path], "o-", color=color, ms=5, label=label)

ax.axvline(3.0, color="gray", ls="--", alpha=0.7, label="Minimum (θ* = 3)")
ax.set_xlabel("Parameter θ")
ax.set_ylabel("Loss L(θ)")
ax.set_title("Gradient descent — analogi menuruni lereng")
ax.legend(fontsize=8)
plt.tight_layout()
Gambar 7: Learning rate kecil (hijau) konvergen stabil; terlalu besar (merah) overshoot dan osilasi.

6.1.1 Learning rate — contoh angka

\(\eta\) Perilaku
Terlalu kecil (0,001) Konvergen lambat — butuh ribuan iterasi
Pas (0,01–0,1) Turun stabil ke minimum
Terlalu besar (1,0) Melompati minimum — loss naik-turun atau divergen

6.1.2 Varian gradient descent

Varian Gradien dihitung dari Kelebihan / kekurangan
Batch GD seluruh data latih Stabil; mahal jika \(n\) besar
SGD satu sampel acak Cepat; noisy
Mini-batch subset kecil (32–256) Standar deep learning

Contoh kapan GD wajib: neural network dengan jutaan bobot — tidak ada \((X^TX)^{-1}X^Ty\) tertutup. Setiap mini-batch memperbarui bobot sedikit demi sedikit hingga loss turun.

7 Regresi logistik (Bab 6)

Klasifikasi biner membutuhkan output di \([0, 1]\) — probabilitas. Regresi linear bisa menghasilkan 1,3 atau −0,2 untuk “probabilitas,” yang tidak bermakna. Regresi logistik memetakan kombinasi linear fitur melalui sigmoid:

\[ P(y=1 \mid x) = \sigma(z) = \frac{1}{1 + e^{-z}}, \qquad z = \beta_0 + \beta_1 x_1 + \cdots + \beta_p x_p \]

7.0.1 Membaca sigmoid

\(z\) \(\sigma(z)\) Interpretasi
\(z = 0\) 0,5 50–50
\(z = 2\) ≈ 0,88 cenderung positif
\(z = -2\) ≈ 0,12 cenderung negatif

Threshold default 0,5: jika \(P(y=1) \geq 0{,}5\), prediksi kelas 1. Threshold bisa digeser jika false negative lebih mahal — misalnya deteksi kanker: turunkan threshold agar lebih banyak yang diperiksa lanjut (recall tinggi, Bab 8).

7.0.2 Log-odds (logit)

\[ \log\!\left(\frac{p}{1-p}\right) = z \]

Hubungan linear pada skala logit, tetapi nonlinear pada skala probabilitas — inilah kekuatan model untuk batas keputusan melengkung.

7.0.3 Contoh kasus: persetujuan pinjaman KPR

Fitur Contoh nilai
Penghasilan bulanan Rp 12 juta
Rasio utang/pendapatan 35%
Skor kredit 720

Model mengeluarkan \(P(\text{disetujui}) = 0{,}78\). Bank bisa menetapkan kebijakan: setujui otomatis jika \(p > 0{,}7\).

import matplotlib.pyplot as plt
import numpy as np
from sklearn.datasets import make_classification
from sklearn.linear_model import LogisticRegression
from sklearn.inspection import DecisionBoundaryDisplay

X, y = make_classification(n_samples=200, n_features=2, n_redundant=0,
                           n_clusters_per_class=1, random_state=42)
clf = LogisticRegression(max_iter=500).fit(X, y)

z = np.linspace(-6, 6, 200)
sigmoid = 1 / (1 + np.exp(-z))

fig, axes = plt.subplots(1, 2, figsize=(10, 4))
axes[0].plot(z, sigmoid, "k-", lw=2)
axes[0].axhline(0.5, color="#e74c3c", ls="--", label="Threshold p = 0,5")
axes[0].set_xlabel("z (logit = β₀ + β₁x₁ + …)")
axes[0].set_ylabel("P(y = 1)")
axes[0].set_title("Fungsi sigmoid σ(z)")
axes[0].legend(fontsize=8)

DecisionBoundaryDisplay.from_estimator(clf, X, response_method="predict", ax=axes[1], alpha=0.4, cmap="Pastel1")
axes[1].scatter(X[:, 0], X[:, 1], c=y, cmap="coolwarm", edgecolors="k", s=30, linewidths=0.3)
axes[1].set_title("Batas keputusan — regresi logistik")
axes[1].set_xlabel("$x_1$")
axes[1].set_ylabel("$x_2$")
plt.tight_layout()
Gambar 8: Kiri: kurva sigmoid — output selalu antara 0 dan 1. Kanan: batas keputusan linear pada ruang fitur (garis lurus setelah transformasi logit).

Pelatihan: memaksimumkan log-likelihood ≡ meminimumkan log-loss (cross-entropy). Optimasi biasanya via gradient descent atau solver numerik (L-BFGS di sklearn).

8 Naive Bayes (Bab 7)

Naive Bayes adalah salah satu algoritme tercepat dan sering mengejutkan efektif — terutama klasifikasi teks (spam) dan baseline awal.

8.1 Teorema Bayes — bahasa awam

“Seberapa yakin kita objek ini kelas \(C_k\), setelah melihat fitur \(x\)?”

\[ P(C_k \mid x) = \frac{P(x \mid C_k)\, P(C_k)}{P(x)} \]

  • \(P(C_k)\) = prior — seberapa sering kelas \(k\) muncul (misalnya 20% email adalah spam).
  • \(P(x \mid C_k)\) = seberapa “khas” fitur \(x\) untuk kelas \(k\).
  • \(P(x)\) = normalisasi — sama untuk semua kelas saat membandingkan.

Prediksi: pilih kelas dengan \(P(C_k \mid x)\) terbesar.

8.2 Asumsi “naïf” — independensi fitur

\[ P(x \mid C_k) = \prod_{j=1}^p P(x_j \mid C_k) \]

Artinya: fitur dianggap independen satu sama lain dalam kelas. Contoh spam: “gratis” dan “klik” dianggap tidak saling mempengaruhi — jelas simplifikasi, tetapi sering cukup baik.

8.2.1 Contoh narasi: filter spam

Email: “Gratis undian klik di sini.”

  • \(P(\text{“gratis”} \mid \text{spam})\) tinggi; \(P(\text{“gratis”} \mid \text{bukan spam})\) rendah.
  • \(P(\text{“klik”} \mid \text{spam})\) tinggi.
  • Prior \(P(\text{spam}) = 0{,}3\).
  • Naive Bayes mengalikan likelihood tiap kata × prior → \(P(\text{spam} \mid \text{email}) = 0{,}92\) → klasifikasi spam.

8.2.2 Gaussian Naive Bayes — fitur numerik

Setiap fitur \(x_j\) pada kelas \(C_k\) dimodelkan distribusi normal \(\mathcal{N}(\mu_{jk}, \sigma_{jk}^2)\) dari data latih.

Kelebihan Keterbatasan
Sangat cepat, skala ke juta baris Asumsi independensi sering dilanggar
Baseline kuat dengan sedikit data Fitur korelasi kuat menurunkan performa
Mudah diinterpretasi (prior + mean per kelas) Distribusi non-normal perlu varian (Multinomial, Bernoulli)
import pandas as pd
from sklearn.datasets import load_iris
from sklearn.metrics import accuracy_score, classification_report
from sklearn.model_selection import train_test_split
from sklearn.naive_bayes import GaussianNB

iris = load_iris(as_frame=True)
X_train, X_test, y_train, y_test = train_test_split(
    iris.data, iris.target, test_size=0.3, stratify=iris.target, random_state=42
)
gnb = GaussianNB().fit(X_train, y_train)
y_pred = gnb.predict(X_test)
acc = accuracy_score(y_test, y_pred)

print("Akurasi uji:", round(acc, 4))
print("\nPrior kelas (dipelajari dari latih):")
for i, name in enumerate(iris.target_names):
    print(f"  P({name}) = {gnb.class_prior_[i]:.3f}")
print("\nLaporan per kelas:")
print(classification_report(y_test, y_pred, target_names=iris.target_names))
Akurasi uji: 0.9111

Prior kelas (dipelajari dari latih):
  P(setosa) = 0.333
  P(versicolor) = 0.333
  P(virginica) = 0.333

Laporan per kelas:
              precision    recall  f1-score   support

      setosa       1.00      1.00      1.00        15
  versicolor       0.82      0.93      0.88        15
   virginica       0.92      0.80      0.86        15

    accuracy                           0.91        45
   macro avg       0.92      0.91      0.91        45
weighted avg       0.92      0.91      0.91        45

Membaca output: prior setara proporsi kelas di latih. Laporan per kelas menunjukkan apakah satu spesies sering tertukar — petunjuk fitur mana yang kurang memisahkan.

9 Penilaian performa model (Bab 8)

StatQuest menekankan: tetapkan metrik utama sebelum melihat hasil uji. Metrik yang salah membuat model terlihat bagus padahal gagal di dunia nyata.

9.1 Metrik regresi — contoh bisnis

Skenario: prediksi konsumsi listrik (kWh). RMSE = 45 kWh artinya rata-rata kesalahan kuadrat setara ~45 kWh — stakeholder bisa mengalikan dengan tarif Rp/kWh untuk estimasi biaya kesalahan.

Metrik Bahasa awam
RMSE = 45 kWh Prediksi meleset “sekitar 45 kWh” (dengan penalti besar untuk error ekstrem)
MAE = 30 kWh Rata-rata meleset 30 kWh — lebih mudah dijelaskan ke non-teknis
\(R^2 = 0{,}72\) Model jauh lebih baik dari tebak rata-rata

9.2 Metrik klasifikasi — confusion matrix

Contoh: deteksi penyakit jarang (prevalensi 2%).

Pred positif Pred negatif
Aktual positif TP (benar alarm) FN (terlewat — berbahaya)
Aktual negatif FP (alarm palsu) TN (benar sehat)

\[ \text{Accuracy} = \frac{TP + TN}{\text{semua}}, \quad \text{Precision} = \frac{TP}{TP + FP}, \quad \text{Recall} = \frac{TP}{TP + FN} \]

9.2.1 Kapan accuracy menipu

Model yang selalu prediksi “sehat” mencapai akurasi 98% — tetapi recall = 0% (tidak ada penyakit yang tertangkap). Untuk penyakit serius, recall biasanya lebih penting daripada accuracy.

Metrik Pertanyaan yang dijawab Contoh prioritas
Precision “Dari yang saya flag positif, berapa % benar?” Spam filter — FP mengganggu
Recall “Dari semua positif sebenarnya, berapa % ketangkap?” Kanker — FN berbahaya
F1 Keseimbangan precision & recall Kelas tidak seimbang

9.2.2 ROC & AUC

ROC memplot True Positive Rate vs False Positive Rate saat threshold \(p\) bervariasi dari 0 ke 1.

  • AUC ≈ 1 — model memisahkan kelas dengan baik.
  • AUC ≈ 0,5 — seburuk tebakan koin.

Contoh: model AUC = 0,87 untuk prediksi churn — cukup untuk ranking pelanggan risiko tinggi, meskipun threshold operasional (mis. hubungi jika \(p > 0{,}3\)) ditetapkan terpisah oleh bisnis.

import matplotlib.pyplot as plt
from sklearn.datasets import make_classification
from sklearn.linear_model import LogisticRegression
from sklearn.metrics import RocCurveDisplay, confusion_matrix, ConfusionMatrixDisplay
from sklearn.model_selection import train_test_split

X, y = make_classification(n_samples=400, weights=[0.75, 0.25], random_state=42)
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, stratify=y, random_state=42)
clf = LogisticRegression(max_iter=500).fit(X_train, y_train)
y_pred = clf.predict(X_test)

fig, axes = plt.subplots(1, 2, figsize=(10, 4.2))
ConfusionMatrixDisplay(confusion_matrix(y_test, y_pred)).plot(ax=axes[0], cmap="Blues", colorbar=False)
axes[0].set_title("Confusion matrix")
RocCurveDisplay.from_estimator(clf, X_test, y_test, ax=axes[1])
axes[1].set_title("Kurva ROC")
plt.tight_layout()
Gambar 9: Kiri: confusion matrix — 75% negatif, 25% positif (tidak seimbang). Kanan: ROC — AUC mengukur kemampuan ranking tanpa memilih threshold tunggal.

10 Regularisasi — mencegah overfitting (Bab 9)

Tanpa regularisasi, OLS atau polinomial tinggi bisa membuat koefisien sangat besar untuk menyesuaikan noise — overfitting. Regularisasi menambah penalti pada besaran parameter.

10.1 Ridge (L2) dan Lasso (L1)

Metode Penalti Efek geometris (intuisi StatQuest) Kapan dipakai
Ridge \(\alpha \sum_j \beta_j^2\) Mengecilkan semua \(\beta\) Banyak fitur berkorelasi
Lasso \(\alpha \sum_j |\beta_j|\) Bisa nolkan \(\beta_j\) → seleksi fitur Ingin model parsimonius
Elastic Net L1 + L2 Kompromi Banyak fitur + korelasi

Hiperparameter \(\alpha\): semakin besar → penalti kuat → model lebih sederhana (bias naik, varians turun). Pilih \(\alpha\) via cross-validation.

10.1.1 Contoh: kurva sinus dengan polinomial tinggi

Data mengikuti \(\sin(2\pi x)\) + noise. Polinomial derajat 12 menghafal titik latih; Ridge menghaluskan kurva dan RMSE uji membaik.

import matplotlib.pyplot as plt
import numpy as np
from sklearn.linear_model import LinearRegression, Ridge
from sklearn.metrics import mean_squared_error
from sklearn.model_selection import train_test_split
from sklearn.preprocessing import PolynomialFeatures, StandardScaler
from sklearn.pipeline import make_pipeline

rng = np.random.default_rng(3)
x = np.sort(rng.uniform(0, 1, 40))
y = np.sin(2 * np.pi * x) + rng.normal(0, 0.25, 40)
X = x.reshape(-1, 1)
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, random_state=1)
x_line = np.linspace(0, 1, 200).reshape(-1, 1)

ols = make_pipeline(PolynomialFeatures(12), LinearRegression()).fit(X_train, y_train)
ridge = make_pipeline(PolynomialFeatures(12), StandardScaler(), Ridge(alpha=0.01)).fit(X_train, y_train)

fig, ax = plt.subplots(figsize=(10, 4))
ax.scatter(X_train, y_train, c="#e74c3c", s=45, edgecolors="white", label="Latih")
ax.scatter(X_test, y_test, c="#3498db", s=45, edgecolors="white", label="Uji")
ax.plot(x_line, ols.predict(x_line), color="#e67e22", lw=2,
        label=f"OLS poly-12 (RMSE uji={np.sqrt(mean_squared_error(y_test, ols.predict(X_test))):.3f})")
ax.plot(x_line, ridge.predict(x_line), color="#27ae60", lw=2,
        label=f"Ridge poly-12 (RMSE uji={np.sqrt(mean_squared_error(y_test, ridge.predict(X_test))):.3f})")
ax.set_xlabel("x")
ax.set_ylabel("y")
ax.set_title("Regularisasi — Ridge menstabilkan polinomial tinggi")
ax.legend(fontsize=8)
plt.tight_layout()
Gambar 10: OLS poly-12 berliku-liuk (overfit); Ridge poly-12 lebih halus dan RMSE uji lebih rendah.

Contoh domain: prediksi harga rumah dengan 50 fitur — banyak yang redundan (luas tanah, luas bangunan, jumlah kamar). Lasso bisa mengecilkan koefisien fitur tidak penting menjadi nol, menyederhanakan model untuk audit regulator.

11 Pohon keputusan (Bab 10)

Pohon keputusan mempartisi data dengan pertanyaan berurutan — sangat mirip flowchart yang bisa dibaca manusia non-teknis.

11.1 Cara kerja — contoh narasi

Prediksi: apakah pelanggan akan churn?

  1. Apakah masa aktif < 6 bulan?
    • Ya → lanjut ke (2)
    • Tidak → prediksi tidak churn (daun)
  2. Apakah keluhan > 2?
    • Ya → prediksi churn
    • Tidak → prediksi tidak churn

Setiap split memilih fitur dan threshold yang memisahkan kelas paling baik.

11.2 Entropy dan information gain

Entropy mengukur “kekacauan” campuran kelas di sebuah node:

\[ H = -\sum_{k} p_k \log_2 p_k \]

Komposisi node Entropy
100% kelas A 0 (murni)
50% A, 50% B 1 (maksimum untuk 2 kelas)
90% A, 10% B Rendah

Information gain = \(H_{\text{sebelum}} - H_{\text{setelah split}}\). Split yang baik menurunkan entropy — anak node lebih murni.

Contoh angka: node induk 50% churn / 50% tidak → \(H = 1\). Setelah split “keluhan > 2”, anak kiri 90% churn → entropy turun → gain tinggi → split ini dipilih.

11.3 Kelebihan, keterbatasan, Random Forest

Aspek Pohon tunggal Random Forest
Interpretabilitas Sangat tinggi Rendah (rata-rata banyak pohon)
Overfitting Mudah jika max_depth besar Lebih tahan (bagging + random fitur)
Performa Cukup untuk baseline Sering lebih akurat
import matplotlib.pyplot as plt
from sklearn.datasets import load_iris
from sklearn.inspection import DecisionBoundaryDisplay
from sklearn.tree import DecisionTreeClassifier, plot_tree

iris = load_iris(as_frame=True)
X = iris.data[["petal length (cm)", "petal width (cm)"]].values
y = iris.target
tree = DecisionTreeClassifier(max_depth=3, random_state=42).fit(X, y)

fig, axes = plt.subplots(1, 2, figsize=(12, 5))
DecisionBoundaryDisplay.from_estimator(tree, X, response_method="predict", ax=axes[0], alpha=0.4, cmap="Pastel1")
axes[0].scatter(X[:, 0], X[:, 1], c=y, cmap="viridis", edgecolors="k", s=40)
axes[0].set_xlabel("Petal length (cm)")
axes[0].set_ylabel("Petal width (cm)")
axes[0].set_title("Batas keputusan (max_depth = 3)")

plot_tree(tree, feature_names=["petal length", "petal width"], class_names=iris.target_names.astype(str),
          filled=True, rounded=True, fontsize=8, ax=axes[1])
axes[1].set_title("Struktur pohon — mudah diaudit")
plt.tight_layout()
Gambar 11: Kiri: batas keputusan berbentuk kotak (axis-aligned). Kanan: struktur pohon — setiap node = pertanyaan, daun = prediksi kelas.

Hiperparameter penting: max_depth (kedalaman), min_samples_leaf (minimal sampel di daun), max_features (Random Forest). Semua dipilih via CV — pohon terlalu dalam = overfit.

12 Support Vector Machine (Bab 11)

SVM mencari batas pemisah yang bukan sekadar memisahkan kelas, tetapi memisahkan dengan margin selebar mungkin — jarak terbesar ke titik terdekat dari kedua kelas.

12.1 Margin dan support vectors

Bayangkan dua kelompok titik di kertas. Banyak garis bisa memisahkan. SVM memilih garis yang sejauh mungkin dari titik terdekat kedua sisi — titik-titik di tepi inilah support vectors. Hanya mereka yang menentukan posisi batas; titik jauh di tengah kelas tidak memengaruhi.

Soft margin (hiperparameter \(C\)):

  • \(C\) besar → sedikit misclassification ditoleransi; margin sempit; bisa overfit.
  • \(C\) kecil → margin lebar; beberapa titik “salah sisi” diizinkan; lebih robust.

12.2 Kernel trick — data bulan sabit

Data tidak linear separable di ruang asli (contoh: dua bulan sabit bersinggungan). Kernel RBF memetakan titik ke dimensi lebih tinggi di mana kelas bisa dipisahkan linear — tanpa menghitung koordinat eksplisit:

\[ K(x, x') = \exp\!\left(-\gamma \|x - x'\|^2\right) \]

\(\gamma\) besar → pengaruh lokal kuat (batas berliku, risiko overfit). \(\gamma\) kecil → batas halus.

import matplotlib.pyplot as plt
from sklearn.datasets import make_moons
from sklearn.inspection import DecisionBoundaryDisplay
from sklearn.svm import SVC

X, y = make_moons(n_samples=200, noise=0.25, random_state=42)
fig, axes = plt.subplots(1, 2, figsize=(10, 4.2))
for ax, kernel, title in zip(axes, ["linear", "rbf"], ["SVM linear — underfit pada moons", "SVM RBF (γ=2)"]):
    svm = SVC(kernel=kernel, gamma=2 if kernel == "rbf" else "scale").fit(X, y)
    DecisionBoundaryDisplay.from_estimator(svm, X, response_method="predict", ax=ax, alpha=0.4, cmap="Pastel1")
    ax.scatter(X[:, 0], X[:, 1], c=y, cmap="coolwarm", edgecolors="k", s=25, linewidths=0.3)
    sv = svm.support_vectors_
    ax.scatter(sv[:, 0], sv[:, 1], s=80, facecolors="none", edgecolors="k", linewidths=1.5, label=f"Support vectors ({len(sv)})")
    ax.set_title(title)
    ax.legend(fontsize=7)
plt.suptitle("SVM — margin maksimum & kernel", y=1.02, fontsize=10)
plt.tight_layout()
Gambar 12: SVM linear gagal pada bulan sabit; SVM RBF menangkap batas non-linear. Lingkaran hitam = support vectors.

Kapan SVM cocok: dataset tidak terlalu besar (kernel RBF mahal \(O(n^2)\)–\(O(n^3)\)), fitur berdimensi sedang–tinggi, butuh batas non-linear. Untuk jutaan baris, gradient boosting atau neural net sering lebih praktis.

13 Neural networks (Bab 12)

Neural network adalah rantai fungsi yang disusun berlapis. Setiap neuron menerima input berbobot, menjumlahkan, lalu menerapkan fungsi aktivasi non-linear — tanpa aktivasi non-linear, jaringan dalam hanya setara satu regresi linear.

13.1 Arsitektur — bahasa awam

\[ a^{(l)} = \sigma\!\left(W^{(l)} a^{(l-1)} + b^{(l)}\right) \]

Lapisan Peran Analogi
Input fitur mentah (pixel, sensor) “Mata” melihat data
Hidden kombinasi abstrak (tepi, bentuk) “Otak” mengekstrak pola
Output prediksi akhir Keputusan (kelas / angka)

Aktivasi umum:

  • ReLU \(\max(0, z)\) — standar hidden layer; menghindari vanishing gradient.
  • Sigmoid — output biner (probabilitas).
  • Softmax — multi-kelas (probabilitas yang jumlahnya 1).

13.2 Pelatihan: backpropagation + mini-batch GD

  1. Forward pass: input → hidden → output → hitung loss.
  2. Backward pass: propagasi gradien loss ke setiap bobot (backpropagation).
  3. Update bobot dengan gradient descent pada mini-batch.

Contoh: klasifikasi gambar digit — input 784 pixel, hidden 128 neuron, output 10 kelas (0–9). Setiap epoch melihat seluruh data dalam batch kecil; loss turun bertahap.

import matplotlib.pyplot as plt
from sklearn.datasets import make_circles
from sklearn.inspection import DecisionBoundaryDisplay
from sklearn.neural_network import MLPClassifier
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler

X, y = make_circles(n_samples=300, noise=0.12, factor=0.45, random_state=42)
mlp = Pipeline([
    ("sc", StandardScaler()),
    ("nn", MLPClassifier(hidden_layer_sizes=(16, 8), max_iter=1000, random_state=42)),
]).fit(X, y)

fig, ax = plt.subplots(figsize=(8, 4.5))
DecisionBoundaryDisplay.from_estimator(mlp, X, response_method="predict", ax=ax, alpha=0.4, cmap="Pastel1")
ax.scatter(X[:, 0], X[:, 1], c=y, cmap="coolwarm", edgecolors="k", s=30, linewidths=0.3)
ax.set_title("MLP (16-8) — lingkaran konsentris")
ax.set_xlabel("$x_1$")
ax.set_ylabel("$x_2$")
plt.tight_layout()
print("Arsitektur hidden:", mlp.named_steps["nn"].hidden_layer_sizes)
print("Iterasi hingga konvergen:", mlp.named_steps["nn"].n_iter_)
Arsitektur hidden: (16, 8)
Iterasi hingga konvergen: 641
Gambar 13: MLP dengan 2 hidden layer (16-8 neuron) memisahkan lingkaran konsentris — pola non-linear yang sulit untuk regresi logistik linear.

13.2.1 Kapan neural network — dan kapan tidak

Gunakan NN Pertimbangkan model lebih sederhana
Gambar, audio, teks panjang Tabel kecil (< 10.000 baris)
Data sangat besar Butuh interpretabilitas penuh (regulasi)
Pola non-linear kompleks Baseline linear/logistic sudah cukup baik

Risiko: butuh banyak data, tuning banyak hiperparameter (lapisan, neuron, learning rate, dropout), dan interpretabilitas rendah — sulit menjelaskan ke auditor mengapa satu nasabah ditolak.

14 Studi kasus end-to-end: prediksi tumor jinak vs ganas

Bab 1–12 memperkenalkan konsep dan algoritme secara terpisah. Bab penutup ini menyatukan semuanya dalam satu alur kerja lengkap — dari pertanyaan bisnis hingga laporan evaluasi final — mengikuti protokol StatQuest: set uji dikunci, CV di latih, Pipeline tanpa kebocoran.

14.1 Latar masalah dan definisi skenario

Konteks (fiktif operasional, data nyata): unit patologi rumah sakit ingin model pendukung yang memperkirakan apakah tumor payudara ganas (malignant) atau jinak (benign) berdasarkan 30 pengukuran morfometrik sel dari aspirasi jarum halus (FNAB). Model bukan pengganti dokter — ia membantu prioritas kasus yang perlu pemeriksaan lanjut.

Elemen Keputusan proyek
Jenis ML Supervised, klasifikasi biner
Target \(y\) malignant (1) vs benign (0)
Fitur \(X\) 30 nilai numerik (radius, tekstur, perimeter, …)
Metrik utama Recall kelas ganas — FN (ganas terlewat) lebih berbahaya daripada FP
Metrik pendukung Precision, F1, ROC-AUC
Baseline Selalu prediksi kelas mayoritas (jinak)

Dataset: Wisconsin Breast Cancer (sklearn) — 569 observasi, 212 ganas (37%), 357 jinak (63%). Cukup kecil untuk diajar, cukup kaya untuk membandingkan beberapa algoritme Bab 6–11.

14.2 Langkah 1 — Memuat data dan inspeksi awal

import pandas as pd
from sklearn.datasets import load_breast_cancer

cancer = load_breast_cancer(as_frame=True)
df = cancer.frame.copy()
df["label_name"] = df["target"].map({0: "malignant", 1: "benign"})

print("Bentuk data:", df.shape)
print("\nDistribusi kelas:")
print(df["label_name"].value_counts())
print("\nProporsi ganas:", round((df["target"] == 0).mean(), 3))
print("\nContoh 3 baris (5 fitur pertama):")
print(df.iloc[:3, :6].to_string())
print("\nMissing values:", df.isna().sum().sum())
Bentuk data: (569, 32)

Distribusi kelas:
label_name
benign       357
malignant    212
Name: count, dtype: int64

Proporsi ganas: 0.373

Contoh 3 baris (5 fitur pertama):
   mean radius  mean texture  mean perimeter  mean area  mean smoothness  mean compactness
0        17.99         10.38           122.8     1001.0          0.11840           0.27760
1        20.57         17.77           132.9     1326.0          0.08474           0.07864
2        19.69         21.25           130.0     1203.0          0.10960           0.15990

Missing values: 0

Membaca output: tidak ada missing — langkah imputasi tidak diperlukan. Kelas tidak seimbang 37/63 — accuracy saja bisa menipu; gunakan stratified split dan metrik yang sensitif terhadap kelas minoritas (ganas).

14.3 Langkah 2 — EDA: statistik deskriptif dan korelasi

Explorasi data memvalidasi asumsi Bab 3: fitur numerik, rentang berbeda-beda (perlu penskalaan), dan beberapa fitur saling berkorelasi.

import matplotlib.pyplot as plt
import numpy as np

feature_cols = cancer.feature_names
X_all = df[feature_cols]

summary = X_all.describe().T[["mean", "std", "min", "max"]].round(2)
print("Ringkasan 5 fitur pertama:")
print(summary.head().to_string())

# Korelasi fitur dengan target (point-biserial via pearson pada 0/1)
corr_target = X_all.apply(lambda col: np.corrcoef(col, df["target"])[0, 1])
top5 = corr_target.abs().sort_values(ascending=False).head(5)
print("\n5 fitur paling berkorelasi dengan target (|r|):")
for feat, r in top5.items():
    print(f"  {feat[:30]:30s}  r = {corr_target[feat]:+.3f}")
Ringkasan 5 fitur pertama:
                   mean     std     min      max
mean radius       14.13    3.52    6.98    28.11
mean texture      19.29    4.30    9.71    39.28
mean perimeter    91.97   24.30   43.79   188.50
mean area        654.89  351.91  143.50  2501.00
mean smoothness    0.10    0.01    0.05     0.16

5 fitur paling berkorelasi dengan target (|r|):
  worst concave points            r = -0.794
  worst perimeter                 r = -0.783
  mean concave points             r = -0.777
  worst radius                    r = -0.776
  mean perimeter                  r = -0.743
import matplotlib.pyplot as plt
import seaborn as sns

plot_feats = ["mean radius", "mean texture", "worst perimeter", "worst concave points"]
fig, axes = plt.subplots(2, 2, figsize=(11, 5))
for ax, feat in zip(axes.ravel(), plot_feats):
    for label, color in [(0, "#e74c3c"), (1, "#3498db")]:
        ax.hist(df.loc[df["target"] == label, feat], bins=20, alpha=0.55,
                color=color, label="malignant" if label == 0 else "benign", edgecolor="white")
    ax.set_title(feat, fontsize=9)
    ax.legend(fontsize=7)
plt.suptitle("Distribusi fitur per kelas — pola terpisah → ML layak", y=1.02, fontsize=10)
plt.tight_layout()

# Heatmap korelasi subset
sub_feats = ["mean radius", "mean perimeter", "mean area", "worst radius", "worst perimeter"]
fig2, ax2 = plt.subplots(figsize=(7, 5))
sns.heatmap(df[sub_feats].corr(), annot=True, fmt=".2f", cmap="RdBu_r", center=0, ax=ax2, square=True)
ax2.set_title("Korelasi tinggi antar fitur → penskalaan + regularisasi relevan")
plt.tight_layout()

EDA: histogram fitur utama per kelas (ganas vs jinak) dan heatmap korelasi antar fitur terkait.

Temuan EDA:

  • Fitur worst concave points dan worst perimeter kuat memisahkan kelas — sel ganas cenderung punya nilai lebih tinggi.
  • mean radius, mean perimeter, mean area sangat berkorelasi (\(r > 0{,}9\)) — multikolinearitas; model linear tetap bisa dipakai dengan StandardScaler; pohon/SVM juga perlu skala untuk beberapa kernel.
  • Tidak ada kebocoran waktu: semua fitur dari pengukuran yang sama dengan label — aman untuk skenario prediksi simultan.

14.4 Langkah 3 — Baseline dan pembagian latih/uji

import numpy as np
from sklearn.dummy import DummyClassifier
from sklearn.metrics import (
    accuracy_score, balanced_accuracy_score, recall_score, f1_score, roc_auc_score
)
from sklearn.model_selection import train_test_split

X = df[feature_cols]
y = df["target"]  # 0 = malignant, 1 = benign

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

# Baseline: selalu prediksi kelas mayoritas (benign = 1)
baseline = DummyClassifier(strategy="most_frequent")
baseline.fit(X_train, y_train)
y_base = baseline.predict(X_test)

def report(name, y_true, y_pred, y_prob_malignant=None):
    row = {
        "Model": name,
        "Accuracy": round(accuracy_score(y_true, y_pred), 4),
        "Balanced acc.": round(balanced_accuracy_score(y_true, y_pred), 4),
        "Recall malignant": round(recall_score(y_true, y_pred, pos_label=0), 4),
        "F1 macro": round(f1_score(y_true, y_pred, average="macro"), 4),
    }
    if y_prob_malignant is not None:
        y_mal = (y_true == 0).astype(int)
        row["ROC-AUC (malignant)"] = round(roc_auc_score(y_mal, y_prob_malignant), 4)
    return row

baseline_row = report("Baseline (kelas mayoritas)", y_test, y_base)
print("Ukuran latih / uji:", X_train.shape[0], "/", X_test.shape[0])
print("\nBaseline — selalu prediksi 'benign':")
for k, v in baseline_row.items():
    if k != "Model":
        print(f"  {k}: {v}")
print("\n→ Recall malignant = 0: model baseline TIDAK PERNAH mendeteksi ganas.")
Ukuran latih / uji: 426 / 143

Baseline — selalu prediksi 'benign':
  Accuracy: 0.6294
  Balanced acc.: 0.5
  Recall malignant: 0.0
  F1 macro: 0.3863

→ Recall malignant = 0: model baseline TIDAK PERNAH mendeteksi ganas.

Pelajaran: accuracy baseline ≈ 63% (proporsi jinak di uji) tetapi recall ganas = 0 — model ML harus secara nyata mengalahkan baseline pada recall malignant dan balanced accuracy.

14.5 Langkah 4 — Pipeline, kandidat model, dan cross-validation

Semua model dibungkus Pipeline dengan StandardScaler agar tidak ada kebocoran: scaler fit hanya di fold latih CV.

import pandas as pd
from sklearn.ensemble import RandomForestClassifier
from sklearn.linear_model import LogisticRegression
from sklearn.model_selection import cross_validate, StratifiedKFold
from sklearn.naive_bayes import GaussianNB
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.svm import SVC
from sklearn.tree import DecisionTreeClassifier

cv = StratifiedKFold(n_splits=5, shuffle=True, random_state=42)

candidates = {
    "Logistic Regression": Pipeline([
        ("sc", StandardScaler()),
        ("m", LogisticRegression(max_iter=1000, random_state=42)),
    ]),
    "Gaussian Naive Bayes": Pipeline([
        ("sc", StandardScaler()),
        ("m", GaussianNB()),
    ]),
    "Decision Tree (depth=4)": DecisionTreeClassifier(max_depth=4, random_state=42),
    "SVM RBF": Pipeline([
        ("sc", StandardScaler()),
        ("m", SVC(kernel="rbf", probability=True, random_state=42)),
    ]),
    "Random Forest": RandomForestClassifier(n_estimators=100, max_depth=6, random_state=42),
}

rows = []
from sklearn.model_selection import cross_val_predict

for name, pipe in candidates.items():
    scores = cross_validate(
        pipe, X_train, y_train, cv=cv,
        scoring=["accuracy", "balanced_accuracy", "f1_macro"],
        return_train_score=False,
    )
    y_cv_pred = cross_val_predict(pipe, X_train, y_train, cv=cv)
    rec_mal = recall_score(y_train, y_cv_pred, pos_label=0)
    # Probabilitas kelas ganas (indeks 0) untuk ROC-AUC
    if hasattr(pipe, "predict_proba"):
        y_cv_prob = cross_val_predict(pipe, X_train, y_train, cv=cv, method="predict_proba")[:, 0]
    else:
        y_cv_prob = cross_val_predict(pipe, X_train, y_train, cv=cv, method="decision_function")
        y_cv_prob = -y_cv_prob  # decision_function: lebih tinggi → lebih yakin benign
    y_mal_train = (y_train == 0).astype(int)
    auc_mal = roc_auc_score(y_mal_train, y_cv_prob)
    rows.append({
        "Model": name,
        "CV Accuracy": round(scores["test_accuracy"].mean(), 4),
        "CV Balanced acc.": round(scores["test_balanced_accuracy"].mean(), 4),
        "CV Recall malignant": round(rec_mal, 4),
        "CV F1 macro": round(scores["test_f1_macro"].mean(), 4),
        "CV ROC-AUC (malignant)": round(auc_mal, 4),
    })

cv_table = pd.DataFrame(rows).sort_values("CV Recall malignant", ascending=False)
cv_table
Model CV Accuracy CV Balanced acc. CV Recall malignant CV F1 macro CV ROC-AUC (malignant)
0 Logistic Regression 0.9789 0.9744 0.9560 0.9773 0.9949
3 SVM RBF 0.9671 0.9625 0.9434 0.9647 0.9935
4 Random Forest 0.9554 0.9519 0.9371 0.9523 0.9890
2 Decision Tree (depth=4) 0.9272 0.9242 0.9119 0.9225 0.9188
1 Gaussian Naive Bayes 0.9319 0.9267 0.9057 0.9271 0.9846

Cara memilih model (StatQuest):

  1. Prioritaskan CV Recall malignant — sesuai biaya FN di rumah sakit.
  2. Jika recall seri, bandingkan ROC-AUC dan F1 macro.
  3. Pertimbangkan interpretabilitas — Logistic Regression / Decision Tree lebih mudah diaudit daripada RBF SVM.

14.6 Langkah 5 — Latih model terpilih dan evaluasi final di set uji

Asumsikan Logistic Regression atau model teratas CV dipilih. Di bawah, kita latih dua model teratas untuk demonstrasi laporan final — hanya sekali di set uji.

import matplotlib.pyplot as plt
from sklearn.metrics import ConfusionMatrixDisplay, RocCurveDisplay, classification_report

best_name = cv_table.iloc[0]["Model"]
final_models = {
    "Logistic Regression": Pipeline([
        ("sc", StandardScaler()),
        ("m", LogisticRegression(max_iter=1000, random_state=42)),
    ]),
    "SVM RBF": Pipeline([
        ("sc", StandardScaler()),
        ("m", SVC(kernel="rbf", probability=True, random_state=42)),
    ]),
}

final_rows = []
fig, axes = plt.subplots(2, 2, figsize=(10, 8))

for i, (name, model) in enumerate(final_models.items()):
    model.fit(X_train, y_train)
    y_pred = model.predict(X_test)
    if hasattr(model, "predict_proba"):
        y_prob_mal = model.predict_proba(X_test)[:, 0]
    else:
        y_prob_mal = -model.decision_function(X_test)

    final_rows.append(report(name, y_test, y_pred, y_prob_mal))

    ConfusionMatrixDisplay.from_predictions(
        y_test, y_pred, display_labels=["malignant", "benign"], ax=axes[i, 0], cmap="Blues", colorbar=False
    )
    axes[i, 0].set_title(f"{name}\nConfusion matrix (uji)")

    y_mal_test = (y_test == 0).astype(int)
    RocCurveDisplay.from_predictions(
        y_mal_test, y_prob_mal, ax=axes[i, 1], name=name
    )
    axes[i, 1].set_title(f"{name} — ROC (uji)")
    axes[i, 1].plot([0, 1], [0, 1], "k--", lw=1, alpha=0.5)

plt.suptitle("Evaluasi final — set uji (25%) yang dikunci sejak awal", y=1.01, fontsize=10)
plt.tight_layout()

final_df = pd.DataFrame(final_rows)
print("Model terbaik menurut CV:", best_name)
print("\n=== Perbandingan final di SET UJI ===")
print(final_df.to_string(index=False))

# Laporan detail model pertama
lr = final_models["Logistic Regression"]
lr.fit(X_train, y_train)
print("\n=== Classification report — Logistic Regression (uji) ===")
print(classification_report(
    y_test, lr.predict(X_test),
    target_names=["malignant", "benign"],
    digits=4,
))
Model terbaik menurut CV: Logistic Regression

=== Perbandingan final di SET UJI ===
              Model  Accuracy  Balanced acc.  Recall malignant  F1 macro  ROC-AUC (malignant)
Logistic Regression     0.986         0.9850            0.9811    0.9850               0.9977
            SVM RBF     0.979         0.9795            0.9811    0.9776               0.9969

=== Classification report — Logistic Regression (uji) ===
              precision    recall  f1-score   support

   malignant     0.9811    0.9811    0.9811        53
      benign     0.9889    0.9889    0.9889        90

    accuracy                         0.9860       143
   macro avg     0.9850    0.9850    0.9850       143
weighted avg     0.9860    0.9860    0.9860       143

Membaca confusion matrix:

  • FN (kanan atas): ganas diprediksi jinak — paling berbahaya; minimalkan dengan threshold atau model recall tinggi.
  • FP (kiri bawah): jinak diprediksi ganas — menambah pemeriksaan lanjut, biaya lebih rendah.

Threshold operasional: predict_proba default threshold 0,5 bisa digeser — misalnya prediksi ganas jika \(P(\text{malignant}) > 0{,}35\) untuk recall lebih tinggi (trade-off precision).

14.7 Langkah 6 — Interpretasi koefisien (model linear)

Regresi logistik setelah penskalaan memungkinkan perbandingan arah pengaruh fitur — selaras filosofi StatQuest “jelaskan, bukan kotak hitam.”

coef_df = pd.DataFrame({
    "fitur": feature_cols,
    "koefisien (setelah skala)": lr.named_steps["m"].coef_[0],
}).assign(abs_coef=lambda d: d["koefisien (setelah skala)"].abs())
coef_df = coef_df.sort_values("abs_coef", ascending=False).head(8)
print("8 fitur dengan |koefisien| terbesar (Logistic Regression):")
print(coef_df[["fitur", "koefisien (setelah skala)"]].to_string(index=False))
print("\nKoefisien positif → cenderung meningkatkan P(benign); negatif → cenderung P(malignant).")
8 fitur dengan |koefisien| terbesar (Logistic Regression):
               fitur  koefisien (setelah skala)
       worst texture                  -1.250149
        radius error                  -1.070102
      worst symmetry                  -0.957045
worst concave points                  -0.941888
          area error                  -0.941059
          worst area                  -0.925812
        worst radius                  -0.917480
     worst concavity                  -0.796758

Koefisien positif → cenderung meningkatkan P(benign); negatif → cenderung P(malignant).

14.8 Langkah 7 — Ringkasan studi kasus dan checklist deploy

Tahap Apa yang dilakukan Output
1. Definisi Klasifikasi biner, metrik = recall ganas Dokumen skenario
2. EDA Distribusi, korelasi, missing Temuan penskalaan perlu
3. Split 75/25 stratified, random_state=42 Train 426 / test 143
4. Baseline Kelas mayoritas Recall ganas = 0 → ML wajib lebih baik
5. CV 5-fold stratified, Pipeline Tabel pemilihan model
6. Final uji Satu kali, confusion matrix + ROC Laporan stakeholder
7. Deploy Simpan Pipeline (scaler + model) Artefak .pkl / ONNX

Checklist sebelum produksi:

  1. Monitor drift — distribusi fitur baru vs latih; jika bergeser, retrain.
  2. Audit fairness — pastikan performa setara antar subgrup pasien (jika data demografi tersedia).
  3. Human-in-the-loop — model hanya pendukung, bukan keputusan otomatis.
  4. Dokumentasi — versi data, seed, hiperparameter, metrik uji, tanggal evaluasi.

Kesimpulan pedagogis: studi kasus ini menerapkan Bab 1 (supervised, train/test), Bab 2 (CV), Bab 3 (korelasi), Bab 6 (logistic), Bab 7 (Naive Bayes), Bab 8 (confusion matrix, ROC), Bab 9 (implisit via regularisasi di logistic C), Bab 10–11 (pohon, SVM, RF), dalam satu narasi koheren — pola yang sama bisa Anda ulangi pada dataset regresi (mis. prediksi harga rumah) dengan RMSE sebagai metrik utama.

15 Ringkasan alur pembelajaran ML

  1. Definisikan masalah — regresi/klasifikasi? apa biaya FN vs FP?
  2. Kumpulkan data — pastikan fitur tersedia saat inferensi.
  3. EDA & persiapan — missing, outlier, skala, encoding.
  4. Baseline — rata-rata / kelas mayoritas / Naive Bayes sederhana.
  5. Pisahkan latih / uji — kunci uji.
  6. Latih kandidat — linear → pohon → SVM → NN (naik kompleksitas jika perlu).
  7. Tuning hiperparameter via cross-validation di latih.
  8. Evaluasi final di uji — metrik yang disepakati stakeholder.
  9. Deploy & monitor — drift data bisa menurunkan performa seiring waktu.

16 Latihan konseptual

  1. Jelaskan perbedaan supervised dan unsupervised dengan satu contoh di bidang kesehatan dan satu di ritel.
  2. Sebuah model polinomial derajat 15 mencapai \(R^2 = 0{,}99\) di latih tetapi \(R^2 = 0{,}45\) di uji. Diagnosis? Tiga langkah mitigasi?
  3. Dataset churn: 95% tidak churn, 5% churn. Model selalu prediksi “tidak churn” — berapa accuracy? Apa masalahnya? Metrik apa yang lebih tepat?
  4. Pada 5-fold CV dengan 500 sampel latih, berapa ukuran fold validasi? Mengapa stratify penting untuk klasifikasi pinjaman macet?
  5. Dua fitur punya \(r = 0{,}92\). Apa implikasinya untuk OLS? Metode Bab 9 mana yang membantu?
  6. Filter spam Naive Bayes: mengapa asumsi independensi kata naïf tetapi model tetap bisa berguna?
  7. Bandingkan precision dan recall untuk skrining diabetes — metrik mana yang Anda prioritaskan dan mengapa?
  8. SVM linear vs RBF pada data bulan sabit — jelaskan perbedaan batas keputusan.
  9. Sebutkan tiga hiperparameter MLP dan efeknya jika nilainya terlalu besar/kecil.
  10. Kapan Anda memilih pohon keputusan tunggal daripada Random Forest?
  11. Pada studi kasus tumor: mengapa baseline “selalu jinak” punya accuracy ~63% tetapi recall ganas = 0? Model ML mana yang Anda deploy jika FN sangat mahal?
  12. Jelaskan mengapa StandardScaler harus berada di dalam Pipeline, bukan dihitung dari train + test sekaligus.

17 Referensi

  • Starmer, J. (2022). The StatQuest Illustrated Guide to Machine Learning!!! StatQuest Publications. PDF lokal: 610435041-The-StatQuest-Illustrated-Guide-to-Machine-Learning-Josh-Starmer.pdf.
  • StatQuest YouTube: StatQuest with Josh Starmer — video pendamping per bab (Linear Regression, Gradient Descent, Logistic Regression, dll.).
  • StatQuest Store: statquest.org/statquest-store